patchcord 0.5.66 → 0.5.67

package/bin/patchcord.mjs

@@ -194,6 +194,8 @@ async function _resolveBearer() {
     (cwd) => readJsonAt(join(cwd, ".vscode", "mcp.json"), ["servers", "patchcord"], "vscode"),
     (cwd) => readJsonAt(join(cwd, "opencode.json"), ["mcp", "patchcord"], "opencode"),
     (cwd) => readCodexTomlShape(join(cwd, ".codex", "config.toml")),
+    // Kimi can be per-project via .kimi/mcp.json + --mcp-config-file
+    (cwd) => readJsonAt(join(cwd, ".kimi", "mcp.json"), ["mcpServers", "patchcord"], "kimi"),
   ];
   let dir = process.cwd();
   while (dir && dir !== "/") {
@@ -240,6 +242,7 @@ async function _resolveBearer() {
     () => readJsonAt(join(HOME, ".openclaw", "openclaw.json"), ["mcp", "servers", "patchcord"], "openclaw"),
     () => readJsonAt(join(HOME, ".gemini", "antigravity", "mcp_config.json"), ["mcpServers", "patchcord"], "antigravity"),
     ...clinePaths.map((p) => () => readJsonAt(p, ["mcpServers", "patchcord"], "cline")),
+    // Global Kimi fallback (only if no per-project .kimi/mcp.json was found)
     () => readJsonAt(join(HOME, ".kimi", "mcp.json"), ["mcpServers", "patchcord"], "kimi"),
   ];
   for (const r of globalCandidates) {
@@ -1196,10 +1199,12 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     let existingConfigFile = "";
     const mcpJsonPath = join(cwd, ".mcp.json");
     const codexTomlPath = join(cwd, ".codex", "config.toml");
+    const kimiJsonPath = join(cwd, ".kimi", "mcp.json");
 
     const slugForCheck = toolSlug ? toolSlug.replace(/-/g, "_") : "";
     const checkMcpJson = !slugForCheck || slugForCheck === "claude_code";
     const checkCodexToml = !slugForCheck || slugForCheck === "codex";
+    const checkKimiJson = !slugForCheck || slugForCheck === "kimi";
 
     if (checkMcpJson && existsSync(mcpJsonPath)) {
       try {
@@ -1221,12 +1226,23 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
         }
       } catch {}
     }
+    if (!existingToken && checkKimiJson && existsSync(kimiJsonPath)) {
+      try {
+        const existing = JSON.parse(readFileSync(kimiJsonPath, "utf-8"));
+        const pt = existing?.mcpServers?.patchcord;
+        if (pt?.headers?.Authorization) {
+          existingToken = pt.headers.Authorization.replace(/^Bearer\s+/i, "");
+          existingConfigFile = kimiJsonPath;
+        }
+      } catch {}
+    }
     // Global configs (Antigravity, OpenClaw, Gemini, Windsurf, Zed) are NOT
     // checked here. They're set up once globally and should not block new
     // project setup. Only per-project configs trigger "already configured."
     if (existingToken) {
       // Figure out which tool is already configured
-      const existingToolName = existingConfigFile.includes(".codex") ? "Codex"
+      const existingToolName = existingConfigFile.includes(".kimi") ? "Kimi CLI"
+        : existingConfigFile.includes(".codex") ? "Codex"
         : existingConfigFile.includes("antigravity") ? "Antigravity"
         : existingConfigFile.includes("openclaw") ? "OpenClaw"
         : existingConfigFile.includes(".cursor") ? "Cursor"
@@ -1701,8 +1717,9 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       console.log(`  ${yellow}Global config — all Cline projects share this agent.${r}`);
     }
   } else if (isKimi) {
-    // Kimi CLI: global ~/.kimi/mcp.json
-    const kimiPath = join(HOME, ".kimi", "mcp.json");
+    // Kimi CLI: 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) => {
       obj.mcpServers = obj.mcpServers || {};
       obj.mcpServers.patchcord = {
@@ -1715,7 +1732,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     });
     if (kimiOk) {
       console.log(`\n  ${green}✓${r} Kimi CLI configured: ${dim}${kimiPath}${r}`);
-      console.log(`  ${yellow}Global config — all Kimi CLI projects share this agent.${r}`);
+      console.log(`  ${dim}Per-project — use the kimi-pc wrapper (see below) so Kimi loads this config.${r}`);
     }
     // Install/update global skills
     const kimiSkillDir = join(HOME, ".kimi", "skills", "patchcord");
@@ -1725,6 +1742,38 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     cpSync(join(pluginRoot, "per-project-skills", "kimi", "SKILL.md"), join(kimiSkillDir, "SKILL.md"));
     cpSync(join(pluginRoot, "per-project-skills", "kimi", "wait", "SKILL.md"), join(kimiWaitDir, "SKILL.md"));
     console.log(`  ${green}✓${r} Skills installed: ${dim}patchcord${r}, ${dim}patchcord-wait${r}`);
+
+    // Install shell wrapper for per-project --mcp-config-file
+    const wrapperPath = join(HOME, ".kimi", "patchcord-kimi-wrapper.sh");
+    const wrapperAlreadyExisted = existsSync(wrapperPath);
+    const wrapperContent = `#!/bin/bash
+# Patchcord Kimi wrapper — auto-detects per-project .kimi/mcp.json
+# Source this in your ~/.bashrc or ~/.zshrc:
+#   source "${HOME}/.kimi/patchcord-kimi-wrapper.sh"
+#
+# Then launch Kimi in any project with:
+#   kimi-pc
+#
+# Plain \`kimi\` still uses the global ~/.kimi/mcp.json.
+
+kimi-pc() {
+  local dir="$PWD"
+  while [ "$dir" != "/" ]; do
+    if [ -f "$dir/.kimi/mcp.json" ]; then
+      kimi --mcp-config-file "$dir/.kimi/mcp.json" "$@"
+      return
+    fi
+    dir="$(dirname "$dir")"
+  done
+  echo "No .kimi/mcp.json found in $PWD or any parent — falling back to global config" >&2
+  kimi "$@"
+}
+`;
+    writeFileSync(wrapperPath, wrapperContent);
+    console.log(`\n  ${green}✓${r} Shell wrapper installed: ${dim}${wrapperPath}${r}`);
+    console.log(`  ${dim}Add this to your ~/.bashrc or ~/.zshrc:${r}`);
+    console.log(`  ${cyan}source "${wrapperPath}"${r}`);
+    console.log(`  ${dim}Then run ${bold}kimi-pc${r}${dim} instead of ${bold}kimi${r}${dim} in project directories.${r}`);
   } else if (isVSCode) {
     // VS Code: write .vscode/mcp.json (per-project)
     const vscodeDir = join(cwd, ".vscode");

package/package.json

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

package/per-project-skills/kimi/SKILL.md

@@ -9,11 +9,24 @@ description: >
 # Patchcord for Kimi CLI
 
 You are connected to Patchcord through the MCP server configured in
-`~/.kimi/mcp.json`. There is no Patchcord plugin for Kimi — behavior comes
-from MCP tools + this skill.
+`.kimi/mcp.json` inside your project directory. Kimi normally uses a global
+config, but Patchcord sets up **per-project agents** via `--mcp-config-file`.
 
-Your identity is **global** (all Kimi projects share the same agent) because
-Kimi stores MCP config in `~/.kimi/mcp.json`.
+**Launch Kimi in project directories with `kimi-pc`** (not plain `kimi`).
+This wrapper auto-detects `.kimi/mcp.json` in the current project and loads
+the right agent identity.
+
+```bash
+# In any project with .kimi/mcp.json:
+kimi-pc
+
+# Falls back to global ~/.kimi/mcp.json if no project config found.
+```
+
+Add this to your `~/.bashrc` or `~/.zshrc` (done once by the installer):
+```bash
+source "$HOME/.kimi/patchcord-kimi-wrapper.sh"
+```
 
 ## Tools available
 
@@ -29,7 +42,7 @@ Kimi stores MCP config in `~/.kimi/mcp.json`.
 
 Kimi has **two** complementary ways to learn about incoming messages:
 
-1. **Stop hook** (always active) — after every turn, Kimi runs `~/.kimi/patchcord-stop-hook.sh`. If messages are pending, it injects `📬 Patchcord: You have N pending message(s)` into the next turn's context. No background task needed.
+1. **Stop hook** (always active) — after every turn, Kimi runs `~/.kimi/patchcord-stop-hook.sh`. It detects the project from `cwd` in stdin, walks up looking for `.kimi/mcp.json`, then checks the inbox. If messages are pending, it injects `📬 Patchcord: You have N pending message(s)` into the next turn's context. No background task needed.
 
 2. **Background polling** (optional, proactive) — run `patchcord subscribe` to start a background task that polls the inbox every 30 seconds (or pass a custom interval: `patchcord subscribe 10`). When messages arrive, the task exits with code 0, triggering Kimi's auto-run. This wakes Kimi even during idle periods.
 
@@ -97,13 +110,14 @@ If send_message fails with a send gate error: call inbox(), reply to or resolve
 Action requests older than 7d (per the `(Xd ago)` stamp): ask human before executing. Acks/FYIs silent-resolve at any age.
 
 1. Read the message from `inbox()` or `wait_for_message()`. Check `message.thread` / `message.thread_id` if present.
-2. Do the work - use real code, real files, real results from your project
-3. Reply with the right flag:
+2. **Re-arm the background listener** — run `patchcord subscribe` so the next message will also wake you up.
+3. Do the work - use real code, real files, real results from your project
+4. Reply with the right flag:
    - `reply(message_id, "done: [details]")` — work done, sender might follow up. Thread auto-inherited.
    - `reply(message_id, "done: [details]", resolve=true)` — work done, thread closed.
    - `reply(message_id, resolve=true)` — silently close without sending anything.
    - `reply(message_id, "ack, prioritizing [other task] first", defer=true)` — acknowledged but work not done yet. Message stays in your inbox as a reminder.
-4. If sender is online: `wait_for_message()` for follow-ups
+5. If sender is online: `wait_for_message()` for follow-ups
 
 When you have multiple pending messages, prioritize by urgency. Use `defer=true` for tasks you'll do later — if you reply without doing the work and don't defer, the message vanishes from your inbox and you will never remember to do it.
 

package/scripts/kimi-stop-hook.sh

@@ -3,6 +3,9 @@ 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.
 
 command -v jq >/dev/null 2>&1 || exit 0
 
@@ -14,9 +17,26 @@ if [ "$STOP_ACTIVE" = "true" ]; then
   exit 0
 fi
 
-# Resolve bearer from ~/.kimi/mcp.json
-HOME_DIR="${HOME}"
-KIMI_MCP="${HOME_DIR}/.kimi/mcp.json"
+# Resolve MCP config: per-project first, then global
+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"
+      break
+    fi
+    dir=$(dirname "$dir")
+  done
+fi
+
+# Fallback to global config
+if [ -z "$KIMI_MCP" ]; then
+  KIMI_MCP="${HOME}/.kimi/mcp.json"
+fi
+
 TOKEN=""
 URL=""
 

package/scripts/kimi-subscribe.sh

@@ -9,16 +9,29 @@ set -euo pipefail
 # Usage: patchcord subscribe        (starts with default 30s interval)
 #        patchcord subscribe 10     (starts with 10s interval)
 #
-# Installed to ~/.kimi/patchcord-subscribe.sh by `npx patchcord@latest`.
+# Supports per-project .kimi/mcp.json (walks up from cwd) and
+# falls back to global ~/.kimi/mcp.json.
 
 command -v jq >/dev/null 2>&1 || { echo "jq required" >&2; exit 1; }
 
-# Resolve auth from ~/.kimi/mcp.json
-HOME_DIR="${HOME}"
-KIMI_MCP="${HOME_DIR}/.kimi/mcp.json"
+# Resolve MCP config: per-project first, then global
+KIMI_MCP=""
+dir="$PWD"
+while [ "$dir" != "/" ]; do
+  if [ -f "$dir/.kimi/mcp.json" ]; then
+    KIMI_MCP="$dir/.kimi/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 — run npx patchcord@latest first" >&2
+  echo "Kimi MCP config not found at $KIMI_MCP or any parent — run npx patchcord@latest first" >&2
   exit 1
 fi
 
@@ -45,7 +58,7 @@ if [ -z "$NAMESPACE_ID" ] || [ -z "$AGENT_ID" ]; then
 fi
 
 PIDFILE="/tmp/patchcord_subscribe_${NAMESPACE_ID}_${AGENT_ID}.pid"
-NOTIFY_FILE="${HOME_DIR}/.kimi/patchcord-subscribe-notify.txt"
+NOTIFY_FILE="${HOME}/.kimi/patchcord-subscribe-notify.txt"
 
 # Pidfile guard: exit if another instance is running
 if [ -f "$PIDFILE" ]; then