@songsid/agend 2.2.0-beta.9 → 2.3.0-beta.1

package/dist/topic-commands.js

@@ -3,7 +3,7 @@ import { LOGIN_BACKEND_ALIASES } from "./login-flows.js";
 import { measureSyncWork } from "./sync-work-attribution.js";
 import { LOOPBACK_HOST_NAMES } from "./web-host-guard.js";
 import { WEB_REMOTE_DOCS_URL } from "./upgrade-notices.js";
-import { readFileSync, existsSync } from "node:fs";
+import { closeSync, readFileSync, existsSync } from "node:fs";
 import { exec, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
 import { join, basename } from "node:path";
@@ -21,11 +21,13 @@ import { runVisibilityCommand } from "./cross-instance-notice.js";
 import { clampContextPercent, parseContextPercent, parseTokenContextRatio, } from "./context-percent.js";
 import { isGeneralInstance } from "./general-instance.js";
 import { instanceSupportsSteer } from "./steer-capability.js";
+import { compareSemver } from "./update-check.js";
 import { SYSINFO_BACKEND_IDS } from "./backend/types.js";
 import { recordInternalRequest, withOrigin } from "./fleet-control-audit.js";
 import { resolveInstalledAgend } from "./update-dispatch.js";
-import { resolveUpdateLaunch, watchUpdateLaunch } from "./update-launch.js";
+import { resolveUpdateLaunch, openUpdateLog, updateLogPath, watchUpdateLaunch } from "./update-launch.js";
 import { selfCommand } from "./cli-entry.js";
+import { GENERAL_POINTING_REFUSALS, placeSuffix } from "./topic-link.js";
 export { parseContextPercent, parseTokenContextRatio } from "./context-percent.js";
 /** Longest one setMyCommands call may take. */
 const TELEGRAM_COMMANDS_TIMEOUT_MS = 10_000;
@@ -160,6 +162,54 @@ function disambiguateLabel(name, explicit, base, used) {
 }
 /** Allowed filename for /save and /load (no path separators, no shell/inject chars). */
 export const SAVE_FILENAME_RE = /^[\w.-]+$/;
+/**
+ * #1809: resolve a display label (as shown by `agend ls`) back to a real instance name.
+ * Returns the real name on a unique match, `null` when the query does not match any label,
+ * or `{ ambiguous: true, realNames }` when two labels are identical under case-folding
+ * (e.g. display_names "Prism" and "prism" both fold to "prism").
+ * Always case-insensitive. Real names are NOT resolved here — callers must try real names first.
+ */
+export function resolveByLabel(query, entries) {
+    const labelMap = assignDisplayLabels(entries);
+    const q = query.toLowerCase();
+    const matches = [];
+    for (const [realName, label] of labelMap) {
+        if (label.toLowerCase() === q)
+            matches.push(realName);
+    }
+    if (matches.length === 0)
+        return null;
+    if (matches.length === 1)
+        return matches[0];
+    return { ambiguous: true, realNames: matches };
+}
+/**
+ * #1809: full label/name resolution pipeline without process.exit or readline — suitable for
+ * unit testing and for callers that want to decide what to do on each outcome.
+ *
+ * Resolution order:
+ * 1. Exact match on real name (case-insensitive) — always wins.
+ * 2. Exact match on the display label `agend ls` shows (via `resolveByLabel`).
+ * 3. No match → `{ kind: "none" }`.
+ *
+ * Returns `{ kind: "name", realName }` on success,
+ *         `{ kind: "ambiguous", realNames }` when two labels are case-identical,
+ *         or `{ kind: "none" }` when nothing matched.
+ */
+export function resolveName(query, entries) {
+    // Step 1: exact real-name match wins.
+    const q = query.toLowerCase();
+    const exactReal = entries.find(e => e.name.toLowerCase() === q);
+    if (exactReal)
+        return { kind: "name", realName: exactReal.name };
+    // Step 2: label match.
+    const labelResult = resolveByLabel(query, entries);
+    if (labelResult === null)
+        return { kind: "none" };
+    if (typeof labelResult === "string")
+        return { kind: "name", realName: labelResult };
+    return { kind: "ambiguous", realNames: labelResult.realNames };
+}
 /** Backends with a native side-question command that does not steer the active turn. */
 export const BTW_SUPPORTED_BACKENDS = new Set(["claude-code"]);
 /**
@@ -187,14 +237,6 @@ export function parsePauseWakeCommand(text) {
         return null;
     return { action: match[1], instance: match[2] };
 }
-/**
- * The in-session compact/context-reset command for a backend NAME (the fleet
- * process routes /compact via IPC and only has the backend string, not a
- * CliBackend instance). Keep in sync with each backend's getCompactCommand().
- * Most CLIs (claude-code, kiro-cli, codex, opencode) use "/compact".
- * Antigravity (agy) has NO summarizing compact — its only manual context-reset
- * is "/clear" (a full reset; it also auto-summarizes at a token threshold).
- */
 /** os.release(), guarded — purely informational, must never break /sysinfo. */
 function osRelease() {
     try {
@@ -241,10 +283,20 @@ function backendCliLines(versions) {
         }),
     ];
 }
-export function compactCommandForBackend(backend) {
-    if (backend === "antigravity")
-        return "/clear";
-    return "/compact";
+/**
+ * Board 0340ec89: agy's own `/compact` summarizes the conversation (verified live on 1.3.6: "Conversation compacted ·
+ * 5 steps summarized", tests/fixtures/agy-1.3.6-compact.pane.txt). agy's release notes add it in 1.3.5, and the 1.3.5
+ * binary registers it ("Compact the conversation now (summarize history to free up the context window)"), so 1.3.5 is
+ * the floor. AgEnD used to send `/clear` for an agy compact, which wiped the conversation instead. An agy known to be
+ * older than that is refused (null), never cleared; an agy whose version is not known yet gets `/compact` (a version
+ * without it ignores the line).
+ */
+export const AGY_COMPACT_MIN_VERSION = "1.3.5";
+export function compactCommandForBackend(backend, version) {
+    if (backend !== "antigravity")
+        return "/compact";
+    const v = typeof version === "string" ? version.match(/\d+\.\d+\.\d+/)?.[0] : undefined;
+    return v && (compareSemver(v, AGY_COMPACT_MIN_VERSION) ?? 0) < 0 ? null : "/compact";
 }
 /**
  * Backends whose `/compact` verifiably takes custom summarization instructions
@@ -256,7 +308,7 @@ export function compactCommandForBackend(backend) {
  *    compact into a prompt, so it must never be appended.
  *  - grok 1.0.46: the binary answers "/compact takes no arguments."
  *  - opencode 1.18: `/compact` calls session.summarize with no text.
- *  - kiro-cli: takes none (audit); antigravity has no summarizing compact.
+ *  - kiro-cli: takes none (audit); antigravity's own /compact (1.3.5+, board 0340ec89) takes none either.
  *  - muse 1.4.2: accepts the line (empty session: "nothing to summarize") but
  *    no use of the text is verifiable — unsupported until shown otherwise.
  */
@@ -447,6 +499,7 @@ const INSTANCE_FORMS = [
     ["collab", bare("collab")],
     ["effort", withArgs("effort")],
     ["model", withArgs("model")],
+    ["backend", withArgs("backend")],
     ["compact", text => parseCompactCommand(text) !== null],
     ["steer", withArgs("steer")],
     ["btw", withArgs("btw")],
@@ -489,12 +542,27 @@ export class TopicCommands {
         }, "telegram");
         if (decision.allow || "passthrough" in decision)
             return null;
+        // A command off for want of fleet admins names where they go (`{0}` in its disabled reply).
+        if (decision.reply === spec.disabled)
+            return [...decision.reply, this.adminListKey(msg.adapterId)];
         return decision.reply;
     }
+    /** Where the adapter's fleet-admin list is in fleet.yaml (the fleet's answer; a bare key without it). */
+    adminListKey(adapterId) {
+        return this.ctx.adminListKey?.(adapterId) ?? "access.allowed_users";
+    }
     async sendRefusal(msg, [key, ...args]) {
         const adapter = this.getReplyAdapter(msg);
-        if (adapter)
-            await adapter.sendText(msg.chatId, t(key, ...args), { threadId: msg.threadId }).catch(() => { });
+        if (!adapter)
+            return;
+        // #1990: a refusal that sends the person to General links to it.
+        const text = t(key, ...args) + (GENERAL_POINTING_REFUSALS.has(key) ? placeSuffix({ kind: "general" }, "General") : "");
+        const out = this.placed(msg, text);
+        await adapter.sendText(msg.chatId, out.text, out.opts).catch(() => { });
+    }
+    /** #1990: a reply in the message's own chat, its place tokens rendered for the world it came from. */
+    placed(msg, text) {
+        return this.ctx.renderPlaces?.(msg.adapterId, text, { threadId: msg.threadId }) ?? { text, opts: { threadId: msg.threadId } };
     }
     getReplyAdapter(msg) {
         if (msg.adapterId && this.ctx.adapters) {
@@ -596,6 +664,13 @@ export class TopicCommands {
         }
         return false;
     }
+    /**
+     * General's action-first menu. The click owns private issuance; no URL or code exists in this copy.
+     */
+    getDashboardMenuText() {
+        const access = this.ctx.getDashboardAccess?.();
+        return access?.ready && access.token ? t("dashboard.menu_instruction") : t("dashboard.starting");
+    }
     /**
      * Pure, secret-free dashboard/menu copy. Issuance belongs to the private
      * delivery action; rendering or previewing this text cannot retire a code.
@@ -633,7 +708,7 @@ export class TopicCommands {
         const threadId = msg.threadId;
         // The caller's own adapter decides, and an empty list means the command is off for everyone.
         if (!this.ctx.hasFleetAdmins(msg.adapterId)) {
-            await adapter.sendText(chatId, t("dashboard.disabled"), { threadId });
+            await adapter.sendText(chatId, t("dashboard.disabled", this.adminListKey(msg.adapterId)), { threadId });
             return;
         }
         if (!this.ctx.isFleetAdmin(msg.userId, msg.adapterId)) {
@@ -770,6 +845,23 @@ export class TopicCommands {
             }
             return true;
         }
+        if (command === "backend") {
+            const adapter = this.getReplyAdapter(msg);
+            if (!adapter)
+                return false;
+            // #1806: the same gate as /model.
+            if (!this.ctx.isFleetAdmin(msg.userId, msg.adapterId)) {
+                await adapter.sendText(msg.chatId, t("permission.denied"), { threadId: msg.threadId });
+                return true;
+            }
+            if (this.ctx.runBackendCommand) {
+                await this.ctx.runBackendCommand(instanceName, text, msg.userId, msg.threadId ?? msg.chatId, adapter, msg.chatId, msg.threadId, msg.adapterId);
+            }
+            else {
+                await adapter.sendText(msg.chatId, t("backend.usage"), { threadId: msg.threadId });
+            }
+            return true;
+        }
         if (command === "compact") {
             const compact = parseCompactCommand(text);
             const adapter = this.getReplyAdapter(msg);
@@ -990,6 +1082,14 @@ export class TopicCommands {
     }
     /** Send the backend-appropriate compact command to an instance's tmux pane */
     async sendCompact(instanceName, instructions) {
+        return this.compactInstance(instanceName, instructions).text;
+    }
+    /**
+     * sendCompact, saying whether the command was handed to the daemon (the web chat follows a sent one to its end,
+     * board 003648ac). `notify` runs only when it is about to be handed over; its id rides along so the daemon says when
+     * the command reached the pane (`raw_paste_written`). A write the IPC refuses is not sent.
+     */
+    compactInstance(instanceName, instructions, notify) {
         const ipc = this.ctx.instanceIpcClients.get(instanceName);
         if (ipc?.connected) {
             const classicBackend = this.ctx.classicChannels?.getChannelIdByInstance(instanceName)
@@ -998,26 +1098,34 @@ export class TopicCommands {
             const backend = this.ctx.fleetConfig?.instances[instanceName]?.backend
                 ?? classicBackend
                 ?? this.ctx.fleetConfig?.defaults?.backend ?? "claude-code";
-            const base = compactCommandForBackend(backend);
+            const agyVersion = backend === "antigravity" ? this.ctx.getBackendCliVersionSnapshot?.()?.antigravity?.version ?? null : null;
+            const base = compactCommandForBackend(backend, agyVersion);
+            if (base === null)
+                return { sent: false, text: t("compact.unsupported_version", backend, agyVersion ?? "?", AGY_COMPACT_MIN_VERSION) };
             const custom = normalizeCompactInstructions(instructions);
             if (custom.length > COMPACT_INSTRUCTIONS_MAX) {
                 // Refuse rather than cut: a truncated instruction is a different instruction.
-                return t("compact.instructions_too_long", String(COMPACT_INSTRUCTIONS_MAX));
+                return { sent: false, text: t("compact.instructions_too_long", String(COMPACT_INSTRUCTIONS_MAX)) };
             }
+            const id = notify?.() ?? null;
+            const paste = (content) => ipc.send({ type: "raw_paste", content, ...(id ? { notify_written: id } : {}) }) !== false;
             if (!custom) {
-                ipc.send({ type: "raw_paste", content: base });
-                return t("compact.sent", base);
+                if (!paste(base))
+                    return { sent: false, text: t("compact.not_connected") };
+                return { sent: true, text: t("compact.sent", base) };
             }
             if (backendSupportsCompactInstructions(backend)) {
-                ipc.send({ type: "raw_paste", content: `${base} ${custom}` });
-                return t("compact.sent_with_instructions", base);
+                if (!paste(`${base} ${custom}`))
+                    return { sent: false, text: t("compact.not_connected") };
+                return { sent: true, text: t("compact.sent_with_instructions", base) };
             }
             // Compact as asked, without the text, and say so — never send it (codex
             // would take it for a chat message) and never drop it unannounced.
-            ipc.send({ type: "raw_paste", content: base });
-            return `${t("compact.sent", base)}\n${t("compact.instructions_ignored", backend)}`;
+            if (!paste(base))
+                return { sent: false, text: t("compact.not_connected") };
+            return { sent: true, text: `${t("compact.sent", base)}\n${t("compact.instructions_ignored", backend)}` };
         }
-        return t("compact.not_connected");
+        return { sent: false, text: t("compact.not_connected") };
     }
     /** Whether the instance backend exposes a verified full-reset command. */
     supportsClear(instanceName) {
@@ -1099,20 +1207,24 @@ export class TopicCommands {
     }
     /** Send the backend-appropriate full conversation reset through raw_paste. */
     async sendClear(instanceName) {
+        return this.clearInstance(instanceName).text;
+    }
+    /** sendClear, saying whether the command was handed to the daemon (board 003648ac: the web chat's card then leaves). */
+    clearInstance(instanceName) {
         const backend = this.effectiveBackend(instanceName);
         const cmd = clearCommandForBackend(backend);
         if (!cmd)
-            return t("clear.unsupported");
+            return { sent: false, text: t("clear.unsupported") };
         const ipc = this.ctx.instanceIpcClients.get(instanceName);
         if (ipc?.connected) {
-            ipc.send({
+            const sent = ipc.send({
                 type: "raw_paste",
                 content: cmd,
                 ...(backend === "kiro-cli" ? { confirm_clear: true } : {}),
-            });
-            return t("clear.sent", cmd);
+            }) !== false;
+            return sent ? { sent: true, text: t("clear.sent", cmd) } : { sent: false, text: t("clear.not_connected") };
         }
-        return t("clear.not_connected");
+        return { sent: false, text: t("clear.not_connected") };
     }
     /** Send a backend-appropriate session-save command to a fleet-topic instance. */
     async sendSave(instanceName, filename) {
@@ -1498,7 +1610,7 @@ export class TopicCommands {
         const threadId = msg.threadId;
         // Access control — only fleet admins of THIS adapter can trigger an update; empty = disabled
         if (!this.ctx.hasFleetAdmins(msg.adapterId)) {
-            await adapter.sendText(chatId, t("update.disabled"), { threadId });
+            await adapter.sendText(chatId, t("update.disabled", this.adminListKey(msg.adapterId)), { threadId });
             return;
         }
         if (!this.ctx.isFleetAdmin(msg.userId, msg.adapterId)) {
@@ -1511,7 +1623,7 @@ export class TopicCommands {
         // agend, verified by identity, by absolute path — or a refusal, never whatever `agend` is first on PATH.
         const installed = await resolveInstalledAgend();
         if (!installed.ok) {
-            this.ctx.failUpdateProgress?.(`/update cannot verify the installed AgEnD (${installed.reason}). Run \`agend update\` from a shell.`);
+            this.ctx.failUpdateProgress?.(`${t("update.failure.shell")} ${t("update.failure.installed", installed.reason)}`);
             return;
         }
         const { spawn } = await import("node:child_process");
@@ -1519,17 +1631,22 @@ export class TopicCommands {
         recordInternalRequest(this.ctx.dataDir, "update", origin);
         const launch = await resolveUpdateLaunch(installed.agend);
         if (!launch.ok) {
-            this.ctx.failUpdateProgress?.(`/update cannot prepare an independent updater (${launch.reason}). Run ` + "`agend update` from a host shell.");
+            this.ctx.failUpdateProgress?.(`${t("update.failure.shell")} ${t("update.failure.independent", launch.reason)}`);
             return;
         }
         if (!this.ctx.hasFleetAdmins(msg.adapterId) || !this.ctx.isFleetAdmin(msg.userId, msg.adapterId) || this.ctx.isFleetStopping()) {
             this.ctx.failUpdateProgress?.(t("not_authorized"));
             return;
         }
+        const logPath = updateLogPath(this.ctx.dataDir);
+        const ts = new Date().toISOString();
+        const logFd = openUpdateLog(logPath, `--- /update ${ts} ---`);
         const child = spawn(launch.command, launch.args, {
-            detached: true, stdio: "ignore", env: withOrigin(origin),
+            detached: true, stdio: ["ignore", logFd ? logFd.fd : "ignore", logFd ? logFd.fd : "ignore"], env: withOrigin(origin),
         });
-        watchUpdateLaunch(child, message => this.ctx.failUpdateProgress?.(message));
+        if (logFd)
+            closeSync(logFd.fd);
+        watchUpdateLaunch(child, message => this.ctx.failUpdateProgress?.(message), logFd ? logPath : undefined, logFd?.offset, installed.agend);
         child.unref();
     }
     /** #1302: `/visibility [full|summary|hidden]` in the General topic. */
@@ -1585,7 +1702,8 @@ export class TopicCommands {
         const adapter = this.getReplyAdapter(msg);
         if (!adapter)
             return;
-        await adapter.sendText(msg.chatId, t("topic.unbound"), { threadId: msg.threadId });
+        const out = this.placed(msg, t("topic.unbound") + placeSuffix({ kind: "general" }, "General"));
+        await adapter.sendText(msg.chatId, out.text, out.opts);
     }
     /**
      * Handle provider-confirmed topic deletion without deleting instance data.