patchcord 0.5.98 → 0.5.100

package/bin/patchcord.mjs

@@ -273,7 +273,7 @@ async function _resolveBearer(options = {}) {
   while (dir && dir !== "/") {
     for (const r of projectReaders) {
       const found = r(dir);
-      if (found) return found;
+      if (found) { found.scope = "project"; return found; }
     }
     dir = dirname(dir);
   }
@@ -323,7 +323,7 @@ async function _resolveBearer(options = {}) {
     : [...defaultGlobalCandidates, kimiGlobalReader, kimiCodeGlobalReader];
   for (const r of globalCandidates) {
     const found = r();
-    if (found) return found;
+    if (found) { found.scope = "global"; return found; }
   }
 
   return null;
@@ -353,6 +353,12 @@ if (cmd === "whoami") {
     console.error("No patchcord config found in current directory or any parent. Run `npx patchcord@latest` from a project directory first.");
     process.exit(1);
   }
+  if (found.scope === "global") {
+    console.error(`\x1b[33m⚠ No project patchcord config in ${process.cwd()} or any parent.`);
+    console.error(`  Falling back to a GLOBAL config: ${found.configFile} (tool: ${found.tool}).`);
+    console.error(`  If this isn't the agent you expected, you're in a directory without its own .mcp.json —`);
+    console.error(`  the identity below belongs to that global config, NOT to whatever harness launched this.\x1b[0m`);
+  }
   const { token, baseUrl } = found;
   if (!isSafeToken(token) || !isSafeUrl(baseUrl)) {
     console.error(`Invalid patchcord URL or token in config.`);
@@ -787,22 +793,25 @@ if (cmd === "subscribe") {
 // 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
 // their own branches above and below.
-// ── Master agent: provisioning + team orchestration ────────────────────────
-// (docs/master-agent.md). A master token is a user-scoped provisioning
-// credential stored at ~/.patchcord/master.json or $PATCHCORD_MASTER_TOKEN.
-if (cmd === "master" || cmd === "provision" || cmd === "team") {
+// ── Main agent: provisioning + team orchestration ──────────────────────────
+// (docs/main-agent.md). The "main" is the managing agent of a team; its main
+// token is a user-scoped provisioning credential stored at ~/.patchcord/main.json
+// (legacy: master.json) or $PATCHCORD_MAIN_TOKEN (legacy: $PATCHCORD_MASTER_TOKEN).
+if (cmd === "main" || cmd === "master" || cmd === "provision" || cmd === "team") {
   const M = { cyan: "\x1b[36m", green: "\x1b[32m", dim: "\x1b[2m", rst: "\x1b[0m" };
-  const MASTER_CONFIG = join(HOME, ".patchcord", "master.json");
+  const MAIN_CONFIG = join(HOME, ".patchcord", "main.json");
+  const LEGACY_CONFIG = join(HOME, ".patchcord", "master.json"); // pre-rename
   const DEFAULT_API = process.env.PATCHCORD_BASE_URL || "https://api.patchcord.dev";
 
-  const readMaster = () => {
-    if (process.env.PATCHCORD_MASTER_TOKEN) {
-      return { token: process.env.PATCHCORD_MASTER_TOKEN, baseUrl: DEFAULT_API };
+  const readMain = () => {
+    const envTok = process.env.PATCHCORD_MAIN_TOKEN || process.env.PATCHCORD_MASTER_TOKEN;
+    if (envTok) return { token: envTok, baseUrl: DEFAULT_API };
+    for (const p of [MAIN_CONFIG, LEGACY_CONFIG]) {
+      try {
+        const m = JSON.parse(readFileSync(p, "utf-8"));
+        if (m && m.token) return { token: m.token, baseUrl: m.baseUrl || DEFAULT_API };
+      } catch {}
     }
-    try {
-      const m = JSON.parse(readFileSync(MASTER_CONFIG, "utf-8"));
-      if (m && m.token) return { token: m.token, baseUrl: m.baseUrl || DEFAULT_API };
-    } catch {}
     return null;
   };
   const flagVal = (name, def = "") => {
@@ -812,9 +821,9 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
     if (i >= 0 && process.argv[i + 1] && !process.argv[i + 1].startsWith("-")) return process.argv[i + 1];
     return def;
   };
-  const requireMaster = () => {
-    const m = readMaster();
-    if (!m) { console.error("No master token. Run: patchcord master connect"); process.exit(1); }
+  const requireMain = () => {
+    const m = readMain();
+    if (!m) { console.error("No main token. Run: patchcord main connect"); process.exit(1); }
     return m;
   };
   const writeWorkerConfig = (tool, dir, baseUrl, token, hostname) => {
@@ -856,16 +865,16 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
     });
   };
 
-  if (cmd === "master") {
+  if (cmd === "main" || cmd === "master") {
     const sub = process.argv[3];
     if (sub === "connect") {
       const harness = flagVal("harness", flagVal("tool", ""));
       const create = run(`curl -sf --max-time 10 -X POST "${DEFAULT_API}/api/master/session" -H "Content-Type: application/json" -d '{"harness":"${harness}"}'`);
       let sessionId = "";
       try { sessionId = (JSON.parse(create).session_id) || ""; } catch {}
-      if (!sessionId) { console.error("Could not start master-connect session."); process.exit(1); }
+      if (!sessionId) { console.error("Could not start main-auth session."); process.exit(1); }
       const url = `https://patchcord.dev/master?session=${sessionId}`;
-      console.log(`\n  Authorize the master agent in your browser:\n  ${M.cyan}${url}${M.rst}\n`);
+      console.log(`\n  Authorize the main agent in your browser:\n  ${M.cyan}${url}${M.rst}\n`);
       console.log(`  ${M.dim}Waiting for authorization...${M.rst}`);
       const http = await import("http");
       const https = await import("https");
@@ -888,24 +897,24 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
         setTimeout(() => { try { req.destroy(); } catch {}; resolve(null); }, 900000);
       });
       if (!token) { console.error("\n  Authorization timed out or failed."); process.exit(1); }
-      mkdirSync(dirname(MASTER_CONFIG), { recursive: true });
-      writeFileSync(MASTER_CONFIG, JSON.stringify({ token, baseUrl: DEFAULT_API }, null, 2) + "\n");
-      console.log(`\n  ${M.green}✓${M.rst} Master token saved: ${M.dim}${MASTER_CONFIG}${M.rst}`);
+      mkdirSync(dirname(MAIN_CONFIG), { recursive: true });
+      writeFileSync(MAIN_CONFIG, JSON.stringify({ token, baseUrl: DEFAULT_API }, null, 2) + "\n");
+      console.log(`\n  ${M.green}✓${M.rst} Main token saved: ${M.dim}${MAIN_CONFIG}${M.rst}`);
       process.exit(0);
     }
     if (sub === "whoami") {
-      const m = requireMaster();
+      const m = requireMain();
       const { status, json } = await _httpJSON("GET", `${m.baseUrl}/api/master/whoami`, m.token);
-      if (status !== "200" || !json) { console.error(`master whoami failed (HTTP ${status})`); process.exit(1); }
-      console.log(`master · user ${json.user_id} · ${json.agents}/${json.quota} agents`);
+      if (status !== "200" || !json) { console.error(`main whoami failed (HTTP ${status})`); process.exit(1); }
+      console.log(`main · user ${json.user_id} · ${json.agents}/${json.quota} agents`);
       process.exit(0);
     }
-    console.error("Usage: patchcord master <connect|whoami>");
+    console.error("Usage: patchcord main <connect|whoami>");
     process.exit(1);
   }
 
   if (cmd === "provision") {
-    const m = requireMaster();
+    const m = requireMain();
     const arg = process.argv[3];
     if (!arg || arg.startsWith("-")) { console.error("Usage: patchcord provision <agent> --tool X --role Y --namespace ns [--dir sub/]"); process.exit(1); }
     if (arg === "revoke") {
@@ -922,7 +931,7 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
     const ns = flagVal("namespace");
     const subdir = flagVal("dir", arg);
     if (!ns) { console.error("--namespace <project-namespace> required"); process.exit(1); }
-    const { status, json } = await _httpJSON("POST", `${m.baseUrl}/api/provision`, m.token, { namespace_id: ns, agent_id: arg, tool, role, label: `master:${tool}` });
+    const { status, json } = await _httpJSON("POST", `${m.baseUrl}/api/provision`, m.token, { namespace_id: ns, agent_id: arg, tool, role, label: `main:${tool}` });
     if (status !== "200" || !json?.token) { console.error(`provision failed (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
     const base = String(json.url || `${m.baseUrl}/mcp`).replace(/\/mcp$/, "");
     const dir = join(process.cwd(), subdir);
@@ -931,6 +940,16 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
     if (role) {
       try { writeFileSync(join(dir, "AGENTS.md"), `# ${arg} — role: ${role}\n\nYou are \`${arg}\` in the \`${ns}\` Patchcord team. Role: ${role}.\nCoordinate with teammates over Patchcord (inbox / send_message / reply).\n`); } catch {}
     }
+    // Record in the local team manifest so `team launch` / `team status` see it.
+    try {
+      const tj = join(process.cwd(), ".patchcord", "team.json");
+      if (existsSync(tj)) {
+        const man = JSON.parse(readFileSync(tj, "utf-8"));
+        man.agents = (man.agents || []).filter((a) => a.agent !== arg);
+        man.agents.push({ agent: arg, tool, role, dir: subdir, namespace: ns });
+        writeFileSync(tj, JSON.stringify(man, null, 2) + "\n");
+      }
+    } catch {}
     console.log(`✓ provisioned ${M.green}${ns}:${arg}${M.rst} [${tool}${role ? "/" + role : ""}] → ${dir}`);
     process.exit(0);
   }
@@ -939,17 +958,39 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
     const sub = process.argv[3];
     if (sub === "init") {
       const project = process.argv[4];
-      if (!project) { console.error("Usage: patchcord team init <project> [--namespace ns]"); process.exit(1); }
+      if (!project) { console.error("Usage: patchcord team init <project> [--namespace ns] [--tool <main-harness>]"); process.exit(1); }
       const ns = flagVal("namespace", project.replace(/[^a-z0-9-]/gi, "-").toLowerCase());
+      const mainTool = flagVal("tool", "claude_code");
       const root = join(process.cwd(), project);
       mkdirSync(join(root, ".patchcord"), { recursive: true });
-      writeFileSync(join(root, ".patchcord", "team.json"), JSON.stringify({ project, namespace: ns, pattern: "architect-workers-reviewer", agents: [] }, null, 2) + "\n");
-      writeFileSync(join(root, "AGENTS.md"), `# ${project} — Patchcord team\n\nNamespace: ${ns}\nProvision: patchcord provision <agent> --tool X --role Y --namespace ${ns} --dir <agent>/\n`);
+      const manifest = { project, namespace: ns, pattern: "architect-workers-reviewer", main: null, agents: [] };
+      // Provision the main's OWN messaging identity IN the team namespace and
+      // write its config at the project root, so the main — running here —
+      // resolves to ns:main and SEES every worker it provisions into ns.
+      // Without this the main has no identity and whoami grabs a stale global.
+      const m = readMain();
+      if (m) {
+        const hostname = run("hostname -s") || run("hostname") || "unknown";
+        const { status, json } = await _httpJSON("POST", `${m.baseUrl}/api/provision`, m.token, { namespace_id: ns, agent_id: "main", tool: mainTool, role: "main", label: "main:self" });
+        if (status === "200" && json?.token) {
+          const base = String(json.url || `${m.baseUrl}/mcp`).replace(/\/mcp$/, "");
+          writeWorkerConfig(mainTool, root, base, json.token, hostname);
+          manifest.main = { agent: "main", tool: mainTool };
+          console.log(`✓ main identity: ${M.green}${ns}:main${M.rst} [${mainTool}] — config written at ${root}`);
+        } else {
+          console.log(`⚠ could not provision main identity (HTTP ${status}: ${json?.error || ""}) — scaffolding only`);
+        }
+      } else {
+        console.log(`⚠ no main token — run 'patchcord main connect' first, then re-run team init`);
+      }
+      writeFileSync(join(root, ".patchcord", "team.json"), JSON.stringify(manifest, null, 2) + "\n");
+      writeFileSync(join(root, "AGENTS.md"), `# ${project} — Patchcord team\n\nNamespace: ${ns}\nMain identity: ${ns}:main (you, when running patchcord from this folder)\nProvision workers: patchcord provision <agent> --tool X --role Y --namespace ${ns} --dir <agent>/\n`);
       console.log(`✓ team scaffolded: ${root} (namespace ${ns})`);
+      console.log(`  ${M.dim}cd ${project} — your identity there is ${ns}:main; you'll see every worker you provision into ${ns}.${M.rst}`);
       process.exit(0);
     }
     if (sub === "list") {
-      const m = requireMaster();
+      const m = requireMain();
       const { status, json } = await _httpJSON("GET", `${m.baseUrl}/api/provision/list`, m.token);
       if (status !== "200") { console.error(`list failed (HTTP ${status})`); process.exit(1); }
       const agents = json?.agents || [];
@@ -957,20 +998,140 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
       if (!agents.length) console.log("  (no agents)");
       process.exit(0);
     }
+    if (sub === "status") {
+      // Reconciler: folder ↔ patchcord identity ↔ tmux session ↔ token-active.
+      // Truth = .patchcord/team.json. For each agent we resolve the token from
+      // ITS folder's config (NOT cwd — identity is the folder), ask the server
+      // who that token is, and cross-check against tmux panes by cwd.
+      let manifest = null;
+      try { manifest = JSON.parse(readFileSync(join(process.cwd(), ".patchcord", "team.json"), "utf-8")); } catch {}
+      if (!manifest) { console.error("No .patchcord/team.json here — cd into the project root."); process.exit(1); }
+      const ns = manifest.namespace;
+      const real = (p) => run(`realpath -m ${JSON.stringify(p)}`) || p;
+      const AGENT_CMDS = /(^|\/)(claude|codex|kimi|kimi-code|opencode|gemini|node)$/;
+
+      // Token reader for a specific folder + tool (folder IS the identity).
+      const tokenInDir = (tool, dir) => {
+        try {
+          if (tool === "codex") {
+            const p = join(dir, ".codex", "config.toml");
+            if (!existsSync(p)) return null;
+            const blk = readFileSync(p, "utf-8").match(/\[mcp_servers\.patchcord[-\w]*\]([\s\S]*?)(?=\n\[|$)/);
+            if (!blk) return null;
+            const u = blk[1].match(/url\s*=\s*"([^"]+)"/);
+            const t = blk[1].match(/Bearer\s+([^\s"]+)/);
+            if (!u || !t) return null;
+            return { token: t[1], baseUrl: u[1].replace(/\/mcp(\/bearer)?$/, "") };
+          }
+          const map = {
+            opencode: [join(dir, "opencode.json"), ["mcp", "patchcord"]],
+            kimi: [join(dir, ".kimi-code", "mcp.json"), ["mcpServers", "patchcord"]],
+            "kimi-code": [join(dir, ".kimi-code", "mcp.json"), ["mcpServers", "patchcord"]],
+            claude_code: [join(dir, ".mcp.json"), ["mcpServers", "patchcord"]],
+          };
+          const [p, keyPath] = map[tool] || map.claude_code;
+          if (!existsSync(p)) return null;
+          const entry = keyPath.reduce((o, k) => o?.[k], JSON.parse(readFileSync(p, "utf-8")));
+          const auth = entry?.headers?.Authorization;
+          const url = entry?.url;
+          if (!auth || !url) return null;
+          return { token: auth.replace(/^Bearer\s+/i, ""), baseUrl: url.replace(/\/mcp(\/bearer)?$/, "") };
+        } catch { return null; }
+      };
+
+      // tmux pane inventory (best-effort).
+      const panes = [];
+      const tmuxOut = run(`tmux list-panes -a -F '#{session_name}\t#{window_index}\t#{pane_current_path}\t#{pane_current_command}'`);
+      if (tmuxOut) for (const l of tmuxOut.split("\n").filter(Boolean)) {
+        const [session, window, path, cmd] = l.split("\t");
+        panes.push({ session, window, path: real(path), cmd, claimed: false });
+      }
+
+      // Build the roster: main first, then workers.
+      const roster = [];
+      const mainEntry = manifest.main || manifest.master; // master = pre-rename
+      if (mainEntry) roster.push({ ...mainEntry, role: "main", dir: ".", _main: true });
+      for (const a of (manifest.agents || [])) roster.push(a);
+
+      const rows = [];
+      for (const a of roster) {
+        const dir = a.dir || a.agent;
+        const abs = real(join(process.cwd(), dir));
+        const exists = existsSync(abs);
+        const cfg = exists ? tokenInDir(a.tool, abs) : null;
+        let token = "no-config", identity = "—";
+        if (cfg) {
+          const { status, json } = await _httpJSON("GET", `${cfg.baseUrl}/api/agent/whoami`, cfg.token);
+          if (status === "200" && json) {
+            identity = `${json.namespace}:${json.agent}`;
+            const expected = `${a.namespace || ns}:${a.agent}`;
+            token = identity === expected ? "live" : `MISMATCH(want ${expected})`;
+          } else if (status === "401" || status === "403") token = `dead(${status})`;
+          else token = `err(${status})`;
+        } else if (!exists) token = "no-folder";
+        // tmux match by folder cwd.
+        let tmux = "—";
+        const hit = panes.find((p) => p.path === abs && AGENT_CMDS.test("/" + p.cmd));
+        if (hit) { hit.claimed = true; tmux = `${hit.session}:${hit.window}(${hit.cmd})`; }
+        else if (panes.some((p) => p.path === abs)) { const p = panes.find((p) => p.path === abs); p.claimed = true; tmux = `${p.session}:${p.window}(shell)`; }
+        rows.push({ role: a.role || "", agent: a.agent, dir: dir === "." ? "./" : dir + "/", identity, token, tmux });
+      }
+
+      // Render.
+      const C = (s, c) => `${c}${s}${M.rst}`;
+      console.log(`\n  team ${C(manifest.project, M.cyan)} · namespace ${C(ns, M.cyan)}\n`);
+      const cols = [["ROLE", "role"], ["AGENT", "agent"], ["FOLDER", "dir"], ["IDENTITY", "identity"], ["TOKEN", "token"], ["TMUX", "tmux"]];
+      const w = cols.map(([h, k]) => Math.max(h.length, ...rows.map((r) => String(r[k]).length)));
+      const line = (cells) => "  " + cells.map((c, i) => String(c).padEnd(w[i])).join("  ");
+      console.log(C(line(cols.map((c) => c[0])), M.dim));
+      for (const r of rows) {
+        const tokColor = r.token === "live" ? M.green : (r.token.startsWith("MISMATCH") || r.token.startsWith("dead") ? "\x1b[31m" : M.dim);
+        const cells = cols.map(([, k]) => k === "token" ? C(String(r[k]).padEnd(w[cols.findIndex((c) => c[1] === "token")]), tokColor) : String(r[k]).padEnd(w[cols.findIndex((c) => c[1] === k)]));
+        console.log("  " + cells.join("  "));
+      }
+
+      // Orphans: agent CLIs running in folders that are NOT team agents.
+      const orphans = panes.filter((p) => !p.claimed && AGENT_CMDS.test("/" + p.cmd));
+      if (orphans.length) {
+        console.log(`\n  ${C("⚠ unanchored agent sessions", "\x1b[33m")} (running outside any team folder — they get GLOBAL identity, not a team seat):`);
+        for (const p of orphans) {
+          const anchored = existsSync(join(p.path, ".mcp.json")) || existsSync(join(p.path, "opencode.json")) || existsSync(join(p.path, ".codex", "config.toml")) || existsSync(join(p.path, ".kimi-code", "mcp.json"));
+          console.log(`    ${p.session}:${p.window}  ${p.cmd}  ${C(p.path, M.dim)}${anchored ? "" : C("  [no project config → falls back to a stale global identity]", "\x1b[33m")}`);
+        }
+        console.log(`\n  ${C("fix:", M.dim)} provision a seat for the folder, then relaunch in place WITH the resume flag:`);
+        console.log(`    ${C(`patchcord provision <agent> --tool <tool> --role <role> --namespace ${ns} --dir <folder>/`, M.dim)}`);
+      }
+      console.log();
+      process.exit(0);
+    }
     if (sub === "launch") {
       let manifest = null;
       try { manifest = JSON.parse(readFileSync(join(process.cwd(), ".patchcord", "team.json"), "utf-8")); } catch {}
       if (!manifest) { console.error("No .patchcord/team.json here — cd into the project root."); process.exit(1); }
       const { spawnSync } = await import("child_process");
+      // Already-running folders: `mux new` would FRESH-launch and wipe their
+      // context. Skip them — relaunch-for-identity must resume in place
+      // (see the team-ops / mux skill). launch is for INITIAL boot only.
+      const real = (p) => run(`realpath -m ${JSON.stringify(p)}`) || p;
+      const running = new Set();
+      const tmuxOut = run(`tmux list-panes -a -F '#{pane_current_path}\t#{pane_current_command}'`);
+      if (tmuxOut) for (const l of tmuxOut.split("\n").filter(Boolean)) {
+        const [path, cmd] = l.split("\t");
+        if (/(^|\/)(claude|codex|kimi|kimi-code|opencode|gemini|node)$/.test("/" + cmd)) running.add(real(path));
+      }
       for (const a of (manifest.agents || [])) {
         const dir = join(process.cwd(), a.dir || a.agent);
+        if (running.has(real(dir))) {
+          console.log(`  ${M.dim}skip ${a.agent} — already running in ${dir}; relaunch-for-identity must resume in place, not fresh-launch (see team-ops skill).${M.rst}`);
+          continue;
+        }
         const muxTool = a.tool === "claude_code" ? "claude" : (a.tool === "kimi-code" ? "kimi" : a.tool);
         console.log(`  launching ${a.agent} (${muxTool}) in ${dir}`);
         spawnSync("mux", ["new", muxTool, "--dir", dir], { stdio: "inherit" });
       }
       process.exit(0);
     }
-    console.error("Usage: patchcord team <init|list|launch>");
+    console.error("Usage: patchcord team <init|list|launch|status>");
     process.exit(1);
   }
 }

package/package.json

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