@nonbot/cli 0.9.2 → 0.9.4

package/dist/commands/daemon.js

@@ -4,8 +4,10 @@ import * as activations from '../lib/activations.js';
 import { fireActivation, makeHeadlessSpawner, } from '../lib/activations.js';
 import { checkCompletions } from '../lib/completion.js';
 import { deliverAnsweredPrompts } from '../lib/run-prompt.js';
+import { loadOrCreateMachineId, resolveMachineName } from '../lib/machine.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 { groupBySession, launchCoordinatedSet, setIsIsolated, } from '../lib/choir/coordinated-set.js';
+import { IsolatedSessionTracker, reconcileAndCleanup as defaultReconcileAndCleanup, resolveBaseBranch as defaultResolveBaseBranch, } from '../lib/choir/isolated-session.js';
 import { applyPaneTitle } from '../lib/pane-title.js';
 import { installService, uninstallService } from '../lib/service.js';
 import { detectTmuxSession, inTmuxSession, nonbotTmuxOptOut, resolveTerminal, } from '../lib/terminal.js';
@@ -177,6 +179,8 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     }
     const detectTmux = deps.detectTmuxSession ?? detectTmuxSession;
     const tmuxSessionName = detectTmux();
+    const machineId = deps.machineId ?? loadOrCreateMachineId();
+    const machineName = resolveMachineName();
     if (tmuxSessionName) {
         applyNonbotTmuxConfig({ spawnSync: deps.spawnSync });
     }
@@ -190,6 +194,10 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     const seen = new Set();
     const launchedSessions = new Set();
     const launchCoordinatedSetFn = deps.launchCoordinatedSet ?? launchCoordinatedSet;
+    const isolatedSessions = deps.isolatedSessions ?? new IsolatedSessionTracker();
+    const reconcileAndCleanupFn = deps.reconcileAndCleanup ?? defaultReconcileAndCleanup;
+    const resolveBaseBranchFn = deps.resolveBaseBranch ?? defaultResolveBaseBranch;
+    const reconcileBuildCommand = deps.reconcileBuildCommand ?? process.env.NONBOT_RECONCILE_BUILD_CMD ?? '';
     const trackedPanes = new Map();
     const killedByStop = new Set();
     const injectedPrompts = new Set();
@@ -304,6 +312,8 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                 'X-CLI-Version': VERSION,
                 'X-Terminal-Kind': terminalKind,
                 'X-Terminal-Launchable': terminalLaunchable ? 'true' : 'false',
+                'X-Machine-Id': machineId,
+                'X-Machine-Name': machineName,
             };
             if (tmuxSessionName)
                 headers['X-Tmux-Session'] = tmuxSessionName;
@@ -346,6 +356,11 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                 const acts = body?.activations ?? [];
                 const { singletons, sets } = groupBySession(acts);
                 for (const [choirSessionId, setActs] of sets) {
+                    if (!setIsIsolated(setActs)) {
+                        for (const a of setActs)
+                            singletons.push(a);
+                        continue;
+                    }
                     for (const a of setActs)
                         if (a?.id)
                             seen.add(a.id);
@@ -391,6 +406,22 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                             catch {
                             }
                         }
+                        try {
+                            isolatedSessions.register({
+                                choirSessionId,
+                                sessionId: result.sessionId,
+                                repoRoot: result.repoRoot,
+                                baseBranch: resolveBaseBranchFn(result.repoRoot, deps.spawnSync),
+                                buildTestCommand: reconcileBuildCommand,
+                                panes: result.panes.map((p) => ({
+                                    activationId: p.activationId,
+                                    branch: p.branch,
+                                    worktreePath: p.worktreePath,
+                                })),
+                            });
+                        }
+                        catch {
+                        }
                         lastFailureReason = null;
                         emitSummary();
                     }
@@ -465,6 +496,7 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                         baseUrl: auth.baseUrl,
                         pat: auth.pat,
                         injected: injectedPrompts,
+                        machineId,
                         fetchImpl,
                         spawnImpl: deps.spawnSync,
                         log,
@@ -506,6 +538,20 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                             trackedMeta.delete(id);
                             safeEmit(id, RUN_STAGE.FINISHED);
                             stopHeartbeat(id, 'daemon-exit');
+                            try {
+                                const session = isolatedSessions.noteTerminal(id);
+                                if (session) {
+                                    reconcileAndCleanupFn(session, {
+                                        spawnImpl: deps.spawnSync,
+                                        log,
+                                    });
+                                }
+                            }
+                            catch (e) {
+                                errLog(statusRow('⚠', 'reconcile failed', e.message, {
+                                    stream: process.stderr,
+                                }) + '\n');
+                            }
                         }
                         emitSummary();
                     }

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

@@ -25,6 +25,12 @@ export function choirSessionIdOf(act) {
         ? p.choirSessionId
         : null;
 }
+export function isolateOf(act) {
+    return payloadOf(act).isolate === true;
+}
+export function setIsIsolated(activations) {
+    return Array.isArray(activations) && activations.some(isolateOf);
+}
 export function groupBySession(activations) {
     const singletons = [];
     const sets = new Map();

package/dist/lib/choir/isolated-session.js

@@ -0,0 +1,92 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { removeWorktree as defaultRemoveWorktree } from './worktree.js';
+import { runReconcile as defaultRunReconcile } from './reconcile.js';
+import { isValidBranch } from './names.js';
+export class IsolatedSessionTracker {
+    sessions = new Map();
+    register(a) {
+        if (this.sessions.has(a.choirSessionId))
+            return;
+        this.sessions.set(a.choirSessionId, {
+            choirSessionId: a.choirSessionId,
+            sessionId: a.sessionId,
+            repoRoot: a.repoRoot,
+            baseBranch: a.baseBranch,
+            buildTestCommand: a.buildTestCommand ?? '',
+            panes: a.panes,
+            pending: new Set(a.panes.map((p) => p.activationId)),
+        });
+    }
+    tracks(activationId) {
+        for (const s of this.sessions.values()) {
+            if (s.pending.has(activationId))
+                return true;
+        }
+        return false;
+    }
+    noteTerminal(activationId) {
+        for (const s of this.sessions.values()) {
+            if (!s.pending.delete(activationId))
+                continue;
+            if (s.pending.size === 0) {
+                this.sessions.delete(s.choirSessionId);
+                return s;
+            }
+            return null;
+        }
+        return null;
+    }
+    get size() {
+        return this.sessions.size;
+    }
+}
+export function resolveBaseBranch(repoRoot, spawnImpl = nodeSpawnSync) {
+    try {
+        const r = spawnImpl('git', ['-C', repoRoot, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+            encoding: 'utf-8',
+            timeout: 5000,
+            windowsHide: true,
+        });
+        const name = typeof r.stdout === 'string' ? r.stdout.trim() : '';
+        if (isValidBranch(name))
+            return name;
+    }
+    catch {
+    }
+    return 'main';
+}
+export function reconcileAndCleanup(session, deps = {}) {
+    const spawnImpl = deps.spawnImpl ?? nodeSpawnSync;
+    const runReconcileImpl = deps.runReconcileImpl ?? defaultRunReconcile;
+    const removeWorktreeImpl = deps.removeWorktreeImpl ?? defaultRemoveWorktree;
+    const log = deps.log;
+    const branches = session.panes.map((p) => p.branch);
+    const reconcile = runReconcileImpl({
+        repoRoot: session.repoRoot,
+        baseBranch: session.baseBranch,
+        branches,
+        buildTestCommand: session.buildTestCommand,
+        sessionId: session.sessionId,
+        spawnImpl,
+        emit: deps.emit,
+    });
+    const removed = [];
+    if (!reconcile.blocked) {
+        for (const p of session.panes) {
+            try {
+                removeWorktreeImpl({ repoRoot: session.repoRoot, worktreePath: p.worktreePath });
+                removed.push(p.worktreePath);
+            }
+            catch {
+            }
+        }
+        log?.(`[reconcile] ${session.sessionId} — merged ${reconcile.merged.length} ` +
+            `branch${reconcile.merged.length === 1 ? '' : 'es'}, ` +
+            `removed ${removed.length} worktree${removed.length === 1 ? '' : 's'}\n`);
+    }
+    else {
+        log?.(`[reconcile] ${session.sessionId} — BLOCKED (${reconcile.reason}); ` +
+            `worktrees kept for the human merge gate\n`);
+    }
+    return { reconcile, removed };
+}

package/dist/lib/machine.js

@@ -0,0 +1,51 @@
+import { homedir, hostname } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+const NAME_MAX = 64;
+function configDir() {
+    const override = process.env.NONBOT_CONFIG_DIR;
+    if (override && override.length > 0)
+        return override;
+    return path.join(homedir(), '.config', 'nonbot');
+}
+export function machineFilePath(dir = configDir()) {
+    return path.join(dir, 'machine.json');
+}
+export function loadOrCreateMachineId(deps = {}) {
+    const fs = deps.fs ?? nodeFs;
+    const uuid = deps.uuid ?? randomUUID;
+    const dir = deps.dir ?? configDir();
+    const file = path.join(dir, 'machine.json');
+    try {
+        if (fs.existsSync(file)) {
+            const raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            if (raw && typeof raw.machineId === 'string' && raw.machineId.length > 0) {
+                return raw.machineId;
+            }
+        }
+    }
+    catch {
+    }
+    const machineId = uuid();
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(file, JSON.stringify({ machineId, createdAt: Date.now() }), { mode: 0o600 });
+    }
+    catch {
+    }
+    return machineId;
+}
+export function resolveMachineName(env = process.env) {
+    const override = env.NONBOT_MACHINE_NAME;
+    if (override && override.trim().length > 0)
+        return override.trim().slice(0, NAME_MAX);
+    try {
+        const h = hostname();
+        if (h && h.length > 0)
+            return h.slice(0, NAME_MAX);
+    }
+    catch {
+    }
+    return 'unknown';
+}

package/dist/lib/run-prompt.js

@@ -99,13 +99,14 @@ export async function reportPrompt(args) {
 export async function pollAnsweredPrompts(args) {
     const fetchImpl = args.fetchImpl ?? fetch;
     try {
-        const res = await fetchImpl(`${args.baseUrl}/api/cli/run-prompts/answered`, {
-            headers: {
-                Authorization: `Bearer ${args.pat}`,
-                'X-Requested-With': 'ConradPM-Native',
-                'X-CLI-Version': VERSION,
-            },
-        });
+        const headers = {
+            Authorization: `Bearer ${args.pat}`,
+            'X-Requested-With': 'ConradPM-Native',
+            'X-CLI-Version': VERSION,
+        };
+        if (args.machineId)
+            headers['X-Machine-Id'] = args.machineId;
+        const res = await fetchImpl(`${args.baseUrl}/api/cli/run-prompts/answered`, { headers });
         if (!res.ok)
             return [];
         const data = (await res.json());
@@ -178,6 +179,7 @@ export async function deliverAnsweredPrompts(opts) {
     const answered = await pollAnsweredPrompts({
         baseUrl: opts.baseUrl,
         pat: opts.pat,
+        machineId: opts.machineId,
         fetchImpl: opts.fetchImpl,
     });
     if (answered.length === 0)

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.9.2';
+export const VERSION = '0.9.4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "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",