patchcord 0.5.97 → 0.5.99

package/bin/patchcord.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { existsSync, mkdirSync, cpSync, readdirSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, cpSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { join, dirname, basename } from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
@@ -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,6 +793,226 @@ 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") {
+  const M = { cyan: "\x1b[36m", green: "\x1b[32m", dim: "\x1b[2m", rst: "\x1b[0m" };
+  const MASTER_CONFIG = join(HOME, ".patchcord", "master.json");
+  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 };
+    }
+    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 = "") => {
+    const eq = process.argv.find((a) => a.startsWith(`--${name}=`));
+    if (eq) return eq.split("=").slice(1).join("=");
+    const i = process.argv.indexOf(`--${name}`);
+    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); }
+    return m;
+  };
+  const writeWorkerConfig = (tool, dir, baseUrl, token, hostname) => {
+    mkdirSync(dir, { recursive: true });
+    const hdr = { Authorization: `Bearer ${token}`, "X-Patchcord-Machine": hostname };
+    const writeJson = (p, mutate) => {
+      let obj = {};
+      try { obj = JSON.parse(readFileSync(p, "utf-8")); } catch {}
+      mutate(obj);
+      writeFileSync(p, JSON.stringify(obj, null, 2) + "\n");
+      return p;
+    };
+    if (tool === "codex") {
+      const cdir = join(dir, ".codex"); mkdirSync(cdir, { recursive: true });
+      const p = join(cdir, "config.toml");
+      let ex = existsSync(p) ? readFileSync(p, "utf-8") : "";
+      ex = ex.replace(/\[mcp_servers\.patchcord[\w.-]*\][^\[]*/g, "").replace(/\n{3,}/g, "\n\n").trim();
+      ex = (ex ? ex + "\n\n" : "") + `[mcp_servers.patchcord-codex]\nurl = "${baseUrl}/mcp"\nhttp_headers = { "Authorization" = "Bearer ${token}", "X-Patchcord-Machine" = "${hostname}" }\ntool_timeout_sec = 300\n`;
+      writeFileSync(p, ex);
+      return p;
+    }
+    if (tool === "kimi" || tool === "kimi-code") {
+      const kdir = join(dir, ".kimi-code"); mkdirSync(kdir, { recursive: true });
+      return writeJson(join(kdir, "mcp.json"), (o) => {
+        o.mcpServers = o.mcpServers || {};
+        o.mcpServers.patchcord = { url: `${baseUrl}/mcp/bearer`, headers: hdr };
+      });
+    }
+    if (tool === "opencode") {
+      return writeJson(join(dir, "opencode.json"), (o) => {
+        o.mcp = o.mcp || {};
+        o.mcp.patchcord = { type: "remote", url: `${baseUrl}/mcp`, headers: hdr };
+      });
+    }
+    // default: claude_code
+    return writeJson(join(dir, ".mcp.json"), (o) => {
+      o.mcpServers = o.mcpServers || {};
+      o.mcpServers.patchcord = { url: `${baseUrl}/mcp`, headers: hdr };
+    });
+  };
+
+  if (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); }
+      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(`  ${M.dim}Waiting for authorization...${M.rst}`);
+      const http = await import("http");
+      const https = await import("https");
+      const token = await new Promise((resolve) => {
+        const lib = DEFAULT_API.startsWith("https") ? https : http;
+        const req = lib.get(`${DEFAULT_API}/api/connect/session/${sessionId}/wait`, { headers: { Accept: "text/event-stream" } }, (res) => {
+          let buf = "";
+          res.on("data", (c) => {
+            buf += c.toString();
+            for (const line of buf.split("\n")) {
+              if (line.startsWith("data: ")) {
+                try { const d = JSON.parse(line.slice(6)); if (d.token) { resolve(d.token); try { req.destroy(); } catch {} return; } } catch {}
+              }
+            }
+          });
+          res.on("end", () => resolve(null));
+          res.on("error", () => resolve(null));
+        });
+        req.on("error", () => resolve(null));
+        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}`);
+      process.exit(0);
+    }
+    if (sub === "whoami") {
+      const m = requireMaster();
+      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`);
+      process.exit(0);
+    }
+    console.error("Usage: patchcord master <connect|whoami>");
+    process.exit(1);
+  }
+
+  if (cmd === "provision") {
+    const m = requireMaster();
+    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") {
+      const ra = process.argv[4];
+      const ns = flagVal("namespace");
+      if (!ra || !ns) { console.error("Usage: patchcord provision revoke <agent> --namespace ns"); process.exit(1); }
+      const { status, json } = await _httpJSON("POST", `${m.baseUrl}/api/provision/revoke`, m.token, { namespace_id: ns, agent_id: ra });
+      if (status !== "200") { console.error(`revoke failed (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
+      console.log(`✓ revoked ${ns}:${ra} (${json.count} token(s))`);
+      process.exit(0);
+    }
+    const tool = flagVal("tool", "claude_code");
+    const role = flagVal("role", "");
+    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}` });
+    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);
+    const hostname = run("hostname -s") || run("hostname") || "unknown";
+    writeWorkerConfig(tool, dir, base, json.token, hostname);
+    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);
+  }
+
+  if (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] [--tool <master-harness>]"); process.exit(1); }
+      const ns = flagVal("namespace", project.replace(/[^a-z0-9-]/gi, "-").toLowerCase());
+      const masterTool = flagVal("tool", "claude_code");
+      const root = join(process.cwd(), project);
+      mkdirSync(join(root, ".patchcord"), { recursive: true });
+      const manifest = { project, namespace: ns, pattern: "architect-workers-reviewer", master: null, agents: [] };
+      // Provision the master's OWN messaging identity IN the team namespace and
+      // write its config at the project root, so the master — running here —
+      // resolves to ns:master and SEES every worker it provisions into ns.
+      // Without this the master has no identity and whoami grabs a stale global.
+      const m = readMaster();
+      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: "master", tool: masterTool, role: "master", label: "master:self" });
+        if (status === "200" && json?.token) {
+          const base = String(json.url || `${m.baseUrl}/mcp`).replace(/\/mcp$/, "");
+          writeWorkerConfig(masterTool, root, base, json.token, hostname);
+          manifest.master = { agent: "master", tool: masterTool };
+          console.log(`✓ master identity: ${M.green}${ns}:master${M.rst} [${masterTool}] — config written at ${root}`);
+        } else {
+          console.log(`⚠ could not provision master identity (HTTP ${status}: ${json?.error || ""}) — scaffolding only`);
+        }
+      } else {
+        console.log(`⚠ no master token — run 'patchcord master 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}\nMaster identity: ${ns}:master (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}:master; you'll see every worker you provision into ${ns}.${M.rst}`);
+      process.exit(0);
+    }
+    if (sub === "list") {
+      const m = requireMaster();
+      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 || [];
+      for (const a of agents) console.log(`  ${a.namespace_id}:${a.agent_id}  ${M.dim}${a.label || ""}${M.rst}`);
+      if (!agents.length) console.log("  (no agents)");
+      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");
+      for (const a of (manifest.agents || [])) {
+        const dir = join(process.cwd(), a.dir || a.agent);
+        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>");
+    process.exit(1);
+  }
+}
+
 if (cmd === "update" || cmd === "--update") {
   const { spawnSync: _spawn } = await import("child_process");
   const r = _spawn("npx", ["--min-release-age=0", "patchcord@latest", "--update-only"], { stdio: "inherit" });

package/package.json

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