patchcord 0.5.117 → 0.5.119

package/.claude-plugin/plugin.json

@@ -1,13 +1,10 @@
 {
   "name": "patchcord",
-  "description": "Cross-machine agent messaging with push delivery. Messages from other agents arrive as native channel notifications.",
-  "version": "0.5.14",
+  "description": "Cross-machine agent messaging. Messages from other agents arrive via inbox with Stop-hook wake-up.",
+  "version": "0.5.119",
   "author": {
     "name": "ppravdin"
   },
   "repository": "https://github.com/ppravdin/patchcord",
-  "skills": "./skills/",
-  "channel": {
-    "server": "./channel/server.ts"
-  }
+  "skills": "./skills/"
 }

package/bin/patchcord.mjs

@@ -66,12 +66,20 @@ function detectFolder(dir) {
 }
 
 
-if (cmd === "help" || cmd === "--help" || cmd === "-h") {
+// A trailing --help/-h on ANY subcommand must show help and exit — never run the
+// command. (patchcord orchestrator --help used to PROVISION an orchestrator;
+// patchcord login --help hung on the browser login. Side-effecting --help is a
+// footgun.) We short-circuit here, before any account/provision/login dispatch.
+if (
+  cmd === "help" || cmd === "--help" || cmd === "-h" ||
+  process.argv.slice(3).some((a) => a === "--help" || a === "-h")
+) {
   console.log(`patchcord — cross-agent messaging + team orchestration for AI coding agents
 
 Two layers: THIS AGENT (a per-project identity, by bearer token) and your ACCOUNT
-(user-level; provisions agents, runs teams + schedules). Account/team/schedule
-commands authenticate the CLI in your browser automatically on first use.
+(user-level; provisions agents, runs teams + schedules). Run \`patchcord login\`
+once to authenticate the CLI; account/team/schedule commands then use that token
+(they never open a browser on their own).
 
 SETUP (per agent / project)
   patchcord                                  Set up this project's agent (browser)
@@ -341,8 +349,12 @@ async function _resolveBearer(options = {}) {
     );
   })();
 
-  const kimiGlobalReader = () => readJsonAt(join(HOME, ".kimi", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
-  const kimiCodeGlobalReader = () => readJsonAt(join(process.env.KIMI_CODE_HOME || join(HOME, ".kimi-code"), "mcp.json"), ["mcpServers", "patchcord"], "kimi");
+  // 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
+  // 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.)
   const defaultGlobalCandidates = [
     () => readJsonAt(join(HOME, ".codeium", "windsurf", "mcp_config.json"), ["mcpServers", "patchcord"], "windsurf"),
     () => readJsonAt(join(HOME, ".gemini", "settings.json"), ["mcpServers", "patchcord"], "gemini"),
@@ -352,9 +364,7 @@ async function _resolveBearer(options = {}) {
     () => readHermesShape(join(HOME, ".hermes", "config.yaml")),
     ...clinePaths.map((p) => () => readJsonAt(p, ["mcpServers", "patchcord"], "cline")),
   ];
-  const globalCandidates = preferKimi
-    ? [kimiGlobalReader, kimiCodeGlobalReader, ...defaultGlobalCandidates]
-    : [...defaultGlobalCandidates, kimiGlobalReader, kimiCodeGlobalReader];
+  const globalCandidates = defaultGlobalCandidates;
   for (const r of globalCandidates) {
     const found = r();
     if (found) { found.scope = "global"; return found; }
@@ -902,7 +912,19 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
     return { token, baseUrl: DEFAULT_API };
   };
   // Auth on demand: any command needing the account logs in if not already.
-  const requireAuth = async () => readAuth() || await doLogin();
+  const requireAuth = async () => {
+    const a = readAuth();
+    if (a) return a;
+    // No account token. NEVER auto-drop into the interactive browser login here:
+    // doLogin() prints a URL and BLOCKS up to 15 minutes for a browser that never
+    // comes in a headless/agent context (the orchestrator misread that hang as
+    // "provision produced no output"). TTY detection is unreliable (a pty/agent
+    // shell can report isTTY=true), so we fail fast unconditionally. Only the
+    // explicit `patchcord login` command opens a browser.
+    console.error("No patchcord account token — no pcm- token in ~/.patchcord/auth.json or $PATCHCORD_TOKEN.");
+    console.error("Run `patchcord login` once (interactive), or set $PATCHCORD_TOKEN. Cannot continue.");
+    process.exit(1);
+  };
   // Account-authed request with stale-token recovery. If the server rejects the
   // stored token (401/403), forget it, re-log-in once, and retry. Returns the
   // _httpJSON result plus the auth used (for callers that need m.baseUrl).
@@ -910,9 +932,11 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
     let m = await requireAuth();
     let r = await _httpJSON(method, `${m.baseUrl}${path}`, m.token, body);
     if (r.status === "401" || r.status === "403") {
+      // Stale/invalid account token. Forget it and fail fast — do NOT auto-relogin
+      // (would hang headless, see requireAuth). The user re-runs `patchcord login`.
       forgetAuth();
-      m = await doLogin();
-      r = await _httpJSON(method, `${m.baseUrl}${path}`, m.token, body);
+      console.error(`patchcord account token rejected (HTTP ${r.status}). Run \`patchcord login\` again. Cannot continue.`);
+      process.exit(1);
     }
     return { ...r, m };
   };
@@ -957,6 +981,31 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
         o.mcpServers.patchcord = { serverUrl: `${baseUrl}/mcp`, headers: hdr };
       });
     }
+    if (tool === "hermes") {
+      // Hermes reads MCP servers ONLY from its GLOBAL ~/.hermes/config.yaml
+      // (mcp_servers key) — it ignores a project-local .mcp.json. So unlike the
+      // other tools we cannot write into `dir`; we upsert the global config,
+      // mirroring the `npx patchcord` installer's Hermes path. NOTE: global =
+      // one patchcord identity per machine, so provisioning a second hermes
+      // worker in another namespace overwrites the first's token. Single-hermes
+      // teams only until Hermes gains project-scoped MCP config.
+      const hermesPath = join(HOME, ".hermes", "config.yaml");
+      mkdirSync(dirname(hermesPath), { recursive: true });
+      let existingYaml = "";
+      try { existingYaml = existsSync(hermesPath) ? readFileSync(hermesPath, "utf-8") : ""; } catch {}
+      writeFileSync(hermesPath, upsertHermesConfig(existingYaml, `${baseUrl}/mcp`, token));
+      // Install the Hermes patchcord skills (inbox/subscribe/wait) so the worker
+      // knows the messaging flow, same as the installer does.
+      try {
+        const hermesSkillsSrc = join(pluginRoot, "per-project-skills", "hermes");
+        if (existsSync(hermesSkillsSrc)) {
+          const hermesSkillsDest = join(HOME, ".hermes", "skills", "integrations");
+          mkdirSync(hermesSkillsDest, { recursive: true });
+          cpSync(hermesSkillsSrc, hermesSkillsDest, { recursive: true });
+        }
+      } catch {}
+      return hermesPath;
+    }
     // default: claude_code. type:"http" is REQUIRED — without it Claude Code
     // defaults to stdio transport and rejects the entry ("command: expected
     // string, received undefined").

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "patchcord",
-  "version": "0.5.117",
+  "version": "0.5.119",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
+  "scripts": {
+    "version": "node scripts/sync-plugin-version.mjs && git add .claude-plugin/plugin.json"
+  },
   "author": "ppravdin",
   "license": "MIT",
   "repository": {

package/scripts/kimi-stop-hook.sh

@@ -18,23 +18,28 @@ 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: per-project first, then global
+# Resolve MCP config: PROJECT-scoped ONLY (walk up from cwd for .kimi/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
+# ~/.kimi/config.toml, so the project-scoped token is the ONLY thing that should
+# make it act.)
 KIMI_MCP=""
 CWD=$(echo "$INPUT" | jq -r '.cwd // empty' 2>/dev/null || echo "")
 
 if [ -n "$CWD" ]; then
   dir="$CWD"
   while [ "$dir" != "/" ]; do
-    if [ -f "$dir/.kimi/mcp.json" ]; then
-      KIMI_MCP="$dir/.kimi/mcp.json"
+    if [ -f "$dir/.kimi-code/mcp.json" ]; then
+      KIMI_MCP="$dir/.kimi-code/mcp.json"
       break
     fi
     dir=$(dirname "$dir")
   done
 fi
 
-# Fallback to global config
-[ -z "$KIMI_MCP" ] && KIMI_MCP="${HOME}/.kimi/mcp.json"
+# No project-scoped .kimi-code/mcp.json in the cwd tree => not a patchcord agent here.
+[ -z "$KIMI_MCP" ] && exit 0
 
 TOKEN=""
 URL=""

package/scripts/kimi-subscribe.sh

@@ -14,25 +14,26 @@ set -euo pipefail
 
 command -v jq >/dev/null 2>&1 || { echo "jq required" >&2; exit 1; }
 
-# Resolve MCP config: per-project first, then global
+# Resolve MCP config: PROJECT-scoped ONLY (walk up from cwd for .kimi-code/mcp.json).
+# Kimi Code (the current product) uses .kimi-code/ — the legacy .kimi/ path is
+# deprecated and MUST NOT be used; it also mismatched where `patchcord provision`
+# writes the config (.kimi-code/mcp.json), so the listener never found it.
+# NO global fallback: auto-launched by the (global) SessionStart hook on EVERY
+# Kimi session, so a global fallback would start a listener for some leftover
+# identity in every folder. No project config in the cwd tree => no patchcord
+# agent here => exit quietly (0, not 1: must not spam stderr in non-patchcord dirs).
 KIMI_MCP=""
 dir="$PWD"
 while [ "$dir" != "/" ]; do
-  if [ -f "$dir/.kimi/mcp.json" ]; then
-    KIMI_MCP="$dir/.kimi/mcp.json"
+  if [ -f "$dir/.kimi-code/mcp.json" ]; then
+    KIMI_MCP="$dir/.kimi-code/mcp.json"
     break
   fi
   dir=$(dirname "$dir")
 done
 
-# Fallback to global config
-if [ -z "$KIMI_MCP" ]; then
-  KIMI_MCP="${HOME}/.kimi/mcp.json"
-fi
-
-if [ ! -f "$KIMI_MCP" ]; then
-  echo "Kimi MCP config not found at $KIMI_MCP or any parent — run npx patchcord@latest first" >&2
-  exit 1
+if [ -z "$KIMI_MCP" ] || [ ! -f "$KIMI_MCP" ]; then
+  exit 0
 fi
 
 TOKEN=$(jq -r '.mcpServers.patchcord.headers.Authorization // empty' "$KIMI_MCP" 2>/dev/null | sed 's/^Bearer //i' || true)

package/scripts/sync-plugin-version.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// Keep .claude-plugin/plugin.json's version in lockstep with package.json.
+//
+// Runs from the npm "version" lifecycle (see package.json scripts.version), so
+// every `npm version <x>` rewrites the plugin manifest and stages it in the same
+// commit. This prevents the drift that shipped a 0.5.14 manifest inside a 0.5.118
+// package — which, combined with a manifest field pointing at an unshipped file,
+// crashed every interactive Claude Code startup.
+import { readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+const manifestPath = join(root, ".claude-plugin", "plugin.json");
+const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+
+if (manifest.version === pkg.version) {
+  process.exit(0);
+}
+
+manifest.version = pkg.version;
+writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+process.stderr.write(`synced plugin.json version -> ${pkg.version}\n`);