@songsid/agend 2.2.0-alpha.9 → 2.2.0-beta.2

package/dist/fleet-manager.js

@@ -51,6 +51,7 @@ import { startEventLoopWatch } from "./event-loop-watch.js";
 import { TmuxManager } from "./tmux-manager.js";
 import { AccessManager } from "./channel/access-manager.js";
 import { IpcClient } from "./channel/ipc-bridge.js";
+import { usesChannelAddress } from "./channel/mcp-tools.js";
 import { formatFleetTime } from "./tz-utils.js";
 import { createAdapter } from "./channel/factory.js";
 import { isWebChannelEcho, WEB_ECHO_PREFIX } from "./web-channel-echo.js";
@@ -132,6 +133,9 @@ import { ReplyButtonStore, parseReplyButtons, replyButtonClickText, replyButtons
 import { ReplyButtonsController } from "./reply-buttons-controller.js";
 import { publicAttachment, sweepOrphanedUploads, WebFileLedger } from "./web-upload.js";
 import { handleViewRequest, isViewPath, profileIdentities, resolveInstanceIdentity } from "./view-api.js";
+import { downloadStickerImage } from "./channel/sticker-download.js";
+import { WebImageCache, imageMimeForFile, WEB_IMAGE_MAX_AGE_MS, WEB_IMAGE_MAX_BYTES, WEB_IMAGE_RETRY_MS } from "./web-images.js";
+import { accentColor, avatarFor, ownBotConnections } from "./instance-avatar.js";
 import { envFileKeys } from "./token-env-name.js";
 import { discordGeneralChannelId } from "./discord-general.js";
 import { parseEnvText } from "./env-file.js";
@@ -180,7 +184,7 @@ import { mayUseTool, resolveToolSet, scheduleOpRefusal, toolForIpcType, toolRefu
 import { authorizeSession, decideWebGate, loadOrCreateWebToken, readWebToken } from "./web-auth.js";
 import { bypassesWebGate, handleAuthRequest, serveSigninPage } from "./auth-api.js";
 import { isWebPageNavigation } from "./web-shell-routes.js";
-import { tokenEpoch, WebSessionStore } from "./web-session.js";
+import { localSessionPolicy, tokenEpoch, WebSessionStore } from "./web-session.js";
 import { WebLoginCodes, LOGIN_CODE_TTL_MS } from "./web-login.js";
 import { CodeRequestLimiter, ReturningDevices } from "./web-returning-device.js";
 import { allowedHostNames, applyWebSecurityHeaders, hostnameOf, isHostAllowed, WEB_HOST_REJECTED_MESSAGE } from "./web-host-guard.js";
@@ -1274,7 +1278,20 @@ export class FleetManager {
     }
     queryDurableDeliveryStatus(callerInstance, selector) {
         this.ensureDeliveryOutbox();
-        return this.deliveryOutbox.queryStatusForInstance(callerInstance, selector);
+        const page = this.deliveryOutbox.queryStatusForInstance(callerInstance, selector);
+        // #1641: a sender that sees only `queued` cannot tell "next in line" from "the target is stuck": say which.
+        return {
+            ...page,
+            items: page.items.map(item => (item.state === "queued" || item.state === "retry_wait")
+                ? { ...item, waiting_reason: this.deliveryWaitingReason(item.target_instance) }
+                : item),
+        };
+    }
+    /** #1641: why a target is not taking queued work right now, or null when nothing known holds it. */
+    deliveryWaitingReason(target) {
+        if (this.lifecycle.isPaused(target))
+            return t("delivery.hold_state", "paused");
+        return this.daemons.get(target)?.notAcceptingReason?.() ?? null;
     }
     getDaemonBootId(instanceName) {
         return this.daemons.get(instanceName)?.bootId;
@@ -4152,6 +4169,33 @@ export class FleetManager {
             names.add(channel.instanceName);
         return [...names];
     }
+    /** #1624: migration cannot infer ownership from the running daemon roster.
+     * Stopped/paused ClassicBot entries count too; their workspace is exactly
+     * the one startClassicInstance builds, not this FleetManager's dataDir.
+     */
+    kiroPeerWorkingDirectories(name) {
+        if (!this.fleetConfig || !this.classicChannels)
+            throw new Error("Kiro peer configuration is not loaded");
+        const peers = [];
+        for (const [peer, cfg] of Object.entries(this.fleetConfig.instances)) {
+            if (peer === name || (cfg.backend ?? this.fleetConfig.defaults?.backend ?? "claude-code") !== "kiro-cli")
+                continue;
+            if (typeof cfg.working_directory !== "string" || !cfg.working_directory)
+                throw new Error("Kiro peer cwd is unknown");
+            peers.push(cfg.working_directory);
+        }
+        for (const ch of this.classicChannels.getAll()) {
+            if (ch.instanceName === name) {
+                if (Object.hasOwn(this.fleetConfig.instances, name))
+                    throw new Error("Kiro instance name has two configurations");
+                continue;
+            }
+            if (this.classicChannels.getBackendByInstance(ch.instanceName, this.fleetConfig.defaults?.backend) === "kiro-cli") {
+                peers.push(join(getAgendHome(), "workspaces", ch.instanceName));
+            }
+        }
+        return peers;
+    }
     /**
      * Probe the same executable set exposed by the web backend catalog.
      *
@@ -4549,6 +4593,9 @@ export class FleetManager {
             this.webSessions = new WebSessionStore({
                 dataDir: this.dataDir,
                 onWarn: message => this.logger.warn(message),
+                // #1620: fleet.yaml's web.session.local, read at every check — a Settings save or a reload applies at once
+                // (shortening ends the sessions it now outlives). The public link's policy stays fixed.
+                localPolicy: () => localSessionPolicy(this.fleetConfig?.web?.session?.local),
             });
         }
         if (!this.returningDevices) {
@@ -4734,6 +4781,42 @@ export class FleetManager {
             this.logger.info({ err: err?.message }, "The code-only follow-up was not sent; the sign-in message holds the code");
         }
     }
+    /**
+     * #1610: re-arm the public link's close prompt on the SAME message — as its confirm step (確定關閉 / 取消) or back as
+     * the close button — with a fresh nonce carrying the same owner gate (owner, requester, exposure, message, adapter),
+     * and swap the message's buttons keyboard-only: its text is the sign-in message, which must stay. A swap that fails
+     * disarms the new nonce and leaves the link open (the General menu and /dashboard revoke still close it).
+     */
+    async armDashboardCloseStep(prev, confirm, data) {
+        const nonce = randomBytes(16).toString("hex");
+        const { timer: _timer, nonce: _old, ...rest } = prev;
+        const entry = { ...rest, nonce, closeStep: confirm, createdAt: Date.now() };
+        entry.timer = setTimeout(() => {
+            if (this.pendingNonceButtons.get(nonce) !== entry)
+                return;
+            this.pendingNonceButtons.delete(nonce);
+            this.collapseNoncePrompt(entry)?.catch(err => this.logger.debug({ err }, "Failed to expire the public link's close prompt"));
+        }, 5 * 60_000);
+        entry.timer.unref?.();
+        this.pendingNonceButtons.set(nonce, entry);
+        const choices = confirm
+            ? [{ id: `dashboard:${nonce}:confirm`, label: t("dashboard.public_close_confirm") }, { id: `dashboard:${nonce}:keep`, label: t("dashboard.public_close_keep") }]
+            : [{ id: `dashboard:${nonce}:close`, label: t("dashboard.public_close") }];
+        try {
+            if (data.replaceClickedButtons)
+                await data.replaceClickedButtons(choices);
+            else if (prev.adapter.replaceMessageButtons)
+                await prev.adapter.replaceMessageButtons(prev.chatId, prev.messageId ?? data.messageId, choices, prev.threadId);
+            else
+                throw new Error("adapter cannot replace buttons");
+        }
+        catch (err) {
+            if (this.pendingNonceButtons.get(nonce) === entry)
+                this.pendingNonceButtons.delete(nonce);
+            clearTimeout(entry.timer);
+            this.logger.warn({ err: err?.message }, "Could not swap the public link's close buttons; the link stays open");
+        }
+    }
     /** Why the DM did not go, for the log only (Discord 50007 = the user does not accept DMs from this server's members). */
     logDashboardDmFailure(err) {
         const code = err?.code;
@@ -4771,7 +4854,11 @@ export class FleetManager {
         return posted !== null;
     }
     async handleDashboardCallback(data, adapterId, adapter) {
-        const claimed = this.consumeNonceCallback("dashboard:", /^dashboard:([0-9a-f]{32}):(local|public|close)$/, data, adapterId, adapter);
+        // #1610: `confirm`/`keep` answer the close button's confirm step and nothing else; `close` is never a confirm step.
+        // A click of the wrong kind is refused like a non-admin's — unconsumed, so the real buttons still work.
+        const kind = /:([a-z]+)$/.exec(data.callbackData)?.[1];
+        const stepAction = kind === "confirm" || kind === "keep";
+        const claimed = this.consumeNonceCallback("dashboard:", /^dashboard:([0-9a-f]{32}):(local|public|close|confirm|keep)$/, data, adapterId, adapter, undefined, (userId, e) => this.isFleetAdmin(userId, adapterId) && stepAction === (e.closeStep === true));
         if (claimed === null)
             return false;
         if (claimed === "consumed")
@@ -4782,7 +4869,15 @@ export class FleetManager {
             data.ack?.(t("not_authorized"));
             return true;
         }
-        if (action === "close") {
+        if (action === "close" || action === "keep") {
+            // A tap on 關閉公開連結 closes nothing: it offers 確定關閉 / 取消 on the same message (the button sits right above
+            // the code a phone taps to copy). 取消 puts the close button back. Both only re-arm the same, owner-gated prompt.
+            if (!entry.publicExposureId)
+                return true;
+            await this.armDashboardCloseStep(entry, action === "close", data);
+            return true;
+        }
+        if (action === "confirm") {
             if (!entry.publicExposureId)
                 return true;
             const result = await this.publicWebLink?.close("admin close", entry.publicExposureId);
@@ -7662,10 +7757,12 @@ export class FleetManager {
             respond(null, "No adapter available");
             return;
         }
+        // Only channel-addressing schemas receive ClassicBot routing metadata.
+        // Non-channel calls (notably strict delivery_status) retain their arguments.
         // For classic instances: force chat_id to channelId and clear thread_id
         // (daemon may have set chat_id to guild_id which is wrong for DC; TG may have set thread_id which causes 'thread not found')
         const classicChannelId = this.classicChannels?.getChannelIdByInstance(senderInstanceName ?? instanceName);
-        if (classicChannelId) {
+        if (classicChannelId && usesChannelAddress(tool)) {
             args.chat_id = classicChannelId;
             // #1085: a Telegram forum ClassicBot replies in the topic it was asked
             // in. Any other thread_id (threadless Telegram, where it echoes the chat
@@ -9454,6 +9551,151 @@ export class FleetManager {
     /** Keyed `<connection>\0<server id>`. */
     guildEmojiCache = new Map();
     guildEmojiFetches = new Map();
+    // ── #1630: what stands for an instance in the web app, and Discord server emoji in web chat ──
+    webImageCaches = null;
+    webImageCache(kind) {
+        const onError = (key, err) => this.logger.debug({ err: err?.message, key }, "web image fetch failed (kept what was cached)");
+        this.webImageCaches ??= {
+            avatars: new WebImageCache({ dir: join(this.dataDir, "cache", "avatars"), onError }),
+            emoji: new WebImageCache({ dir: join(this.dataDir, "cache", "emoji"), onError }),
+        };
+        return this.webImageCaches[kind];
+    }
+    /**
+     * instance → the connection that is its own bot: configured now (a connection removed from fleet.yaml is nobody's,
+     * whatever an instance still names — #1635 review), not the primary, and answering for it alone.
+     */
+    ownBots() {
+        const instances = this.fleetConfig?.instances ?? {};
+        const channels = this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : []);
+        const configured = new Set(channels.map(ch => ch.id ?? ch.type).filter((id) => typeof id === "string"));
+        const assigned = (name) => { const c = this.getInstanceAdapterId(name); return c && configured.has(c) ? c : undefined; };
+        const assignments = Object.keys(instances).map(n => [n, assigned(n)]);
+        for (const room of this.classicChannels?.getAll() ?? []) {
+            if (!Object.hasOwn(instances, room.instanceName))
+                assignments.push([room.instanceName, assigned(room.instanceName)]);
+        }
+        return ownBotConnections(this.getPrimaryAdapterId(), assignments);
+    }
+    /**
+     * The bot a connection is now: its running adapter and that bot's own user id. Everything cached for an own bot is
+     * keyed by both, so a bot put in its place (a token replaced under the same connection id) never shows the old one's
+     * face or colour, and the old one's late answers land under the old key (#1635 review). null while it has no id.
+     */
+    botOwner(connection) {
+        const adapter = this.adapters.get(connection), id = adapter?.getBotUserId?.();
+        return adapter && id ? { adapter, id } : null;
+    }
+    /** Still the same bot behind `connection` (after an await): the same adapter object and the same bot id. */
+    botStillOwns(connection, owner) {
+        return this.adapters.get(connection) === owner.adapter && owner.adapter.getBotUserId?.() === owner.id;
+    }
+    /** keyed `<connection>\0<bot id>\0<channel>`: the bot's colour there, refreshed at most daily (monotonic), one read at a time. */
+    webAccents = new Map();
+    webAccentReads = new Set();
+    webAccent(connection, owner, channelId) {
+        const adapter = owner.adapter;
+        if (!adapter.botAccentColor)
+            return null;
+        const key = `${connection}\0${owner.id}\0${channelId ?? ""}`, now = performance.now(), cached = this.webAccents.get(key);
+        if ((!cached || now >= cached.until) && !this.webAccentReads.has(key)) {
+            this.webAccentReads.add(key);
+            adapter.botAccentColor(channelId)
+                // Keyed by the bot's id: a replaced bot's late answer lands under its own key, which the new bot never reads.
+                .then(value => { this.webAccents.set(key, { value: accentColor(value), until: performance.now() + WEB_IMAGE_MAX_AGE_MS }); }, () => { this.webAccents.set(key, { value: cached?.value ?? null, until: performance.now() + WEB_IMAGE_RETRY_MS }); })
+                .finally(() => this.webAccentReads.delete(key));
+        }
+        return cached?.value ?? null;
+    }
+    /** The cache key of an own bot's avatar, and its loader (which refuses an answer from a bot no longer there). */
+    botAvatarSource(connection, owner) {
+        return {
+            key: `bot:${connection}:${owner.id}`,
+            load: async () => {
+                const got = await owner.adapter.fetchBotAvatar();
+                if (!this.botStillOwns(connection, owner))
+                    throw new Error("the bot was replaced while its avatar was fetched");
+                return got;
+            },
+        };
+    }
+    /** One instance's avatar and ring for the status frame. Synchronous: what is cached now; fetches run behind. */
+    webIdentityImage(name, displayName, profileAvatar, own) {
+        let profileVersion = null;
+        if (profileAvatar && imageMimeForFile(profileAvatar)) {
+            try {
+                profileVersion = Math.floor(statSync(join(this.dataDir, "avatars", basename(profileAvatar))).mtimeMs).toString(36);
+            }
+            catch { /* removed */ }
+        }
+        const connection = own.get(name), owner = connection ? this.botOwner(connection) : null;
+        const source = connection && owner?.adapter.fetchBotAvatar ? this.botAvatarSource(connection, owner) : null;
+        const bot = source ? this.webImageCache("avatars").peek(source.key, source.load) : null;
+        const cfg = this.ownInstanceConfig(name);
+        const avatar = avatarFor({ name, displayName, profileVersion, bot: bot && connection ? { connection, version: bot.version } : null,
+            personaEmoji: cfg?.status_emojis?.delivered });
+        // The ring belongs to the bot's own face: only when that is what is shown.
+        const accent = !profileVersion && bot && connection && owner
+            ? this.webAccent(connection, owner, cfg ? (cfg.topic_id == null ? undefined : String(cfg.topic_id)) : this.classicChannels?.getChannelIdByInstance(name))
+            : null;
+        return accent ? { avatar, accent } : { avatar };
+    }
+    /** GET /ui/img/bot|avatar/<key>: what is cached, never a fetch. Only an own-bot connection, or a known instance's upload. */
+    webImage(kind, key) {
+        if (kind === "bot") {
+            if (![...this.ownBots().values()].includes(key))
+                return null;
+            const owner = this.botOwner(key);
+            return owner ? this.webImageCache("avatars").read(this.botAvatarSource(key, owner).key) : null;
+        }
+        const known = Object.hasOwn(this.fleetConfig?.instances ?? {}, key) || this.classicChannels?.getChannelIdByInstance(key) !== undefined;
+        if (!known)
+            return null;
+        const file = profileIdentities(this.dataDir).get(key)?.avatar_path;
+        const mime = file ? imageMimeForFile(file) : null;
+        if (!file || !mime)
+            return null;
+        try {
+            const path = join(this.dataDir, "avatars", basename(file));
+            return { bytes: readFileSync(path), mime, version: Math.floor(statSync(path).mtimeMs).toString(36) };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** GET /ui/emojis: the custom emoji of every server the fleet's Discord bots are in (the Settings picker's cache). */
+    async webEmojiList() {
+        const adopted = [];
+        for (const [id, world] of [...this.worlds]) {
+            if (world.type !== "discord")
+                continue;
+            const listed = await this.listGuildEmojis(id);
+            if (listed.ok)
+                adopted.push({ id, world, emojis: listed.emojis });
+        }
+        // After the LAST await (#1635 review r2): only the lists whose world is still the one that was read — a connection
+        // removed or replaced while a later list was awaited takes its servers along, whenever it went.
+        const out = new Map();
+        for (const a of adopted) {
+            if (this.worlds.get(a.id) !== a.world)
+                continue;
+            for (const e of a.emojis)
+                if (!out.has(e.id))
+                    out.set(e.id, { id: e.id, name: e.name, animated: e.animated });
+        }
+        return [...out.values()];
+    }
+    /** GET /ui/img/emoji/<id>: only an emoji of those servers; fetched once from Discord's CDN, then from the host cache. */
+    async webEmoji(id) {
+        if (!/^\d{15,25}$/.test(id))
+            return null;
+        const emoji = (await this.webEmojiList()).find(e => e.id === id);
+        if (!emoji)
+            return null;
+        const image = await this.webImageCache("emoji").get(`emoji:${id}`, () => downloadStickerImage(`https://cdn.discordapp.com/emojis/${id}.${emoji.animated ? "gif" : "png"}?size=64`, { maxBytes: WEB_IMAGE_MAX_BYTES }));
+        // Still an emoji of the fleet's servers once it is here (a connection removed meanwhile takes its servers along).
+        return image && (await this.webEmojiList()).some(e => e.id === id) ? image : null;
+    }
     /**
      * What `instanceName` may pick as its persona emoji (the `list_emojis`
      * tool): its current status set with where each value comes from, the
@@ -10641,6 +10883,15 @@ export class FleetManager {
         if (pending && pending.prefix !== prefix)
             pending = undefined;
         if (!match || !pending) {
+            // #1610 (Fable r1): the same message may already carry the prompt's NEXT step (the public link's 確定關閉 / 取消
+            // on the sign-in DM, armed by the first tap). A double tap, or a late second one from an old keyboard, lands
+            // here with the spent nonce — and collapsing would wipe the message's text and the live buttons. The clicker is
+            // told; the message is left alone.
+            // #1617: and of the same bot — two bots' DM message ids can collide; another bot's live prompt says nothing here.
+            if ([...this.pendingNonceButtons.values()].some(e => e.prefix === prefix && e.adapterId === callbackAdapterId && e.chatId === data.chatId && e.messageId === data.messageId)) {
+                data.ack?.(t("buttons.stale_notice"));
+                return "consumed";
+            }
             const adapter = receivingAdapter ?? this.adapter;
             // The clicker always hears why nothing happens (#1133); collapsing the
             // dead buttons is a courtesy that can fail (>48h on Telegram, message gone).
@@ -17884,7 +18135,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             // Never the token: fleet.log is readable by anything that can read the
             // data dir, is copied into bug reports, and is tailed in shared terminals.
             // `/dashboard` and `agend web` are the ways to get an authorized link.
-            this.logger.info({ url: `http://localhost:${port}/ui` }, "Web UI available (open it with /dashboard or `agend web`)");
+            this.logger.info({ url: `http://localhost:${port}/ui` }, "Web UI available (open it with /web or `agend web`)");
             this.logger.info({ url: `http://localhost:${port}/view` }, "Web View available");
             // #1306: the preview listener starts once the web listener is bound — its frame-ancestors name the real port.
             const bound = this.healthServer?.address();
@@ -18026,6 +18277,14 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // /api/profiles (resolveInstanceIdentity) — the sidebar groups, searches and labels with it on every page.
         const classicRooms = new Map((this.classicChannels?.getAll() ?? []).map(ch => [ch.instanceName, ch]));
         const profiles = profileIdentities(this.dataDir);
+        // #1630: decorative — whatever goes wrong deciding an avatar never costs the frame (every instance gets its first character).
+        let ownBots = new Map();
+        try {
+            ownBots = this.ownBots();
+        }
+        catch (err) {
+            this.logger.debug({ err }, "own bots unreadable (getUiStatus)");
+        }
         const instances = names.map(name => {
             const statusFile = join(this.getInstanceDir(name), "statusline.json");
             let cost = 0;
@@ -18063,9 +18322,19 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             const effort = (effortStrategy === "unsupported" || isAgy) ? null : effortResolved.effort;
             const effort_source = (effortStrategy === "unsupported" || isAgy) ? null : effortResolved.source;
             const identity = resolveInstanceIdentity({ cfg: this.fleetConfig?.instances[name], classic: classicRooms.get(name), profile: profiles.get(name) });
+            let image;
+            try {
+                image = this.webIdentityImage(name, identity.display_name, profiles.get(name)?.avatar_path, ownBots);
+            }
+            catch (err) {
+                this.logger.debug({ err, name }, "avatar unreadable (getUiStatus)");
+                image = { avatar: avatarFor({ name, displayName: identity.display_name }) };
+            }
             return {
                 name,
                 display_name: identity.display_name || undefined,
+                avatar: image.avatar,
+                ...(image.accent ? { accent: image.accent } : {}),
                 description: identity.description || undefined,
                 role: identity.role || undefined,
                 tags: identity.tags,