@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/gateway/server-chat.js

@@ -10,8 +10,9 @@ import { formatForLog } from "./ws-log.js";
  */
 function shouldSuppressHeartbeatBroadcast(runId) {
     const runContext = getAgentRunContext(runId);
-    if (!runContext?.isHeartbeat)
+    if (!runContext?.isHeartbeat) {
         return false;
+    }
     try {
         const cfg = loadConfig();
         const visibility = resolveHeartbeatVisibility({ cfg, channel: "webchat" });
@@ -36,23 +37,28 @@ export function createChatRunRegistry() {
     const peek = (sessionId) => chatRunSessions.get(sessionId)?.[0];
     const shift = (sessionId) => {
         const queue = chatRunSessions.get(sessionId);
-        if (!queue || queue.length === 0)
+        if (!queue || queue.length === 0) {
             return undefined;
+        }
         const entry = queue.shift();
-        if (!queue.length)
+        if (!queue.length) {
             chatRunSessions.delete(sessionId);
+        }
         return entry;
     };
     const remove = (sessionId, clientRunId, sessionKey) => {
         const queue = chatRunSessions.get(sessionId);
-        if (!queue || queue.length === 0)
+        if (!queue || queue.length === 0) {
             return undefined;
+        }
         const idx = queue.findIndex((entry) => entry.clientRunId === clientRunId && (sessionKey ? entry.sessionKey === sessionKey : true));
-        if (idx < 0)
+        if (idx < 0) {
             return undefined;
+        }
         const [entry] = queue.splice(idx, 1);
-        if (!queue.length)
+        if (!queue.length) {
             chatRunSessions.delete(sessionId);
+        }
         return entry;
     };
     const clear = () => {
@@ -79,13 +85,69 @@ export function createChatRunState() {
         clear,
     };
 }
-export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRunSeq, chatRunState, resolveSessionKeyForRun, clearAgentRunContext, }) {
+const TOOL_EVENT_RECIPIENT_TTL_MS = 10 * 60 * 1000;
+const TOOL_EVENT_RECIPIENT_FINAL_GRACE_MS = 30 * 1000;
+export function createToolEventRecipientRegistry() {
+    const recipients = new Map();
+    const prune = () => {
+        if (recipients.size === 0) {
+            return;
+        }
+        const now = Date.now();
+        for (const [runId, entry] of recipients) {
+            const cutoff = entry.finalizedAt
+                ? entry.finalizedAt + TOOL_EVENT_RECIPIENT_FINAL_GRACE_MS
+                : entry.updatedAt + TOOL_EVENT_RECIPIENT_TTL_MS;
+            if (now >= cutoff) {
+                recipients.delete(runId);
+            }
+        }
+    };
+    const add = (runId, connId) => {
+        if (!runId || !connId) {
+            return;
+        }
+        const now = Date.now();
+        const existing = recipients.get(runId);
+        if (existing) {
+            existing.connIds.add(connId);
+            existing.updatedAt = now;
+        }
+        else {
+            recipients.set(runId, {
+                connIds: new Set([connId]),
+                updatedAt: now,
+            });
+        }
+        prune();
+    };
+    const get = (runId) => {
+        const entry = recipients.get(runId);
+        if (!entry) {
+            return undefined;
+        }
+        entry.updatedAt = Date.now();
+        prune();
+        return entry.connIds;
+    };
+    const markFinal = (runId) => {
+        const entry = recipients.get(runId);
+        if (!entry) {
+            return;
+        }
+        entry.finalizedAt = Date.now();
+        prune();
+    };
+    return { add, get, markFinal };
+}
+export function createAgentEventHandler({ broadcast, broadcastToConnIds, nodeSendToSession, agentRunSeq, chatRunState, resolveSessionKeyForRun, clearAgentRunContext, toolEventRecipients, }) {
     const emitChatDelta = (sessionKey, clientRunId, seq, text) => {
         chatRunState.buffers.set(clientRunId, text);
         const now = Date.now();
         const last = chatRunState.deltaSentAt.get(clientRunId) ?? 0;
-        if (now - last < 150)
+        if (now - last < 150) {
             return;
+        }
         chatRunState.deltaSentAt.set(clientRunId, now);
         const payload = {
             runId: clientRunId,
@@ -139,23 +201,26 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
         broadcast("chat", payload);
         nodeSendToSession(sessionKey, "chat", payload);
     };
-    const shouldEmitToolEvents = (runId, sessionKey) => {
+    const resolveToolVerboseLevel = (runId, sessionKey) => {
         const runContext = getAgentRunContext(runId);
         const runVerbose = normalizeVerboseLevel(runContext?.verboseLevel);
-        if (runVerbose)
-            return runVerbose === "on";
-        if (!sessionKey)
-            return false;
+        if (runVerbose) {
+            return runVerbose;
+        }
+        if (!sessionKey) {
+            return "off";
+        }
         try {
             const { cfg, entry } = loadSessionEntry(sessionKey);
             const sessionVerbose = normalizeVerboseLevel(entry?.verboseLevel);
-            if (sessionVerbose)
-                return sessionVerbose === "on";
+            if (sessionVerbose) {
+                return sessionVerbose;
+            }
             const defaultVerbose = normalizeVerboseLevel(cfg.agents?.defaults?.verboseDefault);
-            return defaultVerbose === "on";
+            return defaultVerbose ?? "off";
         }
         catch {
-            return false;
+            return "off";
         }
     };
     return (evt) => {
@@ -166,10 +231,17 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
         // Include sessionKey so Control UI can filter tool streams per session.
         const agentPayload = sessionKey ? { ...evt, sessionKey } : evt;
         const last = agentRunSeq.get(evt.runId) ?? 0;
-        if (evt.stream === "tool" && !shouldEmitToolEvents(evt.runId, sessionKey)) {
-            agentRunSeq.set(evt.runId, evt.seq);
-            return;
-        }
+        const isToolEvent = evt.stream === "tool";
+        const toolVerbose = isToolEvent ? resolveToolVerboseLevel(evt.runId, sessionKey) : "off";
+        // Build tool payload: strip result/partialResult unless verbose=full
+        const toolPayload = isToolEvent && toolVerbose !== "full"
+            ? (() => {
+                const data = evt.data ? { ...evt.data } : {};
+                delete data.result;
+                delete data.partialResult;
+                return sessionKey ? { ...evt, sessionKey, data } : { ...evt, data };
+            })()
+            : agentPayload;
         if (evt.seq !== last + 1) {
             broadcast("agent", {
                 runId: evt.runId,
@@ -184,10 +256,26 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
             });
         }
         agentRunSeq.set(evt.runId, evt.seq);
-        broadcast("agent", agentPayload);
+        if (isToolEvent) {
+            // Always broadcast tool events to registered WS recipients with
+            // tool-events capability, regardless of verboseLevel. The verbose
+            // setting only controls whether tool details are sent as channel
+            // messages to messaging surfaces (Telegram, Discord, etc.).
+            const recipients = toolEventRecipients.get(evt.runId);
+            if (recipients && recipients.size > 0) {
+                broadcastToConnIds("agent", toolPayload, recipients);
+            }
+        }
+        else {
+            broadcast("agent", agentPayload);
+        }
         const lifecyclePhase = evt.stream === "lifecycle" && typeof evt.data?.phase === "string" ? evt.data.phase : null;
         if (sessionKey) {
-            nodeSendToSession(sessionKey, "agent", agentPayload);
+            // Send tool events to node/channel subscribers only when verbose is enabled;
+            // WS clients already received the event above via broadcastToConnIds.
+            if (!isToolEvent || toolVerbose !== "off") {
+                nodeSendToSession(sessionKey, "agent", isToolEvent ? toolPayload : agentPayload);
+            }
             if (!isAborted && evt.stream === "assistant" && typeof evt.data?.text === "string") {
                 emitChatDelta(sessionKey, clientRunId, evt.seq, evt.data.text);
             }
@@ -215,6 +303,7 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
             }
         }
         if (lifecyclePhase === "end" || lifecyclePhase === "error") {
+            toolEventRecipients.markFinal(evt.runId);
             clearAgentRunContext(evt.runId);
         }
     };

package/dist/gateway/server-discovery-runtime.js

@@ -1,6 +1,6 @@
 import { startGatewayBonjourAdvertiser } from "../infra/bonjour.js";
 import { pickPrimaryTailnetIPv4, pickPrimaryTailnetIPv6 } from "../infra/tailnet.js";
-import { WIDE_AREA_DISCOVERY_DOMAIN, writeWideAreaGatewayZone } from "../infra/widearea-dns.js";
+import { resolveWideAreaDiscoveryDomain, writeWideAreaGatewayZone } from "../infra/widearea-dns.js";
 import { formatBonjourInstanceName, resolveBonjourCliPath, resolveTailnetDnsHint, } from "./server-discovery.js";
 export async function startGatewayDiscovery(params) {
     let bonjourStop = null;
@@ -40,6 +40,13 @@ export async function startGatewayDiscovery(params) {
         }
     }
     if (params.wideAreaDiscoveryEnabled) {
+        const wideAreaDomain = resolveWideAreaDiscoveryDomain({
+            configDomain: params.wideAreaDiscoveryDomain ?? undefined,
+        });
+        if (!wideAreaDomain) {
+            params.logDiscovery.warn("discovery.wideArea.enabled is true, but no domain was configured; set discovery.wideArea.domain to enable unicast DNS-SD");
+            return { bonjourStop };
+        }
         const tailnetIPv4 = pickPrimaryTailnetIPv4();
         if (!tailnetIPv4) {
             params.logDiscovery.warn("discovery.wideArea.enabled is true, but no Tailscale IPv4 address was found; skipping unicast DNS-SD zone update");
@@ -48,6 +55,7 @@ export async function startGatewayDiscovery(params) {
             try {
                 const tailnetIPv6 = pickPrimaryTailnetIPv6();
                 const result = await writeWideAreaGatewayZone({
+                    domain: wideAreaDomain,
                     gatewayPort: params.port,
                     displayName: formatBonjourInstanceName(params.machineDisplayName),
                     tailnetIPv4,
@@ -58,7 +66,7 @@ export async function startGatewayDiscovery(params) {
                     sshPort,
                     cliPath: resolveBonjourCliPath(),
                 });
-                params.logDiscovery.info(`wide-area DNS-SD ${result.changed ? "updated" : "unchanged"} (${WIDE_AREA_DISCOVERY_DOMAIN} → ${result.zonePath})`);
+                params.logDiscovery.info(`wide-area DNS-SD ${result.changed ? "updated" : "unchanged"} (${wideAreaDomain} → ${result.zonePath})`);
             }
             catch (err) {
                 params.logDiscovery.warn(`wide-area discovery update failed: ${String(err)}`);

package/dist/gateway/server-discovery.js

@@ -5,10 +5,10 @@ import { runExec } from "../process/exec.js";
 export function formatBonjourInstanceName(displayName) {
     const trimmed = displayName.trim();
     if (!trimmed)
-        return "Moltbot";
+        return "Poolbot";
     if (/poolbot/i.test(trimmed))
         return trimmed;
-    return `${trimmed} (Moltbot)`;
+    return `${trimmed} (Poolbot)`;
 }
 export function resolveBonjourCliPath(opts = {}) {
     const env = opts.env ?? process.env;

package/dist/gateway/server-http.js

@@ -1,12 +1,16 @@
 import { createServer as createHttpServer, } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
-import { handleA2uiHttpRequest } from "../canvas-host/a2ui.js";
+import { A2UI_PATH, CANVAS_HOST_PATH, CANVAS_WS_PATH, handleA2uiHttpRequest, } from "../canvas-host/a2ui.js";
 import { loadConfig } from "../config/config.js";
-import { handleSlackHttpRequest } from "../slack/http/index.js";
 import { resolveAgentAvatar } from "../agents/identity-avatar.js";
-import { handleControlUiAvatarRequest, handleControlUiHttpRequest } from "./control-ui.js";
-import { extractHookToken, getHookChannelError, normalizeAgentPayload, normalizeHookHeaders, normalizeWakePayload, readJsonBody, resolveHookChannel, resolveHookDeliver, } from "./hooks.js";
+import { handleSlackHttpRequest } from "../slack/http/index.js";
+import { authorizeGatewayConnect, isLocalDirectRequest } from "./auth.js";
+import { handleControlUiAvatarRequest, handleControlUiHttpRequest, } from "./control-ui.js";
+import { extractHookToken, getHookAgentPolicyError, getHookChannelError, isHookAgentAllowed, normalizeAgentPayload, normalizeHookHeaders, normalizeWakePayload, readJsonBody, resolveHookTargetAgentId, resolveHookChannel, resolveHookDeliver, } from "./hooks.js";
 import { applyHookMappings } from "./hooks-mapping.js";
+import { sendUnauthorized } from "./http-common.js";
+import { getBearerToken, getHeader } from "./http-utils.js";
+import { resolveGatewayClientIp } from "./net.js";
 import { handleOpenAiHttpRequest } from "./openai-http.js";
 import { handleOpenResponsesHttpRequest } from "./openresponses-http.js";
 import { handleToolsInvokeHttpRequest } from "./tools-invoke-http.js";
@@ -15,6 +19,49 @@ function sendJson(res, status, body) {
     res.setHeader("Content-Type", "application/json; charset=utf-8");
     res.end(JSON.stringify(body));
 }
+function isCanvasPath(pathname) {
+    return (pathname === A2UI_PATH ||
+        pathname.startsWith(`${A2UI_PATH}/`) ||
+        pathname === CANVAS_HOST_PATH ||
+        pathname.startsWith(`${CANVAS_HOST_PATH}/`) ||
+        pathname === CANVAS_WS_PATH);
+}
+function hasAuthorizedWsClientForIp(clients, clientIp) {
+    for (const client of clients) {
+        if (client.clientIp && client.clientIp === clientIp) {
+            return true;
+        }
+    }
+    return false;
+}
+async function authorizeCanvasRequest(params) {
+    const { req, auth, trustedProxies, clients } = params;
+    if (isLocalDirectRequest(req, trustedProxies)) {
+        return true;
+    }
+    const token = getBearerToken(req);
+    if (token) {
+        const authResult = await authorizeGatewayConnect({
+            auth: { ...auth, allowTailscale: false },
+            connectAuth: { token, password: token },
+            req,
+            trustedProxies,
+        });
+        if (authResult.ok) {
+            return true;
+        }
+    }
+    const clientIp = resolveGatewayClientIp({
+        remoteAddr: req.socket?.remoteAddress ?? "",
+        forwardedFor: getHeader(req, "x-forwarded-for"),
+        realIp: getHeader(req, "x-real-ip"),
+        trustedProxies,
+    });
+    if (!clientIp) {
+        return false;
+    }
+    return hasAuthorizedWsClientForIp(clients, clientIp);
+}
 export function createHooksRequestHandler(opts) {
     const { getHooksConfig, bindHost, port, logHooks, dispatchAgentHook, dispatchWakeHook } = opts;
     return async (req, res) => {
@@ -26,6 +73,8 @@ export function createHooksRequestHandler(opts) {
         if (url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`)) {
             return false;
         }
+        // pool-bot keeps the deprecation-warning approach for query-param tokens
+        // (upstream hard-rejects; we warn and allow for now)
         const { token, fromQuery } = extractHookToken(req, url);
         if (!token || token !== hooksConfig.token) {
             res.statusCode = 401;
@@ -36,7 +85,7 @@ export function createHooksRequestHandler(opts) {
         if (fromQuery) {
             logHooks.warn("Hook token provided via query parameter is deprecated for security reasons. " +
                 "Tokens in URLs appear in logs, browser history, and referrer headers. " +
-                "Use Authorization: Bearer <token> or X-Moltbot-Token header instead.");
+                "Use Authorization: Bearer <token> or X-Poolbot-Token header instead.");
         }
         if (req.method !== "POST") {
             res.statusCode = 405;
@@ -76,7 +125,14 @@ export function createHooksRequestHandler(opts) {
                 sendJson(res, 400, { ok: false, error: normalized.error });
                 return true;
             }
-            const runId = dispatchAgentHook(normalized.value);
+            if (!isHookAgentAllowed(hooksConfig, normalized.value.agentId)) {
+                sendJson(res, 400, { ok: false, error: getHookAgentPolicyError() });
+                return true;
+            }
+            const runId = dispatchAgentHook({
+                ...normalized.value,
+                agentId: resolveHookTargetAgentId(hooksConfig, normalized.value.agentId),
+            });
             sendJson(res, 202, { ok: true, runId });
             return true;
         }
@@ -111,9 +167,14 @@ export function createHooksRequestHandler(opts) {
                         sendJson(res, 400, { ok: false, error: getHookChannelError() });
                         return true;
                     }
+                    if (!isHookAgentAllowed(hooksConfig, mapped.action.agentId)) {
+                        sendJson(res, 400, { ok: false, error: getHookAgentPolicyError() });
+                        return true;
+                    }
                     const runId = dispatchAgentHook({
                         message: mapped.action.message,
                         name: mapped.action.name ?? "Hook",
+                        agentId: resolveHookTargetAgentId(hooksConfig, mapped.action.agentId),
                         wakeMode: mapped.action.wakeMode,
                         sessionKey: mapped.action.sessionKey ?? "",
                         deliver: resolveHookDeliver(mapped.action.deliver),
@@ -141,7 +202,7 @@ export function createHooksRequestHandler(opts) {
     };
 }
 export function createGatewayHttpServer(opts) {
-    const { canvasHost, controlUiEnabled, controlUiBasePath, openAiChatCompletionsEnabled, openResponsesEnabled, openResponsesConfig, handleHooksRequest, handlePluginRequest, resolvedAuth, } = opts;
+    const { canvasHost, clients, controlUiEnabled, controlUiBasePath, controlUiRoot, openAiChatCompletionsEnabled, openResponsesEnabled, openResponsesConfig, handleHooksRequest, handlePluginRequest, resolvedAuth, } = opts;
     const httpServer = opts.tlsOptions
         ? createHttpsServer(opts.tlsOptions, (req, res) => {
             void handleRequest(req, res);
@@ -183,6 +244,19 @@ export function createGatewayHttpServer(opts) {
                     return;
             }
             if (canvasHost) {
+                const url = new URL(req.url ?? "/", "http://localhost");
+                if (isCanvasPath(url.pathname)) {
+                    const ok = await authorizeCanvasRequest({
+                        req,
+                        auth: resolvedAuth,
+                        trustedProxies,
+                        clients,
+                    });
+                    if (!ok) {
+                        sendUnauthorized(res);
+                        return;
+                    }
+                }
                 if (await handleA2uiHttpRequest(req, res))
                     return;
                 if (await canvasHost.handleHttpRequest(req, res))
@@ -197,6 +271,7 @@ export function createGatewayHttpServer(opts) {
                 if (handleControlUiHttpRequest(req, res, {
                     basePath: controlUiBasePath,
                     config: configSnapshot,
+                    root: controlUiRoot,
                 }))
                     return;
             }
@@ -213,12 +288,35 @@ export function createGatewayHttpServer(opts) {
     return httpServer;
 }
 export function attachGatewayUpgradeHandler(opts) {
-    const { httpServer, wss, canvasHost } = opts;
+    const { httpServer, wss, canvasHost, clients, resolvedAuth } = opts;
     httpServer.on("upgrade", (req, socket, head) => {
-        if (canvasHost?.handleUpgrade(req, socket, head))
-            return;
-        wss.handleUpgrade(req, socket, head, (ws) => {
-            wss.emit("connection", ws, req);
+        void (async () => {
+            if (canvasHost) {
+                const url = new URL(req.url ?? "/", "http://localhost");
+                if (url.pathname === CANVAS_WS_PATH) {
+                    const configSnapshot = loadConfig();
+                    const trustedProxies = configSnapshot.gateway?.trustedProxies ?? [];
+                    const ok = await authorizeCanvasRequest({
+                        req,
+                        auth: resolvedAuth,
+                        trustedProxies,
+                        clients,
+                    });
+                    if (!ok) {
+                        socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
+                        socket.destroy();
+                        return;
+                    }
+                }
+                if (canvasHost.handleUpgrade(req, socket, head)) {
+                    return;
+                }
+            }
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                wss.emit("connection", ws, req);
+            });
+        })().catch(() => {
+            socket.destroy();
         });
     });
 }

package/dist/gateway/server-methods/agent-timestamp.js

@@ -0,0 +1,60 @@
+import { resolveUserTimezone } from "../../agents/date-time.js";
+import { formatZonedTimestamp } from "../../infra/format-time/format-datetime.js";
+/**
+ * Cron jobs inject "Current time: ..." into their messages.
+ * Skip injection for those.
+ */
+const CRON_TIME_PATTERN = /Current time: /;
+/**
+ * Matches a leading `[... YYYY-MM-DD HH:MM ...]` envelope -- either from
+ * channel plugins or from a previous injection. Uses the same YYYY-MM-DD
+ * HH:MM format as {@link formatZonedTimestamp}, so detection stays in sync
+ * with the formatting.
+ */
+const TIMESTAMP_ENVELOPE_PATTERN = /^\[.*\d{4}-\d{2}-\d{2} \d{2}:\d{2}/;
+/**
+ * Injects a compact timestamp prefix into a message if one isn't already
+ * present. Uses the same `YYYY-MM-DD HH:MM TZ` format as channel envelope
+ * timestamps ({@link formatZonedTimestamp}), keeping token cost low (~7
+ * tokens) and format consistent across all agent contexts.
+ *
+ * Used by the gateway `agent` and `chat.send` handlers to give TUI, web,
+ * spawned subagents, `sessions_send`, and heartbeat wake events date/time
+ * awareness -- without modifying the system prompt (which is cached).
+ *
+ * Channel messages (Discord, Telegram, etc.) already have timestamps via
+ * envelope formatting and take a separate code path -- they never reach
+ * these handlers, so there is no double-stamping risk. The detection
+ * pattern is a safety net for edge cases.
+ */
+export function injectTimestamp(message, opts) {
+    if (!message.trim()) {
+        return message;
+    }
+    // Already has an envelope or injected timestamp
+    if (TIMESTAMP_ENVELOPE_PATTERN.test(message)) {
+        return message;
+    }
+    // Already has a cron-injected timestamp
+    if (CRON_TIME_PATTERN.test(message)) {
+        return message;
+    }
+    const now = opts?.now ?? new Date();
+    const timezone = opts?.timezone ?? "UTC";
+    const formatted = formatZonedTimestamp(now, { timeZone: timezone });
+    if (!formatted) {
+        return message;
+    }
+    // 3-letter DOW: small models (8B) can't reliably derive day-of-week from
+    // a date, and may treat a bare "Wed" as a typo. Costs ~1 token.
+    const dow = new Intl.DateTimeFormat("en-US", { timeZone: timezone, weekday: "short" }).format(now);
+    return `[${dow} ${formatted}] ${message}`;
+}
+/**
+ * Build TimestampInjectionOptions from a PoolBotConfig.
+ */
+export function timestampOptsFromConfig(cfg) {
+    return {
+        timezone: resolveUserTimezone(cfg.agents?.defaults?.userTimezone),
+    };
+}