patchcord 0.5.60 → 0.5.62

package/bin/patchcord.mjs

@@ -457,16 +457,26 @@ if (cmd === "upload") {
 // of a wall of bash. subscribe.mjs handles its own pidfile guard
 // (exits with code 2 + "already running" if another listener is up),
 // so this command needs zero pre-checks.
+//
+// We resolve the bearer here (all 11 tool configs) and inject it as
+// env vars so subscribe.mjs works regardless of which MCP client is
+// running — OpenCode, Codex, Cursor, etc. — not just Claude Code.
 if (cmd === "subscribe") {
   const subscribeScript = join(pluginRoot, "scripts", "subscribe.mjs");
   if (!existsSync(subscribeScript)) {
     console.error(`subscribe.mjs not found at ${subscribeScript}`);
     process.exit(1);
   }
+  const bearerInfo = await _resolveBearer();
+  const spawnEnv = { ...process.env };
+  if (bearerInfo) {
+    spawnEnv.PATCHCORD_BASE_URL = bearerInfo.baseUrl;
+    spawnEnv.PATCHCORD_BEARER_TOKEN = bearerInfo.token;
+  }
   const { spawnSync } = await import("child_process");
   const result = spawnSync(process.execPath, [subscribeScript], {
     stdio: "inherit",
-    env: process.env,
+    env: spawnEnv,
   });
   process.exit(result.status ?? (result.signal ? 1 : 0));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.5.60",
+  "version": "0.5.62",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
   "author": "ppravdin",
   "license": "MIT",

package/scripts/subscribe.mjs

@@ -11,6 +11,7 @@ import { readFileSync, writeFileSync, unlinkSync, existsSync } from "node:fs";
 import { request as httpsRequest } from "node:https";
 import { request as httpRequest } from "node:http";
 import { URL } from "node:url";
+import { dirname } from "node:path";
 import { connect as wsConnect } from "./lib/ws.mjs";
 
 const JWT_REFRESH_SAFETY_MARGIN_SEC = 120;
@@ -53,24 +54,36 @@ function die(msg, code = 1) {
 }
 
 function readMcpConfig(cwd) {
-  const path = `${cwd}/.mcp.json`;
-  if (!existsSync(path)) die(`no .mcp.json in ${cwd}`);
-  let json;
-  try {
-    json = JSON.parse(readFileSync(path, "utf8"));
-  } catch (e) {
-    die(`.mcp.json parse error: ${e.message}`);
+  // Prefer env vars injected by patchcord.mjs, which already ran _resolveBearer()
+  // and supports all 11 tool configs (Claude Code, OpenCode, Codex, Cursor, etc.).
+  if (process.env.PATCHCORD_BASE_URL && process.env.PATCHCORD_BEARER_TOKEN) {
+    return { baseUrl: process.env.PATCHCORD_BASE_URL, token: process.env.PATCHCORD_BEARER_TOKEN };
   }
-  const pc = json?.mcpServers?.patchcord;
-  if (!pc?.url || !pc?.headers?.Authorization) {
-    die(".mcp.json missing mcpServers.patchcord.url or Authorization");
+  // Fallback: direct invocation — try .mcp.json walking up from cwd.
+  let dir = cwd;
+  while (dir && dir !== "/") {
+    const path = `${dir}/.mcp.json`;
+    if (existsSync(path)) {
+      let json;
+      try {
+        json = JSON.parse(readFileSync(path, "utf8"));
+      } catch (e) {
+        die(`.mcp.json parse error: ${e.message}`);
+      }
+      const pc = json?.mcpServers?.patchcord;
+      if (!pc?.url || !pc?.headers?.Authorization) {
+        die(".mcp.json missing mcpServers.patchcord.url or Authorization");
+      }
+      let baseUrl = pc.url.replace(/\/mcp\/bearer$/, "").replace(/\/mcp$/, "");
+      const auth = pc.headers.Authorization;
+      const token = auth.startsWith("Bearer ") ? auth.slice(7) : auth;
+      return { baseUrl, token };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
-  let baseUrl = pc.url;
-  // Strip known MCP path suffixes to get the API base
-  baseUrl = baseUrl.replace(/\/mcp\/bearer$/, "").replace(/\/mcp$/, "");
-  const auth = pc.headers.Authorization;
-  const token = auth.startsWith("Bearer ") ? auth.slice(7) : auth;
-  return { baseUrl, token };
+  die(`no patchcord config found — run from a project directory or use 'patchcord subscribe'`);
 }
 
 function httpJson(urlStr, { method = "GET", headers = {}, body = null } = {}) {
@@ -393,6 +406,43 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
       } catch {
         return;
       }
+
+      // Surface channel-state failures so silent server-side channel
+      // termination becomes visible. Previously we discarded every
+      // non-postgres_changes frame, which masked phx_join rejections,
+      // channel_error system messages, and post-refresh access_token
+      // rejections — exactly the cases where the WS stays "open" but
+      // realtime delivery is dead. Force a reconnect on any of those.
+      if (frame.event === "phx_reply") {
+        const status = frame.payload?.status;
+        if (status === "error") {
+          const reason = frame.payload?.response?.reason || frame.payload?.response || "unknown";
+          logErr(`subscribe: phx_reply error on topic=${frame.topic} ref=${frame.ref}: ${JSON.stringify(reason)}`);
+          done(new Error(`phx_reply error: ${JSON.stringify(reason)}`));
+          return;
+        }
+        return;
+      }
+      if (frame.event === "system") {
+        const status = frame.payload?.status;
+        const message = frame.payload?.message || frame.payload?.extension || "";
+        if (status === "error" || status === "channel_error") {
+          logErr(`subscribe: system error on topic=${frame.topic}: ${message}`);
+          done(new Error(`system error: ${message}`));
+          return;
+        }
+        // Successful subscribe ack — log once for confirmation, then quiet.
+        if (status === "ok" && message) {
+          logErr(`subscribe: system ok on ${frame.topic}: ${message}`);
+        }
+        return;
+      }
+      if (frame.event === "phx_error" || frame.event === "phx_close") {
+        logErr(`subscribe: ${frame.event} on topic=${frame.topic}: ${JSON.stringify(frame.payload || {})}`);
+        done(new Error(`${frame.event} on ${frame.topic}`));
+        return;
+      }
+
       if (frame.event !== "postgres_changes") return;
       const data = frame.payload?.data;
       if (!data || data.type !== "INSERT") return;