patchcord 0.5.31 → 0.5.33

package/bin/patchcord.mjs

@@ -67,7 +67,7 @@ Usage:
   npx patchcord@latest --token <token>                    Self-hosted / CI setup
   npx patchcord@latest --token <token> --server <url>     Self-hosted with custom server
   npx patchcord@latest --full                             Same + full statusline
-  npx patchcord@latest --rename <new-name>                Rename this agent (paste from dashboard)
+  npx patchcord@latest --rename <new-name> [--tool <slug>] Rename this agent (paste from dashboard)
   npx patchcord@latest skill apply                        Fetch custom skill from web console`);
   process.exit(0);
 }
@@ -77,47 +77,110 @@ if (cmd === "plugin-path") {
   process.exit(0);
 }
 
-// ── --rename <new> [--expect-token <prefix>] ────────────────────
-// Renames the agent in cwd's .mcp.json. Dashboard generates the full
-// pasted command including --expect-token to prevent wrong-machine paste.
+// ── --rename <new> [--tool <slug>] [--expect-token <prefix>] ────
+// Renames the agent's bearer in its tool's per-project config. Supported
+// tools: claude_code, codex, cursor, vscode, opencode. Dashboard generates
+// the full pasted command including --tool (so we read the right file)
+// and --expect-token (sha256 prefix, prevents wrong-machine paste).
 {
   const renameIdx = process.argv.indexOf("--rename");
   if (renameIdx !== -1) {
     const newName = (process.argv[renameIdx + 1] || "").trim().toLowerCase();
     const expectIdx = process.argv.indexOf("--expect-token");
     const expectPrefix = expectIdx !== -1 ? (process.argv[expectIdx + 1] || "").trim() : "";
+    const toolIdx = process.argv.indexOf("--tool");
+    const tool = toolIdx !== -1 ? (process.argv[toolIdx + 1] || "").trim().toLowerCase() : "";
 
     if (!newName || !/^[a-z][a-z0-9-]{1,49}$/.test(newName)) {
-      console.error("Usage: npx patchcord@latest --rename <new-name> [--expect-token <prefix>]");
-      console.error("       <new-name> must be lowercase letters, digits, dashes; 2-50 chars");
+      console.error("Usage: npx patchcord@latest --rename <new-name> [--tool <slug>] [--expect-token <prefix>]");
+      console.error("       <new-name>: lowercase letters, digits, dashes; 2-50 chars");
+      console.error("       <slug>: claude_code | codex | cursor | vscode | opencode");
       process.exit(1);
     }
 
-    const cwd = process.cwd();
-    let mcpJson = null;
-    let dir = cwd;
-    while (dir && dir !== "/") {
-      const p = join(dir, ".mcp.json");
-      if (existsSync(p)) { mcpJson = p; break; }
-      dir = dirname(dir);
-    }
-    if (!mcpJson) {
-      console.error(`No .mcp.json found above ${cwd}. Run from your patchcord project folder.`);
+    const { readFileSync } = await import("fs");
+
+    // Per-tool token readers. Each returns {token, baseUrl, configFile} or null.
+    const readMcpJsonShape = (path, key = "mcpServers") => {
+      if (!existsSync(path)) return null;
+      try {
+        const obj = JSON.parse(readFileSync(path, "utf-8"));
+        const pt = obj?.[key]?.patchcord;
+        if (!pt?.headers?.Authorization || !pt?.url) return null;
+        return {
+          token: pt.headers.Authorization.replace(/^Bearer\s+/i, ""),
+          baseUrl: pt.url.replace(/\/mcp(\/bearer)?$/, ""),
+          configFile: path,
+        };
+      } catch { return null; }
+    };
+    const readOpenCodeShape = (path) => {
+      if (!existsSync(path)) return null;
+      try {
+        const obj = JSON.parse(readFileSync(path, "utf-8"));
+        const pt = obj?.mcp?.patchcord;
+        if (!pt?.headers?.Authorization || !pt?.url) return null;
+        return {
+          token: pt.headers.Authorization.replace(/^Bearer\s+/i, ""),
+          baseUrl: pt.url.replace(/\/mcp(\/bearer)?$/, ""),
+          configFile: path,
+        };
+      } catch { return null; }
+    };
+    const readCodexTomlShape = (path) => {
+      if (!existsSync(path)) return null;
+      try {
+        const content = readFileSync(path, "utf-8");
+        const block = content.match(/\[mcp_servers\.patchcord[-\w]*\]([\s\S]*?)(?=\n\[|$)/);
+        if (!block) return null;
+        const urlMatch = block[1].match(/url\s*=\s*"([^"]+)"/);
+        const tokenMatch = block[1].match(/Bearer\s+([^\s"]+)/);
+        if (!urlMatch || !tokenMatch) return null;
+        return {
+          token: tokenMatch[1],
+          baseUrl: urlMatch[1].replace(/\/mcp(\/bearer)?$/, ""),
+          configFile: path,
+        };
+      } catch { return null; }
+    };
+
+    const READERS = {
+      claude_code: (cwd) => readMcpJsonShape(join(cwd, ".mcp.json")),
+      cursor:      (cwd) => readMcpJsonShape(join(cwd, ".cursor", "mcp.json")),
+      vscode:      (cwd) => readMcpJsonShape(join(cwd, ".vscode", "mcp.json"), "servers"),
+      opencode:    (cwd) => readOpenCodeShape(join(cwd, "opencode.json")),
+      codex:       (cwd) => readCodexTomlShape(join(cwd, ".codex", "config.toml")),
+    };
+
+    if (tool && !READERS[tool]) {
+      console.error(`✗ Rename not supported for --tool=${tool}.`);
+      console.error(`  Supported: ${Object.keys(READERS).join(", ")}.`);
+      console.error(`  This usually means the tool stores its config in a global location`);
+      console.error(`  not yet wired up to --rename. Open an issue.`);
       process.exit(1);
     }
 
-    const { readFileSync } = await import("fs");
-    let config;
-    try {
-      config = JSON.parse(readFileSync(mcpJson, "utf-8"));
-    } catch (e) {
-      console.error(`Cannot parse ${mcpJson}: ${e.message}`);
+    // Walk up from cwd looking for any supported config. If --tool given,
+    // only check that tool; otherwise try all in priority order.
+    const cwd = process.cwd();
+    const tryReaders = tool ? [READERS[tool]] : Object.values(READERS);
+    let found = null;
+    let dir = cwd;
+    while (dir && dir !== "/" && !found) {
+      for (const r of tryReaders) {
+        const result = r(dir);
+        if (result) { found = result; break; }
+      }
+      if (!found) dir = dirname(dir);
+    }
+    if (!found) {
+      const whichFile = tool
+        ? `the ${tool} config file in or above ${cwd}`
+        : `any supported tool config (.mcp.json, .cursor/mcp.json, .vscode/mcp.json, opencode.json, .codex/config.toml) above ${cwd}`;
+      console.error(`No patchcord bearer found in ${whichFile}. Run from the agent's project folder.`);
       process.exit(1);
     }
-    const mcpUrl = config?.mcpServers?.patchcord?.url || "";
-    const auth = config?.mcpServers?.patchcord?.headers?.Authorization || "";
-    const baseUrl = mcpUrl.replace(/\/mcp(\/bearer)?$/, "");
-    const token = auth.replace(/^Bearer\s+/, "");
+    const { token, baseUrl, configFile: mcpJson } = found;
 
     if (!baseUrl || !token || !isSafeToken(token) || !isSafeUrl(baseUrl)) {
       console.error(`Cannot read patchcord URL/token from ${mcpJson}.`);

package/package.json

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

package/scripts/subscribe.mjs

@@ -23,19 +23,27 @@ const RECONNECT_BACKOFF_MS = [1000, 2000, 4000, 8000, 15_000, 30_000];
 const FRESHNESS_CHECK_INTERVAL_MS = 30_000;
 const FRESHNESS_STALE_MS = 90_000;
 
+// Short HH:MM:SS prefix so the Monitor output can be scanned at a glance.
+// Local time — Monitor's reader is always a human looking at one machine.
+function logErr(msg) {
+  const d = new Date();
+  const ts = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+  process.stderr.write(`[${ts}] ${msg}\n`);
+}
+
 // Guarantee a terminal stderr line on any unhandled failure so the agent
 // reading Monitor's output file always sees WHY the process died.
 process.on("uncaughtException", (err) => {
-  process.stderr.write(`subscribe: fatal: uncaught: ${err?.stack || err?.message || err}\n`);
+  logErr(`subscribe: fatal: uncaught: ${err?.stack || err?.message || err}`);
   process.exit(1);
 });
 process.on("unhandledRejection", (err) => {
-  process.stderr.write(`subscribe: fatal: unhandled rejection: ${err?.stack || err?.message || err}\n`);
+  logErr(`subscribe: fatal: unhandled rejection: ${err?.stack || err?.message || err}`);
   process.exit(1);
 });
 
 function die(msg, code = 1) {
-  process.stderr.write(msg + "\n");
+  logErr(msg);
   process.exit(code);
 }
 
@@ -178,7 +186,7 @@ function removePidfile(path) {
 async function run() {
   const cwd = process.cwd();
   const { baseUrl, token } = readMcpConfig(cwd);
-  process.stderr.write(`subscribe: cwd=${cwd} server=${baseUrl}\n`);
+  logErr(`subscribe: cwd=${cwd} server=${baseUrl}`);
 
   let ticket = await fetchTicket(baseUrl, token);
   const pidfile = `/tmp/patchcord_subscribe_${ticket.namespace_ids[0]}_${ticket.agent_id}.pid`;
@@ -195,9 +203,7 @@ async function run() {
     process.exit(0);
   });
 
-  process.stderr.write(
-    `subscribe: agent=${ticket.agent_id} namespaces=${ticket.namespace_ids.join(",")}\n`
-  );
+  logErr(`subscribe: agent=${ticket.agent_id} namespaces=${ticket.namespace_ids.join(",")}`);
 
   let backoffIdx = 0;
 
@@ -210,16 +216,16 @@ async function run() {
         });
         backoffIdx = 0; // clean disconnect resets backoff
       } catch (e) {
-        process.stderr.write(`subscribe: ${e.message}\n`);
+        logErr(`subscribe: ${e.message}`);
       }
       const delay = RECONNECT_BACKOFF_MS[Math.min(backoffIdx, RECONNECT_BACKOFF_MS.length - 1)];
       backoffIdx++;
-      process.stderr.write(`subscribe: reconnecting in ${delay}ms\n`);
+      logErr(`subscribe: reconnecting in ${delay}ms`);
       await new Promise((r) => setTimeout(r, delay));
       try {
         ticket = await fetchTicket(baseUrl, token);
       } catch (e) {
-        process.stderr.write(`subscribe: ticket refresh failed: ${e.message}\n`);
+        logErr(`subscribe: ticket refresh failed: ${e.message}`);
       }
     }
   };
@@ -255,7 +261,7 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
     };
 
     ws.on("open", () => {
-      process.stderr.write("subscribe: connected\n");
+      logErr("subscribe: connected");
       for (const topic of ticket.topics) {
         ws.send(
           JSON.stringify({
@@ -277,7 +283,7 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
       // failure here just means we miss queued messages this round;
       // the next reconnect retries.
       drainQueueOnce(baseUrl, token).catch((e) => {
-        process.stderr.write(`subscribe: queue check failed: ${e.message}\n`);
+        logErr(`subscribe: queue check failed: ${e.message}`);
       });
       heartbeatTimer = setInterval(() => {
         try {
@@ -300,9 +306,7 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
       freshnessTimer = setInterval(() => {
         const stale = Date.now() - lastEventAt;
         if (stale > FRESHNESS_STALE_MS) {
-          process.stderr.write(
-            `subscribe: ws stale ${Math.round(stale / 1000)}s, forcing reconnect\n`
-          );
+          logErr(`subscribe: ws stale ${Math.round(stale / 1000)}s, forcing reconnect`);
           done(new Error(`ws stale ${Math.round(stale / 1000)}s`));
         }
       }, FRESHNESS_CHECK_INTERVAL_MS);
@@ -340,13 +344,16 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
               })
             );
           }
-          process.stderr.write("subscribe: token refreshed\n");
+          // Routine refresh success — don't log. Over days this fills the
+          // Monitor output with ~250 identical lines and buries the rare
+          // interesting events (connects, errors). Refresh failures DO log,
+          // because those are the ones worth scanning for.
           scheduleRefresh(fresh.jwt_expires_in);
         } catch (e) {
           // Transient network/server error — do NOT close the live
           // connection. The current JWT is still valid for ~2 more min
           // (JWT_REFRESH_SAFETY_MARGIN_SEC). Retry sooner.
-          process.stderr.write(`subscribe: token refresh failed, retrying in 30s: ${e.message}\n`);
+          logErr(`subscribe: token refresh failed, retrying in 30s: ${e.message}`);
           refreshTimer = setTimeout(doRefresh, 30_000);
         }
       };
@@ -384,20 +391,20 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
     });
 
     ws.on("error", (err) => {
-      process.stderr.write(`subscribe: ws error: ${err.message}\n`);
+      logErr(`subscribe: ws error: ${err.message}`);
       done(err);
     });
 
     ws.on("close", (info) => {
       const codeStr = info?.code != null ? `code=${info.code}` : "code=none";
       const reasonStr = info?.reason ? ` reason=${JSON.stringify(info.reason)}` : "";
-      process.stderr.write(`subscribe: ws closed (${codeStr}${reasonStr})\n`);
+      logErr(`subscribe: ws closed (${codeStr}${reasonStr})`);
       done();
     });
   });
 }
 
 run().catch((e) => {
-  process.stderr.write(`subscribe: fatal: ${e.message}\n`);
+  logErr(`subscribe: fatal: ${e.message}`);
   process.exit(1);
 });