patchcord 0.6.36 → 0.6.38

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

package/bin/patchcord.mjs

@@ -1735,6 +1735,7 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
     // supersede anything.
     if (!forceRemint) {
       let reusable = null;
+      let undetermined = null;   // a candidate we could NOT judge — see below
       try {
         const { listProjectBearers } = await import(
           new URL("../scripts/lib/resolve-project-bearer.mjs", import.meta.url).href
@@ -1747,7 +1748,27 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
           seen.add(cand.token);
           const baseUrl = String(cand.url || "").replace(/\/mcp(\/bearer)?$/, "") || DEFAULT_API;
           const probe = await _httpJSON("GET", `${baseUrl}/api/agent/whoami`, cand.token);
-          if (probe.status !== "200") continue;         // dead or superseded — skip
+          const code = String(probe.status ?? "");
+
+          // THREE outcomes, not two. Collapsing them is the whole bug class this
+          // command exists to stop causing:
+          //
+          //   401/403  the credential is genuinely dead (revoked in the web
+          //            console, or superseded). Skip it; minting is CORRECT.
+          //   200      alive — check whose it is below.
+          //   anything else (000 from a failed connection, null when curl itself
+          //            died, any 5xx) we DO NOT KNOW. Treating "could not ask"
+          //            as "dead" would skip a HEALTHY token and mint, which
+          //            destroys the live session this command exists to protect
+          //            — and it would do that exactly when the backend is
+          //            already unwell. Absent, dead and unavailable are three
+          //            different answers.
+          if (code === "401" || code === "403") continue;
+          if (code !== "200") {
+            undetermined = { token: cand.token, base: baseUrl, code: code || "no response" };
+            continue;
+          }
+
           const who = probe.json || {};
           const gotNs = who.namespace_id || who.namespace || (who.self && who.self.namespace_id);
           const gotAgent = who.agent_id || who.agent || (who.self && who.self.agent_id);
@@ -1760,9 +1781,22 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
           }
         }
       } catch (e) {
-        // Reuse is an optimisation over the old behaviour; if it cannot run we
-        // fall through and mint, exactly as before.
-        console.error(`  ${M.dim}(could not check for a reusable credential: ${e?.message || e})${M.rst}`);
+        // A crash in the reuse scan is itself "undetermined", not "dead". Same
+        // reasoning: never let a local failure authorise a destructive remint.
+        undetermined = undetermined || { code: `scan failed: ${e?.message || e}` };
+      }
+
+      // Could not determine, and found nothing provably alive: STOP. Do not
+      // mint. Minting is the irreversible half of this command — it kills a
+      // credential a running session may be holding — and an unreachable server
+      // is not evidence that anything needs replacing. Retrying is free; a
+      // revoked live session is not.
+      if (!reusable && undetermined) {
+        console.error(`✗ cannot verify the existing credential for ${M.green}${ns}:${arg}${M.rst} (${undetermined.code}).`);
+        console.error(`  Refusing to mint a replacement: that would revoke the token any`);
+        console.error(`  running session for this agent is currently using.`);
+        console.error(`  ${M.dim}Retry when the server is reachable, or force it deliberately with --force-remint.${M.rst}`);
+        process.exit(1);
       }
       if (reusable) {
         writeWorkerConfig(tool, dir, reusable.base, reusable.token, hostname);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.6.36",
+  "version": "0.6.38",
   "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/check-inbox.sh

@@ -75,7 +75,22 @@ fi
 # Check inbox — one lightweight HTTP call
 MACHINE_NAME=$(hostname -s 2>/dev/null || echo "unknown")
 INSTALL_PATH=$(dirname "$MCP_JSON")
-HTTP_CODE=$(curl -s -o /tmp/patchcord_inbox.json -w "%{http_code}" --max-time 5 \
+
+# PER-INVOCATION response file. This was a FIXED path (/tmp/patchcord_inbox.json)
+# shared by every agent on the machine, and a host running several seats stops
+# them at overlapping times: one hook's curl truncates and rewrites the file
+# another hook is reading, and either one's `rm -f` deletes it underneath the
+# other. The reader then hands a half-written body to jq, which is exactly the
+# "Invalid numeric literal at line 1, column N" this produced on the Mac mini.
+# A shared mutable temp path between concurrent agents is not a race that
+# happens rarely; it is one that happens whenever the machine is busy.
+RESP_FILE=$(mktemp "${TMPDIR:-/tmp}/patchcord_inbox.XXXXXX" 2>/dev/null || echo "")
+[ -z "$RESP_FILE" ] && exit 0
+# Remove it on ANY exit path, including the early returns below, so a crash
+# cannot leave per-invocation files accumulating in /tmp.
+trap 'rm -f "$RESP_FILE"' EXIT
+
+HTTP_CODE=$(curl -s -o "$RESP_FILE" -w "%{http_code}" --max-time 5 \
   -H "Authorization: Bearer ${TOKEN}" \
   -H "x-patchcord-machine: ${MACHINE_NAME}" \
   -H "x-patchcord-install-path: ${INSTALL_PATH}" \
@@ -86,18 +101,25 @@ if [ "$HTTP_CODE" = "401" ] || [ "$HTTP_CODE" = "403" ]; then
     "decision": "block",
     "reason": "PATCHCORD AUTH FAILED: token rejected by server (HTTP '"$HTTP_CODE"'). Check your token in .mcp.json — it may be wrong, expired, or not yet registered on the server."
   }'
-  rm -f /tmp/patchcord_inbox.json
   exit 0
 fi
 
 if [ "$HTTP_CODE" = "000" ]; then
   # Server unreachable — skip silently
-  rm -f /tmp/patchcord_inbox.json
   exit 0
 fi
 
-RESPONSE=$(cat /tmp/patchcord_inbox.json 2>/dev/null || echo '{"count":0}')
-rm -f /tmp/patchcord_inbox.json
+RESPONSE=$(cat "$RESP_FILE" 2>/dev/null || echo "")
+
+# "COULD NOT TELL" IS NOT "NOTHING PENDING". Below, an unparseable body used to
+# fall through jq's `// 0` default to COUNT=0, which takes the same exit path as
+# a genuinely empty inbox AND clears the streak state. So a corrupted response
+# told the agent it had no messages, silently, with no way to tell the two apart
+# — the same absence-reads-as-a-value shape that cost this project a night.
+# Refuse to answer instead: leave the streak state alone and say nothing.
+if ! printf '%s' "$RESPONSE" | jq -e 'type == "object"' >/dev/null 2>&1; then
+  exit 0
+fi
 
 # ── Auto-apply custom skill from web console ──────────────────
 # Writes to .claude/skills/patchcord-custom/SKILL.md — Claude Code
@@ -142,7 +164,14 @@ if [ "$COUNT" -eq 0 ]; then
   exit 0
 fi
 
-NOTIFY_LOCK="/tmp/patchcord_notify_lock"
+# PER-IDENTITY lock. This was a single global path, so on a host running several
+# seats one agent's notification suppressed EVERY other agent's for 5s — an
+# agent with real pending messages could be silenced by an unrelated seat that
+# happened to stop first. The dedupe is meant to stop ONE identity being told
+# twice by the Stop and Notification hooks, never to stop a second identity
+# being told at all.
+NOTIFY_LOCK=$(pc_state_path "patchcord_notify_lock" "$NAMESPACE" "$AGENT_ID" 2>/dev/null || echo "")
+[ -z "$NOTIFY_LOCK" ] && NOTIFY_LOCK="${TMPDIR:-/tmp}/patchcord_notify_lock_$(printf '%s' "${NAMESPACE}/${AGENT_ID}" | tr -c 'a-zA-Z0-9' '_')"
 LOCK_AGE=5
 if [ -f "$NOTIFY_LOCK" ]; then
   LOCK_MTIME=$(stat -c %Y "$NOTIFY_LOCK" 2>/dev/null || stat -f %m "$NOTIFY_LOCK" 2>/dev/null || echo "0")