patchcord 0.6.10 → 0.6.12

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "patchcord",
   "description": "Cross-machine agent messaging. Messages from other agents land in the inbox and wake the agent to reply.",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "author": {
     "name": "ppravdin"
   },

package/bin/patchcord.mjs

@@ -10,6 +10,7 @@ const HOME = homedir();
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pluginRoot = join(__dirname, "..");
+import { resolveProjectBearer, harnessContext } from "../scripts/lib/resolve-project-bearer.mjs";
 const cmd = process.argv[2];
 
 if (cmd === "--version" || cmd === "-v") {
@@ -134,13 +135,7 @@ if (cmd === "plugin-path") {
 // opencode (per-project) + windsurf, gemini, zed, openclaw, antigravity,
 // cline, kimi (global). Each tool stores the bearer in its own shape.
 function _kimiContextRequested(options = {}) {
-  const forceTool = (process.env.PATCHCORD_FORCE_TOOL || process.env.PATCHCORD_TOOL || "").toLowerCase();
-  return options.preferKimi === true
-    || forceTool === "kimi"
-    || Boolean(process.env.KIMI_CLI)
-    || Boolean(process.env.KIMI_SESSION_ID)
-    || Boolean(process.env.KIMI_CONFIG_FILE)
-    || Boolean(process.env.KIMI_MCP_CONFIG_FILE);
+  return harnessContext(process.env, options).preferKimi;
 }
 
 // Strip legacy Python kimi-cli per-project artifacts. Kimi Code (Node) uses
@@ -182,7 +177,73 @@ function _purgeLegacyKimiProjectConfig(dir) {
   } catch {}
 }
 
-// Insert-or-update mcp_servers.patchcord in a Hermes ~/.hermes/config.yaml,
+// Cursor indexes skills from multiple trees. Leftover Codex globals
+// (~/.agents/skills/patchcord*) and Claude colon-named plugin skills bundled
+// inside cursor-agent's node_modules/patchcord both register duplicate slash
+// commands (/patchcordinbox vs /patchcord-inbox). Keep only skills-cursor.
+function _purgeCursorSkillDuplicates() {
+  const staleNames = [
+    "patchcord",
+    "patchcord-inbox",
+    "patchcord-wait",
+    "patchcord-subscribe",
+    "patchcordinbox",
+    "patchcordwait",
+    "patchcordsubscribe",
+    "patchcord:inbox",
+    "patchcord:wait",
+    "patchcord:subscribe",
+  ];
+  for (const root of [
+    join(HOME, ".agents", "skills"),
+    join(HOME, ".cursor", "skills-cursor"),
+  ]) {
+    for (const name of staleNames) {
+      const d = join(root, name);
+      if (!existsSync(d)) continue;
+      try { rmSync(d, { recursive: true, force: true }); } catch {}
+    }
+  }
+  // cursor-agent ships patchcord@* with Claude plugin skills/ — Cursor must not
+  // index those; only per-project skills-cursor copies are valid for Cursor CLI.
+  const cursorAgentRoot = join(HOME, ".local", "share", "cursor-agent");
+  if (existsSync(cursorAgentRoot)) {
+    const walk = (dir, depth = 0) => {
+      if (depth > 8) return;
+      let entries;
+      try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+      for (const ent of entries) {
+        const p = join(dir, ent.name);
+        if (ent.isDirectory()) {
+          if (ent.name === "patchcord" && dir.endsWith("node_modules")) {
+            for (const pluginSkill of ["inbox", "wait", "subscribe"]) {
+              const sd = join(p, "skills", pluginSkill);
+              if (existsSync(sd)) {
+                try { rmSync(sd, { recursive: true, force: true }); } catch {}
+              }
+            }
+            continue;
+          }
+          walk(p, depth + 1);
+        }
+      }
+    };
+    walk(cursorAgentRoot);
+  }
+  const syncManifest = join(HOME, ".cursor", "skills-cursor", ".sync-manifest.json");
+  if (existsSync(syncManifest)) {
+    try {
+      const obj = JSON.parse(readFileSync(syncManifest, "utf-8"));
+      if (obj?.skills) {
+        for (const stale of ["patchcord", "patchcordinbox", "patchcordwait", "patchcordsubscribe", "patchcord:inbox", "patchcord:wait", "patchcord:subscribe"]) {
+          delete obj.skills[stale];
+        }
+        writeFileSync(syncManifest, JSON.stringify(obj, null, 2) + "\n");
+      }
+    } catch {}
+  }
+}
+
 // preserving the rest of the user's YAML. Block-style only (what Hermes writes).
 function upsertHermesConfig(existing, url, token) {
   const block = [
@@ -268,7 +329,9 @@ function readGrokTomlShape(path) {
 
 async function _resolveBearer(options = {}) {
   const { readFileSync } = await import("fs");
-  const preferKimi = _kimiContextRequested(options);
+
+  const projectFound = resolveProjectBearer(process.cwd(), options);
+  if (projectFound) return projectFound;
 
   // Strict JSON first; fall back to JSONC stripping for zed/gemini-style
   // settings (which allow // /* */ trailing commas). The fallback strips
@@ -357,30 +420,6 @@ async function _resolveBearer(options = {}) {
     } catch { return null; }
   };
 
-  // Per-project (walk up from cwd). First win.
-  const kimiProjectReader = (cwd) => readJsonAt(join(cwd, ".kimi", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
-  const kimiCodeProjectReader = (cwd) => readJsonAt(join(cwd, ".kimi-code", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
-  const defaultProjectReaders = [
-    (cwd) => readJsonAt(join(cwd, ".mcp.json"), ["mcpServers", "patchcord"], "claude_code"),
-    (cwd) => readJsonAt(join(cwd, ".cursor", "mcp.json"), ["mcpServers", "patchcord"], "cursor"),
-    (cwd) => readJsonAt(join(cwd, ".vscode", "mcp.json"), ["servers", "patchcord"], "vscode"),
-    (cwd) => readJsonAt(join(cwd, "opencode.json"), ["mcp", "patchcord"], "opencode"),
-    (cwd) => readJsonAt(join(cwd, ".agents", "mcp_config.json"), ["mcpServers", "patchcord"], "antigravity"),
-    (cwd) => readGrokTomlShape(join(cwd, ".grok", "config.toml")),
-    (cwd) => readCodexTomlShape(join(cwd, ".codex", "config.toml")),
-  ];
-  const projectReaders = preferKimi
-    ? [kimiProjectReader, kimiCodeProjectReader, ...defaultProjectReaders]
-    : [...defaultProjectReaders, kimiProjectReader, kimiCodeProjectReader];
-  let dir = process.cwd();
-  while (dir && dir !== "/") {
-    for (const r of projectReaders) {
-      const found = r(dir);
-      if (found) { found.scope = "project"; return found; }
-    }
-    dir = dirname(dir);
-  }
-
   // Global fallbacks. Order by likelihood for current install base.
   const zedPath = process.platform === "darwin"
     ? join(HOME, "Library", "Application Support", "Zed", "settings.json")
@@ -1809,6 +1848,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   const cursorSkillsRoot = join(HOME, ".cursor", "skills-cursor");
   const hasCursorAgent = run("which cursor-agent");
   if (hasCursorAgent || existsSync(cursorSkillsRoot)) {
+    _purgeCursorSkillDuplicates();
     mkdirSync(cursorSkillsRoot, { recursive: true });
     const cursorInboxDir = join(cursorSkillsRoot, "patchcord-inbox");
     const cursorWaitDir = join(cursorSkillsRoot, "patchcord-wait");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.6.10",
+  "version": "0.6.12",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
   "scripts": {
     "version": "node scripts/sync-plugin-version.mjs && git add .claude-plugin/plugin.json"

package/scripts/lib/resolve-project-bearer.mjs

@@ -0,0 +1,200 @@
+// Shared per-project bearer resolution for patchcord.mjs and subscribe.mjs.
+// When multiple tool configs exist in one directory (common: .mcp.json from
+// Claude Code + .cursor/mcp.json from Cursor), pick the config matching the
+// invoking harness instead of always preferring .mcp.json first.
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+function stripJsoncOutsideStrings(raw) {
+  let out = "";
+  let i = 0;
+  let inStr = false;
+  let strCh = "";
+  let prev = "";
+  while (i < raw.length) {
+    const c = raw[i];
+    if (inStr) {
+      out += c;
+      if (c === strCh && prev !== "\\") inStr = false;
+      prev = c;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      inStr = true;
+      strCh = c;
+      out += c;
+      prev = c;
+      i++;
+      continue;
+    }
+    if (c === "/" && raw[i + 1] === "/") {
+      while (i < raw.length && raw[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && raw[i + 1] === "*") {
+      i += 2;
+      while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += c;
+    prev = c;
+    i++;
+  }
+  return out.replace(/,(\s*[}\]])/g, "$1");
+}
+
+function parseJsonc(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {}
+  return JSON.parse(stripJsoncOutsideStrings(raw));
+}
+
+function extractBearer(entry) {
+  if (!entry) return null;
+  const auth = entry?.headers?.Authorization;
+  const url = entry.url || entry.httpUrl || entry.serverUrl;
+  if (!auth || !url) return null;
+  return {
+    token: auth.replace(/^Bearer\s+/i, ""),
+    baseUrl: url.replace(/\/mcp(\/bearer)?$/, ""),
+  };
+}
+
+function readJsonAt(path, keyPath, tool) {
+  if (!existsSync(path)) return null;
+  try {
+    const obj = parseJsonc(readFileSync(path, "utf-8"));
+    const entry = keyPath.reduce((o, k) => o?.[k], obj);
+    const b = extractBearer(entry);
+    return b ? { ...b, configFile: path, tool } : null;
+  } catch {
+    return null;
+  }
+}
+
+function 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,
+      tool: "codex",
+    };
+  } catch {
+    return null;
+  }
+}
+
+function readGrokTomlShape(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const content = readFileSync(path, "utf-8");
+    const header = content.match(/^\[mcp_servers\.patchcord(?:[-\w]*)?\]\s*$/m);
+    if (!header) return null;
+    const rest = content.slice(header.index + header[0].length);
+    const nextSection = rest.search(/^\[(?!mcp_servers\.patchcord(?:\.|[-\w]*\]))/m);
+    const block = nextSection === -1 ? rest : rest.slice(0, nextSection);
+    const urlMatch = block.match(/^\s*url\s*=\s*["']([^"']+)["']/m);
+    const tokenMatch = block.match(/["']?Authorization["']?\s*=\s*["']Bearer\s+([^"']+)["']/i);
+    if (!urlMatch || !tokenMatch) return null;
+    return {
+      token: tokenMatch[1],
+      baseUrl: urlMatch[1].replace(/\/mcp(\/bearer)?$/, ""),
+      configFile: path,
+      tool: "grok",
+    };
+  } catch {
+    return null;
+  }
+}
+
+const claudeReader = (cwd) => readJsonAt(join(cwd, ".mcp.json"), ["mcpServers", "patchcord"], "claude_code");
+const cursorReader = (cwd) => readJsonAt(join(cwd, ".cursor", "mcp.json"), ["mcpServers", "patchcord"], "cursor");
+const vscodeReader = (cwd) => readJsonAt(join(cwd, ".vscode", "mcp.json"), ["servers", "patchcord"], "vscode");
+const opencodeReader = (cwd) => readJsonAt(join(cwd, "opencode.json"), ["mcp", "patchcord"], "opencode");
+const antigravityReader = (cwd) => readJsonAt(join(cwd, ".agents", "mcp_config.json"), ["mcpServers", "patchcord"], "antigravity");
+const grokReader = (cwd) => readGrokTomlShape(join(cwd, ".grok", "config.toml"));
+const codexReader = (cwd) => readCodexTomlShape(join(cwd, ".codex", "config.toml"));
+const kimiReader = (cwd) => readJsonAt(join(cwd, ".kimi", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
+const kimiCodeReader = (cwd) => readJsonAt(join(cwd, ".kimi-code", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
+
+/** Detect which harness launched this process (env + explicit overrides). */
+export function harnessContext(env = process.env, options = {}) {
+  const forceTool = (env.PATCHCORD_FORCE_TOOL || env.PATCHCORD_TOOL || "").toLowerCase();
+  const preferKimi =
+    options.preferKimi === true
+    || forceTool === "kimi"
+    || Boolean(env.KIMI_CLI)
+    || Boolean(env.KIMI_SESSION_ID)
+    || Boolean(env.KIMI_CONFIG_FILE)
+    || Boolean(env.KIMI_MCP_CONFIG_FILE);
+  const preferCursor =
+    options.preferCursor === true
+    || forceTool === "cursor"
+    || Boolean(env.CURSOR_AGENT);
+  return { forceTool, preferKimi, preferCursor };
+}
+
+/** Ordered per-project readers for the active harness. */
+export function projectReadersForContext(ctx) {
+  const defaultReaders = [
+    claudeReader,
+    cursorReader,
+    vscodeReader,
+    opencodeReader,
+    antigravityReader,
+    grokReader,
+    codexReader,
+  ];
+  const kimiReaders = [kimiReader, kimiCodeReader];
+
+  if (ctx.preferKimi) {
+    return [...kimiReaders, ...defaultReaders];
+  }
+  if (ctx.preferCursor) {
+    // Cursor CLI/IDE: .cursor/mcp.json must win over stale .mcp.json in the
+    // same repo (e.g. leftover Claude Code token from an old provision).
+    return [
+      cursorReader,
+      vscodeReader,
+      opencodeReader,
+      antigravityReader,
+      grokReader,
+      codexReader,
+      claudeReader,
+      ...kimiReaders,
+    ];
+  }
+  return [...defaultReaders, ...kimiReaders];
+}
+
+/** Walk up from startDir; return first matching project bearer or null. */
+export function resolveProjectBearer(startDir, options = {}) {
+  const ctx = harnessContext(process.env, options);
+  const readers = projectReadersForContext(ctx);
+  let dir = startDir;
+  while (dir && dir !== "/") {
+    for (const r of readers) {
+      const found = r(dir);
+      if (found) {
+        found.scope = "project";
+        return found;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}

package/scripts/subscribe.mjs

@@ -13,6 +13,7 @@ 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";
+import { resolveProjectBearer } from "./lib/resolve-project-bearer.mjs";
 
 // --- Hermes webhook bridge mode -------------------------------------------
 // Default mode writes "PATCHCORD: ..." lines to stdout for Claude Code's
@@ -70,35 +71,15 @@ function die(msg, code = 1) {
 
 function readMcpConfig(cwd) {
   // Prefer env vars injected by patchcord.mjs, which already ran _resolveBearer()
-  // and supports all 12 tool configs (Claude Code, OpenCode, Codex, Cursor, Kimi, etc.).
+  // and supports all tool configs with harness-aware ordering.
   if (process.env.PATCHCORD_BASE_URL && process.env.PATCHCORD_BEARER_TOKEN) {
     return { baseUrl: process.env.PATCHCORD_BASE_URL, token: process.env.PATCHCORD_BEARER_TOKEN };
   }
-  // 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;
+  const found = resolveProjectBearer(cwd);
+  if (!found) {
+    die(`no patchcord config found — run from a project directory or use 'patchcord subscribe'`);
   }
-  die(`no patchcord config found — run from a project directory or use 'patchcord subscribe'`);
+  return { baseUrl: found.baseUrl, token: found.token };
 }
 
 function httpJson(urlStr, { method = "GET", headers = {}, body = null } = {}) {