@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/gateway/server-methods.js

@@ -29,7 +29,11 @@ const READ_SCOPE = "operator.read";
 const WRITE_SCOPE = "operator.write";
 const APPROVALS_SCOPE = "operator.approvals";
 const PAIRING_SCOPE = "operator.pairing";
-const APPROVAL_METHODS = new Set(["exec.approval.request", "exec.approval.resolve"]);
+const APPROVAL_METHODS = new Set([
+    "exec.approval.request",
+    "exec.approval.waitDecision",
+    "exec.approval.resolve",
+]);
 const NODE_ROLE_METHODS = new Set(["node.invoke.result", "node.event", "skills.bins"]);
 const PAIRING_METHODS = new Set([
     "node.pair.request",
@@ -69,6 +73,8 @@ const READ_METHODS = new Set([
     "node.list",
     "node.describe",
     "chat.history",
+    "config.get",
+    "talk.config",
 ]);
 const WRITE_METHODS = new Set([
     "send",
@@ -87,13 +93,15 @@ const WRITE_METHODS = new Set([
     "browser.request",
 ]);
 function authorizeGatewayMethod(method, client) {
-    if (!client?.connect)
+    if (!client?.connect) {
         return null;
+    }
     const role = client.connect.role ?? "operator";
     const scopes = client.connect.scopes ?? [];
     if (NODE_ROLE_METHODS.has(method)) {
-        if (role === "node")
+        if (role === "node") {
             return null;
+        }
         return errorShape(ErrorCodes.INVALID_REQUEST, `unauthorized role: ${role}`);
     }
     if (role === "node") {
@@ -102,8 +110,9 @@ function authorizeGatewayMethod(method, client) {
     if (role !== "operator") {
         return errorShape(ErrorCodes.INVALID_REQUEST, `unauthorized role: ${role}`);
     }
-    if (scopes.includes(ADMIN_SCOPE))
+    if (scopes.includes(ADMIN_SCOPE)) {
         return null;
+    }
     if (APPROVAL_METHODS.has(method) && !scopes.includes(APPROVALS_SCOPE)) {
         return errorShape(ErrorCodes.INVALID_REQUEST, "missing scope: operator.approvals");
     }
@@ -116,14 +125,18 @@ function authorizeGatewayMethod(method, client) {
     if (WRITE_METHODS.has(method) && !scopes.includes(WRITE_SCOPE)) {
         return errorShape(ErrorCodes.INVALID_REQUEST, "missing scope: operator.write");
     }
-    if (APPROVAL_METHODS.has(method))
+    if (APPROVAL_METHODS.has(method)) {
         return null;
-    if (PAIRING_METHODS.has(method))
+    }
+    if (PAIRING_METHODS.has(method)) {
         return null;
-    if (READ_METHODS.has(method))
+    }
+    if (READ_METHODS.has(method)) {
         return null;
-    if (WRITE_METHODS.has(method))
+    }
+    if (WRITE_METHODS.has(method)) {
         return null;
+    }
     if (ADMIN_METHOD_PREFIXES.some((prefix) => method.startsWith(prefix))) {
         return errorShape(ErrorCodes.INVALID_REQUEST, "missing scope: operator.admin");
     }
@@ -131,6 +144,9 @@ function authorizeGatewayMethod(method, client) {
         method.startsWith("wizard.") ||
         method.startsWith("update.") ||
         method === "channels.logout" ||
+        method === "agents.create" ||
+        method === "agents.update" ||
+        method === "agents.delete" ||
         method === "skills.install" ||
         method === "skills.update" ||
         method === "cron.add" ||

package/dist/gateway/server-node-events.js

@@ -1,19 +1,183 @@
 import { randomUUID } from "node:crypto";
+import { resolveSessionAgentId } from "../agents/agent-scope.js";
 import { normalizeChannelId } from "../channels/plugins/index.js";
+import { createOutboundSendDeps } from "../cli/outbound-send-deps.js";
 import { agentCommand } from "../commands/agent.js";
 import { loadConfig } from "../config/config.js";
 import { updateSessionStore } from "../config/sessions.js";
 import { requestHeartbeatNow } from "../infra/heartbeat-wake.js";
+import { deliverOutboundPayloads } from "../infra/outbound/deliver.js";
+import { resolveOutboundTarget } from "../infra/outbound/targets.js";
 import { enqueueSystemEvent } from "../infra/system-events.js";
 import { normalizeMainKey } from "../routing/session-key.js";
 import { defaultRuntime } from "../runtime.js";
-import { loadSessionEntry } from "./session-utils.js";
+import { parseMessageWithAttachments } from "./chat-attachments.js";
+import { normalizeRpcAttachmentsToChatAttachments } from "./server-methods/attachment-normalize.js";
+import { loadSessionEntry, pruneLegacyStoreKeys, resolveGatewaySessionStoreTarget, } from "./session-utils.js";
 import { formatForLog } from "./ws-log.js";
+const MAX_EXEC_EVENT_OUTPUT_CHARS = 180;
+const VOICE_TRANSCRIPT_DEDUPE_WINDOW_MS = 1500;
+const MAX_RECENT_VOICE_TRANSCRIPTS = 200;
+const recentVoiceTranscripts = new Map();
+function normalizeNonEmptyString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeFiniteInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : null;
+}
+function resolveVoiceTranscriptFingerprint(obj, text) {
+    const eventId = normalizeNonEmptyString(obj.eventId) ??
+        normalizeNonEmptyString(obj.providerEventId) ??
+        normalizeNonEmptyString(obj.transcriptId);
+    if (eventId) {
+        return `event:${eventId}`;
+    }
+    const callId = normalizeNonEmptyString(obj.providerCallId) ?? normalizeNonEmptyString(obj.callId);
+    const sequence = normalizeFiniteInteger(obj.sequence) ?? normalizeFiniteInteger(obj.seq);
+    if (callId && sequence !== null) {
+        return `call-seq:${callId}:${sequence}`;
+    }
+    const eventTimestamp = normalizeFiniteInteger(obj.timestamp) ??
+        normalizeFiniteInteger(obj.ts) ??
+        normalizeFiniteInteger(obj.eventTimestamp);
+    if (callId && eventTimestamp !== null) {
+        return `call-ts:${callId}:${eventTimestamp}`;
+    }
+    if (eventTimestamp !== null) {
+        return `timestamp:${eventTimestamp}|text:${text}`;
+    }
+    return `text:${text}`;
+}
+function shouldDropDuplicateVoiceTranscript(params) {
+    const previous = recentVoiceTranscripts.get(params.sessionKey);
+    if (previous &&
+        previous.fingerprint === params.fingerprint &&
+        params.now - previous.ts <= VOICE_TRANSCRIPT_DEDUPE_WINDOW_MS) {
+        return true;
+    }
+    recentVoiceTranscripts.set(params.sessionKey, {
+        fingerprint: params.fingerprint,
+        ts: params.now,
+    });
+    if (recentVoiceTranscripts.size > MAX_RECENT_VOICE_TRANSCRIPTS) {
+        const cutoff = params.now - VOICE_TRANSCRIPT_DEDUPE_WINDOW_MS * 2;
+        for (const [key, value] of recentVoiceTranscripts) {
+            if (value.ts < cutoff) {
+                recentVoiceTranscripts.delete(key);
+            }
+            if (recentVoiceTranscripts.size <= MAX_RECENT_VOICE_TRANSCRIPTS) {
+                break;
+            }
+        }
+        while (recentVoiceTranscripts.size > MAX_RECENT_VOICE_TRANSCRIPTS) {
+            const oldestKey = recentVoiceTranscripts.keys().next().value;
+            if (oldestKey === undefined) {
+                break;
+            }
+            recentVoiceTranscripts.delete(oldestKey);
+        }
+    }
+    return false;
+}
+function compactExecEventOutput(raw) {
+    const normalized = raw.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return "";
+    }
+    if (normalized.length <= MAX_EXEC_EVENT_OUTPUT_CHARS) {
+        return normalized;
+    }
+    const safe = Math.max(1, MAX_EXEC_EVENT_OUTPUT_CHARS - 1);
+    return `${normalized.slice(0, safe)}…`;
+}
+async function touchSessionStore(params) {
+    const { storePath } = params;
+    if (!storePath) {
+        return;
+    }
+    await updateSessionStore(storePath, (store) => {
+        const target = resolveGatewaySessionStoreTarget({
+            cfg: params.cfg,
+            key: params.sessionKey,
+            store,
+        });
+        pruneLegacyStoreKeys({
+            store,
+            canonicalKey: target.canonicalKey,
+            candidates: target.storeKeys,
+        });
+        store[params.canonicalKey] = {
+            sessionId: params.sessionId,
+            updatedAt: params.now,
+            thinkingLevel: params.entry?.thinkingLevel,
+            verboseLevel: params.entry?.verboseLevel,
+            reasoningLevel: params.entry?.reasoningLevel,
+            systemSent: params.entry?.systemSent,
+            sendPolicy: params.entry?.sendPolicy,
+            lastChannel: params.entry?.lastChannel,
+            lastTo: params.entry?.lastTo,
+        };
+    });
+}
+function queueSessionStoreTouch(params) {
+    void touchSessionStore({
+        cfg: params.cfg,
+        sessionKey: params.sessionKey,
+        storePath: params.storePath,
+        canonicalKey: params.canonicalKey,
+        entry: params.entry,
+        sessionId: params.sessionId,
+        now: params.now,
+    }).catch((err) => {
+        params.ctx.logGateway.warn("voice session-store update failed: " + formatForLog(err));
+    });
+}
+function parseSessionKeyFromPayloadJSON(payloadJSON) {
+    let payload;
+    try {
+        payload = JSON.parse(payloadJSON);
+    }
+    catch {
+        return null;
+    }
+    if (typeof payload !== "object" || payload === null) {
+        return null;
+    }
+    const obj = payload;
+    const sessionKey = typeof obj.sessionKey === "string" ? obj.sessionKey.trim() : "";
+    return sessionKey.length > 0 ? sessionKey : null;
+}
+async function sendReceiptAck(params) {
+    const resolved = resolveOutboundTarget({
+        channel: params.channel,
+        to: params.to,
+        cfg: params.cfg,
+        mode: "explicit",
+    });
+    if (!resolved.ok) {
+        throw new Error(String(resolved.error));
+    }
+    const agentId = resolveSessionAgentId({ sessionKey: params.sessionKey, config: params.cfg });
+    await deliverOutboundPayloads({
+        cfg: params.cfg,
+        channel: params.channel,
+        to: resolved.to,
+        payloads: [{ text: params.text }],
+        agentId,
+        bestEffort: true,
+        deps: createOutboundSendDeps(params.deps),
+    });
+}
 export const handleNodeEvent = async (ctx, nodeId, evt) => {
     switch (evt.event) {
         case "voice.transcript": {
-            if (!evt.payloadJSON)
+            if (!evt.payloadJSON) {
                 return;
+            }
             let payload;
             try {
                 payload = JSON.parse(evt.payloadJSON);
@@ -23,53 +187,60 @@ export const handleNodeEvent = async (ctx, nodeId, evt) => {
             }
             const obj = typeof payload === "object" && payload !== null ? payload : {};
             const text = typeof obj.text === "string" ? obj.text.trim() : "";
-            if (!text)
+            if (!text) {
                 return;
-            if (text.length > 20_000)
+            }
+            if (text.length > 20_000) {
                 return;
+            }
             const sessionKeyRaw = typeof obj.sessionKey === "string" ? obj.sessionKey.trim() : "";
             const cfg = loadConfig();
             const rawMainKey = normalizeMainKey(cfg.session?.mainKey);
             const sessionKey = sessionKeyRaw.length > 0 ? sessionKeyRaw : rawMainKey;
             const { storePath, entry, canonicalKey } = loadSessionEntry(sessionKey);
             const now = Date.now();
-            const sessionId = entry?.sessionId ?? randomUUID();
-            if (storePath) {
-                await updateSessionStore(storePath, (store) => {
-                    store[canonicalKey] = {
-                        sessionId,
-                        updatedAt: now,
-                        thinkingLevel: entry?.thinkingLevel,
-                        verboseLevel: entry?.verboseLevel,
-                        reasoningLevel: entry?.reasoningLevel,
-                        systemSent: entry?.systemSent,
-                        sendPolicy: entry?.sendPolicy,
-                        lastChannel: entry?.lastChannel,
-                        lastTo: entry?.lastTo,
-                    };
-                });
+            const fingerprint = resolveVoiceTranscriptFingerprint(obj, text);
+            if (shouldDropDuplicateVoiceTranscript({ sessionKey: canonicalKey, fingerprint, now })) {
+                return;
             }
+            const sessionId = entry?.sessionId ?? randomUUID();
+            queueSessionStoreTouch({
+                ctx,
+                cfg,
+                sessionKey,
+                storePath,
+                canonicalKey,
+                entry,
+                sessionId,
+                now,
+            });
             // Ensure chat UI clients refresh when this run completes (even though it wasn't started via chat.send).
             // This maps agent bus events (keyed by sessionId) to chat events (keyed by clientRunId).
             ctx.addChatRun(sessionId, {
-                sessionKey,
+                sessionKey: canonicalKey,
                 clientRunId: `voice-${randomUUID()}`,
             });
             void agentCommand({
                 message: text,
                 sessionId,
-                sessionKey,
+                sessionKey: canonicalKey,
                 thinking: "low",
                 deliver: false,
                 messageChannel: "node",
+                inputProvenance: {
+                    kind: "external_user",
+                    sourceChannel: "voice",
+                    sourceTool: "gateway.voice.transcript",
+                },
             }, defaultRuntime, ctx.deps).catch((err) => {
                 ctx.logGateway.warn(`agent failed node=${nodeId}: ${formatForLog(err)}`);
             });
             return;
         }
         case "agent.request": {
-            if (!evt.payloadJSON)
+            if (!evt.payloadJSON) {
                 return;
+            }
             let link = null;
             try {
                 link = JSON.parse(evt.payloadJSON);
@@ -77,43 +248,84 @@ export const handleNodeEvent = async (ctx, nodeId, evt) => {
             catch {
                 return;
             }
-            const message = (link?.message ?? "").trim();
-            if (!message)
+            let message = (link?.message ?? "").trim();
+            const normalizedAttachments = normalizeRpcAttachmentsToChatAttachments(link?.attachments ?? undefined);
+            let images = [];
+            if (normalizedAttachments.length > 0) {
+                try {
+                    const parsed = await parseMessageWithAttachments(message, normalizedAttachments, {
+                        maxBytes: 5_000_000,
+                        log: ctx.logGateway,
+                    });
+                    message = parsed.message.trim();
+                    images = parsed.images;
+                }
+                catch {
+                    return;
+                }
+            }
+            if (!message) {
                 return;
-            if (message.length > 20_000)
+            }
+            if (message.length > 20_000) {
                 return;
+            }
             const channelRaw = typeof link?.channel === "string" ? link.channel.trim() : "";
-            const channel = normalizeChannelId(channelRaw) ?? undefined;
-            const to = typeof link?.to === "string" && link.to.trim() ? link.to.trim() : undefined;
-            const deliver = Boolean(link?.deliver) && Boolean(channel);
+            let channel = normalizeChannelId(channelRaw) ?? undefined;
+            let to = typeof link?.to === "string" && link.to.trim() ? link.to.trim() : undefined;
+            const deliverRequested = Boolean(link?.deliver);
+            const wantsReceipt = Boolean(link?.receipt);
+            const receiptTextRaw = typeof link?.receiptText === "string" ? link.receiptText.trim() : "";
+            const receiptText = receiptTextRaw || "Just received your iOS share + request, working on it.";
             const sessionKeyRaw = (link?.sessionKey ?? "").trim();
             const sessionKey = sessionKeyRaw.length > 0 ? sessionKeyRaw : `node-${nodeId}`;
+            const cfg = loadConfig();
             const { storePath, entry, canonicalKey } = loadSessionEntry(sessionKey);
             const now = Date.now();
             const sessionId = entry?.sessionId ?? randomUUID();
-            if (storePath) {
-                await updateSessionStore(storePath, (store) => {
-                    store[canonicalKey] = {
-                        sessionId,
-                        updatedAt: now,
-                        thinkingLevel: entry?.thinkingLevel,
-                        verboseLevel: entry?.verboseLevel,
-                        reasoningLevel: entry?.reasoningLevel,
-                        systemSent: entry?.systemSent,
-                        sendPolicy: entry?.sendPolicy,
-                        lastChannel: entry?.lastChannel,
-                        lastTo: entry?.lastTo,
-                    };
+            await touchSessionStore({ cfg, sessionKey, storePath, canonicalKey, entry, sessionId, now });
+            if (deliverRequested && (!channel || !to)) {
+                const entryChannel = typeof entry?.lastChannel === "string"
+                    ? normalizeChannelId(entry.lastChannel)
+                    : undefined;
+                const entryTo = typeof entry?.lastTo === "string" ? entry.lastTo.trim() : "";
+                if (!channel && entryChannel) {
+                    channel = entryChannel;
+                }
+                if (!to && entryTo) {
+                    to = entryTo;
+                }
+            }
+            const deliver = deliverRequested && Boolean(channel && to);
+            const deliveryChannel = deliver ? channel : undefined;
+            const deliveryTo = deliver ? to : undefined;
+            if (deliverRequested && !deliver) {
+                ctx.logGateway.warn(`agent delivery disabled node=${nodeId}: missing session delivery route (channel=${channel ?? "-"} to=${to ?? "-"})`);
+            }
+            if (wantsReceipt && deliveryChannel && deliveryTo) {
+                void sendReceiptAck({
+                    cfg,
+                    deps: ctx.deps,
+                    sessionKey: canonicalKey,
+                    channel: deliveryChannel,
+                    to: deliveryTo,
+                    text: receiptText,
+                }).catch((err) => {
+                    ctx.logGateway.warn(`agent receipt failed node=${nodeId}: ${formatForLog(err)}`);
                 });
             }
+            else if (wantsReceipt) {
+                ctx.logGateway.warn(`agent receipt skipped node=${nodeId}: missing delivery route (channel=${deliveryChannel ?? "-"} to=${deliveryTo ?? "-"})`);
+            }
             void agentCommand({
                 message,
+                images,
                 sessionId,
-                sessionKey,
+                sessionKey: canonicalKey,
                 thinking: link?.thinking ?? undefined,
                 deliver,
-                to,
-                channel,
+                to: deliveryTo,
+                channel: deliveryChannel,
                 timeout: typeof link?.timeoutSeconds === "number" ? link.timeoutSeconds.toString() : undefined,
                 messageChannel: "node",
             }, defaultRuntime, ctx.deps).catch((err) => {
@@ -122,44 +334,33 @@ export const handleNodeEvent = async (ctx, nodeId, evt) => {
             return;
         }
         case "chat.subscribe": {
-            if (!evt.payloadJSON)
+            if (!evt.payloadJSON) {
                 return;
-            let payload;
-            try {
-                payload = JSON.parse(evt.payloadJSON);
             }
-            catch {
+            const sessionKey = parseSessionKeyFromPayloadJSON(evt.payloadJSON);
+            if (!sessionKey) {
                 return;
             }
-            const obj = typeof payload === "object" && payload !== null ? payload : {};
-            const sessionKey = typeof obj.sessionKey === "string" ? obj.sessionKey.trim() : "";
-            if (!sessionKey)
-                return;
             ctx.nodeSubscribe(nodeId, sessionKey);
             return;
         }
         case "chat.unsubscribe": {
-            if (!evt.payloadJSON)
+            if (!evt.payloadJSON) {
                 return;
-            let payload;
-            try {
-                payload = JSON.parse(evt.payloadJSON);
             }
-            catch {
+            const sessionKey = parseSessionKeyFromPayloadJSON(evt.payloadJSON);
+            if (!sessionKey) {
                 return;
             }
-            const obj = typeof payload === "object" && payload !== null ? payload : {};
-            const sessionKey = typeof obj.sessionKey === "string" ? obj.sessionKey.trim() : "";
-            if (!sessionKey)
-                return;
             ctx.nodeUnsubscribe(nodeId, sessionKey);
             return;
         }
         case "exec.started":
         case "exec.finished":
         case "exec.denied": {
-            if (!evt.payloadJSON)
+            if (!evt.payloadJSON) {
                 return;
+            }
             let payload;
             try {
                 payload = JSON.parse(evt.payloadJSON);
@@ -169,8 +370,9 @@ export const handleNodeEvent = async (ctx, nodeId, evt) => {
             }
             const obj = typeof payload === "object" && payload !== null ? payload : {};
             const sessionKey = typeof obj.sessionKey === "string" ? obj.sessionKey.trim() : `node-${nodeId}`;
-            if (!sessionKey)
+            if (!sessionKey) {
                 return;
+            }
             const runId = typeof obj.runId === "string" ? obj.runId.trim() : "";
             const command = typeof obj.command === "string" ? obj.command.trim() : "";
             const exitCode = typeof obj.exitCode === "number" && Number.isFinite(obj.exitCode)
@@ -182,19 +384,27 @@ export const handleNodeEvent = async (ctx, nodeId, evt) => {
             let text = "";
             if (evt.event === "exec.started") {
                 text = `Exec started (node=${nodeId}${runId ? ` id=${runId}` : ""})`;
-                if (command)
+                if (command) {
                     text += `: ${command}`;
+                }
             }
             else if (evt.event === "exec.finished") {
                 const exitLabel = timedOut ? "timeout" : `code ${exitCode ?? "?"}`;
+                const compactOutput = compactExecEventOutput(output);
+                const shouldNotify = timedOut || exitCode !== 0 || compactOutput.length > 0;
+                if (!shouldNotify) {
+                    return;
+                }
                 text = `Exec finished (node=${nodeId}${runId ? ` id=${runId}` : ""}, ${exitLabel})`;
-                if (output)
-                    text += `\n${output}`;
+                if (compactOutput) {
+                    text += `\n${compactOutput}`;
+                }
             }
             else {
                 text = `Exec denied (node=${nodeId}${runId ? ` id=${runId}` : ""}${reason ? `, ${reason}` : ""})`;
-                if (command)
+                if (command) {
                     text += `: ${command}`;
+                }
             }
             enqueueSystemEvent(text, { sessionKey, contextKey: runId ? `exec:${runId}` : "exec" });
             requestHeartbeatNow({ reason: "exec-event" });