@nonbot/cli 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # @nonbot/cli changelog
 
+## 0.9.0
+
+- **Choir collapses into Run.** Launching multiple coordinated agents now comes from the canvas (select stories -> "Run together"), not a terminal command. The daemon groups activations that share a coordinated-set id and launches them with a git worktree per agent + the coordination MCP wired in, each pane on its own per-pane provider (e.g. 2 Claude + 1 Gemini).  remains as internal plumbing only.
+- The set spawn is hardened: repo path validated daemon-side, command written to a 0700 temp script (not an inline shell string), all panes asserted to share one repo, and the plan-not-API unset guard applies.
+
 ## 0.8.0
 
 - **Conductor: Choir runs headless, panes appear only when needed.** `nonbot choir` no longer opens N terminal panes. Each agent runs headless in its own git worktree; the live radar is the web dashboard at /choir. A tmux pane is summoned (kill + `claude --resume` in the same worktree) ONLY when an agent hits awaiting-input or an escalated stall, and torn back down when resolved — so the steady state is zero extra windows. A tunable concurrency cap (`choir.maxActiveAgents`, default 2) keeps only K agents working at once.

package/dist/commands/daemon.js

@@ -4,6 +4,7 @@ import * as activations from '../lib/activations.js';
 import { fireActivation, makeHeadlessSpawner, } from '../lib/activations.js';
 import { checkCompletions } from '../lib/completion.js';
 import { emitRunStage as defaultEmitRunStage, startRunHeartbeat as defaultStartRunHeartbeat, RUN_STAGE, } from '../lib/choir/run-progress.js';
+import { groupBySession, launchCoordinatedSet, } from '../lib/choir/coordinated-set.js';
 import { applyPaneTitle } from '../lib/pane-title.js';
 import { installService, uninstallService } from '../lib/service.js';
 import { detectTmuxSession, inTmuxSession, nonbotTmuxOptOut, resolveTerminal, } from '../lib/terminal.js';
@@ -132,6 +133,8 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
         applyNonbotTmuxConfig({ spawnSync: deps.spawnSync });
     }
     const seen = new Set();
+    const launchedSessions = new Set();
+    const launchCoordinatedSetFn = deps.launchCoordinatedSet ?? launchCoordinatedSet;
     const trackedPanes = new Map();
     const killedByStop = new Set();
     const emitRunStageFn = deps.emitRunStage ?? defaultEmitRunStage;
@@ -282,7 +285,66 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                     void activations.executePendingKills(pendingKills, auth.baseUrl, auth.pat);
                 }
                 const acts = body?.activations ?? [];
-                for (const act of acts) {
+                const { singletons, sets } = groupBySession(acts);
+                for (const [choirSessionId, setActs] of sets) {
+                    for (const a of setActs)
+                        if (a?.id)
+                            seen.add(a.id);
+                    if (launchedSessions.has(choirSessionId))
+                        continue;
+                    launchedSessions.add(choirSessionId);
+                    firedThisPoll = true;
+                    for (const a of setActs) {
+                        if (a.kind === 'real')
+                            safeEmit(a.id, RUN_STAGE.LAUNCHING, seqMetrics(a));
+                    }
+                    try {
+                        const result = await launchCoordinatedSetFn({
+                            choirSessionId,
+                            activations: setActs,
+                            auth,
+                            deps: deps.coordinatedSetDeps,
+                        });
+                        for (const pane of result.panes) {
+                            const a = setActs.find((x) => x.id === pane.activationId);
+                            const metrics = a && a.kind === 'real' ? seqMetrics(a) : undefined;
+                            if (pane.tmuxPaneId) {
+                                trackedPanes.set(pane.activationId, pane.tmuxPaneId);
+                                trackedMeta.set(pane.activationId, {
+                                    story: pane.paneName,
+                                    provider: pane.provider,
+                                    startedAt: Date.now(),
+                                    paneId: pane.tmuxPaneId,
+                                });
+                                retitlePane('running', pane.tmuxPaneId, pane.paneName);
+                            }
+                            safeEmit(pane.activationId, RUN_STAGE.AGENT_STARTED, metrics);
+                            try {
+                                const hb = startRunHeartbeatFn({
+                                    baseUrl: auth.baseUrl,
+                                    pat: auth.pat,
+                                    activationId: pane.activationId,
+                                    furthestStage: RUN_STAGE.AGENT_STARTED,
+                                    lastEventSeq: 0,
+                                });
+                                runHeartbeats.set(pane.activationId, hb);
+                            }
+                            catch {
+                            }
+                        }
+                        emitSummary();
+                    }
+                    catch (e) {
+                        errLog(statusRow('⚠', 'coordinated set failed', e.message, { stream: process.stderr }) + '\n');
+                        for (const a of setActs) {
+                            if (a.kind === 'real')
+                                safeEmit(a.id, RUN_STAGE.FAILED, seqMetrics(a));
+                            failedCount++;
+                        }
+                        emitSummary();
+                    }
+                }
+                for (const act of singletons) {
                     if (!act?.id || seen.has(act.id))
                         continue;
                     seen.add(act.id);

package/dist/lib/choir/coordinated-set.js

@@ -0,0 +1,207 @@
+import nodeFs from 'node:fs';
+import nodePath from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+import { assertValidName } from './names.js';
+import { addWorktree as defaultAddWorktree } from './worktree.js';
+import { createHub as defaultCreateHub } from './hub.js';
+import { PROVIDER_PROFILES } from '../command-builders.js';
+import { validateRepoPath } from '../payload-validator.js';
+const defaultFs = {
+    mkdirSync: (p, opts) => nodeFs.mkdirSync(p, opts),
+    writeFileSync: (p, data, opts) => nodeFs.writeFileSync(p, data, opts),
+};
+const MAX_PANES = 16;
+const PLAN_AUTH_GUARD = `unset ANTHROPIC_API_KEY; unset ANTHROPIC_AUTH_TOKEN`;
+function defaultRandom() {
+    return randomBytes(24).toString('hex');
+}
+function payloadOf(act) {
+    return (act?.payload ?? {});
+}
+export function choirSessionIdOf(act) {
+    const p = payloadOf(act);
+    return typeof p.choirSessionId === 'string' && p.choirSessionId.length > 0
+        ? p.choirSessionId
+        : null;
+}
+export function groupBySession(activations) {
+    const singletons = [];
+    const sets = new Map();
+    for (const act of activations) {
+        const sid = choirSessionIdOf(act);
+        if (sid === null) {
+            singletons.push(act);
+            continue;
+        }
+        const arr = sets.get(sid);
+        if (arr)
+            arr.push(act);
+        else
+            sets.set(sid, [act]);
+    }
+    return { singletons, sets };
+}
+function resolveProvider(act) {
+    const raw = payloadOf(act).provider;
+    if (typeof raw === 'string' && raw in PROVIDER_PROFILES)
+        return raw;
+    return 'claude';
+}
+function deriveSessionName(choirSessionId) {
+    let s = String(choirSessionId)
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 31);
+    if (s.length === 0 || !/^[a-z0-9]/.test(s))
+        s = `s${s}`.slice(0, 31);
+    return assertValidName(s, 'session');
+}
+function buildMcpJson() {
+    return JSON.stringify({
+        mcpServers: {
+            choir: {
+                command: 'nonbot',
+                args: ['choir-mcp'],
+                env: {
+                    CHOIR_SESSION_TOKEN: '',
+                    CHOIR_PANE_NONCE: '',
+                    CHOIR_PANE_ID: '',
+                },
+            },
+        },
+    }, null, 2);
+}
+function buildPaneCommand(worktreePath, provider, storyTitle) {
+    const cli = PROVIDER_PROFILES[provider].realCli;
+    const safeWt = worktreePath.replace(/'/g, `'\\''`);
+    const title = storyTitle.replace(/[\r\n]+/g, ' ');
+    const prompt = `You are one pane of a coordinated set. Read .choir/ for your brief, ` +
+        `use the choir MCP radar to coordinate, then work on: ${title}`;
+    const safePrompt = prompt.replace(/'/g, `'\\''`);
+    return `${PLAN_AUTH_GUARD}; cd '${safeWt}' && ${cli} '${safePrompt}'`;
+}
+export async function launchCoordinatedSet(args) {
+    const { choirSessionId, activations, auth } = args;
+    const deps = args.deps ?? {};
+    const fsImpl = deps.fsImpl ?? defaultFs;
+    const randomImpl = deps.randomImpl ?? defaultRandom;
+    const addWorktreeImpl = deps.addWorktreeImpl ?? defaultAddWorktree;
+    const createHubImpl = deps.createHubImpl ?? defaultCreateHub;
+    const spawnPane = deps.spawnPaneImpl ?? resolveDefaultSpawnPane(auth);
+    if (!Array.isArray(activations) || activations.length === 0) {
+        throw new Error('coordinated set has no activations');
+    }
+    if (activations.length > MAX_PANES) {
+        throw new Error(`coordinated set exceeds ${MAX_PANES} panes`);
+    }
+    const sessionName = deriveSessionName(choirSessionId);
+    const repoRootRaw = typeof payloadOf(activations[0]).repoPath === 'string'
+        ? payloadOf(activations[0]).repoPath
+        : (activations[0].repoPath ?? '');
+    if (!repoRootRaw)
+        throw new Error('coordinated set activation has no repoPath');
+    const repoRoot = validateRepoPath(repoRootRaw);
+    for (const act of activations) {
+        const p = payloadOf(act);
+        const actRepo = typeof p.repoPath === 'string' ? p.repoPath : (act.repoPath ?? '');
+        if (actRepo !== repoRoot) {
+            throw new Error('coordinated set spans multiple repoPaths — a set must be one repo');
+        }
+    }
+    const token = randomImpl();
+    if (typeof token !== 'string' || token.length === 0) {
+        throw new Error('coordinated set token minting produced an empty token');
+    }
+    const sessionId = `choir_${sessionName}_${token.slice(0, 8)}`;
+    const baseBranch = 'HEAD';
+    const hub = createHubImpl({
+        sessionId,
+        repoRoot,
+        baseBranch,
+        token,
+        baseUrl: auth.baseUrl,
+        pat: auth.pat,
+        autoTimers: true,
+    });
+    hub.start();
+    const panes = [];
+    let paneIndex = 0;
+    for (const act of activations) {
+        paneIndex += 1;
+        const paneName = assertValidName(`pane${paneIndex}`, 'pane');
+        const provider = resolveProvider(act);
+        const story = typeof payloadOf(act).storyTitle === 'string'
+            ? payloadOf(act).storyTitle
+            : `${act.kind} activation`;
+        const { worktreePath, branch } = addWorktreeImpl({
+            repoRoot,
+            sessionName,
+            paneName,
+            baseBranch,
+        });
+        const nonce = randomImpl();
+        const mcpPath = nodePath.join(worktreePath, '.mcp.json');
+        fsImpl.mkdirSync(worktreePath, { recursive: true });
+        fsImpl.writeFileSync(mcpPath, buildMcpJson(), { mode: 0o600 });
+        hub.dispatch({
+            type: 'register',
+            paneId: branch,
+            name: paneName,
+            branch,
+            worktreePath,
+            nonce,
+            ts: Date.now(),
+        });
+        const command = buildPaneCommand(worktreePath, provider, story);
+        const scriptPath = nodePath.join(tmpdir(), `nonbot-choir-${sessionId}-${paneName}.sh`);
+        const scriptBody = `#!/bin/bash\n${command}\n`;
+        fsImpl.writeFileSync(scriptPath, scriptBody, { mode: 0o700 });
+        const env = {
+            ...process.env,
+            CHOIR_SESSION_TOKEN: token,
+            CHOIR_PANE_NONCE: nonce,
+            CHOIR_PANE_ID: branch,
+            NONBOT_PAT: auth.pat,
+            NONBOT_RUN_ID: act.id,
+            NONBOT_BASE_URL: auth.baseUrl,
+            NONBOT_ROLE: 'lead',
+        };
+        const spawnResult = (await spawnPane({ command, scriptPath, cwd: worktreePath, env, provider, activationId: act.id, paneName })) ??
+            {};
+        const tmuxPaneId = spawnResult.tmuxPaneId ?? null;
+        panes.push({
+            activationId: act.id,
+            paneName,
+            branch,
+            worktreePath,
+            provider,
+            tmuxPaneId,
+        });
+    }
+    return { choirSessionId, sessionId, repoRoot, hub, panes, tokenForTest: token };
+}
+function resolveDefaultSpawnPane(_auth) {
+    return async (a) => {
+        const { spawn } = await import('node:child_process');
+        const proc = spawn('tmux', ['new-window', '-P', '-F', '#{pane_id}', '-n', a.paneName, `bash ${shArg(a.scriptPath)}`], {
+            cwd: a.cwd,
+            env: a.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return await new Promise((resolve) => {
+            const chunks = [];
+            proc.stdout?.on('data', (c) => chunks.push(c));
+            proc.on('error', () => resolve({ tmuxPaneId: null }));
+            proc.on('exit', () => {
+                const out = Buffer.concat(chunks).toString('utf-8').trim().split(/\s+/)[0] ?? '';
+                resolve({ tmuxPaneId: /^%\d+$/.test(out) ? out : null });
+            });
+        });
+    };
+}
+function shArg(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.8.0';
+export const VERSION = '0.9.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "description": "The local host for non.bot ▶ Run — opens a terminal on your machine and starts the work in your linked repo.",
   "license": "UNLICENSED",