@songsid/agend 2.1.8-beta.3 → 2.1.8-beta.5

package/dist/fleet-manager.d.ts

@@ -552,8 +552,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /**
      * Ask the daemon to capture the pane before answering, then wait for any state
      * report produced after this request. The ordinary query is intentionally
-     * cache-only (idle gates call it frequently); this opt-in refresh is reserved
-     * for lifecycle decisions where a stale state would strand UI.
+     * cache-only; delivery idle gates opt into their own pane/input proof, and
+     * this refresh serves lifecycle decisions where a stale state would strand UI.
      */
     private refreshInstanceExecutionState;
     private deliverWithIdleGate;
@@ -961,7 +961,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private refuseTypedIpc;
     private dispatchTypedIpc;
-    /** `list_emojis` / `set_persona_emoji` over IPC; the agent endpoint calls the same two methods. */
+    /** `list_emojis` / `set_persona_emoji` / `preview_emojis` over IPC; the agent endpoint calls the same methods. */
     private handlePersonaEmoji;
     private handleScheduleCrud;
     private handleDecisionCrud;
@@ -992,6 +992,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     handleSetDisplayNameHttp(instance: string, name: string): Promise<unknown>;
     handleListEmojisHttp(instance: string, refresh: boolean): Promise<unknown>;
     handleSetPersonaEmojiHttp(instance: string, args: Record<string, unknown>): Promise<unknown>;
+    handlePreviewEmojisHttp(instance: string, args: Record<string, unknown>): Promise<unknown>;
     handleSetDescriptionHttp(instance: string, description: string): Promise<unknown>;
     private summarizeToolCall;
     private handleTaskCrud;
@@ -1126,6 +1127,24 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * Settings picker (#1005/#1021), so an agent and an operator see one truth.
      */
     listEmojisFor(instanceName: string, refresh?: boolean): Promise<Record<string, unknown>>;
+    /**
+     * `preview_emojis` (#1040): download a few Discord server emojis so an agent
+     * can look at them before it picks one — a name and an id say nothing about
+     * what an emoji looks like. The fleet fetches, not the agent (not every
+     * backend can), and returns a local path per emoji to Read, as
+     * download_attachment does for an attachment.
+     *
+     * SSRF-safe by construction: nothing from the caller reaches a URL. The
+     * caller names emojis; each must be an available one in a server this bot
+     * can draw on (the list set_persona_emoji checks), and the CDN URL is built
+     * from that listed emoji's numeric id. Static PNG, size-capped, cached by id.
+     */
+    previewEmojis(instanceName: string, args: Record<string, unknown>): Promise<Record<string, unknown>>;
+    private static EMOJI_PREVIEW_MAX;
+    private static EMOJI_PREVIEW_MAX_BYTES;
+    private static EMOJI_PREVIEW_TTL_MS;
+    /** One emoji's static PNG under the inbox, reused while fresh; stale ones are pruned. */
+    private fetchEmojiPreview;
     /**
      * `set_persona_emoji`: `instanceName` sets one of its own status emojis —
      * `delivered` unless it names another — in its per-instance `status_emojis`

package/dist/fleet-manager.js

@@ -17,7 +17,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /** Fallback access policy for a channel with no `access:` block — open (no gate). */
 const DEFAULT_OPEN_ACCESS = { mode: "open", allowed_users: [], max_pending_codes: 0, code_expiry_minutes: 0 };
-import { STATUS_EMOJI_CONFIG_KEYS, STATUS_EMOJI_KEYS, STATUS_EMOJI_SUGGESTIONS, TELEGRAM_REACTION_EMOJIS, builtinStatusEmojis, customEmojiValue, normalizeEmoji, previewStatusEmojis, reactionForm, reactionMatchKey, resolveStatusEmojis, statusAvoidList, statusEmojiProblem, statusMatchKey, statusMatchKeys, textForm, } from "./status-emojis.js";
+import { STATUS_EMOJI_CONFIG_KEYS, STATUS_EMOJI_KEYS, STATUS_EMOJI_SUGGESTIONS, TELEGRAM_REACTION_EMOJIS, builtinStatusEmojis, customEmojiValue, emojiImageUrl, normalizeEmoji, previewStatusEmojis, reactionForm, reactionMatchKey, resolveStatusEmojis, statusAvoidList, statusEmojiProblem, statusMatchKey, statusMatchKeys, textForm, } from "./status-emojis.js";
 import { isProbeableRouteTarget } from "./fleet-context.js";
 import { loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG } from "./config.js";
 import { EventLog } from "./event-log.js";
@@ -1730,7 +1730,10 @@ export class FleetManager {
             const query = () => {
                 const ipc = this.instanceIpcClients.get(instanceName);
                 if (ipc?.connected) {
-                    ipc.send({ type: "query_instance_state", requestId: `idle-gate-${Date.now()}` });
+                    // The daemon owns the backend/TTY proof and its 10s startup-input
+                    // timer. A cache-only query can never discover a Context-less idle
+                    // pane, and a second fleet timer would stack another 10s wait.
+                    ipc.send({ type: "query_instance_state", requestId: `idle-gate-${Date.now()}`, deliveryIdle: true });
                 }
                 check();
             };
@@ -1745,8 +1748,8 @@ export class FleetManager {
     /**
      * Ask the daemon to capture the pane before answering, then wait for any state
      * report produced after this request. The ordinary query is intentionally
-     * cache-only (idle gates call it frequently); this opt-in refresh is reserved
-     * for lifecycle decisions where a stale state would strand UI.
+     * cache-only; delivery idle gates opt into their own pane/input proof, and
+     * this refresh serves lifecycle decisions where a stale state would strand UI.
      */
     refreshInstanceExecutionState(instanceName, timeoutMs) {
         const ipc = this.instanceIpcClients.get(instanceName);
@@ -5851,7 +5854,7 @@ export class FleetManager {
             : type.startsWith("fleet_decision_") ? "fleet_decision_response"
                 : type === "fleet_task" ? "fleet_task_response"
                     : type === "fleet_set_display_name" ? "fleet_display_name_response"
-                        : type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" ? "fleet_persona_emoji_response"
+                        : type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis" ? "fleet_persona_emoji_response"
                             : "fleet_description_response";
         ipc.send({ type: responseType, fleetRequestId, error: message });
     }
@@ -5877,21 +5880,21 @@ export class FleetManager {
             this.handleSetDescription(name, msg);
             return;
         }
-        if (type === "fleet_list_emojis" || type === "fleet_set_persona_emoji") {
+        if (type === "fleet_list_emojis" || type === "fleet_set_persona_emoji" || type === "fleet_preview_emojis") {
             this.handlePersonaEmoji(name, msg);
             return;
         }
     }
-    /** `list_emojis` / `set_persona_emoji` over IPC; the agent endpoint calls the same two methods. */
+    /** `list_emojis` / `set_persona_emoji` / `preview_emojis` over IPC; the agent endpoint calls the same methods. */
     handlePersonaEmoji(instanceName, msg) {
         const fleetRequestId = msg.fleetRequestId;
         const payload = (msg.payload ?? {});
         const ipc = this.instanceIpcClients.get(instanceName);
         if (!ipc)
             return;
-        const op = msg.type === "fleet_list_emojis"
-            ? this.listEmojisFor(instanceName, payload.refresh === true)
-            : this.setPersonaEmoji(instanceName, payload);
+        const op = msg.type === "fleet_list_emojis" ? this.listEmojisFor(instanceName, payload.refresh === true)
+            : msg.type === "fleet_preview_emojis" ? this.previewEmojis(instanceName, payload)
+                : this.setPersonaEmoji(instanceName, payload);
         op.then((r) => typeof r.error === "string"
             ? ipc.send({ type: "fleet_persona_emoji_response", fleetRequestId, error: r.error })
             : ipc.send({ type: "fleet_persona_emoji_response", fleetRequestId, result: r }), (err) => ipc.send({ type: "fleet_persona_emoji_response", fleetRequestId, error: err.message }));
@@ -6243,6 +6246,9 @@ export class FleetManager {
     async handleSetPersonaEmojiHttp(instance, args) {
         return this.setPersonaEmoji(instance, args);
     }
+    async handlePreviewEmojisHttp(instance, args) {
+        return this.previewEmojis(instance, args);
+    }
     async handleSetDescriptionHttp(instance, description) {
         if (!this.fleetConfig)
             return { error: "Fleet config not available" };
@@ -6982,12 +6988,117 @@ export class FleetManager {
             const listed = await this.listGuildEmojis(worldId, refresh);
             out.server_emojis = listed.ok
                 ? listed.guilds.map(g => g.emojis
-                    ? { server: g.name || g.id, primary: g.primary, emojis: g.emojis.filter(e => e.available).map(e => customEmojiValue(e)) }
+                    ? {
+                        server: g.name || g.id, primary: g.primary,
+                        emojis: g.emojis.filter(e => e.available).map(e => {
+                            const value = customEmojiValue(e);
+                            return { value, image_url: emojiImageUrl(value) };
+                        }),
+                    }
                     : { server: g.name || g.id, primary: g.primary, error: g.error })
                 : { error: listed.error };
         }
         return out;
     }
+    /**
+     * `preview_emojis` (#1040): download a few Discord server emojis so an agent
+     * can look at them before it picks one — a name and an id say nothing about
+     * what an emoji looks like. The fleet fetches, not the agent (not every
+     * backend can), and returns a local path per emoji to Read, as
+     * download_attachment does for an attachment.
+     *
+     * SSRF-safe by construction: nothing from the caller reaches a URL. The
+     * caller names emojis; each must be an available one in a server this bot
+     * can draw on (the list set_persona_emoji checks), and the CDN URL is built
+     * from that listed emoji's numeric id. Static PNG, size-capped, cached by id.
+     */
+    async previewEmojis(instanceName, args) {
+        const self = this.fleetConfig?.instances[instanceName];
+        if (!self)
+            return { error: this.personaEmojiMissing(instanceName) };
+        const wanted = args.emojis;
+        if (!Array.isArray(wanted) || wanted.length === 0 || wanted.some(e => typeof e !== "string")) {
+            return { error: "emojis is required: a list of <:name:id> values from list_emojis" };
+        }
+        if (wanted.length > FleetManager.EMOJI_PREVIEW_MAX) {
+            return { error: `at most ${FleetManager.EMOJI_PREVIEW_MAX} at a time: narrow them down by name first` };
+        }
+        const { platform } = this.resolveStatusEmojisFor(instanceName);
+        const worldId = this.getInstanceAdapterId(instanceName);
+        if (platform !== "discord" || !worldId) {
+            return { error: "only Discord server emojis need a preview; standard emojis are what they look like" };
+        }
+        const listed = await this.listGuildEmojis(worldId);
+        if (!listed.ok)
+            return { error: `cannot list this bot's server emojis: ${listed.error}` };
+        const previews = [];
+        const errors = [];
+        for (const raw of wanted) {
+            const e = normalizeEmoji(raw);
+            if (e?.kind !== "custom") {
+                errors.push({ emoji: raw, error: "not a server emoji (a standard emoji needs no preview)" });
+                continue;
+            }
+            const found = listed.emojis.find(g => g.id === e.id);
+            if (!found?.available) {
+                errors.push({ emoji: raw, error: "not a server emoji this bot can use" });
+                continue;
+            }
+            try {
+                previews.push({ emoji: customEmojiValue(found), path: await this.fetchEmojiPreview(found.id) });
+            }
+            catch (err) {
+                errors.push({ emoji: raw, error: `download failed: ${err.message}` });
+            }
+        }
+        return { previews, errors, note: "Read each path to see the emoji (a static PNG)." };
+    }
+    static EMOJI_PREVIEW_MAX = 8;
+    static EMOJI_PREVIEW_MAX_BYTES = 256 * 1024;
+    static EMOJI_PREVIEW_TTL_MS = 24 * 60 * 60_000;
+    /** One emoji's static PNG under the inbox, reused while fresh; stale ones are pruned. */
+    async fetchEmojiPreview(id) {
+        if (!/^\d{15,25}$/.test(id))
+            throw new Error("not a Discord emoji id");
+        const dir = join(this.dataDir, "inbox", "emoji-previews");
+        mkdirSync(dir, { recursive: true });
+        const now = Date.now();
+        for (const name of readdirSync(dir)) {
+            try {
+                if (now - statSync(join(dir, name)).mtimeMs > FleetManager.EMOJI_PREVIEW_TTL_MS)
+                    unlinkSync(join(dir, name));
+            }
+            catch { /* raced */ }
+        }
+        const path = join(dir, `${id}.png`);
+        if (existsSync(path))
+            return path;
+        const response = await fetch(`https://cdn.discordapp.com/emojis/${id}.png?size=96`, { signal: AbortSignal.timeout(10_000), redirect: "error" });
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        if (!/^image\/png\b/.test(response.headers.get("content-type") ?? ""))
+            throw new Error("not a PNG");
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error("empty response");
+        const chunks = [];
+        let size = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > FleetManager.EMOJI_PREVIEW_MAX_BYTES) {
+                await reader.cancel();
+                throw new Error("image too large");
+            }
+            chunks.push(value);
+        }
+        const tmp = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmp, Buffer.concat(chunks));
+        renameSync(tmp, path);
+        return path;
+    }
     /**
      * `set_persona_emoji`: `instanceName` sets one of its own status emojis —
      * `delivered` unless it names another — in its per-instance `status_emojis`