patchcord 0.5.107 → 0.5.109

package/bin/patchcord.mjs

@@ -86,14 +86,18 @@ THIS AGENT — identity + messaging
   patchcord subscribe [interval]             Start the realtime listener (Kimi: bg poll)
   patchcord upload <file> [--mime <t>] [--as <name>]   Share a file as an attachment
 
-ACCOUNT — user-level (auto-auths the CLI in your browser on first use)
-  patchcord main                             Log in / re-authenticate the CLI
+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>
-
-TEAM — the main agent's tools (run from the project root)
-  patchcord team init <project> [--namespace <ns>] [--tool <harness>]
   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
@@ -819,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 };
@@ -847,15 +852,15 @@ 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;
   };
-  // Browser auth flow → saves + returns the account token.
-  const connectMain = async () => {
-    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}"}'`);
+  // 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/login/session" -H "Content-Type: application/json" -d '{}'`);
     let sessionId = "";
     try { sessionId = (JSON.parse(create).session_id) || ""; } catch {}
-    if (!sessionId) { console.error("Could not start auth session."); process.exit(1); }
-    const url = `https://patchcord.dev/master?session=${sessionId}`;
-    console.log(`\n  Authenticate the patchcord CLI in your browser:\n  ${M.cyan}${url}${M.rst}\n`);
+    if (!sessionId) { console.error("Could not start login session."); process.exit(1); }
+    const url = `https://patchcord.dev/connect/cli?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");
@@ -877,15 +882,14 @@ if (cmd === "main" || cmd === "provision" || cmd === "team" || cmd === "schedule
       req.on("error", () => resolve(null));
       setTimeout(() => { try { req.destroy(); } catch {}; resolve(null); }, 900000);
     });
-    if (!token) { console.error("\n  Authentication 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(`  ${M.green}✓${M.rst} CLI authenticated ${M.dim}(${MAIN_CONFIG})${M.rst}\n`);
+    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 token authenticates the
-  // CLI in the browser if it isn't logged in yet, then proceeds.
-  const requireMain = async () => readMain() || await connectMain();
+  // 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 };
@@ -925,15 +929,15 @@ if (cmd === "main" || cmd === "provision" || cmd === "team" || cmd === "schedule
     });
   };
 
-  if (cmd === "main") {
-    // Explicit (re)authentication. Other commands auth on demand via
-    // requireMain(), so this is only needed to log in ahead of time or switch.
-    await connectMain();
+  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 = await 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") {
@@ -973,39 +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 = await requireMain();
-      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`);
-      }
-      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 = await 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
@@ -1073,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 = [];
@@ -1157,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 = await 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.107",
+  "version": "0.5.109",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
   "author": "ppravdin",
   "license": "MIT",