patchwork-os 0.2.0-beta.10.canary.99 → 0.2.0-beta.11

package/scripts/mcp-stdio-shim.cjs

@@ -30,6 +30,27 @@ const { randomUUID } = require("node:crypto");
 // Resolve ws from the bridge's own node_modules (script lives in scripts/)
 const { WebSocket } = require(path.join(__dirname, "..", "node_modules", "ws"));
 
+// process.kill(pid, 0) probes liveness without delivering a signal: it throws
+// ESRCH when the process is gone and EPERM when it exists but isn't ours (still
+// alive). A stale lock whose bridge has exited would otherwise be "selected"
+// (newest mtime within its tier) and every connect would hang on a refused port
+// until backoff gives up — the multi-bridge footgun. Mirrors the shared
+// src/bridgeLockDiscovery.ts isLive() check.
+function isAlive(pid) {
+  if (typeof pid !== "number" || !Number.isFinite(pid)) return true; // unknown pid → don't exclude
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+
+// Remembers the last lock we logged a selection for, so the diagnostic below
+// fires once at startup (and again only when the selection actually changes)
+// rather than on every poll tick.
+let lastSelectedLockPath = null;
+
 function findLockFile() {
   const lockDir = path.join(
     process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"),
@@ -38,49 +59,40 @@ function findLockFile() {
   // Three-tier preference: orchestrator > bridge > any lock (each by newest mtime).
   // Orchestrator locks win because child bridge restarts produce newer lock files,
   // which would hijack the shim away from the orchestrator if we only used mtime.
-  let orchestratorLock = null;
-  let orchestratorMtime = 0;
-  let bridgeLock = null;
-  let bridgeMtime = 0;
-  let fallbackLock = null;
-  let fallbackMtime = 0;
+  const orchestrator = { path: null, mtime: 0, data: null };
+  const bridge = { path: null, mtime: 0, data: null };
+  const fallback = { path: null, mtime: 0, data: null };
   try {
     for (const f of fs.readdirSync(lockDir)) {
       if (!f.endsWith(".lock")) continue;
       const fullPath = path.join(lockDir, f);
       try {
         const stat = fs.statSync(fullPath);
-        let isBridge = false;
-        let isOrchestrator = false;
+        let data = null;
         try {
-          const data = JSON.parse(fs.readFileSync(fullPath, "utf8"));
-          isBridge = data.isBridge === true;
-          isOrchestrator = data.orchestrator === true;
-          // Skip locks that don't match the requested workspace
-          if (
-            workspaceFilter &&
-            data.workspace &&
-            data.workspace !== workspaceFilter
-          )
-            continue;
+          data = JSON.parse(fs.readFileSync(fullPath, "utf8"));
         } catch {
-          // unparseable — treat as non-bridge
+          // unparseable — treated as a fallback lock with no metadata
         }
-        if (isOrchestrator) {
-          if (stat.mtimeMs > orchestratorMtime) {
-            orchestratorMtime = stat.mtimeMs;
-            orchestratorLock = fullPath;
-          }
-        } else if (isBridge) {
-          if (stat.mtimeMs > bridgeMtime) {
-            bridgeMtime = stat.mtimeMs;
-            bridgeLock = fullPath;
-          }
-        } else {
-          if (stat.mtimeMs > fallbackMtime) {
-            fallbackMtime = stat.mtimeMs;
-            fallbackLock = fullPath;
-          }
+        // Skip locks whose owning bridge process has exited. Without this a
+        // wedged/stale lock can be picked and the connection hangs.
+        if (data && !isAlive(data.pid)) continue;
+        // When a workspace filter is set, require an EXACT workspace match — a
+        // lock with a missing/blank workspace field must not be picked under the
+        // filter (otherwise the shim can latch onto an unrelated bridge).
+        if (workspaceFilter && (!data || data.workspace !== workspaceFilter))
+          continue;
+        const isBridge = data ? data.isBridge === true : false;
+        const isOrchestrator = data ? data.orchestrator === true : false;
+        const tier = isOrchestrator
+          ? orchestrator
+          : isBridge
+            ? bridge
+            : fallback;
+        if (stat.mtimeMs > tier.mtime) {
+          tier.mtime = stat.mtimeMs;
+          tier.path = fullPath;
+          tier.data = data;
         }
       } catch {
         // skip unreadable files
@@ -90,7 +102,25 @@ function findLockFile() {
     // lock dir doesn't exist
   }
   // Prefer orchestrator > bridge > fallback (each newest mtime within tier)
-  return orchestratorLock ?? bridgeLock ?? fallbackLock;
+  const chosen = orchestrator.path
+    ? orchestrator
+    : bridge.path
+      ? bridge
+      : fallback.path
+        ? fallback
+        : null;
+  // One-line stderr diagnostic so operators can see which bridge/workspace the
+  // shim latched onto — silent wrong-bridge selection was a real footgun. stderr
+  // is not the JSON-RPC stream, so this never corrupts protocol traffic.
+  if (chosen && chosen.path !== lastSelectedLockPath) {
+    lastSelectedLockPath = chosen.path;
+    const wsName = chosen.data?.workspace || "(unknown workspace)";
+    const pid = chosen.data?.pid || "?";
+    process.stderr.write(
+      `mcp-stdio-shim: selected ${path.basename(chosen.path)} (workspace=${wsName}, pid=${pid})\n`,
+    );
+  }
+  return chosen ? chosen.path : null;
 }
 
 function parseLock(lockPath) {
@@ -199,11 +229,16 @@ function scheduleBackoffReconnect(errorType) {
 // Parse named flags first so they don't pollute positional port/token detection.
 const args = process.argv.slice(2);
 let workspaceFilter = null;
+let pingMode = false;
 for (let i = 0; i < args.length; i++) {
-  if (args[i] === "--workspace" && args[i + 1]) {
+  if (args[i] === "--ping" || args[i] === "--probe") {
+    pingMode = true;
+    args.splice(i, 1);
+    i--;
+  } else if (args[i] === "--workspace" && args[i + 1] !== undefined) {
     workspaceFilter = args[i + 1];
     args.splice(i, 2);
-    break;
+    i--;
   }
 }
 const explicitPort = args[0] && args[1] ? Number(args[0]) : null;
@@ -369,8 +404,104 @@ function startPoll() {
   }, POLL_INTERVAL_MS);
 }
 
-// --- Initial connection ---
-if (explicitPort !== null) {
+// --- Ping mode: one-shot probe, then exit ---
+// `grok mcp doctor` (and similar stdio MCP verifiers) hang on this shim because
+// it is a long-lived relay that only exits on stdin EOF. `--ping` / `--probe`
+// gives those tools a clean check: connect, run initialize + tools/list, print a
+// one-line summary, and exit. It skips the relay, lock watcher, and reconnect
+// loops entirely.
+if (pingMode) {
+  let pingPort = explicitPort;
+  let pingToken = explicitToken;
+  if (pingPort === null) {
+    const lockFile = findLockFile();
+    if (!lockFile) {
+      process.stderr.write("mcp-stdio-shim: --ping: no bridge lock found.\n");
+      process.exit(1);
+    }
+    try {
+      const parsed = parseLock(lockFile);
+      pingPort = parsed.port;
+      pingToken = parsed.authToken;
+    } catch (err) {
+      process.stderr.write(
+        `mcp-stdio-shim: --ping: lock unreadable (${err.message}).\n`,
+      );
+      process.exit(1);
+    }
+  }
+  let pingDone = false;
+  const pingWs = new WebSocket(`ws://127.0.0.1:${pingPort}`, {
+    headers: {
+      "x-claude-code-ide-authorization": pingToken,
+      "x-claude-code-session-id": CLIENT_SESSION_ID,
+    },
+  });
+  const failPing = (msg) => {
+    if (pingDone) return;
+    pingDone = true;
+    process.stderr.write(`mcp-stdio-shim: --ping: ${msg}\n`);
+    try {
+      pingWs.terminate();
+    } catch {
+      /* ignore */
+    }
+    process.exit(1);
+  };
+  const pingTimer = setTimeout(
+    () => failPing(`timed out after 5s (port ${pingPort})`),
+    5000,
+  );
+  pingWs.on("open", () => {
+    pingWs.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2025-06-18",
+          capabilities: {},
+          clientInfo: { name: "shim-ping", version: "1" },
+        },
+      }),
+    );
+  });
+  pingWs.on("message", (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    if (msg.id === 1) {
+      pingWs.send(
+        JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }),
+      );
+      pingWs.send(
+        JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list" }),
+      );
+    } else if (msg.id === 2) {
+      clearTimeout(pingTimer);
+      pingDone = true;
+      const n =
+        msg.result && Array.isArray(msg.result.tools)
+          ? msg.result.tools.length
+          : "?";
+      process.stdout.write(`bridge OK — port ${pingPort}, ${n} tools\n`);
+      try {
+        pingWs.close();
+      } catch {
+        /* ignore */
+      }
+      process.exit(0);
+    }
+  });
+  pingWs.on("error", (err) => failPing(`connect failed (${err.message})`));
+  pingWs.on("close", (code) =>
+    failPing(`closed before tools/list (code ${code})`),
+  );
+} else if (explicitPort !== null) {
+  // --- Initial connection ---
   connect(explicitPort, explicitToken);
 } else {
   const lockFile = findLockFile();
@@ -398,7 +529,7 @@ if (explicitPort !== null) {
 // Watches ~/.claude/ide/ for .lock file changes. When a new bridge lock appears
 // on a different port, reconnects automatically. This means Claude Desktop never
 // needs to be restarted when the bridge restarts on a new port.
-if (explicitPort === null) {
+if (!pingMode && explicitPort === null) {
   const lockDir = path.join(
     process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"),
     "ide",
@@ -439,52 +570,38 @@ if (explicitPort === null) {
 
 // --- stdin → bridge (newline-delimited JSON-RPC) ---
 // Messages that arrive before the WebSocket is open are queued and flushed on connect.
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", (chunk) => {
-  buffer += chunk;
-  const lines = buffer.split("\n");
-  buffer = lines.pop() ?? "";
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    if (ws && ws.readyState === WebSocket.OPEN) {
-      try {
-        ws.send(trimmed);
-      } catch (sendErr) {
+// Skipped in --ping mode — the one-shot probe manages its own lifecycle and exits.
+if (!pingMode) {
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        try {
+          ws.send(trimmed);
+        } catch (sendErr) {
+          process.stderr.write(
+            `mcp-stdio-shim: ws.send failed (${sendErr.message}) — queuing message.\n`,
+          );
+          if (pendingLines.length < MAX_PENDING_LINES) {
+            pendingLines.push(trimmed);
+          }
+        }
+      } else if (pendingLines.length < MAX_PENDING_LINES) {
+        pendingLines.push(trimmed);
+      } else {
         process.stderr.write(
-          `mcp-stdio-shim: ws.send failed (${sendErr.message}) — queuing message.\n`,
+          `mcp-stdio-shim: pendingLines overflow (${MAX_PENDING_LINES}) — dropping message (bridge not connected)\n`,
         );
-        if (pendingLines.length < MAX_PENDING_LINES) {
-          pendingLines.push(trimmed);
-        }
       }
-    } else if (pendingLines.length < MAX_PENDING_LINES) {
-      pendingLines.push(trimmed);
-    } else {
-      process.stderr.write(
-        `mcp-stdio-shim: pendingLines overflow (${MAX_PENDING_LINES}) — dropping message (bridge not connected)\n`,
-      );
     }
-  }
-});
-
-process.stdin.on("end", () => {
-  if (ws) {
-    try {
-      ws.close();
-    } catch {
-      /* ignore */
-    }
-  }
-  process.exit(0);
-});
+  });
 
-process.stdin.on("error", (err) => {
-  // EPIPE / ERR_STREAM_DESTROYED means the MCP host closed the pipe — clean shutdown.
-  if (err.code === "EPIPE" || err.code === "ERR_STREAM_DESTROYED") {
-    process.stderr.write(
-      `mcp-stdio-shim: stdin closed (${err.code}) — shutting down.\n`,
-    );
+  process.stdin.on("end", () => {
     if (ws) {
       try {
         ws.close();
@@ -493,6 +610,23 @@ process.stdin.on("error", (err) => {
       }
     }
     process.exit(0);
-  }
-  process.stderr.write(`mcp-stdio-shim: stdin error: ${err.message}\n`);
-});
+  });
+
+  process.stdin.on("error", (err) => {
+    // EPIPE / ERR_STREAM_DESTROYED means the MCP host closed the pipe — clean shutdown.
+    if (err.code === "EPIPE" || err.code === "ERR_STREAM_DESTROYED") {
+      process.stderr.write(
+        `mcp-stdio-shim: stdin closed (${err.code}) — shutting down.\n`,
+      );
+      if (ws) {
+        try {
+          ws.close();
+        } catch {
+          /* ignore */
+        }
+      }
+      process.exit(0);
+    }
+    process.stderr.write(`mcp-stdio-shim: stdin error: ${err.message}\n`);
+  });
+}

package/templates/recipes/incident-to-pr.yaml

@@ -0,0 +1,187 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/patchworkos/recipes/main/schema/recipe.v1.json
+apiVersion: patchwork.sh/v1
+version: 1.0.0
+name: incident-to-pr
+description: |
+  FLAGSHIP — the end-to-end AI-native incident-response loop. Turns a
+  production incident into a reviewed, ready-to-merge pull request. Every
+  primitive Patchwork added during the connector + judge→refine campaign
+  shows up here in one pipeline:
+
+    1. investigate — an agent root-causes the incident against THIS repo
+                     using the read/git tools it has via MCP (no writes).
+    2. draft_fix   — an agent writes the smallest correct patch + a PR
+                     title/body. This is the draft the judge reviews.
+    3. review_fix  — a JUDGE step (agent.kind: judge) gives the draft a
+                     cold-eyes senior-engineer review. On `request_changes`
+                     it DRIVES the judge→refine loop: the draft step is
+                     re-run with the judge's fix-list injected, up to
+                     `max_revisions` cycles, until the judge approves. This
+                     is the moat — quality is gated by an AI reviewer, not
+                     by hope.
+    4. open_pr     — an agent opens the PR via the githubCreatePR MCP tool.
+                     Opening a PR is a high-risk WRITE, so the runtime
+                     approval gate pauses here for a human to sign off — the
+                     human-in-the-loop checkpoint before anything lands.
+    5. notify      — posts the PR link + judge verdict to Slack.
+
+  REQUIREMENTS
+    - Bridge running with `--driver subprocess` so the agent steps have MCP
+      tool access (read files, git, githubCreatePR).
+    - GitHub connector connected (for the PR) and Slack connector connected
+      (for the alert) — visit /connections, or `patchwork connect github` /
+      `patchwork connect slack`.
+    - An approval gate of "high" or "all" to exercise the open_pr pause
+      (with the gate off, the PR opens unattended).
+
+  MANUAL RUN
+    patchwork recipe run incident-to-pr \
+      --var INCIDENT_TITLE="checkout 500s on /api/pay" \
+      --var STACK_TRACE="TypeError: cannot read 'id' of undefined at pay.ts:42"
+
+  WEBHOOK CONVERSION (PagerDuty / Sentry / Datadog)
+    Replace the trigger block with:
+      trigger:
+        type: webhook
+        path: /hooks/incident-to-pr
+    and reference {{payload.title}} / {{payload.body}} in place of the vars.
+
+trigger:
+  type: manual
+  vars:
+    - name: INCIDENT_TITLE
+      description: "One-line incident summary (seeds the PR title)"
+      required: true
+    - name: STACK_TRACE
+      description: "Stack trace / error text to root-cause (optional, recommended)"
+      required: false
+    - name: SEVERITY
+      description: "critical | high | medium | low"
+      required: false
+      default: "high"
+    - name: SLACK_CHANNEL
+      description: "Slack channel for the resolution alert"
+      required: false
+      default: "#incidents"
+
+steps:
+  - id: investigate
+    agent:
+      driver: claude-code
+      prompt: |
+        A production incident has fired. Root-cause it against THIS repository.
+
+        Incident: {{INCIDENT_TITLE}}
+        Severity: {{SEVERITY}}
+        Stack trace / error:
+        {{STACK_TRACE}}
+
+        Use the read and git tools available to you — read files, search the
+        codebase, inspect recent commits and run git blame on the implicated
+        files. Do NOT write any files in this step.
+
+        Respond with a concise root-cause analysis containing:
+          - the offending file(s) and line(s)
+          - what is going wrong and why
+          - the commit that most likely introduced it (if identifiable)
+          - the smallest correct fix you would make
+      into: investigation
+    risk: low
+
+  - id: draft_fix
+    awaits:
+      - investigate
+    agent:
+      driver: claude-code
+      prompt: |
+        Using the root-cause analysis below, write a concrete, MINIMAL fix.
+
+        Root-cause analysis:
+        {{investigation}}
+
+        Output exactly these four markdown sections and nothing else:
+
+        ## PR title
+        <conventional-commit-style title, <= 70 chars>
+
+        ## Summary
+        <2-4 sentences: what the bug was and how this change fixes it>
+
+        ## Patch
+        <a unified diff of the smallest change that fixes the root cause —
+         touch as few lines as possible; no drive-by refactors>
+
+        ## Test
+        <the test you would add or modify to prove the fix (a diff), or a
+         short note if existing coverage already exercises the path>
+
+        Do NOT write files in this step — only emit the four sections.
+      into: fix_draft
+    risk: low
+
+  - id: review_fix
+    awaits:
+      - draft_fix
+    agent:
+      kind: judge
+      reviews: fix_draft
+      max_revisions: 2
+      on_exhausted: proceed
+      driver: claude-code
+      prompt: |
+        You are a senior engineer doing a cold-eyes review of the proposed
+        fix below BEFORE it becomes a pull request. Judge it on:
+          - correctness:  does it actually fix the root cause?
+          - minimality:   smallest possible change, nothing unrelated?
+          - safety:       regression risk, edge cases, missing guards?
+          - tests:        is there a test that would FAIL without the fix?
+          - PR hygiene:   clear, accurate title and summary?
+
+        Return a verdict: approve | request_changes | unparseable.
+        If request_changes, list concrete, actionable fixes — each one a
+        specific change the author must make. Those drive the revision loop;
+        the draft is regenerated with your fix-list and re-reviewed.
+      into: review
+    risk: low
+
+  - id: open_pr
+    awaits:
+      - review_fix
+    agent:
+      driver: claude-code
+      prompt: |
+        The fix below has passed judge review. Open a pull request for it.
+
+        Approved fix:
+        {{fix_draft}}
+
+        Do this:
+          1. Create a branch off the default branch named
+             fix/<short-slug-derived-from-the-PR-title>.
+          2. Apply the change from the "## Patch" section and add the test
+             from the "## Test" section.
+          3. Open a pull request using the githubCreatePR tool, with the
+             "## PR title" as the title and the "## Summary" — followed by a
+             line "Fixes incident: {{INCIDENT_TITLE}}" — as the body.
+
+        Opening a PR is a write action; it will pause at the approval gate
+        for a human to confirm before it lands. After it succeeds, respond
+        with ONLY this JSON object (no markdown fences):
+        {"prUrl": "<url>", "prNumber": <number>, "branch": "<branch>"}
+
+        If the GitHub connector is not connected, respond with:
+        {"error": "GitHub connector not connected — visit /connections"}
+      into: pr
+    risk: high
+
+  - id: notify
+    awaits:
+      - open_pr
+    tool: slack.post_message
+    channel: "{{SLACK_CHANNEL}}"
+    text: |
+      :white_check_mark: Incident fix ready for review
+      *Incident:* {{INCIDENT_TITLE}} ({{SEVERITY}})
+      *Pull request:* {{pr}}
+      *Judge review:* {{review}}
+    risk: medium