@nonbot/cli 0.5.14 → 0.6.0

package/dist/lib/choir/hub.js

@@ -0,0 +1,478 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { appendFileSync as nodeAppendFileSync, statSync as nodeStatSync, renameSync as nodeRenameSync, writeFileSync as nodeWriteFileSync, } from 'node:fs';
+import { applyAction, selectRadar } from './hub-reducer.js';
+import { appendAction, replayJournal } from './journal.js';
+import { pollGitStatus } from './worktree.js';
+import { EmissionGate } from './debounce.js';
+import { makeEvent, sanitizeForEgress, assertNoForbiddenFields } from './progress-events.js';
+import { LOCAL_TEXT_MAX, SUMMARY_MAX, } from './types.js';
+const DEFAULT_POLL_MS = 5_000;
+const DEFAULT_HEARTBEAT_MS = 30_000;
+const DEFAULT_WRITE_RATE_LIMIT = 60;
+const DEFAULT_WRITE_RATE_WINDOW_MS = 60_000;
+const READ_TOOLS = new Set(['choir_radar', 'choir_check', 'choir_status']);
+const WRITE_TOOLS = new Set(['choir_announce', 'choir_release', 'choir_broadcast']);
+const ALL_TOOLS = new Set([...READ_TOOLS, ...WRITE_TOOLS]);
+function constantTimeEqual(a, b) {
+    if (typeof a !== 'string' || typeof b !== 'string')
+        return false;
+    if (a.length !== b.length) {
+        let acc = 1;
+        const n = Math.max(a.length, b.length);
+        for (let i = 0; i < n; i++) {
+            acc |= (a.charCodeAt(i) || 0) ^ (b.charCodeAt(i) || 0);
+        }
+        return false && acc === 0;
+    }
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return result === 0;
+}
+export function createHub(opts) {
+    const now = opts.now ?? (() => Date.now());
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const spawnImpl = opts.spawnImpl;
+    const journalFs = opts.journalFs ?? {
+        appendFileSync: nodeAppendFileSync,
+        statSync: nodeStatSync,
+        renameSync: nodeRenameSync,
+        writeFileSync: nodeWriteFileSync,
+    };
+    const pollIntervalMs = opts.pollIntervalMs ?? DEFAULT_POLL_MS;
+    const heartbeatIntervalMs = opts.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS;
+    const writeRateLimit = opts.writeRateLimit ?? DEFAULT_WRITE_RATE_LIMIT;
+    const writeRateWindowMs = opts.writeRateWindowMs ?? DEFAULT_WRITE_RATE_WINDOW_MS;
+    const sockPath = opts.sockPath ??
+        process.env.CHOIR_SOCK ??
+        path.join(homedir(), '.nonbot', 'choir.sock');
+    const journalPath = opts.journalPath ?? path.join(opts.repoRoot, '.choir', 'journal.ndjson');
+    const baseUrl = opts.baseUrl ?? process.env.NONBOT_BASE_URL ?? 'https://non.bot';
+    const pat = opts.pat ?? process.env.NONBOT_PAT ?? '';
+    let state = bootstrapState();
+    const rateWindows = new Map();
+    const gate = new EmissionGate();
+    let pendingEvents = [];
+    let server = null;
+    let pollTimer = null;
+    let heartbeatTimer = null;
+    let egressTimer = null;
+    function bootstrapState() {
+        let recovered;
+        try {
+            const text = safeReadJournal();
+            if (text) {
+                recovered = replayJournal(text.split('\n'), applyAction, undefined);
+            }
+        }
+        catch {
+            recovered = undefined;
+        }
+        if (recovered && recovered.sessionId)
+            return recovered;
+        return applyAction(undefined, {
+            type: 'session-init',
+            sessionId: opts.sessionId,
+            repoRoot: opts.repoRoot,
+            baseBranch: opts.baseBranch,
+            ts: now(),
+        });
+    }
+    function safeReadJournal() {
+        try {
+            const anyFs = journalFs;
+            if (typeof anyFs.readFileSync === 'function') {
+                return anyFs.readFileSync(journalPath, 'utf-8');
+            }
+            const fs = require('node:fs');
+            if (!fs.existsSync(journalPath))
+                return null;
+            return fs.readFileSync(journalPath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    function dispatch(action) {
+        const before = state;
+        let next;
+        try {
+            next = applyAction(state, action);
+        }
+        catch {
+            return;
+        }
+        if (next === before)
+            return;
+        state = next;
+        try {
+            appendAction(journalPath, action, journalFs);
+        }
+        catch {
+        }
+        try {
+            enqueueEgress(action);
+        }
+        catch {
+        }
+    }
+    function handleCall(ident, tool, claimedPaneId, args) {
+        if (!ident.authenticated || !ident.paneId) {
+            return { ok: false, error: 'not authenticated' };
+        }
+        if (!ALL_TOOLS.has(tool)) {
+            return { ok: false, error: 'unknown tool' };
+        }
+        if (claimedPaneId !== ident.paneId) {
+            return { ok: false, error: 'pane identity mismatch' };
+        }
+        const paneId = ident.paneId;
+        if (WRITE_TOOLS.has(tool) && !allowWrite(paneId)) {
+            return { ok: false, error: 'rate limited' };
+        }
+        const ts = now();
+        switch (tool) {
+            case 'choir_radar':
+                return { ok: true, result: selectRadar(state) };
+            case 'choir_check': {
+                const paths = toStringArray(args.paths);
+                const overlaps = state.claims
+                    .filter((c) => c.paneId !== paneId && c.paths.some((p) => paths.includes(p)))
+                    .map((c) => ({
+                    paneId: c.paneId,
+                    area: c.area,
+                    overlap: c.paths.filter((p) => paths.includes(p)),
+                }));
+                return { ok: true, result: { overlaps } };
+            }
+            case 'choir_status': {
+                const pane = state.panes[paneId];
+                if (!pane)
+                    return { ok: false, error: 'unknown pane' };
+                return {
+                    ok: true,
+                    result: {
+                        paneId: pane.paneId,
+                        branch: pane.branch,
+                        worktreePath: pane.worktreePath,
+                        status: pane.status,
+                        dirtyFiles: pane.dirtyFiles,
+                        commitsAhead: pane.commitsAhead,
+                        mergeReady: pane.mergeReady,
+                    },
+                };
+            }
+            case 'choir_announce': {
+                dispatch({
+                    type: 'announce',
+                    paneId,
+                    area: clampLocal(String(args.area ?? '')),
+                    paths: toStringArray(args.paths),
+                    summary: clampSummary(String(args.summary ?? '')),
+                    ts,
+                });
+                return { ok: true, result: selectRadar(state) };
+            }
+            case 'choir_release': {
+                dispatch({ type: 'release', paneId, paths: toStringArray(args.paths), ts });
+                return { ok: true, result: selectRadar(state) };
+            }
+            case 'choir_broadcast': {
+                const kind = args.kind === 'contract-change' ? 'contract-change' : 'note';
+                dispatch({
+                    type: 'broadcast',
+                    paneId,
+                    kind,
+                    msg: clampLocal(String(args.msg ?? '')),
+                    ts,
+                });
+                return { ok: true, result: selectRadar(state) };
+            }
+            default:
+                return { ok: false, error: 'unknown tool' };
+        }
+    }
+    function allowWrite(paneId) {
+        const t = now();
+        let w = rateWindows.get(paneId);
+        if (!w || t - w.windowStart >= writeRateWindowMs) {
+            w = { count: 0, windowStart: t };
+            rateWindows.set(paneId, w);
+        }
+        if (w.count >= writeRateLimit)
+            return false;
+        w.count += 1;
+        return true;
+    }
+    function onConnection(sock) {
+        const ident = { authenticated: false, paneId: null };
+        let buffer = '';
+        const respond = (obj) => {
+            try {
+                sock.write(JSON.stringify(obj) + '\n');
+            }
+            catch {
+            }
+        };
+        const onData = (chunk) => {
+            try {
+                buffer += chunk.toString();
+                let nl;
+                while ((nl = buffer.indexOf('\n')) !== -1) {
+                    const line = buffer.slice(0, nl).trim();
+                    buffer = buffer.slice(nl + 1);
+                    if (line === '')
+                        continue;
+                    handleLine(line);
+                }
+            }
+            catch {
+            }
+        };
+        const handleLine = (line) => {
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                respond({ ok: false, error: 'bad json' });
+                return;
+            }
+            if (msg && msg.type === 'hello') {
+                const tokenOk = constantTimeEqual(String(msg.token ?? ''), opts.token);
+                const pane = state.panes[String(msg.paneId ?? '')];
+                const nonceOk = !!pane && constantTimeEqual(String(msg.nonce ?? ''), pane.nonce);
+                if (!tokenOk || !nonceOk) {
+                    respond({ ok: false, error: 'unauthorized' });
+                    try {
+                        sock.destroy();
+                    }
+                    catch {
+                    }
+                    return;
+                }
+                ident.authenticated = true;
+                ident.paneId = String(msg.paneId);
+                respond({ ok: true, result: { bound: ident.paneId } });
+                return;
+            }
+            if (msg && msg.type === 'call') {
+                const res = handleCall(ident, String(msg.tool ?? ''), String(msg.paneId ?? ''), msg.args ?? {});
+                respond(res);
+                return;
+            }
+            respond({ ok: false, error: 'unknown message type' });
+        };
+        try {
+            sock.on('data', onData);
+            sock.on('error', () => {
+            });
+            sock.on('close', () => {
+            });
+        }
+        catch {
+        }
+    }
+    function pollOnce() {
+        if (!spawnImpl)
+            return;
+        for (const pane of Object.values(state.panes)) {
+            try {
+                const poll = pollGitStatus(pane.worktreePath, spawnImpl, opts.baseBranch);
+                dispatch({
+                    type: 'infer',
+                    paneId: pane.paneId,
+                    paths: poll.dirtyPaths,
+                    dirtyFiles: poll.dirtyFiles,
+                    commitsAhead: poll.commitsAhead,
+                    ts: now(),
+                });
+            }
+            catch {
+            }
+        }
+    }
+    function enqueueEgress(action) {
+        const mapping = stageForAction(action);
+        if (!mapping)
+            return;
+        const ts = now();
+        const event = makeEvent({
+            sessionId: state.sessionId,
+            engine: 'choir',
+            paneId: 'paneId' in action ? action.paneId : null,
+            stage: mapping.stage,
+            summary: mapping.summary,
+            ts,
+            metrics: mapping.metrics,
+            refs: mapping.branch ? { branch: mapping.branch } : undefined,
+        }, { now });
+        const decision = gate.consider(event, ts, mapping.hints);
+        if (decision.action === 'suppress')
+            return;
+        pendingEvents.push(event);
+    }
+    function stageForAction(action) {
+        switch (action.type) {
+            case 'register': {
+                const pane = state.panes[action.paneId];
+                return {
+                    stage: 'pane-spawned',
+                    summary: `pane ${pane?.name ?? ''} spawned`,
+                    branch: pane?.branch,
+                    metrics: { paneTotal: Object.keys(state.panes).length },
+                };
+            }
+            case 'announce':
+                return {
+                    stage: 'claim-announced',
+                    summary: clampSummary(action.summary || `claim on ${action.area}`),
+                    metrics: { claimCount: state.claims.length },
+                };
+            case 'broadcast':
+                return {
+                    stage: 'broadcast-sent',
+                    summary: action.kind === 'contract-change' ? 'contract change broadcast' : 'broadcast sent',
+                };
+            case 'status': {
+                const pane = state.panes[action.paneId];
+                if (action.status === 'complete')
+                    return { stage: 'pane-complete', summary: 'pane complete', branch: pane?.branch };
+                if (action.status === 'failed')
+                    return { stage: 'pane-failed', summary: 'pane failed', branch: pane?.branch };
+                if (action.status === 'stopped')
+                    return { stage: 'pane-stopped', summary: 'pane stopped', branch: pane?.branch };
+                return null;
+            }
+            default:
+                return null;
+        }
+    }
+    function flushEgress() {
+        if (pendingEvents.length === 0)
+            return;
+        const batch = pendingEvents.map((e) => sanitizeForEgress(e));
+        pendingEvents = [];
+        const safe = [];
+        for (const ev of batch) {
+            try {
+                assertNoForbiddenFields(ev);
+                safe.push(ev);
+            }
+            catch {
+            }
+        }
+        if (safe.length === 0)
+            return;
+        postJson(`${baseUrl}/api/cli/choir/events`, { sessionId: state.sessionId, events: safe });
+    }
+    function sendHeartbeat() {
+        const panes = Object.values(state.panes);
+        const body = {
+            sessionId: state.sessionId,
+            lastEventSeq: state.lastEventSeq,
+            ts: now(),
+            metrics: {
+                paneTotal: panes.length,
+                panesComplete: panes.filter((p) => p.status === 'complete').length,
+                overlapCount: state.collisions.length,
+                claimCount: state.claims.length,
+            },
+        };
+        const safe = {
+            sessionId: body.sessionId,
+            lastEventSeq: body.lastEventSeq,
+            ts: body.ts,
+            metrics: sanitizeForEgress({ metrics: body.metrics }).metrics ?? {},
+        };
+        try {
+            assertNoForbiddenFields(safe);
+        }
+        catch {
+            return;
+        }
+        postJson(`${baseUrl}/api/cli/choir/heartbeat`, safe);
+    }
+    function postJson(url, body) {
+        try {
+            const p = fetchImpl(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${pat}`,
+                    'Content-Type': 'application/json',
+                    'X-Requested-With': 'ConradPM-Native',
+                    'X-Requested-With-Engine': 'choir',
+                },
+                body: JSON.stringify(body),
+            });
+            if (p && typeof p.catch === 'function') {
+                ;
+                p.catch(() => {
+                });
+            }
+        }
+        catch {
+        }
+    }
+    return {
+        start() {
+            try {
+                const impl = opts.netImpl;
+                if (!impl)
+                    return;
+                server = impl.createServer((sock) => onConnection(sock));
+                server.listen(sockPath, () => {
+                });
+            }
+            catch {
+                server = null;
+            }
+            if (opts.autoTimers) {
+                try {
+                    pollTimer = setInterval(() => pollOnce(), pollIntervalMs);
+                    pollTimer.unref?.();
+                    egressTimer = setInterval(() => flushEgress(), Math.min(pollIntervalMs, 5_000));
+                    egressTimer.unref?.();
+                    heartbeatTimer = setInterval(() => sendHeartbeat(), heartbeatIntervalMs);
+                    heartbeatTimer.unref?.();
+                }
+                catch {
+                }
+            }
+        },
+        stop() {
+            try {
+                if (pollTimer)
+                    clearInterval(pollTimer);
+                if (egressTimer)
+                    clearInterval(egressTimer);
+                if (heartbeatTimer)
+                    clearInterval(heartbeatTimer);
+                server?.close(() => {
+                });
+            }
+            catch {
+            }
+        },
+        getState() {
+            return state;
+        },
+        dispatch,
+        pollOnce,
+        flushEgress,
+        sendHeartbeat,
+    };
+}
+function toStringArray(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v.filter((x) => typeof x === 'string');
+}
+function clampLocal(s) {
+    return s.slice(0, LOCAL_TEXT_MAX);
+}
+function clampSummary(s) {
+    return s.slice(0, SUMMARY_MAX);
+}

package/dist/lib/choir/journal.js

@@ -0,0 +1,59 @@
+import { appendFileSync as nodeAppendFileSync, statSync as nodeStatSync, renameSync as nodeRenameSync, writeFileSync as nodeWriteFileSync, } from 'node:fs';
+export const JOURNAL_MODE = 0o600;
+export const JOURNAL_SIZE_CAP = 2 * 1024 * 1024;
+export function serializeAction(action) {
+    return JSON.stringify(action) + '\n';
+}
+export function parseJournal(text) {
+    return parseLines(text.split('\n'));
+}
+function parseLines(lines) {
+    const out = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (line === '')
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+        }
+    }
+    return out;
+}
+export function replayJournal(lines, apply, initial) {
+    const actions = parseLines(lines);
+    let state = initial;
+    for (const action of actions) {
+        state = apply(state, action);
+    }
+    return state;
+}
+const defaultFs = {
+    appendFileSync: nodeAppendFileSync,
+    statSync: nodeStatSync,
+    renameSync: nodeRenameSync,
+    writeFileSync: nodeWriteFileSync,
+};
+export function appendAction(filePath, action, fs = defaultFs) {
+    const line = serializeAction(action);
+    const size = currentSize(filePath, fs);
+    if (size === null) {
+        fs.writeFileSync(filePath, line, { mode: JOURNAL_MODE });
+        return;
+    }
+    if (size > JOURNAL_SIZE_CAP) {
+        fs.renameSync(filePath, `${filePath}.1`);
+        fs.writeFileSync(filePath, line, { mode: JOURNAL_MODE });
+        return;
+    }
+    fs.appendFileSync(filePath, line);
+}
+function currentSize(filePath, fs) {
+    try {
+        return fs.statSync(filePath).size;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/choir/launcher.js

@@ -0,0 +1,133 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import nodeFs from 'node:fs';
+import nodePath from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { assertValidName, assertValidBranch } from './names.js';
+import { addWorktree as defaultAddWorktree } from './worktree.js';
+import { buildChoirBrief } from './brief.js';
+const defaultFs = {
+    mkdirSync: (p, opts) => nodeFs.mkdirSync(p, opts),
+    writeFileSync: (p, data, opts) => nodeFs.writeFileSync(p, data, opts),
+};
+const MAX_PANES = 16;
+function defaultRandom() {
+    return randomBytes(24).toString('hex');
+}
+function buildPaneShell(worktreePath, briefRelPath) {
+    const safeWt = worktreePath.replace(/'/g, `'\\''`);
+    const safeBrief = briefRelPath.replace(/'/g, `'\\''`);
+    const prompt = `Read ${safeBrief} (your Choir brief) and start work in this worktree.`;
+    const safePrompt = prompt.replace(/'/g, `'\\''`);
+    return (`cd '${safeWt}' && claude '${safePrompt}'` +
+        `; printf '\\n%s\\n' 'Choir pane finished — press enter to close'` +
+        `; read _` +
+        `; tmux kill-pane`);
+}
+function spawnPane(spawnImpl, shell, env) {
+    const r = spawnImpl('tmux', ['split-window', '-P', '-F', '#{pane_id}', shell, ';', 'select-layout', 'tiled'], {
+        encoding: 'utf-8',
+        timeout: 15_000,
+        windowsHide: true,
+        env,
+    });
+    if (r.status !== 0) {
+        throw new Error('choir pane spawn failed (tmux split-window)');
+    }
+    const out = typeof r.stdout === 'string' ? r.stdout : '';
+    const first = out.trim().split(/\s+/)[0] ?? '';
+    if (!/^%\d+$/.test(first)) {
+        throw new Error('choir pane spawn produced no pane id');
+    }
+    return first;
+}
+function buildMcpJson() {
+    const obj = {
+        mcpServers: {
+            choir: {
+                command: 'npx',
+                args: ['-y', '@nonbot/choir-mcp'],
+                env: {
+                    CHOIR_SESSION_TOKEN: '',
+                    CHOIR_PANE_NONCE: '',
+                    CHOIR_PANE_ID: '',
+                },
+            },
+        },
+    };
+    return JSON.stringify(obj, null, 2);
+}
+export function launchChoir(args) {
+    const { repoRoot, sessionName: rawSession, paneCount, baseBranch: rawBase, joinMode, spawnImpl = nodeSpawnSync, fsImpl = defaultFs, randomImpl = defaultRandom, addWorktreeImpl = defaultAddWorktree, startHub, } = args;
+    const sessionName = assertValidName(rawSession, 'session');
+    assertValidBranch(rawBase, 'base branch');
+    const baseBranch = rawBase;
+    if (!Number.isInteger(paneCount) ||
+        paneCount < 1 ||
+        paneCount > MAX_PANES) {
+        throw new Error(`choir pane count must be an integer in 1..${MAX_PANES}`);
+    }
+    const paneNames = Array.from({ length: paneCount }, (_v, i) => assertValidName(`pane${i + 1}`, 'pane'));
+    const token = randomImpl();
+    if (typeof token !== 'string' || token.length === 0) {
+        throw new Error('choir token minting produced an empty token');
+    }
+    const sessionId = `choir_${sessionName}_${token.slice(0, 8)}`;
+    const panes = [];
+    for (const paneName of paneNames) {
+        const { worktreePath, branch } = addWorktreeImpl({
+            repoRoot,
+            sessionName,
+            paneName,
+            baseBranch,
+        });
+        const nonce = randomImpl();
+        const briefRelPath = nodePath.join('.choir', `brief-${paneName}.md`);
+        const briefAbsPath = nodePath.join(worktreePath, briefRelPath);
+        const brief = buildChoirBrief({ paneName, sessionName, area: paneName });
+        fsImpl.mkdirSync(nodePath.dirname(briefAbsPath), { recursive: true });
+        fsImpl.writeFileSync(briefAbsPath, brief, { mode: 0o600 });
+        if (joinMode === 'launched-only') {
+            const mcpPath = nodePath.join(worktreePath, '.mcp.json');
+            fsImpl.writeFileSync(mcpPath, buildMcpJson(), { mode: 0o600 });
+        }
+        else {
+        }
+        const shell = buildPaneShell(worktreePath, briefRelPath);
+        const childEnv = {
+            ...process.env,
+            CHOIR_SESSION_TOKEN: token,
+            CHOIR_PANE_NONCE: nonce,
+            CHOIR_PANE_ID: branch,
+        };
+        const paneId = spawnPane(spawnImpl, shell, childEnv);
+        panes.push({ name: paneName, paneId, branch, worktreePath });
+    }
+    if (startHub !== false) {
+        const start = startHub ?? resolveDefaultStartHub();
+        start({ repoRoot, sessionId, baseBranch, token });
+    }
+    return {
+        sessionName,
+        sessionId,
+        repoRoot,
+        baseBranch,
+        joinMode,
+        panes,
+        tokenForTest: token,
+    };
+}
+function resolveDefaultStartHub() {
+    return ((arg) => {
+        return import('./hub.js')
+            .then((m) => {
+            const mod = m;
+            if (typeof mod.createHub !== 'function') {
+                throw new Error('choir hub module is missing createHub');
+            }
+            return mod.createHub(arg);
+        })
+            .catch((e) => {
+            throw new Error(`choir hub failed to start: ${e instanceof Error ? e.message : 'unknown'}`);
+        });
+    });
+}