@loompad/cli 1.2.3 → 1.2.5

package/dist/cli/index.js

@@ -27,7 +27,7 @@ import qrcode from "qrcode-terminal";
     }
 }
 import { exitCodeFor, turnOutcome } from "../core/turn-wait.js";
-import { DaemonClient, DaemonError, daemonRunning, desktopOwnsDaemon, ensureDaemon, stopDaemon, } from "../daemon/client.js";
+import { DaemonClient, DaemonError, daemonRunning, desktopOwnsDaemon, ensureDaemon, stopDaemon, turnsInFlight, } from "../daemon/client.js";
 import { installCrashGuards } from "../daemon/guards.js";
 import { LoomDaemon, DEFAULT_PORT } from "../daemon/server.js";
 import { ensureLoomHome, findProject, loomHome, readDaemonConfig } from "../core/registry.js";
@@ -200,7 +200,7 @@ program
     .description("start the loom daemon in the background")
     .option("--tailnet", "bind to this machine's Tailscale IP", false)
     .option("--restart", "restart even if a daemon is already running", false)
-    .option("--force", "with --restart: replace even Loom Desktop's daemon with this CLI's")
+    .option("--force", "with --restart: replace even Loom Desktop's daemon with this CLI's, and restart even with turns running")
     .action(async (opts) => {
     const running = await daemonRunning();
     if (running && !opts.force && (await desktopOwnsDaemon(running))) {
@@ -218,6 +218,14 @@ program
             console.log(pc.dim("daemon already running (loom up --restart to bounce it)"));
             return;
         }
+        // a restart kills turns in flight: say whose, and leave them be unless told otherwise
+        const busy = opts.force ? [] : await turnsInFlight(new DaemonClient(running));
+        if (busy.length) {
+            console.log(pc.yellow(`${busy.length} turn${busy.length === 1 ? " is" : "s are"} running (${busy.slice(0, 4).join(", ")}${busy.length > 4 ? ", …" : ""}) — ` +
+                `a restart would kill ${busy.length === 1 ? "it" : "them"}. Try again when they finish, or loom up --restart --force.`));
+            process.exitCode = 1;
+            return;
+        }
         console.log(pc.dim(stale ? "daemon is running an older build — restarting" : "restarting daemon"));
         await stopDaemon();
         const gone = Date.now() + 6000;
@@ -274,9 +282,27 @@ program
         return void console.log(JSON.stringify(projects)); // #315
     if (!projects.length)
         console.log(pc.dim("no projects yet — loom init"));
-    for (const p of projects)
-        console.log(formatProjectRow(p));
+    // inside a project, it comes first and says so: "is my turn running here?" is the usual question
+    const here = await resolveCurrentProject(client).catch(() => null);
+    const ordered = here ? [...projects.filter((p) => p.id === here.id), ...projects.filter((p) => p.id !== here.id)] : projects;
+    for (const p of ordered)
+        console.log(formatProjectRow(p) + (here && p.id === here.id ? pc.bold(pc.cyan("  ← here")) : ""));
 });
+/**
+ * Outside a project there's no roster, but the question "what can I run?" still has an
+ * answer: the agents installed on this machine (#feedback: agents outside a project).
+ */
+async function printMachineAgents(json) {
+    const { ADES, detectAdes } = await import("../core/ades.js");
+    const found = await detectAdes();
+    const rows = ADES.map((a) => ({ kind: a.kind, label: a.label, tier: a.tier, installed: a.tier === "adapter" ? Boolean(found[a.kind]) : null }));
+    if (json)
+        return void console.log(JSON.stringify({ project: null, machine: rows }));
+    console.log(pc.dim("not in a Loom project — this machine can drive:"));
+    for (const r of rows)
+        console.log(`  ${r.kind.padEnd(18)} ${r.label.padEnd(20)} ${r.installed === false ? pc.dim("not installed") : r.installed ? pc.green("installed") : pc.dim("app (launch it)")}`);
+    console.log(pc.dim("\nloom init here to make this folder a project with them"));
+}
 // ---------------------------------------------------------------------------
 // init / projects / agents
 // ---------------------------------------------------------------------------
@@ -335,7 +361,10 @@ program
     .option("--json", "print the agent roster as JSON")
     .action(async (opts) => {
     const client = await ensureDaemon();
-    const project = await currentProject(client);
+    const project = await resolveCurrentProject(client).catch((err) => { if (err instanceof NoProjectError)
+        return null; throw err; });
+    if (!project)
+        return void (await printMachineAgents(Boolean(opts.json)));
     if (opts.json) {
         console.log(JSON.stringify(project.agents));
         return;
@@ -1894,12 +1923,17 @@ program
         console.log(pc.dim(`no crews here yet — loom crew create [${templates.join("|")}] [name]`));
         return;
     }
+    // status shows every crew unless one is named; everything else needs to know which
+    if (a === "status" && !opts.crew) {
+        for (const c of crews)
+            printCrew(c);
+        return;
+    }
     const crew = opts.crew ? crews.find((c) => c.id === opts.crew || c.name === opts.crew) : crews.length === 1 ? crews[0] : undefined;
     if (!crew)
         throw new Error(`which crew? --crew ${crews.map((c) => c.id).join(" | ")}`);
     if (a === "status") {
-        for (const c of opts.crew ? [crew] : crews)
-            printCrew(c);
+        printCrew(crew);
         return;
     }
     if (a === "diff") {
@@ -1955,7 +1989,7 @@ function printCrew(c) {
 }
 program
     .command("team [action] [args...]")
-    .description("Loom Teams: status | signin [hub] | create <name> | invite | join <link> | share | unshare | brain [inbox|promote|resolve|correct|trust|private] | landing | doctor [fix] | adopt <pr> | deploys | release-notes <since> | webhook [--repo r] [--install] | remove <github> | leave")
+    .description("Loom Teams: status | auto [on] | signin [hub] | create <name> | invite | join <link> | share | unshare | brain [inbox|promote|resolve|correct|trust|private] | landing | doctor [fix] | adopt <pr> | deploys | release-notes <since> | webhook [--repo r] [--install] | remove <github> | leave")
     .option("--github <login>", "your GitHub login (defaults to the gh CLI's)")
     .option("--repo <owner/name>", "webhook: which repo (defaults to this project's)")
     .option("--install", "webhook: create it on the repo with gh (needs repo admin)")
@@ -1971,6 +2005,24 @@ program
     try {
         if (a === "status")
             return void printTeam(await client.team());
+        if (a === "auto") {
+            // team auto-orchestration: your goals split across teammates' machines, theirs across yours
+            const project = await currentProject(client);
+            const st = await client.teamAuto(project.id, arg === "on");
+            if (st.wrotePolicy)
+                console.log(`${pc.green("✓")} wrote loom.team.json (runners.shared) — commit and merge it; policy is reviewed like code`);
+            const mark = (ok) => (ok ? pc.green("✓") : pc.dim("·"));
+            console.log(`${mark(st.shared)} project shared with your team`);
+            console.log(`${mark(st.policyShared)} repo policy lets teammates' runners take its work`);
+            console.log(`${mark(st.myRunner.running && st.myRunner.shared)} your runner is on and shared (teammates' goals can use your agents)`);
+            const on = st.teammates.filter((t) => t.online);
+            console.log(`${mark(on.length > 0)} teammates' runners online: ${on.length ? on.map((t) => `${t.github} (${t.kinds.join(", ")})`).join(", ") : "none yet"}`);
+            if (st.ready)
+                console.log(`\n${pc.green("ready")} — goals you start get ${st.workers.join(", ")} as workers. ${pc.dim("loom orchestrate \"…\" (--solo to keep one local)")}`);
+            else
+                console.log(`\n${pc.yellow("not yet")} — ${st.missing.join("; ")}`);
+            return;
+        }
         if (a === "signin") {
             const { hostedHubUrl, hostedSupabaseUrl, publishableKeyFor } = await import("../core/hosted.js");
             const supabaseUrl = hostedSupabaseUrl(arg);
@@ -2505,13 +2557,43 @@ program
         process.exitCode = 1;
     }
 });
+program
+    .command("agents:mode <agentId> [mode]")
+    .description("an agent's access: bypass (no sandbox — can commit, push, use the network), auto (the default), or ask. No mode: show what each means for it")
+    .action(async (agentId, mode) => {
+    const client = await ensureDaemon();
+    const project = await currentProject(client);
+    const agent = project.agents.find((a) => a.id === agentId);
+    if (!agent)
+        fail(`no agent "${agentId}" here — loom agents`);
+    const { PERMISSION_PROFILES } = await import("../core/permissions.js");
+    const profile = PERMISSION_PROFILES[agent.kind];
+    if (!profile)
+        fail(`${agent.kind} has no access modes to choose from`);
+    const now = (agent.permissions ?? profile.default);
+    if (!mode) {
+        for (const [m, cell] of Object.entries(profile.modes)) {
+            const off = cell.unsupported;
+            console.log(`${m === now ? pc.green("●") : pc.dim("○")} ${pc.bold(m.padEnd(6))} ${off ? pc.dim(`${cell.label} — unavailable: ${off}`) : cell.label}`);
+        }
+        return void console.log(pc.dim(`\nloom agents:mode ${agentId} <bypass|auto|ask>`));
+    }
+    const res = await client.setAgentPermissions(project.id, agentId, mode);
+    const cell = profile.modes[(res.agent.permissions ?? mode)];
+    console.log(`${pc.green("✓")} ${agentId}: ${cell?.label ?? mode}`);
+    if (mode === "bypass")
+        console.log(pc.yellow("  no sandbox: it can commit, push, reach the network and run anything — on this machine, as you"));
+});
 program
     .command("agents:available")
     .description("which agents this machine can drive, and how many sessions are here")
     .option("--json", "print as JSON")
     .action(async (opts) => {
     const client = await ensureDaemon();
-    const project = await currentProject(client);
+    const project = await resolveCurrentProject(client).catch((err) => { if (err instanceof NoProjectError)
+        return null; throw err; });
+    if (!project)
+        return void (await printMachineAgents(Boolean(opts.json)));
     const { ades } = await client.availableAgents(project.id);
     if (opts.json)
         return void console.log(JSON.stringify(ades, null, 2));
@@ -2592,26 +2674,31 @@ async function offerGitignore(dir, choice) {
         return; // already ignored
     }
     catch { /* not ignored (exit 1), or no git: fall through */ }
-    const yes = choice === true || (process.stdin.isTTY && (await confirm(pc.yellow("add .loom/ to .gitignore? it's this machine's state (event log, attachments) — not for the repo"))));
+    // in a terminal, ask; in a script (no one to ask), do it — .loom/ is never meant for the repo
+    const yes = choice === true || !process.stdin.isTTY || (await confirm(pc.yellow("add .loom/ to .gitignore? it's this machine's state (event log, attachments) — not for the repo")));
     if (!yes)
         return void console.log(pc.dim("tip: .loom/ is local state — add it to .gitignore (loom init --gitignore)"));
     const file = path.join(dir, ".gitignore");
     const before = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
     fs.writeFileSync(file, `${before}${before && !before.endsWith("\n") ? "\n" : ""}# Loom's local state (event log, attachments, machine config)\n.loom/\n`);
-    console.log(pc.green("✓ added .loom/ to .gitignore"));
+    console.log(pc.green("✓ added .loom/ to .gitignore") + (process.stdin.isTTY ? "" : pc.dim(" (loom init --no-gitignore to leave it alone)")));
 }
-async function sendWithHandoffConfirm(client, projectId, text, agentId, interactive = true, fresh = false) {
+async function sendWithHandoffConfirm(client, projectId, text, agentId, interactive = true, fresh = false, handoff = false) {
     try {
         return await client.send(projectId, text, agentId, { fresh });
     }
     catch (err) {
         if (err instanceof DaemonError && err.status === 409 && agentId) {
             const holder = String(err.body?.holder ?? "another agent");
-            if (!interactive)
-                fail(`${agentId} doesn't hold the baton (holder: ${holder}) — loom handoff ${agentId}`);
-            const yes = await confirm(pc.yellow(`⟶ ${holder} holds the baton. Hand off to ${agentId} (interrupts current work)?`));
-            if (!yes)
+            // no one to ask (a script, --json) and no --handoff: fail loudly, never a quiet exit 0
+            if (!handoff && !interactive)
+                fail(`${agentId} doesn't hold the baton (holder: ${holder}) — add --handoff, or loom handoff ${agentId}`);
+            const yes = handoff || (await confirm(pc.yellow(`⟶ ${holder} holds the baton. Hand off to ${agentId} (interrupts current work)?`)));
+            if (!yes) {
+                process.exitCode = 1;
+                console.error(pc.dim(`not sent — ${holder} keeps the baton (--handoff hands it over without asking)`));
                 return null;
+            }
             await client.handoff(projectId, agentId);
             return await client.send(projectId, text, agentId, { fresh });
         }
@@ -2622,10 +2709,11 @@ program
     .command("send <text...>")
     .description("send one message into the shared thread")
     .option("-a, --agent <id>", "address a specific agent (may require a handoff)")
-    .option("--wait", "wait for the turn to end; print the reply and cost; exit 0 done, 1 failed, 2 asked a question, 124 timed out")
+    .option("--wait", "wait for the turn to end; print the reply and cost; exit 0 done, 1 failed, 2 asked a question, 75 interrupted (the daemon restarted), 124 timed out")
     .option("--json", "with --wait: print the outcome as one JSON object")
     .option("--timeout <seconds>", "with --wait: give up after this long", "1800")
     .option("--fresh", "start the agent's session in this chat over — a short question needn't re-read a long one")
+    .option("--handoff", "with --agent: take the baton from whoever holds it, without asking")
     .action(async (words, opts) => {
     const client = await ensureDaemon();
     const project = await currentProject(client);
@@ -2647,23 +2735,49 @@ program
     }
     // where the log is now, so the wait reads only what this send causes (#254)
     const since = opts.wait ? ((await client.events(project.id, undefined, 1)).events.at(-1)?.id ?? 0) : 0;
-    const result = await sendWithHandoffConfirm(client, project.id, words.join(" "), opts.agent, !opts.wait || process.stdin.isTTY, Boolean(opts.fresh));
+    // a question needs a person at a terminal — not a script, and never --json output
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !opts.json;
+    const result = await sendWithHandoffConfirm(client, project.id, words.join(" "), opts.agent, interactive, Boolean(opts.fresh), Boolean(opts.handoff));
     if (!result)
         return;
     if (!opts.wait)
         return void console.log(pc.dim(`→ sent to ${result.agentId} (loom log --follow to watch)`));
     const deadline = Date.now() + Math.max(1, Number(opts.timeout) || 1800) * 1000;
     let seen = [], outcome = null, cursor = since;
+    // the daemon this turn runs in: if it goes away or comes back as another process, the turn is gone
+    const daemonPid = await client.version().then((v) => v.pid).catch(() => null);
+    let lastPidCheck = Date.now(), interrupted = false;
     while (Date.now() < deadline && !outcome) {
-        const { events } = await client.events(project.id, cursor, 500);
-        if (events.length) {
-            seen = seen.concat(events);
-            cursor = events.at(-1).id;
+        try {
+            const { events } = await client.events(project.id, cursor, 500);
+            if (events.length) {
+                seen = seen.concat(events);
+                cursor = events.at(-1).id;
+            }
+            outcome = turnOutcome(seen, result.agentId, since);
+            if (!outcome && daemonPid && Date.now() - lastPidCheck > 5000) {
+                lastPidCheck = Date.now();
+                if ((await client.version()).pid !== daemonPid)
+                    interrupted = true;
+            }
+        }
+        catch {
+            interrupted = true; // the daemon stopped answering (or answered "event log is closed") mid-turn
         }
-        outcome = turnOutcome(seen, result.agentId, since);
+        if (interrupted)
+            break;
         if (!outcome)
             await new Promise((r) => setTimeout(r, 400));
     }
+    if (interrupted && !outcome) {
+        // EX_TEMPFAIL: not the agent's failure, and worth trying again
+        process.exitCode = 75;
+        const again = `loom send -a ${result.agentId} --wait "continue where you left off"`;
+        if (opts.json)
+            return void console.log(JSON.stringify({ status: "interrupted", agent: result.agentId, reason: "the Loom daemon restarted or stopped during the turn", resume: again }));
+        return void console.error(pc.yellow(`⚠ the Loom daemon restarted or stopped while ${result.agentId} was working — the turn was interrupted. ` +
+            `What it did so far is still in the working tree. To carry on: ${again}`));
+    }
     process.exitCode = exitCodeFor(outcome);
     if (opts.json)
         return void console.log(JSON.stringify(outcome ?? { status: "timeout", agent: result.agentId }));