@songsid/agend 2.1.8-beta.1 → 2.1.8-beta.11

package/dist/cli.js

@@ -550,6 +550,92 @@ delivery
         process.exitCode = 1;
     }
 });
+delivery
+    .command("scan-forged-envelopes")
+    .description("Detect fabricated peer envelopes in a kiro receiver's own transcript (#995)")
+    .option("--instance <name>", "Scan one instance")
+    .option("--all", "Scan every kiro-cli instance in fleet.yaml")
+    .option("--json", "Machine-readable output")
+    .option("--kiro-db <path>", "Override the kiro conversation store path (testing)")
+    .option("--outbox-db <path>", "Override the delivery-outbox path (testing)")
+    .action(async (opts) => {
+    const { executeForgedEnvelopeScan, resolveScanTarget, loadReportedEnvelopeIds, recordReportedEnvelopeIds } = await import("./forged-envelope-scan.js");
+    if (!opts.instance && !opts.all) {
+        console.error("Specify --instance <name> or --all.");
+        process.exitCode = 1;
+        return;
+    }
+    let rawConfig;
+    try {
+        const loaded = loadRawFleetConfig(FLEET_CONFIG_PATH);
+        rawConfig = {
+            ...(loaded.defaults ? { defaults: loaded.defaults } : {}),
+            ...(loaded.instances ? { instances: loaded.instances } : {}),
+        };
+    }
+    catch (err) {
+        console.error(`Could not read fleet config: ${err.message}`);
+        process.exitCode = 1;
+        return;
+    }
+    const instances = rawConfig.instances ?? {};
+    const defaults = (rawConfig.defaults ?? {});
+    const knownInstances = new Set(Object.keys(instances));
+    const names = opts.all ? [...knownInstances] : [opts.instance];
+    if (names.length === 0 || (names.length === 1 && !knownInstances.has(names[0]))) {
+        console.error(`Unknown instance: ${names[0] ?? "(fleet has no instances)"}`);
+        process.exitCode = 1;
+        return;
+    }
+    // Effective config exactly like the daemon's: fleet defaults deep-merged
+    // under instance overrides — a credential profile inherited from defaults
+    // must resolve to the profile store (#1007 round-3).
+    const targets = names.map(name => resolveScanTarget(name, instances[name], defaults));
+    const reported = loadReportedEnvelopeIds(DATA_DIR);
+    const result = executeForgedEnvelopeScan({
+        targets,
+        knownInstances,
+        outboxDbPath: opts.outboxDb ?? join(DATA_DIR, "delivery-outbox.db"),
+        dataDir: DATA_DIR,
+        ...(opts.kiroDb ? { kiroDbOverride: opts.kiroDb } : {}),
+        alreadyReportedIds: reported,
+    });
+    for (const row of result.rows) {
+        for (const f of row.findings)
+            reported.add(f.message_id);
+    }
+    recordReportedEnvelopeIds(DATA_DIR, reported);
+    if (opts.json) {
+        console.log(JSON.stringify({ scans: result.rows, new_findings: result.newFindings }, null, 2));
+    }
+    else {
+        for (const row of result.rows) {
+            if (row.status === "unsupported-backend" || row.status === "error" || row.status === "unreadable-store") {
+                console.log(`- ${row.instance}: ${row.status} (${row.reason ?? row.note})`);
+                continue;
+            }
+            console.log(`- ${row.instance}: ${row.status} (checked ${row.checked}, delivered ${row.delivered}, unverifiable ${row.unverifiable})`);
+            for (const f of row.findings) {
+                console.log(`  FORGED [from:${f.from}] (message_id: ${f.message_id})`);
+                console.log(`  excerpt: ${f.excerpt}`);
+                console.log(`  inject via send_to_instance: ${f.suggested_injection}`);
+            }
+        }
+    }
+    // Operator notification: visible here; wire to a schedule for routine runs.
+    if (result.newFindings > 0) {
+        console.error(`FORGED ENVELOPES: ${result.newFindings} new finding(s) — notify the operator and inject the warning(s) above.`);
+    }
+    else if (result.exitCode === 3) {
+        console.error(`UNREADABLE TRANSCRIPT: ${result.unreadable} instance(s) could not be scanned — not clean.`);
+    }
+    else if (result.exitCode === 4) {
+        // Fail-closed: no-conversation / partially-unverified / missing
+        // working_directory are "could not verify", never clean.
+        console.error(`INCOMPLETE SCAN: ${result.incomplete} instance(s) could not be fully verified — not clean.`);
+    }
+    process.exitCode = result.exitCode;
+});
 fleet
     .command("activity")
     .description("Show fleet activity log — who talked to whom, tool calls, task updates")
@@ -1604,7 +1690,7 @@ program
     // service's own HOME, which may differ from what this command resolves (sudo,
     // AGEND_HOME) — an absent pid file does NOT mean it's stopped. Ask the service
     // manager first. This is the canonical restart the `update` flow spawns.
-    const { detectPlatform, getServicePath, getSystemServicePath, getSystemdServiceState, restartSystemdService, } = await import("./service-installer.js");
+    const { detectPlatform, getServicePath, getSystemServicePath, getSystemdServiceState, restartSystemdService, ensureSystemdKillModeMixed, } = await import("./service-installer.js");
     const { spawn, spawnSync } = await import("node:child_process");
     const plat = detectPlatform();
     const pidPath = join(DATA_DIR, "fleet.pid");
@@ -1643,7 +1729,52 @@ program
             process.exitCode = 1;
             return;
         }
-        run(systemdTarget.user ? "systemctl --user daemon-reload" : "systemctl daemon-reload");
+        // #908: before this restart's stop, so it already lets the fleet quit
+        // each CLI itself instead of systemd SIGTERMing them all at once. A
+        // restart that would still run on control-group (the line could not be
+        // read, written or loaded) is refused: it is exactly the restart that
+        // aborts kiro-cli into a core dump.
+        const unitPath = systemdTarget.user ? getServicePath() : getSystemServicePath();
+        const reloadCmd = systemdTarget.user ? "systemctl --user daemon-reload" : "systemctl daemon-reload";
+        let outcome = "present";
+        if (unitPath) {
+            try {
+                outcome = ensureSystemdKillModeMixed(unitPath);
+            }
+            catch {
+                outcome = "unwritable";
+            }
+        }
+        if (outcome === "unreadable" || outcome === "unwritable") {
+            console.error(`  ✗ Could not ${outcome === "unreadable" ? "read" : "update"} ${unitPath}, so this restart would still let systemd SIGTERM every CLI at once (kiro-cli core dumps, #908).`);
+            console.error(`    Not restarting. Add KillMode=mixed under [Service] in ${unitPath}, run \`${reloadCmd}\`, then \`agend restart\`.`);
+            process.exitCode = 1;
+            return;
+        }
+        if (outcome === "custom")
+            console.log(`  ⚠ ${unitPath} sets its own KillMode; left as is. KillMode=mixed avoids kiro-cli core dumps on restart (#908).`);
+        const reloaded = run(reloadCmd);
+        if (outcome !== "custom") {
+            // Gate on what systemd has LOADED, not on what this run wrote: `agend
+            // update` runs the new binary's `install --no-activate` first, which
+            // already puts KillMode=mixed in the file, so a failed reload here
+            // would otherwise go unnoticed and stop the fleet with control-group.
+            const showCmd = `systemctl${systemdTarget.user ? " --user" : ""} show -p KillMode --value ${systemdTarget.unit}`;
+            let loaded = "";
+            try {
+                loaded = execSync(showCmd, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000 }).trim();
+            }
+            catch { /* unknown → refused below */ }
+            if (loaded !== "mixed") {
+                console.error(`  ✗ systemd has ${loaded ? `KillMode=${loaded}` : "an unknown KillMode"} loaded for ${systemdTarget.unit}${reloaded ? "" : ` (\`${reloadCmd}\` failed)`}, so it would still SIGTERM every CLI at once (kiro-cli core dumps, #908).`);
+                console.error(`    Not restarting. Make sure ${unitPath ?? "the unit"} has KillMode=mixed under [Service], run \`${reloadCmd}\`, then \`agend restart\`.`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (outcome === "added") {
+            console.log(`  ✓ ${unitPath}: added KillMode=mixed (the fleet stops its CLIs; systemd no longer signals them all at once)`);
+        }
         if (systemdTarget.user) {
             try {
                 execSync("systemctl --user reset-failed com.agend.fleet", { stdio: "pipe", timeout: 5000 });
@@ -2368,7 +2499,7 @@ async function lsAction(opts) {
     };
     // Row collection runs concurrently (see ls-rows.ts): the per-instance
     // tmux captures overlap instead of stacking their 2s bounds serially.
-    const { collectLsRows, capturePaneAsync, formatTimeSince } = await import("./ls-rows.js");
+    const { collectLsRows, capturePaneAsync, formatTimeSince, lsStatusIcon, lsStatusLabel, displayWidth } = await import("./ls-rows.js");
     const { getTmuxSocketName } = await import("./paths.js");
     const socketName = getTmuxSocketName();
     const rows = await collectLsRows(allNames.map(name => {
@@ -2434,51 +2565,10 @@ async function lsAction(opts) {
         console.log(JSON.stringify(rows, null, 2));
         return;
     }
-    // Status icon — prefer tri-state 'state' field, fall back to idle boolean
-    const statusIcon = (s, idle, state) => {
-        if (s === "crashed")
-            return "\x1b[31m●\x1b[0m";
-        if (s === "stopped")
-            return "\x1b[90m○\x1b[0m";
-        if (state === "stuck")
-            return "\x1b[31m●\x1b[0m";
-        if (state === "paused" || s === "paused")
-            return "\x1b[2;33m●\x1b[0m";
-        if (state === "working")
-            return "\x1b[34m●\x1b[0m";
-        if (state === "idle")
-            return "\x1b[32m●\x1b[0m";
-        // Fallback for when API is unreachable
-        if (s === "running")
-            return idle === false ? "\x1b[34m●\x1b[0m" : "\x1b[32m●\x1b[0m";
-        return "\x1b[90m○\x1b[0m";
-    };
-    const statusLabel = (s, idle, state) => {
-        if (s === "crashed")
-            return "Crashed";
-        if (s === "stopped")
-            return "Stopped";
-        if (state === "stuck")
-            return "Stuck";
-        if (state === "paused" || s === "paused")
-            return "Paused";
-        if (state === "working")
-            return "Working";
-        if (state === "idle")
-            return "Idle";
-        if (s === "running")
-            return idle === false ? "Busy" : "Idle";
-        return "Stopped";
-    };
-    /** Get display width accounting for fullwidth (CJK) characters */
-    const displayWidth = (s) => {
-        let w = 0;
-        for (const ch of s) {
-            const cp = ch.codePointAt(0);
-            w += (cp > 0x7f && cp !== 0x200b) ? 2 : 1;
-        }
-        return w;
-    };
+    // Merged State column (#1052): one glyph per lifecycle/execution state,
+    // shared with /status via ls-rows (○ paused, ✗ stopped).
+    const statusIcon = lsStatusIcon;
+    const statusLabel = lsStatusLabel;
     const padDisplay = (s, width) => s + " ".repeat(Math.max(0, width - displayWidth(s)));
     const displayName = (row) => row.name;
     const nameW = Math.max(20, ...rows.map(r => displayWidth(displayName(r)) + 2));