feat: add the mcp:start command for A4D

Author: justinwilaby

packages/cli/package.json

@@ -15,6 +15,7 @@
     "@heroku/eventsource": "^1.0.7",
     "@heroku/heroku-cli-util": "^9.0.2",
     "@heroku/http-call": "^5.4.0",
+    "@heroku/mcp-server": "1.0.7-alpha.1",
     "@heroku/plugin-ai": "^1.0.1",
     "@inquirer/prompts": "^5.0.5",
     "@oclif/core": "^2.16.0",

packages/cli/src/commands/mcp/start.ts

@@ -0,0 +1,35 @@
+import {Command, flags} from '@heroku-cli/command'
+import {spawn} from 'child_process'
+import {join} from 'path'
+
+export default class MCPStart extends Command {
+  static description = 'starts the Heroku platform MCP server in stdio mode'
+  static hidden = true
+
+  static flags = {
+    help: flags.help({char: 'h'}),
+  }
+
+  public async run() {
+    const serverPath = join(require.resolve('@heroku/mcp-server'), '../../bin/heroku-mcp-server.mjs')
+    const server = spawn('node', [serverPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: true,
+    })
+
+    // Pipe all stdio streams
+    process.stdin.pipe(server.stdin)
+    server.stdout.pipe(process.stdout)
+    server.stderr.pipe(process.stderr)
+
+    // Handle process termination
+    process.on('SIGINT', () => {
+      server.kill('SIGINT')
+    })
+    process.on('SIGTERM', () => {
+      server.kill('SIGTERM')
+    })
+
+    return server
+  }
+}

packages/cli/test/unit/commands/mcp/start.unit.test.ts

@@ -0,0 +1,118 @@
+import {expect} from 'chai'
+import {stderr, stdout} from 'stdout-stderr'
+import runCommand from '../../../helpers/runCommand'
+import MCPStart from '../../../../src/commands/mcp/start'
+import * as child_process from 'child_process'
+
+// Mock child_process.spawn
+const mockPipe: (...args: any[]) => any = function (this: any) {
+  return this
+}
+
+const mockOn: (...args: any[]) => any = function (this: any) {
+  return this
+}
+
+const mockOnce: (...args: any[]) => any = function (this: any) {
+  return this
+}
+
+const mockStream: any = {
+  pipe: function (this: any, ..._args: any[]) {
+    return this
+  },
+  on: function (this: any, ..._args: any[]) {
+    return this
+  },
+  once: function (this: any, ..._args: any[]) {
+    return this
+  },
+  unpipe: function (this: any, ..._args: any[]) {
+    return this
+  },
+  removeListener: function (this: any, ..._args: any[]) {
+    return this
+  },
+  addListener: function (this: any, ..._args: any[]) {
+    return this
+  },
+  emit: function (this: any, ..._args: any[]) {
+    return true
+  },
+}
+
+const mockKill = function () {
+  return true
+}
+
+const mockServer: any = {
+  stdin: Object.create(mockStream),
+  stdout: Object.create(mockStream),
+  stderr: Object.create(mockStream),
+  kill: mockKill,
+}
+
+describe('mcp:start', function () {
+  let origSpawn: any
+  let origOn: any
+  let signalHandlers: Record<string, (...args: any[]) => any> = {}
+
+  beforeEach(function () {
+    origSpawn = child_process.spawn
+    Object.defineProperty(child_process, 'spawn', {
+      value: (...args: any[]) => mockServer,
+      configurable: true,
+      writable: true,
+    })
+    origOn = process.on
+    // @ts-expect-error override for test: process.on is not assignable
+    process.on = (sig: string, handler: (...args: any[]) => any) => {
+      signalHandlers[sig] = handler
+    }
+
+    signalHandlers = {}
+    stdout.start()
+    stderr.start()
+  })
+
+  afterEach(function () {
+    Object.defineProperty(child_process, 'spawn', {
+      value: origSpawn,
+      configurable: true,
+      writable: true,
+    })
+    process.on = origOn
+    stdout.stop()
+    stderr.stop()
+  })
+
+  it('spawns the server with correct arguments and pipes stdio', async function () {
+    let calledArgs: any[] = []
+    Object.defineProperty(child_process, 'spawn', {
+      value: (...args: any[]) => {
+        calledArgs = args
+        return mockServer
+      },
+      configurable: true,
+      writable: true,
+    })
+    const result = await runCommand(MCPStart, [])
+    expect(calledArgs[0]).to.equal('node')
+    expect(calledArgs[1][0]).to.include('heroku-mcp-server.mjs')
+    expect(calledArgs[2]).to.include({shell: true})
+    expect(calledArgs[2].stdio).to.eql(['pipe', 'pipe', 'pipe'])
+    // Check that piping was called (mockPipe is a no-op, but no error means it was called)
+    expect(result).to.equal(mockServer)
+  })
+
+  it('handles SIGINT and SIGTERM signals', async function () {
+    await runCommand(MCPStart, [])
+    expect(signalHandlers).to.have.property('SIGINT')
+    expect(signalHandlers).to.have.property('SIGTERM')
+  })
+
+  it('returns the server process', async function () {
+    const result = await runCommand(MCPStart, [])
+    expect(result).to.equal(mockServer)
+  })
+})