patchcord 0.5.122 → 0.5.124

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.5.122",
+  "version": "0.5.124",
   "author": {
     "name": "ppravdin"
   },

package/bin/patchcord.mjs

@@ -349,18 +349,19 @@ async function _resolveBearer(options = {}) {
     );
   })();
 
-  // NO global kimi/kimi-code reader. Kimi is a PER-PROJECT identity
-  // (.kimi-code/mcp.json in the worktree); a global ~/.kimi(-code)/mcp.json would
-  // make a leftover token hijack every kimi session everywhere. A kimi outside a
+  // NO global reader for PER-PROJECT tools. Kimi (.kimi-code/mcp.json) and
+  // Antigravity (.agents/mcp_config.json) are per-project identities: a leftover
+  // token in a global config (~/.kimi(-code)/mcp.json, ~/.gemini/antigravity/
+  // mcp_config.json) would hijack every session everywhere and make the agent
+  // "check inbox" in projects it has nothing to do with. Such a tool outside a
   // patchcord worktree is simply not an agent. (The tools below are global-ONLY
-  // by nature — Windsurf/Gemini/Zed/etc. store MCP config globally — so they keep
-  // their global readers.)
+  // by nature — Windsurf/Gemini CLI/Zed/etc. store MCP config globally — so they
+  // keep their global readers.)
   const defaultGlobalCandidates = [
     () => readJsonAt(join(HOME, ".codeium", "windsurf", "mcp_config.json"), ["mcpServers", "patchcord"], "windsurf"),
     () => readJsonAt(join(HOME, ".gemini", "settings.json"), ["mcpServers", "patchcord"], "gemini"),
     () => readJsonAt(zedPath, ["context_servers", "patchcord"], "zed"),
     () => readJsonAt(join(HOME, ".openclaw", "openclaw.json"), ["mcp", "servers", "patchcord"], "openclaw"),
-    () => readJsonAt(join(HOME, ".gemini", "antigravity", "mcp_config.json"), ["mcpServers", "patchcord"], "antigravity"),
     () => readHermesShape(join(HOME, ".hermes", "config.yaml")),
     ...clinePaths.map((p) => () => readJsonAt(p, ["mcpServers", "patchcord"], "cline")),
   ];
@@ -596,7 +597,7 @@ if (cmd === "subscribe") {
   const forceKimi = args.includes("--kimi");
   const intervalArg = args.find((a) => a !== "--kimi") || "30";
 
-  // Kimi CLI uses polling instead of WebSocket realtime.
+  // Kimi Code uses polling instead of WebSocket realtime.
   // Force Kimi mode with --kimi flag, or auto-detect from bearer config.
   let isKimi = forceKimi;
   let bearerInfo = null;
@@ -606,13 +607,15 @@ if (cmd === "subscribe") {
   }
 
   if (isKimi) {
+    const kimiCodeHome = process.env.KIMI_CODE_HOME || join(HOME, ".kimi-code");
     // Remove old combined skill so only patchcord:inbox/subscribe/wait appear
-    const oldKimiSkillDir = join(HOME, ".kimi", "skills", "patchcord");
-    if (existsSync(oldKimiSkillDir)) {
-      try { rmSync(oldKimiSkillDir, { recursive: true, force: true }); } catch {}
+    for (const oldSkillRoot of [join(kimiCodeHome, "skills", "patchcord"), join(HOME, ".kimi", "skills", "patchcord")]) {
+      if (existsSync(oldSkillRoot)) {
+        try { rmSync(oldSkillRoot, { recursive: true, force: true }); } catch {}
+      }
     }
 
-    const kimiSubScript = join(HOME, ".kimi", "patchcord-subscribe.sh");
+    const kimiSubScript = join(kimiCodeHome, "patchcord-subscribe.sh");
     if (!existsSync(kimiSubScript)) {
       console.error(`Kimi subscribe script not found at ${kimiSubScript}`);
       console.error(`Run npx patchcord@latest to install it.`);
@@ -835,7 +838,7 @@ if (cmd === "subscribe") {
 // ── main flow: global setup + project setup (or just install/agent for back-compat) ──
 // Any --flag enters this branch so equals-form (--token=foo, --tool=foo, --server=foo)
 // works the same as the space-form (--token foo). The internal flag parsing below
-// supports both. Non-flag commands (channel, init, skill, help, plugin-path) have
+// supports both. Non-flag commands (init, skill, help, plugin-path) have
 // their own branches above and below.
 // ── CLI account auth + orchestrator/team/provisioning/schedule ─────────────
 // These commands act on the user's ACCOUNT, so they require CLI login. The
@@ -1667,13 +1670,33 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     if (windsurfChanged) globalChanges.push("Windsurf skills installed");
   }
 
-  // Gemini CLI + Antigravity (they SHARE ~/.gemini/skills and ~/.gemini/commands).
-  // Seed the patchcord skill ONLY when patchcord MCP is actually configured for
-  // one of these surfaces. Otherwise a bare session (esp. Antigravity, which
-  // inherits this dir) reads a skill with no backing MCP tool and improvises
-  // destructively — scavenging other agents' bearer tokens off disk and curling
-  // the API. Invariant: skill present ⟺ patchcord MCP present under ~/.gemini.
+  // Gemini CLI + Antigravity SHARE ~/.gemini/skills and ~/.gemini/commands, but
+  // their MCP config is NOT shared: Gemini CLI stores patchcord globally
+  // (~/.gemini/settings.json) while Antigravity is PER-PROJECT
+  // (<project>/.agents/mcp_config.json). So the shared global skill must be
+  // seeded ONLY off Gemini CLI's global config — never off an Antigravity config.
+  // A patchcord entry in the global ~/.gemini/antigravity(-cli)/mcp_config.json is
+  // a leaked per-project token: it makes agy load the patchcord MCP (and its
+  // "check inbox first" instruction) in EVERY project, and it kept this skill
+  // seeded everywhere. We strip that leak below and gate the skill on Gemini only.
   if (existsSync(join(HOME, ".gemini"))) {
+    // Remove any leaked patchcord server from Antigravity's GLOBAL configs so a
+    // per-project token stops hijacking every agy session. Preserve other MCP
+    // servers; only drop patchcord.
+    for (const agGlobal of [
+      join(HOME, ".gemini", "antigravity", "mcp_config.json"),
+      join(HOME, ".gemini", "antigravity-cli", "mcp_config.json"),
+    ]) {
+      if (!existsSync(agGlobal)) continue;
+      try {
+        const j = JSON.parse(readFileSync(agGlobal, "utf-8"));
+        if (j?.mcpServers?.patchcord) {
+          delete j.mcpServers.patchcord;
+          writeFileSync(agGlobal, JSON.stringify(j, null, 2) + "\n");
+          globalChanges.push("Removed leaked global Antigravity patchcord MCP (agy is per-project)");
+        }
+      } catch {}
+    }
     // true = configured, false = file absent (definitely not), null = unparseable (unknown)
     const hasPatchcordMcp = (p, keyPath) => {
       if (!existsSync(p)) return false;
@@ -1682,8 +1705,6 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     };
     const checks = [
       hasPatchcordMcp(join(HOME, ".gemini", "settings.json"), ["mcpServers", "patchcord"]),
-      hasPatchcordMcp(join(HOME, ".gemini", "antigravity", "mcp_config.json"), ["mcpServers", "patchcord"]),
-      hasPatchcordMcp(join(HOME, ".gemini", "antigravity-cli", "mcp_config.json"), ["mcpServers", "patchcord"]),
     ];
     const mcpConfigured = checks.some((c) => c === true);
     const mcpUnknown = checks.some((c) => c === null);
@@ -1743,7 +1764,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     }
   }
 
-  // Kimi CLI
+  // Kimi Code
   const hasKimi = run("which kimi");
   if (hasKimi) {
     let kimiChanged = false;
@@ -1755,15 +1776,16 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       copyFileSync(src, dest);
       return changed;
     };
-    // Kimi CLI (Python) reads ~/.kimi/skills; Kimi Code (Node) reads
+    // Kimi Code (Python) reads ~/.kimi/skills; Kimi Code (Node) reads
     // ~/.kimi-code/skills. Install into BOTH user dirs that exist — a global
     // `npx patchcord` must fix whichever Kimi the user runs. Clean up the old
     // combined skill AND colon-named flow skills (Kimi requires names to be
     // lowercase/digits/hyphens only — a colon kept them out of /flow:, showing
     // them only under /skill:). Renamed to patchcord-inbox etc.
     const kimiCodeHome = process.env.KIMI_CODE_HOME || join(HOME, ".kimi-code");
-    const kimiSkillRoots = [join(HOME, ".kimi", "skills")];
-    if (existsSync(kimiCodeHome)) kimiSkillRoots.push(join(kimiCodeHome, "skills"));
+    // Kimi Code (Node) reads ~/.kimi-code/skills. The legacy Python kimi-cli
+    // (~/.kimi) is deprecated — install only into Kimi Code's home.
+    const kimiSkillRoots = [join(kimiCodeHome, "skills")];
     for (const root of kimiSkillRoots) {
       for (const stale of ["patchcord", "patchcord-wait", "patchcord:inbox", "patchcord:wait", "patchcord:subscribe"]) {
         const d = join(root, stale);
@@ -1774,16 +1796,20 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       kimiChanged = installKimiSkill(join(root, "patchcord-subscribe"), "subscribe") || kimiChanged;
     }
 
-    // Install/update stop hook — fires after each Kimi turn to check inbox
+    // Install/update stop hook — fires after each Kimi turn to check inbox.
+    // Kimi Code (the current product) reads ~/.kimi-code/config.toml and the
+    // hook scripts it points to. The legacy Python kimi-cli home (~/.kimi) is
+    // deprecated, so install into Kimi Code's home and strip any patchcord
+    // artifacts a prior install left in ~/.kimi (see legacy cleanup below).
     let hookChanged = false;
     const kimiHookSrc = join(pluginRoot, "scripts", "kimi-stop-hook.sh");
-    const kimiHookDest = join(HOME, ".kimi", "patchcord-stop-hook.sh");
+    const kimiHookDest = join(kimiCodeHome, "patchcord-stop-hook.sh");
     if (existsSync(kimiHookSrc)) {
-      const hookAlreadyExisted = existsSync(kimiHookDest);
+      mkdirSync(kimiCodeHome, { recursive: true });
       copyFileSync(kimiHookSrc, kimiHookDest);
       chmodSync(kimiHookDest, 0o755);
 
-      const kimiConfigPath = join(HOME, ".kimi", "config.toml");
+      const kimiConfigPath = join(kimiCodeHome, "config.toml");
       let kimiConfig = existsSync(kimiConfigPath) ? readFileSync(kimiConfigPath, "utf-8") : "";
 
       // Remove old inline hooks = [] (conflicts with [[hooks]] array-of-tables)
@@ -1796,7 +1822,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
 
       // Install session-start hook
       const kimiSessionSrc = join(pluginRoot, "scripts", "kimi-session-start.sh");
-      const kimiSessionDest = join(HOME, ".kimi", "patchcord-session-start.sh");
+      const kimiSessionDest = join(kimiCodeHome, "patchcord-session-start.sh");
       if (existsSync(kimiSessionSrc)) {
         copyFileSync(kimiSessionSrc, kimiSessionDest);
         chmodSync(kimiSessionDest, 0o755);
@@ -1807,28 +1833,40 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       const kept2 = segments2.filter((seg, idx) => idx === 0 || !seg.includes("patchcord-session-start") && !seg.includes("patchcord-prompt-hook"));
       kimiConfig = kept2.join("[[hooks]]").replace(/\n{3,}/g, "\n\n").trim();
 
-      // Remove the legacy UserPromptSubmit shim script if a prior install left it.
-      // Kimi displays stderr to the user but does not feed it to the LLM, so the
-      // shim never auto-executed anything — flow skills handle slash invocations.
-      const kimiPromptDest = join(HOME, ".kimi", "patchcord-prompt-hook.sh");
-      if (existsSync(kimiPromptDest)) {
-        try { rmSync(kimiPromptDest, { force: true }); } catch {}
-      }
-
       // Append new hooks
       kimiConfig = kimiConfig.trimEnd() + `\n\n[[hooks]]\nevent = "SessionStart"\ncommand = "${kimiSessionDest}"\ntimeout = 10\n\n[[hooks]]\nevent = "Stop"\ncommand = "${kimiHookDest}"\ntimeout = 10\n`;
 
       mkdirSync(dirname(kimiConfigPath), { recursive: true });
       writeFileSync(kimiConfigPath, kimiConfig);
       hookChanged = true;
+
+      // Clean up deprecated ~/.kimi patchcord artifacts: stale hook/subscribe
+      // scripts and any [[hooks]] blocks pointing at patchcord in the legacy
+      // config, so the dead Python CLI can't double-fire or reference a script
+      // we no longer maintain there.
+      const legacyKimiHome = join(HOME, ".kimi");
+      for (const f of ["patchcord-stop-hook.sh", "patchcord-session-start.sh", "patchcord-prompt-hook.sh", "patchcord-subscribe.sh"]) {
+        const p = join(legacyKimiHome, f);
+        if (existsSync(p)) { try { rmSync(p, { force: true }); } catch {} }
+      }
+      const legacyConfigPath = join(legacyKimiHome, "config.toml");
+      if (existsSync(legacyConfigPath)) {
+        try {
+          let lc = readFileSync(legacyConfigPath, "utf-8");
+          const segs = lc.split("[[hooks]]");
+          const keptLegacy = segs.filter((seg, idx) => idx === 0 || !seg.includes("patchcord-"));
+          lc = keptLegacy.join("[[hooks]]").replace(/\n{3,}/g, "\n\n").trim();
+          writeFileSync(legacyConfigPath, lc ? lc + "\n" : "");
+        } catch {}
+      }
     }
 
     // Install/update Kimi subscribe script (background polling)
     let subChanged = false;
     const kimiSubSrc = join(pluginRoot, "scripts", "kimi-subscribe.sh");
-    const kimiSubDest = join(HOME, ".kimi", "patchcord-subscribe.sh");
+    const kimiSubDest = join(kimiCodeHome, "patchcord-subscribe.sh");
     if (existsSync(kimiSubSrc)) {
-      const subAlreadyExisted = existsSync(kimiSubDest);
+      mkdirSync(kimiCodeHome, { recursive: true });
       copyFileSync(kimiSubSrc, kimiSubDest);
       chmodSync(kimiSubDest, 0o755);
       subChanged = true;
@@ -1839,7 +1877,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     if (hookChanged) kimiParts.push("hooks");
     if (subChanged) kimiParts.push("subscribe script");
     if (kimiParts.length > 0) {
-      globalChanges.push(`Kimi CLI ${kimiParts.join(" + ")} installed`);
+      globalChanges.push(`Kimi Code ${kimiParts.join(" + ")} installed`);
     }
   }
 
@@ -1907,8 +1945,8 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   }
 
   if (!hasClaude && !existsSync(codexConfig) && !hasKimi) {
-    console.log(`${dim}No Claude Code, Codex CLI, or Kimi CLI detected — skipping global setup.${r}`);
-    console.log(`${dim}  Kimi CLI: https://kimi.moonshot.cn/download${r}`);
+    console.log(`${dim}No Claude Code, Codex CLI, or Kimi Code detected — skipping global setup.${r}`);
+    console.log(`${dim}  Kimi Code: https://kimi.moonshot.cn/download${r}`);
   }
 
   if (updateOnly) process.exit(0);
@@ -1981,7 +2019,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       console.log(`  ${cyan}1.${r} Claude Code   ${cyan}5.${r} Gemini CLI   ${cyan}9.${r} OpenClaw`);
       console.log(`  ${cyan}2.${r} Codex CLI     ${cyan}6.${r} VS Code      ${cyan}10.${r} Antigravity CLI`);
       console.log(`  ${cyan}3.${r} Cursor        ${cyan}7.${r} Zed          ${cyan}11.${r} Cline`);
-      console.log(`  ${cyan}4.${r} Windsurf      ${cyan}8.${r} OpenCode     ${cyan}12.${r} Kimi CLI`);
+      console.log(`  ${cyan}4.${r} Windsurf      ${cyan}8.${r} OpenCode     ${cyan}12.${r} Kimi Code`);
       console.log(`  ${cyan}13.${r} Hermes\n`);
       choice = (await ask(`${dim}Choose (1-13):${r} `)).trim();
       if (!["1","2","3","4","5","6","7","8","9","10","11","12","13"].includes(choice)) {
@@ -2065,7 +2103,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     // project setup. Only per-project configs trigger "already configured."
     if (existingToken) {
       // Figure out which tool is already configured
-      const existingToolName = existingConfigFile.includes(".kimi") ? "Kimi CLI"
+      const existingToolName = existingConfigFile.includes(".kimi") ? "Kimi Code"
         : existingConfigFile.includes(".codex") ? "Codex"
         : existingConfigFile.includes(".agents") ? "Antigravity CLI"
         : existingConfigFile.includes("antigravity") ? "Antigravity"
@@ -2635,7 +2673,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       console.log(`  ${green}✓${r} Skills installed: ${dim}${join(kimiCodeHome, "skills")}${r} ${dim}(/flow:patchcord-inbox)${r}`);
     } catch {}
   } else if (isKimi) {
-    // Kimi CLI (Python): per-project .kimi/mcp.json + shell wrapper for --mcp-config-file
+    // Kimi Code (Python): per-project .kimi/mcp.json + shell wrapper for --mcp-config-file
     const kimiDir = join(cwd, ".kimi");
     const kimiPath = join(kimiDir, "mcp.json");
     const kimiOk = updateJsonConfig(kimiPath, (obj) => {
@@ -2649,7 +2687,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       };
     });
     if (kimiOk) {
-      console.log(`\n  ${green}✓${r} Kimi CLI configured: ${dim}${kimiPath}${r}`);
+      console.log(`\n  ${green}✓${r} Kimi Code configured: ${dim}${kimiPath}${r}`);
       console.log(`  ${dim}Per-project — use the kimi-pc wrapper (see below) so Kimi loads this config.${r}`);
     }
     // Install/update global skills. Hyphen names → /flow:patchcord-inbox
@@ -2968,7 +3006,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     }
   }
 
-  const toolName = isHermes ? "Hermes" : isKimiCode ? "Kimi Code" : isKimi ? "Kimi CLI" : isAntigravity ? "Antigravity CLI" : isCline ? "Cline" : isOpenClaw ? "OpenClaw" : isOpenCode ? "OpenCode" : isZed ? "Zed" : isVSCode ? "VS Code" : isGemini ? "Gemini CLI" : isWindsurf ? "Windsurf" : isCursor ? "Cursor" : isCodex ? "Codex" : "Claude Code";
+  const toolName = isHermes ? "Hermes" : isKimiCode ? "Kimi Code" : isKimi ? "Kimi Code" : isAntigravity ? "Antigravity CLI" : isCline ? "Cline" : isOpenClaw ? "OpenClaw" : isOpenCode ? "OpenCode" : isZed ? "Zed" : isVSCode ? "VS Code" : isGemini ? "Gemini CLI" : isWindsurf ? "Windsurf" : isCursor ? "Cursor" : isCodex ? "Codex" : "Claude Code";
 
   if (!isWindsurf && !isGemini && !isZed && !isOpenClaw && !isCline && !isKimi && !isHermes) {
     console.log(`\n  ${dim}To connect a second agent:${r}`);
@@ -2987,7 +3025,6 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   process.exit(0);
 }
 
-// ── channel: spawn the channel MCP server (used by .mcp.json) ──
 // ── skill: custom skill from web console ─────────────────────
 if (cmd === "skill") {
   const sub = process.argv[3];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.5.122",
+  "version": "0.5.124",
   "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/kimi-session-start.sh

@@ -5,13 +5,13 @@ set -euo pipefail
 # Runs when a Kimi session starts or resumes. Idempotent: the subscribe script
 # has a pidfile guard that prevents duplicate instances.
 
-KIMI_SUB="${HOME}/.kimi/patchcord-subscribe.sh"
+KIMI_SUB="${KIMI_CODE_HOME:-${HOME}/.kimi-code}/patchcord-subscribe.sh"
 if [ ! -f "$KIMI_SUB" ]; then
   exit 0
 fi
 
 # Kimi sends hook metadata on stdin. Use its cwd when present so the
-# subscribe script resolves the right per-project .kimi/mcp.json.
+# subscribe script resolves the right per-project .kimi-code/mcp.json.
 if [ -t 0 ]; then
   INPUT=""
 else

package/scripts/kimi-stop-hook.sh

@@ -4,8 +4,8 @@ set -euo pipefail
 # Kimi Stop hook — checks patchcord inbox after each turn.
 # Installed automatically by `npx patchcord` when Kimi CLI is detected.
 #
-# Supports per-project .kimi/mcp.json (walks up from cwd) and
-# falls back to global ~/.kimi/mcp.json.
+# Resolves per-project .kimi-code/mcp.json only (walks up from cwd).
+# No global fallback — a Kimi outside a patchcord worktree is not that agent.
 #
 # CRITICAL: Kimi v1.44.0 ONLY acts on Stop hooks when they BLOCK (exit code 2).
 # stdout is silently discarded. stderr becomes the "reason" that triggers a new turn.
@@ -18,7 +18,7 @@ INPUT=$(cat)
 STOP_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false' 2>/dev/null || echo "false")
 [ "$STOP_ACTIVE" = "true" ] && exit 0
 
-# Resolve MCP config: PROJECT-scoped ONLY (walk up from cwd for .kimi/mcp.json).
+# Resolve MCP config: PROJECT-scoped ONLY (walk up from cwd for .kimi-code/mcp.json).
 # NO global ~/.kimi/mcp.json fallback — a Kimi launched outside a patchcord
 # worktree is not that agent and must not be nagged. No MCP authed in the cwd
 # tree => no inbox check. (This Stop hook is registered globally in

package/scripts/kimi-subscribe.sh

@@ -9,8 +9,8 @@ set -euo pipefail
 # Usage: patchcord subscribe        (starts with default 30s interval)
 #        patchcord subscribe 10     (starts with 10s interval)
 #
-# Supports per-project .kimi/mcp.json (walks up from cwd) and
-# falls back to global ~/.kimi/mcp.json.
+# Resolves per-project .kimi-code/mcp.json only (walks up from cwd).
+# No global fallback.
 
 command -v jq >/dev/null 2>&1 || { echo "jq required" >&2; exit 1; }