@songsid/agend 2.2.0-beta.2 → 2.2.0-beta.20

package/dist/topic-commands.js

@@ -1,8 +1,9 @@
 import { PaneContextCache } from "./pane-context-cache.js";
+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";
@@ -20,10 +21,11 @@ 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";
 export { parseContextPercent, parseTokenContextRatio } from "./context-percent.js";
 /** Longest one setMyCommands call may take. */
@@ -159,6 +161,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"]);
 /**
@@ -240,10 +290,18 @@ function backendCliLines(versions) {
         }),
     ];
 }
-export function compactCommandForBackend(backend) {
-    if (backend === "antigravity")
-        return "/clear";
-    return "/compact";
+/**
+ * Board 0340ec89: agy's own `/compact` summarizes the conversation (verified on 1.3.6: "Conversation compacted · 5 steps
+ * summarized", tests/fixtures/agy-1.3.6-compact.pane.txt). AgEnD used to send `/clear` for an agy compact, which wiped
+ * the conversation instead. An agy known to be older than the version `/compact` was verified on 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.6";
+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
@@ -255,7 +313,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.6+, 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.
  */
@@ -446,6 +504,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")],
@@ -488,8 +547,15 @@ 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)
@@ -595,6 +661,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.
@@ -632,7 +705,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)) {
@@ -769,6 +842,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);
@@ -989,6 +1079,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)
@@ -997,26 +1095,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) {
@@ -1046,7 +1152,7 @@ export class TopicCommands {
         const ipc = this.ctx.instanceIpcClients.get(instanceName);
         if (!ipc?.connected)
             return t("steer.not_connected");
-        ipc.send({
+        const payload = {
             type: "steer",
             content,
             delivery_epoch: this.ctx.getDeliveryEpoch?.(instanceName) ?? undefined,
@@ -1059,7 +1165,12 @@ export class TopicCommands {
                 adapter_id: msg.adapterId ?? "",
                 source: msg.source,
             },
-        });
+        };
+        const sent = this.ctx.sendHumanControl
+            ? this.ctx.sendHumanControl(instanceName, payload, msg.humanOrigin, msg.humanOriginalBody ?? content)
+            : ipc.send(payload) !== false;
+        if (!sent)
+            return t("steer.not_connected");
         return t("steer.sent", instanceName);
     }
     /** Ask a Claude Code side question without folding it into the active turn. */
@@ -1070,7 +1181,7 @@ export class TopicCommands {
         const ipc = this.ctx.instanceIpcClients.get(instanceName);
         if (!ipc?.connected)
             return t("btw.not_connected");
-        ipc.send({
+        const payload = {
             type: "btw",
             content,
             delivery_epoch: this.ctx.getDeliveryEpoch?.(instanceName) ?? undefined,
@@ -1083,25 +1194,34 @@ export class TopicCommands {
                 adapter_id: msg.adapterId ?? "",
                 source: msg.source,
             },
-        });
+        };
+        const sent = this.ctx.sendHumanControl
+            ? this.ctx.sendHumanControl(instanceName, payload, msg.humanOrigin, msg.humanOriginalBody ?? content)
+            : ipc.send(payload) !== false;
+        if (!sent)
+            return t("btw.not_connected");
         return t("btw.sent", instanceName);
     }
     /** 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) {
@@ -1212,11 +1332,17 @@ export class TopicCommands {
             await adapter.sendText(msg.chatId, await this.ctx.cancelLoginSession(), { threadId: msg.threadId });
             return;
         }
-        if (/\s/.test(arg)) {
+        // `<backend> [profile]` (#1699 part 2): a second word is the credential profile to sign in; nothing more.
+        const words = arg.split(/\s+/);
+        // A profile only after a backend this fleet can sign in: `/login reinstall codex` stays a usage error (#1137).
+        if (words.length > 2 || (words.length === 2 && !Object.hasOwn(LOGIN_BACKEND_ALIASES, words[0].toLowerCase()))) {
             await adapter.sendText(msg.chatId, t("login.usage"), { threadId: msg.threadId });
             return;
         }
-        const started = await this.ctx.startLoginSession(arg, chat);
+        const [backend, profile] = words;
+        const started = profile !== undefined
+            ? await this.ctx.startLoginSession(backend, chat, { profile })
+            : await this.ctx.startLoginSession(backend, chat);
         // null → the still-valid-auth confirmation prompt was posted instead.
         if (started)
             await adapter.sendText(msg.chatId, started, { threadId: msg.threadId });
@@ -1481,7 +1607,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)) {
@@ -1494,7 +1620,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");
@@ -1502,17 +1628,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. */
@@ -1704,6 +1835,8 @@ export class TopicCommands {
             this.ctx.logger.warn({ adapterId }, "Skipping Telegram bot-command registration — the bot token is not set");
             return;
         }
+        // #1736: honour telegram_api_root the same way the adapter does.
+        const apiRoot = (ch.telegram_api_root ?? "https://api.telegram.org").replace(/\/+$/, "");
         // Locks come from the command table's Telegram column (#1177), descriptions from the locale.
         const menu = (which) => telegramMenu(which).map(({ name, lock, argHint }) => ({
             command: name,
@@ -1712,7 +1845,7 @@ export class TopicCommands {
         const fleetCommands = menu("fleet");
         const classicCommands = menu("classic");
         const setCommands = async (commands, scope) => {
-            const response = await fetch(`https://api.telegram.org/bot${botToken}/setMyCommands`, {
+            const response = await fetch(`${apiRoot}/bot${botToken}/setMyCommands`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({ commands, scope }),