harness-mcp (squashed)

Author: frenchie4111

package.json

@@ -46,6 +46,12 @@
     "asarUnpack": [
       "**/node_modules/node-pty/**/*"
     ],
+    "extraResources": [
+      {
+        "from": "resources/mcp-bridge.js",
+        "to": "mcp-bridge.js"
+      }
+    ],
     "mac": {
       "category": "public.app-category.developer-tools",
       "icon": "resources/icon.icns",

resources/mcp-bridge.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+// Harness MCP bridge — minimal MCP stdio server that forwards tool calls
+// to the Harness control HTTP server running inside the Electron main process.
+// Spawned by Claude Code via `ELECTRON_RUN_AS_NODE=1 <electron-binary> <this>`.
+
+const http = require('http')
+const readline = require('readline')
+
+const PORT = process.env.HARNESS_PORT
+const TOKEN = process.env.HARNESS_TOKEN
+const TERMINAL_ID = process.env.HARNESS_TERMINAL_ID || ''
+
+if (!PORT || !TOKEN) {
+  process.stderr.write('harness-mcp: HARNESS_PORT and HARNESS_TOKEN required\n')
+  process.exit(1)
+}
+
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n')
+}
+
+function logErr(...args) {
+  process.stderr.write('[harness-mcp] ' + args.join(' ') + '\n')
+}
+
+function callControl(method, path, body) {
+  return new Promise((resolve, reject) => {
+    const data = body ? JSON.stringify(body) : undefined
+    const req = http.request(
+      {
+        host: '127.0.0.1',
+        port: Number(PORT),
+        path,
+        method,
+        headers: {
+          Authorization: 'Bearer ' + TOKEN,
+          'Content-Type': 'application/json',
+          ...(data ? { 'Content-Length': Buffer.byteLength(data) } : {})
+        }
+      },
+      (res) => {
+        let chunks = ''
+        res.on('data', (c) => (chunks += c))
+        res.on('end', () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(chunks ? JSON.parse(chunks) : {})
+            } catch (e) {
+              reject(new Error('bad json from harness: ' + chunks))
+            }
+          } else {
+            reject(new Error('harness HTTP ' + res.statusCode + ': ' + chunks))
+          }
+        })
+      }
+    )
+    req.on('error', reject)
+    if (data) req.write(data)
+    req.end()
+  })
+}
+
+const TOOLS = [
+  {
+    name: 'create_worktree',
+    description:
+      'Create a new git worktree in a Harness-managed repo. Harness will open a new Claude chat tab inside the new worktree automatically.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        branchName: {
+          type: 'string',
+          description: 'Name of the new branch to create for the worktree.'
+        },
+        repoRoot: {
+          type: 'string',
+          description:
+            'Absolute path to the repo root. Optional when only one repo is open in Harness.'
+        },
+        baseBranch: {
+          type: 'string',
+          description:
+            "Branch to fork the new worktree from. Defaults to the repo's configured base."
+        }
+      },
+      required: ['branchName']
+    }
+  },
+  {
+    name: 'list_worktrees',
+    description: 'List git worktrees currently managed by Harness.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        repoRoot: {
+          type: 'string',
+          description: 'Optional repo root to filter by.'
+        }
+      }
+    }
+  },
+  {
+    name: 'list_repos',
+    description: 'List the repo roots currently open in Harness.',
+    inputSchema: { type: 'object', properties: {} }
+  }
+]
+
+async function handleToolCall(name, args) {
+  if (name === 'create_worktree') {
+    if (!args || !args.branchName) throw new Error('branchName is required')
+    const r = await callControl('POST', '/worktrees', {
+      terminalId: TERMINAL_ID,
+      repoRoot: args.repoRoot,
+      branchName: args.branchName,
+      baseBranch: args.baseBranch
+    })
+    return (
+      'Created worktree ' +
+      r.path +
+      ' on branch ' +
+      r.branch +
+      '. Harness will open a new Claude chat tab in it.'
+    )
+  }
+  if (name === 'list_worktrees') {
+    const q =
+      args && args.repoRoot ? '?repoRoot=' + encodeURIComponent(args.repoRoot) : ''
+    const r = await callControl('GET', '/worktrees' + q)
+    return JSON.stringify(r, null, 2)
+  }
+  if (name === 'list_repos') {
+    const r = await callControl('GET', '/repos')
+    return JSON.stringify(r, null, 2)
+  }
+  throw new Error('unknown tool: ' + name)
+}
+
+async function handle(msg) {
+  const { id, method, params } = msg
+  try {
+    if (method === 'initialize') {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo: { name: 'harness-control', version: '1.0.0' }
+        }
+      }
+    }
+    if (method === 'notifications/initialized' || method === 'initialized') {
+      return null
+    }
+    if (method === 'tools/list') {
+      return { jsonrpc: '2.0', id, result: { tools: TOOLS } }
+    }
+    if (method === 'tools/call') {
+      const text = await handleToolCall(
+        params && params.name,
+        (params && params.arguments) || {}
+      )
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: { content: [{ type: 'text', text }] }
+      }
+    }
+    return {
+      jsonrpc: '2.0',
+      id,
+      error: { code: -32601, message: 'Method not found: ' + method }
+    }
+  } catch (err) {
+    const message = (err && err.message) || String(err)
+    logErr('error', method, message)
+    if (method === 'tools/call') {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          content: [{ type: 'text', text: message }],
+          isError: true
+        }
+      }
+    }
+    return {
+      jsonrpc: '2.0',
+      id,
+      error: { code: -32603, message }
+    }
+  }
+}
+
+const rl = readline.createInterface({ input: process.stdin })
+rl.on('line', async (line) => {
+  if (!line.trim()) return
+  let msg
+  try {
+    msg = JSON.parse(line)
+  } catch {
+    return
+  }
+  const response = await handle(msg)
+  if (response) send(response)
+})
+rl.on('close', () => process.exit(0))

src/main/control-server.ts

@@ -0,0 +1,139 @@
+import { createServer, IncomingMessage, ServerResponse } from 'http'
+import { randomBytes } from 'crypto'
+import { addWorktree, listWorktrees, defaultWorktreeDir, WorktreeInfo } from './worktree'
+import { log } from './debug'
+
+export interface ControlServerDeps {
+  getRepoRoots: () => string[]
+  getWorktreeBase: () => 'remote' | 'local'
+  broadcast: (channel: string, ...args: unknown[]) => void
+}
+
+let serverInfo: { port: number; token: string } | null = null
+
+export function getControlServerInfo(): { port: number; token: string } | null {
+  return serverInfo
+}
+
+export function startControlServer(deps: ControlServerDeps): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const token = randomBytes(32).toString('hex')
+
+    const server = createServer((req, res) => {
+      handleRequest(req, res, token, deps).catch((err) => {
+        log('control', 'handler threw', err instanceof Error ? err.message : String(err))
+        if (!res.headersSent) {
+          res.writeHead(500, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
+        }
+      })
+    })
+
+    server.listen(0, '127.0.0.1', () => {
+      const addr = server.address()
+      if (addr && typeof addr === 'object') {
+        serverInfo = { port: addr.port, token }
+        log('control', `listening on 127.0.0.1:${addr.port}`)
+        resolve()
+      } else {
+        reject(new Error('failed to bind control server'))
+      }
+    })
+    server.on('error', (err) => {
+      log('control', 'server error', err.message)
+    })
+  })
+}
+
+async function handleRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  token: string,
+  deps: ControlServerDeps
+): Promise<void> {
+  const auth = req.headers.authorization
+  if (auth !== 'Bearer ' + token) {
+    res.writeHead(401)
+    res.end('unauthorized')
+    return
+  }
+
+  const url = new URL(req.url || '/', 'http://127.0.0.1')
+  const path = url.pathname
+
+  if (req.method === 'GET' && path === '/health') {
+    return sendJson(res, 200, { ok: true })
+  }
+
+  if (req.method === 'GET' && path === '/repos') {
+    return sendJson(res, 200, { repoRoots: deps.getRepoRoots() })
+  }
+
+  if (req.method === 'GET' && path === '/worktrees') {
+    const repoRoot = url.searchParams.get('repoRoot')
+    const roots = repoRoot ? [repoRoot] : deps.getRepoRoots()
+    const all: WorktreeInfo[] = []
+    for (const r of roots) {
+      try {
+        all.push(...(await listWorktrees(r)))
+      } catch (e) {
+        log('control', `list worktrees failed for ${r}`, e instanceof Error ? e.message : e)
+      }
+    }
+    return sendJson(res, 200, all)
+  }
+
+  if (req.method === 'POST' && path === '/worktrees') {
+    const body = await readJson(req)
+    let repoRoot = typeof body.repoRoot === 'string' ? body.repoRoot : undefined
+    if (!repoRoot) {
+      const roots = deps.getRepoRoots()
+      if (roots.length === 1) {
+        repoRoot = roots[0]
+      } else if (roots.length === 0) {
+        return sendJson(res, 400, { error: 'no repos open in Harness' })
+      } else {
+        return sendJson(res, 400, {
+          error: 'repoRoot required when multiple repos are open',
+          repoRoots: roots
+        })
+      }
+    }
+    const branchName = String(body.branchName || '').trim()
+    if (!branchName) {
+      return sendJson(res, 400, { error: 'branchName required' })
+    }
+    const wtDir = defaultWorktreeDir(repoRoot)
+    const mode = deps.getWorktreeBase()
+    const created = await addWorktree(repoRoot, wtDir, branchName, {
+      baseBranch: typeof body.baseBranch === 'string' ? body.baseBranch : undefined,
+      fetchRemote: !body.baseBranch && mode === 'remote'
+    })
+    deps.broadcast('worktrees:externalCreate', { repoRoot, worktree: created })
+    return sendJson(res, 200, created)
+  }
+
+  res.writeHead(404)
+  res.end('not found')
+}
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+  res.writeHead(status, { 'Content-Type': 'application/json' })
+  res.end(JSON.stringify(body))
+}
+
+function readJson(req: IncomingMessage): Promise<Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    req.on('data', (c: Buffer) => chunks.push(c))
+    req.on('end', () => {
+      if (chunks.length === 0) return resolve({})
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString('utf-8')))
+      } catch (e) {
+        reject(e)
+      }
+    })
+    req.on('error', reject)
+  })
+}