@songsid/agend 2.1.2-beta.15 → 2.1.2-beta.16

package/dist/cli.js

@@ -14,6 +14,7 @@ import { getAgendHome, getTmuxSocketName } from "./paths.js";
 import { readClassicLastActivityAt } from "./classic-channel-manager.js";
 import { hasPausedMarker } from "./pause-marker.js";
 import { PIE_PERCENT_RE } from "./tui-glyphs.js";
+import { COMPLETION_SHELLS, completionScript } from "./completion.js";
 import { getUpdateSelector, lookupTargetVersion, reportUpdateRestart, shouldSkipUpdate, } from "./update-check.js";
 /** Prefix tmux args with -L when socket isolation is active. */
 function tmuxArgs(args) {
@@ -68,8 +69,14 @@ fleet
         const fleet = loadFleetConfig(FLEET_CONFIG_PATH);
         const port = fleet.health_port ?? 19280;
         try {
-            const healthResp = await fetch(`http://127.0.0.1:${port}/health`);
-            if (healthResp.ok) {
+            // Any HTTP answer means a fleet daemon is listening — including a 503,
+            // which /health now returns when the fleet is degraded (no adapter
+            // connected, an instance crashed). Checking `.ok` here would treat a
+            // degraded fleet as "not running" and start a SECOND fleet on the same
+            // data dir, whose startup cleanup kills the first one's tmux windows.
+            // Only a connection error means nothing is there (the catch below).
+            await fetch(`http://127.0.0.1:${port}/health`);
+            {
                 try {
                     const resp = await fetch(`http://127.0.0.1:${port}/api/instance/${encodeURIComponent(instance)}/start`, { method: "POST" });
                     const body = await resp.json();
@@ -92,6 +99,59 @@ fleet
     }
     const { FleetManager } = await import("./fleet-manager.js");
     const fm = new FleetManager(DATA_DIR);
+    // Register crash/signal handlers BEFORE startAll(). Startup routinely takes
+    // minutes (sequential general spawn, staggered instances, warmup waits), and
+    // without these a Ctrl-C or `systemctl stop` in that window got Node's default
+    // behaviour: instant death with fleet.pid already written, databases unclosed,
+    // and every tmux window orphaned.
+    let stopping = false;
+    const shutdown = async () => {
+        if (stopping)
+            return; // SIGINT and SIGTERM share this, and crash paths call stopAll too
+        stopping = true;
+        console.log("\nStopping fleet...");
+        await fm.stopAll().catch(err => console.error("Shutdown error:", err));
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("uncaughtException", (err) => {
+        // An uncaught exception leaves unknown state — still the one case worth
+        // tearing down for.
+        console.error("Uncaught exception:", err);
+        if (stopping)
+            return;
+        stopping = true;
+        fm.stopAll().catch(() => { }).finally(() => process.exit(1));
+    });
+    process.on("unhandledRejection", (err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        // 409 = another bot poller exists — the adapter retries, don't crash.
+        if (msg.includes("409") && msg.includes("getUpdates")) {
+            console.error("Bot polling conflict (409) — retrying...");
+            return;
+        }
+        // Do NOT take the fleet down. A rejected promise in one instance's tmux
+        // call, health tick, or model switch used to stop every other working
+        // instance and exit(1) — the widest blast radius in the process. The
+        // per-instance health check and crash recovery handle a genuinely broken
+        // instance on their own.
+        //
+        // Surviving quietly would be its own failure mode, so this reports to the
+        // General topic as well as the log: the operator must not have to read
+        // daemon.log to learn the fleet swallowed a fault. notifyFleetError()
+        // throttles repeats, since these usually arrive from a loop.
+        console.error("Unhandled rejection (fleet continues):", err);
+        if (err instanceof Error && err.stack)
+            console.error(err.stack);
+        try {
+            fm.notifyFleetError(`⚠️ Fleet caught an unhandled error and kept running:\n\`${msg}\`\nSee daemon.log for the stack trace.`);
+        }
+        catch (notifyErr) {
+            // Never let the reporting path itself become an unhandled rejection.
+            console.error("Failed to report unhandled rejection:", notifyErr);
+        }
+    });
     if (instance) {
         const config = fm.loadConfig(FLEET_CONFIG_PATH);
         const inst = config.instances[instance];
@@ -109,30 +169,6 @@ fleet
         await fm.startAll(FLEET_CONFIG_PATH);
     }
     console.log("Fleet started");
-    // Keep process alive + clean shutdown on Ctrl+C
-    const shutdown = async () => {
-        console.log("\nStopping fleet...");
-        await fm.stopAll();
-        process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    process.on("uncaughtException", async (err) => {
-        console.error("Uncaught exception:", err);
-        await fm.stopAll().catch(() => { });
-        process.exit(1);
-    });
-    process.on("unhandledRejection", async (err) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        // 409 = another bot poller exists — adapter handles retry, don't crash
-        if (msg.includes("409") && msg.includes("getUpdates")) {
-            console.error("Bot polling conflict (409) — retrying...");
-            return;
-        }
-        console.error("Unhandled rejection:", err);
-        await fm.stopAll().catch(() => { });
-        process.exit(1);
-    });
 });
 fleet
     .command("stop")
@@ -1835,28 +1871,7 @@ async function fuzzyMatch(query, names) {
     return null;
 }
 async function resolveInstance(query, config) {
-    const names = Object.keys(config.instances);
-    // Include classic instances from classicBot.yaml
-    try {
-        const classicPath = join(DATA_DIR, "classicBot.yaml");
-        if (existsSync(classicPath)) {
-            const yamlMod = (await import("js-yaml")).default;
-            const classic = yamlMod.load(readFileSync(classicPath, "utf-8"));
-            if (classic?.channels) {
-                for (const [key, val] of Object.entries(classic.channels)) {
-                    // New format persists instanceName; old format keyed by channelId.
-                    if (val.instanceName) {
-                        names.push(val.instanceName);
-                        continue;
-                    }
-                    const channelId = val.channelId ?? key;
-                    const chName = (val.name ?? channelId).toLowerCase().replace(/[^\p{L}\d-]/gu, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "project";
-                    names.push(`classic-${chName}-${channelId.slice(-4)}`);
-                }
-            }
-        }
-    }
-    catch { /* ignore */ }
+    const names = await listInstanceNames(config);
     const match = await fuzzyMatch(query, names);
     if (!match) {
         console.error(`No instance matching "${query}". Available: ${names.join(", ")}`);
@@ -1989,10 +2004,48 @@ const defaultParser = (output) => {
 };
 /** Optional backend-specific overrides; none needed — defaultParser covers all. */
 const contextParsers = {};
+/**
+ * Every instance name the CLI accepts: fleet.yaml instances plus the
+ * dynamically-created ClassicBot ones. Shared by `resolveInstance` (fuzzy
+ * matching for `attach`) and `ls --names-only` (shell completion), so the
+ * candidates offered by tab-completion are exactly the ones `attach` resolves.
+ */
+async function listInstanceNames(config) {
+    const names = Object.keys(config.instances);
+    try {
+        const classicPath = join(DATA_DIR, "classicBot.yaml");
+        if (existsSync(classicPath)) {
+            const yamlMod = (await import("js-yaml")).default;
+            const classic = yamlMod.load(readFileSync(classicPath, "utf-8"));
+            if (classic?.channels) {
+                for (const [key, val] of Object.entries(classic.channels)) {
+                    // New format persists instanceName; old format keyed by channelId.
+                    if (val.instanceName) {
+                        names.push(val.instanceName);
+                        continue;
+                    }
+                    const channelId = val.channelId ?? key;
+                    const chName = (val.name ?? channelId).toLowerCase().replace(/[^\p{L}\d-]/gu, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "project";
+                    names.push(`classic-${chName}-${channelId.slice(-4)}`);
+                }
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return names;
+}
 async function lsAction(opts) {
     const yaml = (await import("js-yaml")).default;
     const config = yaml.load(readFileSync(FLEET_CONFIG_PATH, "utf-8"));
     const names = Object.keys(config.instances);
+    // --names-only feeds shell completion, so it must return before any tmux or
+    // status work (a tab press should not wait on the fleet) and must print
+    // nothing but names — a "no instances" notice would become a candidate.
+    if (opts.namesOnly) {
+        for (const n of await listInstanceNames(config))
+            console.log(n);
+        return;
+    }
     // Load classic channels from classicBot.yaml (keyed by channelId)
     const classicPath = join(DATA_DIR, "classicBot.yaml");
     let classicConfig = null;
@@ -2278,12 +2331,38 @@ program
     .command("ls")
     .description("List all instances with status, backend, team, and last activity")
     .option("--json", "Output as JSON")
+    .option("--names-only", "Print instance names one per line (for shell completion)")
     .action(async (opts) => {
     await lsAction(opts);
 });
 program
-    .command("health")
-    .description("Fleet health check — shows problems and diagnostics")
+    .command("completion")
+    .description("Print a shell completion script (bash or zsh)")
+    .argument("<shell>", `Shell to generate for (${COMPLETION_SHELLS.join(", ")})`)
+    .addHelpText("after", `
+Install:
+  bash   echo 'eval "$(agend completion bash)"' >> ~/.bashrc
+  zsh    echo 'eval "$(agend completion zsh)"'  >> ~/.zshrc
+
+Then reload the shell. Tab-completes instance names for \`agend attach\` and
+\`agend fleet start|stop|restart\`, and subcommands elsewhere.`)
+    .action((shell) => {
+    if (!COMPLETION_SHELLS.includes(shell)) {
+        console.error(`Unsupported shell: ${shell}. Supported: ${COMPLETION_SHELLS.join(", ")}`);
+        process.exit(2);
+    }
+    // Subcommand names come from commander itself, so the script can't drift
+    // out of sync with the CLI the way a hardcoded list would.
+    const fleetCmd = program.commands.find(c => c.name() === "fleet");
+    console.log(completionScript(shell, {
+        topLevel: program.commands.map(c => c.name()),
+        fleetSub: fleetCmd?.commands.map(c => c.name()) ?? [],
+        instanceCommands: ["attach"],
+        fleetInstanceCommands: ["start", "stop", "restart"],
+    }));
+});
+program
+    .command("health").description("Fleet health check — shows problems and diagnostics")
     .option("--json", "Output as JSON")
     .option("-q, --quiet", "One-line summary only")
     .action(async (opts) => {