patchcord 0.5.106 → 0.5.108

package/bin/patchcord.mjs

@@ -67,22 +67,52 @@ function detectFolder(dir) {
 
 
 if (cmd === "help" || cmd === "--help" || cmd === "-h") {
-  console.log(`patchcord — agent messaging for AI coding agents
-
-Usage:
-  patchcord                                               Setup via browser (patchcord.dev)
-  patchcord --token <token> [--server <url>]              Headless / self-hosted setup
-  patchcord --full                                        Same + full statusline
-  patchcord --rename <new-name> [--agent-type <type>]     Rename this agent
-  patchcord whoami                                        Show your identity + project
-  patchcord whoami --propose "<text>"                     Update your whoami (two-shot: first call asks you to show human, second call applies)
-  patchcord agents                                        List every agent (with whoami)
-  patchcord agents <name>                                 Show one agent's whoami
-  patchcord upload <file> [--mime <type>] [--as <name>]   Upload a file as a patchcord attachment (prints the storage path)
-  patchcord subscribe [interval]                          Start the realtime listener (Kimi: background poll, default 30s)
-  patchcord update                                        Update to the latest version
-  patchcord --version                                     Show installed version
-  patchcord --help                                        Show this help
+  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.
+
+SETUP (per agent / project)
+  patchcord                                  Set up this project's agent (browser)
+  patchcord --token <t> [--server <url>]     Headless / self-hosted setup
+  patchcord --full                           Same + full statusline
+  patchcord --rename <name> [--agent-type <t>]   Rename this agent
+
+THIS AGENT — identity + messaging
+  patchcord whoami                           Who am I — this agent's identity + project
+  patchcord whoami --propose "<text>"        Set your self-description (two-shot confirm)
+  patchcord agents [name]                    List agents in your namespace (or show one)
+  patchcord subscribe [interval]             Start the realtime listener (Kimi: bg poll)
+  patchcord upload <file> [--mime <t>] [--as <name>]   Share a file as an attachment
+
+ACCOUNT — log in to the CLI (commands below log in on demand)
+  patchcord login                            Authenticate the CLI (your account)
+
+TEAMLEAD — set up the team-lead agent (the shepherd) in this folder
+  patchcord teamlead [--namespace <ns>] [--tool <harness>]
+                                             Provision the teamlead here; launch it
+                                             to adopt this project or build a new team
+
+TEAM — the teamlead's tools (run from the project root)
+  patchcord provision <agent> --tool <X> --role <Y> --namespace <ns> [--dir <sub/>]
+                                             Create a worker agent (identity + config)
+  patchcord provision revoke <agent> --namespace <ns>
+  patchcord team list [--namespace <ns>]     Provisioned agents (server view, deduped)
+  patchcord team status                      Reconcile folder ↔ identity ↔ tmux ↔ token
+  patchcord team launch                      Launch each worker in mux
+
+SCHEDULES — timed / recurring messages (user-level)
+  patchcord schedule create <name> --namespace <ns> --to <agent> --content "..." \\
+        (--at <ISO> | --cron "<expr>" | --every <sec>) \\
+        [--timezone <tz>] [--thread <slug>] [--max-runs N] [--expires <ISO>]
+  patchcord schedule list [--namespace <ns>]
+  patchcord schedule cancel|test|pause|resume <id>
+
+MISC
+  patchcord update                           Update to the latest version
+  patchcord --version                        Show installed version
+  patchcord --help                           Show this help
 
 First install: npx patchcord@latest`);
   process.exit(0);
@@ -793,20 +823,21 @@ 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.
-// ── 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 === "provision" || cmd === "team" || cmd === "schedule") {
+// ── CLI account auth + teamlead/team/provisioning/schedule ─────────────────
+// These commands act on the user's ACCOUNT, so they require CLI login. The
+// account token (user-level, tied to NO agent) lives at ~/.patchcord/auth.json
+// (legacy: main.json / master.json) or $PATCHCORD_TOKEN (legacy: *_MAIN/MASTER).
+// `patchcord login` authenticates; everything else logs in on demand.
+if (cmd === "login" || cmd === "teamlead" || cmd === "provision" || cmd === "team" || cmd === "schedule") {
   const M = { cyan: "\x1b[36m", green: "\x1b[32m", dim: "\x1b[2m", rst: "\x1b[0m" };
-  const MAIN_CONFIG = join(HOME, ".patchcord", "main.json");
-  const LEGACY_CONFIG = join(HOME, ".patchcord", "master.json"); // pre-rename
+  const AUTH_CONFIG = join(HOME, ".patchcord", "auth.json");
+  const LEGACY_CONFIGS = [join(HOME, ".patchcord", "main.json"), join(HOME, ".patchcord", "master.json")];
   const DEFAULT_API = process.env.PATCHCORD_BASE_URL || "https://api.patchcord.dev";
 
-  const readMain = () => {
-    const envTok = process.env.PATCHCORD_MAIN_TOKEN || process.env.PATCHCORD_MASTER_TOKEN;
+  const readAuth = () => {
+    const envTok = process.env.PATCHCORD_TOKEN || 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]) {
+    for (const p of [AUTH_CONFIG, ...LEGACY_CONFIGS]) {
       try {
         const m = JSON.parse(readFileSync(p, "utf-8"));
         if (m && m.token) return { token: m.token, baseUrl: m.baseUrl || DEFAULT_API };
@@ -821,11 +852,44 @@ if (cmd === "main" || cmd === "provision" || cmd === "team" || cmd === "schedule
     if (i >= 0 && process.argv[i + 1] && !process.argv[i + 1].startsWith("-")) return process.argv[i + 1];
     return def;
   };
-  const requireMain = () => {
-    const m = readMain();
-    if (!m) { console.error("No main token. Run: patchcord main connect"); process.exit(1); }
-    return m;
+  // Browser login → saves + returns the account token. Authenticates the CLI;
+  // not related to any agent.
+  const doLogin = async () => {
+    const create = run(`curl -sf --max-time 10 -X POST "${DEFAULT_API}/api/main/session" -H "Content-Type: application/json" -d '{}'`);
+    let sessionId = "";
+    try { sessionId = (JSON.parse(create).session_id) || ""; } catch {}
+    if (!sessionId) { console.error("Could not start login session."); process.exit(1); }
+    const url = `https://patchcord.dev/master?session=${sessionId}`;
+    console.log(`\n  Log in to patchcord in your browser:\n  ${M.cyan}${url}${M.rst}\n`);
+    console.log(`  ${M.dim}Waiting...${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  Login timed out or failed."); process.exit(1); }
+    mkdirSync(dirname(AUTH_CONFIG), { recursive: true });
+    writeFileSync(AUTH_CONFIG, JSON.stringify({ token, baseUrl: DEFAULT_API }, null, 2) + "\n");
+    console.log(`  ${M.green}✓${M.rst} Logged in ${M.dim}(${AUTH_CONFIG})${M.rst}\n`);
+    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 writeWorkerConfig = (tool, dir, baseUrl, token, hostname) => {
     mkdirSync(dir, { recursive: true });
     const hdr = { Authorization: `Bearer ${token}`, "X-Patchcord-Machine": hostname };
@@ -865,49 +929,15 @@ if (cmd === "main" || cmd === "provision" || cmd === "team" || cmd === "schedule
     });
   };
 
-  if (cmd === "main") {
-    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/main/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 main-auth session."); process.exit(1); }
-      const url = `https://patchcord.dev/master?session=${sessionId}`;
-      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");
-      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(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);
-    }
-    console.error("Usage: patchcord main connect");
-    process.exit(1);
+  if (cmd === "login") {
+    // Explicit CLI login. Other commands log in on demand via requireAuth(),
+    // so this is only needed to authenticate ahead of time or switch accounts.
+    await doLogin();
+    process.exit(0);
   }
 
   if (cmd === "provision") {
-    const m = requireMain();
+    const m = await requireAuth();
     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") {
@@ -947,43 +977,55 @@ if (cmd === "main" || cmd === "provision" || cmd === "team" || cmd === "schedule
     process.exit(0);
   }
 
+  if (cmd === "teamlead") {
+    // Set up the TEAMLEAD agent in THIS folder. The teamlead is a distinct kind
+    // of agent — it shepherds a team: provisions, connects, and manages the
+    // other agents. It is NOT a normal agent: it gets its own identity, its own
+    // onboarding instruction, and on launch either ADOPTS this existing project
+    // or CREATES a new team by interviewing the user.
+    const m = await requireAuth();
+    const root = process.cwd();
+    const ns = (flagVal("namespace", basename(root)) || "team").replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+    const tool = flagVal("tool", "claude_code");
+    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: "teamlead", tool, role: "teamlead", label: "teamlead:self" });
+    if (status !== "200" || !json?.token) { console.error(`could not set up teamlead (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
+    const base = String(json.url || `${m.baseUrl}/mcp`).replace(/\/mcp$/, "");
+    writeWorkerConfig(tool, root, base, json.token, hostname);
+    mkdirSync(join(root, ".patchcord"), { recursive: true });
+    const tj = join(root, ".patchcord", "team.json");
+    let manifest = { project: basename(root), namespace: ns, teamlead: { agent: "teamlead", tool }, agents: [] };
+    try { if (existsSync(tj)) manifest = { ...JSON.parse(readFileSync(tj, "utf-8")), namespace: ns, teamlead: { agent: "teamlead", tool } }; } catch {}
+    writeFileSync(tj, JSON.stringify(manifest, null, 2) + "\n");
+    // The teamlead's onboarding instruction (read on launch).
+    writeFileSync(join(root, "TEAMLEAD.md"), `# You are the TEAMLEAD (${ns}:teamlead)
+
+You shepherd a team of patchcord agents in this folder. You are NOT a worker —
+you design the team, provision its agents, launch them, and manage them.
+
+## On start, pick ONE
+1. **Adopt this project.** If a team already exists here (\`.patchcord/team.json\`
+   lists workers, or agents are already set up), take it into management:
+   \`patchcord team status\` to reconcile folder ↔ identity ↔ tmux ↔ token, then run it.
+2. **Create a new team.** Otherwise interview the user — what are we building,
+   which roles/harnesses, how many — confirm the plan, then build it.
+
+## Build / run
+- Provision each worker: \`patchcord provision <agent> --tool <claude_code|codex|opencode|kimi> --role <role> --namespace ${ns} --dir <agent>/\`
+- Launch: \`patchcord team launch\` (mux), verify with \`patchcord team status\`.
+- Coordinate over patchcord (inbox / send_message); manage at the meta level.
+- Your own identity here is ${ns}:teamlead — \`patchcord whoami\` confirms it.
+`);
+    console.log(`\n  ${M.green}✓${M.rst} Teamlead ready: ${M.green}${ns}:teamlead${M.rst} [${tool}] in ${root}`);
+    console.log(`  ${M.dim}Launch it here — it adopts this project or creates a new team, asking you:${M.rst}`);
+    console.log(`    mux new ${tool === "claude_code" ? "claude" : (tool === "kimi-code" ? "kimi" : tool)} --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 <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 });
-      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 = requireMain();
+      const m = await requireAuth();
       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); }
       // Dedup by namespace:agent — the server returns one row per token, so a
@@ -1051,10 +1093,10 @@ if (cmd === "main" || cmd === "provision" || cmd === "team" || cmd === "schedule
         panes.push({ session, window, path: real(path), cmd, claimed: false });
       }
 
-      // Build the roster: main first, then workers.
+      // Build the roster: teamlead first, then workers.
       const roster = [];
-      const mainEntry = manifest.main || manifest.master; // master = pre-rename
-      if (mainEntry) roster.push({ ...mainEntry, role: "main", dir: ".", _main: true });
+      const leadEntry = manifest.teamlead || manifest.main || manifest.master; // pre-rename names
+      if (leadEntry) roster.push({ ...leadEntry, role: "teamlead", dir: ".", _lead: true });
       for (const a of (manifest.agents || [])) roster.push(a);
 
       const rows = [];
@@ -1135,14 +1177,14 @@ if (cmd === "main" || cmd === "provision" || cmd === "team" || cmd === "schedule
       }
       process.exit(0);
     }
-    console.error("Usage: patchcord team <init|list|launch|status>");
+    console.error("Usage: patchcord team <list|launch|status>");
     process.exit(1);
   }
 
   if (cmd === "schedule") {
     // User-level scheduled / recurring messages (server Plan 041). Authed by
     // the main token — the user can manage schedules in any namespace they own.
-    const m = requireMain();
+    const m = await requireAuth();
     const sub = process.argv[3];
     const BASE = `${m.baseUrl}/api/dashboard/scheduled`;
     const when = (s) => s.cron_expr ? `cron ${s.cron_expr}` : s.interval_sec ? `every ${s.interval_sec}s` : s.fire_at ? `once @ ${s.fire_at}` : s.schedule_kind;

package/package.json

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