@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/terminal/restore.js

@@ -0,0 +1,45 @@
+import { clearActiveProgressLine } from "./progress-line.js";
+const RESET_SEQUENCE = "\x1b[0m\x1b[?25h\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?2004l";
+function reportRestoreFailure(scope, err, reason) {
+    const suffix = reason ? ` (${reason})` : "";
+    const message = `[terminal] restore ${scope} failed${suffix}: ${String(err)}`;
+    try {
+        process.stderr.write(`${message}\n`);
+    }
+    catch (writeErr) {
+        console.error(`[terminal] restore reporting failed${suffix}: ${String(writeErr)}`);
+    }
+}
+export function restoreTerminalState(reason) {
+    try {
+        clearActiveProgressLine();
+    }
+    catch (err) {
+        reportRestoreFailure("progress line", err, reason);
+    }
+    const stdin = process.stdin;
+    if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+        try {
+            stdin.setRawMode(false);
+        }
+        catch (err) {
+            reportRestoreFailure("raw mode", err, reason);
+        }
+        if (typeof stdin.isPaused === "function" && stdin.isPaused()) {
+            try {
+                stdin.resume();
+            }
+            catch (err) {
+                reportRestoreFailure("stdin resume", err, reason);
+            }
+        }
+    }
+    if (process.stdout.isTTY) {
+        try {
+            process.stdout.write(RESET_SEQUENCE);
+        }
+        catch (err) {
+            reportRestoreFailure("stdout reset", err, reason);
+        }
+    }
+}

package/dist/test-helpers/state-dir-env.js

@@ -0,0 +1,16 @@
+export function snapshotStateDirEnv() {
+    return {
+        clawdbotStateDir: process.env.CLAWDBOT_STATE_DIR,
+    };
+}
+export function restoreStateDirEnv(snapshot) {
+    if (snapshot.clawdbotStateDir === undefined) {
+        delete process.env.CLAWDBOT_STATE_DIR;
+    }
+    else {
+        process.env.CLAWDBOT_STATE_DIR = snapshot.clawdbotStateDir;
+    }
+}
+export function setStateDirEnv(stateDir) {
+    process.env.CLAWDBOT_STATE_DIR = stateDir;
+}

package/dist/test-helpers/workspace.js

@@ -0,0 +1,11 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export async function makeTempWorkspace(prefix = "poolbot-workspace-") {
+    return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+export async function writeWorkspaceFile(params) {
+    const filePath = path.join(params.dir, params.name);
+    await fs.writeFile(filePath, params.content, "utf-8");
+    return filePath;
+}

package/dist/test-utils/channel-plugins.js

@@ -0,0 +1,82 @@
+import { imessageOutbound } from "../channels/plugins/outbound/imessage.js";
+import { normalizeIMessageHandle } from "../imessage/targets.js";
+export const createTestRegistry = (channels = []) => ({
+    plugins: [],
+    tools: [],
+    hooks: [],
+    typedHooks: [],
+    channels,
+    providers: [],
+    gatewayHandlers: {},
+    httpHandlers: [],
+    httpRoutes: [],
+    cliRegistrars: [],
+    services: [],
+    commands: [],
+    diagnostics: [],
+});
+export const createIMessageTestPlugin = (params) => ({
+    id: "imessage",
+    meta: {
+        id: "imessage",
+        label: "iMessage",
+        selectionLabel: "iMessage (imsg)",
+        docsPath: "/channels/imessage",
+        blurb: "iMessage test stub.",
+        aliases: ["imsg"],
+    },
+    capabilities: { chatTypes: ["direct", "group"], media: true },
+    config: {
+        listAccountIds: () => [],
+        resolveAccount: () => ({}),
+    },
+    status: {
+        collectStatusIssues: (accounts) => accounts.flatMap((account) => {
+            const lastError = typeof account.lastError === "string" ? account.lastError.trim() : "";
+            if (!lastError)
+                return [];
+            return [
+                {
+                    channel: "imessage",
+                    accountId: account.accountId,
+                    kind: "runtime",
+                    message: `Channel error: ${lastError}`,
+                },
+            ];
+        }),
+    },
+    outbound: params?.outbound ?? imessageOutbound,
+    messaging: {
+        targetResolver: {
+            looksLikeId: (raw) => {
+                const trimmed = raw.trim();
+                if (!trimmed)
+                    return false;
+                if (/^(imessage:|sms:|auto:|chat_id:|chat_guid:|chat_identifier:)/i.test(trimmed)) {
+                    return true;
+                }
+                if (trimmed.includes("@"))
+                    return true;
+                return /^\+?\d{3,}$/.test(trimmed);
+            },
+            hint: "<handle|chat_id:ID>",
+        },
+        normalizeTarget: (raw) => normalizeIMessageHandle(raw),
+    },
+});
+export const createOutboundTestPlugin = (params) => ({
+    id: params.id,
+    meta: {
+        id: params.id,
+        label: params.label ?? String(params.id),
+        selectionLabel: params.label ?? String(params.id),
+        docsPath: params.docsPath ?? `/channels/${params.id}`,
+        blurb: "test stub.",
+    },
+    capabilities: params.capabilities ?? { chatTypes: ["direct"] },
+    config: {
+        listAccountIds: () => [],
+        resolveAccount: () => ({}),
+    },
+    outbound: params.outbound,
+});

package/dist/test-utils/ports.js

@@ -0,0 +1,73 @@
+import { createServer } from "node:net";
+import { isMainThread, threadId } from "node:worker_threads";
+async function isPortFree(port) {
+    if (!Number.isFinite(port) || port <= 0 || port > 65535)
+        return false;
+    return await new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", () => resolve(false));
+        server.listen(port, "127.0.0.1", () => {
+            server.close(() => resolve(true));
+        });
+    });
+}
+async function getOsFreePort() {
+    return await new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                server.close();
+                reject(new Error("failed to acquire free port"));
+                return;
+            }
+            const port = addr.port;
+            server.close((err) => (err ? reject(err) : resolve(port)));
+        });
+    });
+}
+let nextTestPortOffset = 0;
+/**
+ * Allocate a deterministic per-worker port block.
+ *
+ * Motivation: many tests spin up gateway + related services that use derived ports
+ * (e.g. +1/+2/+3/+4). If each test just grabs an OS free port, parallel test runs
+ * can collide on derived ports and get flaky EADDRINUSE.
+ */
+export async function getDeterministicFreePortBlock(params) {
+    const offsets = params?.offsets ?? [0, 1, 2, 3, 4];
+    const maxOffset = Math.max(...offsets);
+    const workerIdRaw = process.env.VITEST_WORKER_ID ?? process.env.VITEST_POOL_ID ?? "";
+    const workerId = Number.parseInt(workerIdRaw, 10);
+    const shard = Number.isFinite(workerId)
+        ? Math.max(0, workerId)
+        : isMainThread
+            ? Math.abs(process.pid)
+            : Math.abs(threadId);
+    const rangeSize = 1000;
+    const shardCount = 30;
+    const base = 30_000 + (Math.abs(shard) % shardCount) * rangeSize; // <= 59_999
+    const usable = rangeSize - maxOffset;
+    // Allocate in blocks to avoid derived-port overlaps (e.g. port+3).
+    const blockSize = Math.max(maxOffset + 1, 8);
+    for (let attempt = 0; attempt < usable; attempt += 1) {
+        const start = base + ((nextTestPortOffset + attempt) % usable);
+        // eslint-disable-next-line no-await-in-loop
+        const ok = (await Promise.all(offsets.map((offset) => isPortFree(start + offset)))).every(Boolean);
+        if (!ok)
+            continue;
+        nextTestPortOffset = (nextTestPortOffset + attempt + blockSize) % usable;
+        return start;
+    }
+    // Fallback: let the OS pick a port block (best effort).
+    for (let attempt = 0; attempt < 25; attempt += 1) {
+        // eslint-disable-next-line no-await-in-loop
+        const port = await getOsFreePort();
+        // eslint-disable-next-line no-await-in-loop
+        const ok = (await Promise.all(offsets.map((offset) => isPortFree(port + offset)))).every(Boolean);
+        if (ok)
+            return port;
+    }
+    throw new Error("failed to acquire a free port block");
+}

package/dist/tts/tts.js

@@ -579,9 +579,15 @@ export const OPENAI_TTS_MODELS = ["gpt-4o-mini-tts", "tts-1", "tts-1-hd"];
  * Custom OpenAI-compatible TTS endpoint.
  * When set, model/voice validation is relaxed to allow non-OpenAI models.
  * Example: OPENAI_TTS_BASE_URL=http://localhost:8880/v1
+ *
+ * Note: Read at runtime (not module load) to support config.env loading.
  */
-const OPENAI_TTS_BASE_URL = (process.env.OPENAI_TTS_BASE_URL?.trim() || "https://api.openai.com/v1").replace(/\/+$/, "");
-const isCustomOpenAIEndpoint = OPENAI_TTS_BASE_URL !== "https://api.openai.com/v1";
+function getOpenAITtsBaseUrl() {
+    return (process.env.OPENAI_TTS_BASE_URL?.trim() || "https://api.openai.com/v1").replace(/\/+$/, "");
+}
+function isCustomOpenAIEndpoint() {
+    return getOpenAITtsBaseUrl() !== "https://api.openai.com/v1";
+}
 export const OPENAI_TTS_VOICES = [
     "alloy",
     "ash",
@@ -595,13 +601,13 @@ export const OPENAI_TTS_VOICES = [
 ];
 function isValidOpenAIModel(model) {
     // Allow any model when using custom endpoint (e.g., Kokoro, LocalAI)
-    if (isCustomOpenAIEndpoint)
+    if (isCustomOpenAIEndpoint())
         return true;
     return OPENAI_TTS_MODELS.includes(model);
 }
 function isValidOpenAIVoice(voice) {
     // Allow any voice when using custom endpoint (e.g., Kokoro Chinese voices)
-    if (isCustomOpenAIEndpoint)
+    if (isCustomOpenAIEndpoint())
         return true;
     return OPENAI_TTS_VOICES.includes(voice);
 }
@@ -679,7 +685,7 @@ async function summarizeText(params) {
     catch (err) {
         const error = err;
         if (error.name === "AbortError") {
-            throw new Error("Summarization timed out");
+            throw new Error("Summarization timed out", { cause: err });
         }
         throw err;
     }
@@ -754,7 +760,7 @@ async function openaiTTS(params) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        const response = await fetch(`${OPENAI_TTS_BASE_URL}/audio/speech`, {
+        const response = await fetch(`${getOpenAITtsBaseUrl()}/audio/speech`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${apiKey}`,

package/dist/tui/tui-session-actions.js

@@ -1,8 +1,9 @@
 import { normalizeAgentId, normalizeMainKey, parseAgentSessionKey, } from "../routing/session-key.js";
 import { asString, extractTextFromMessage, isCommandMessage } from "./tui-formatters.js";
 export function createSessionActions(context) {
-    const { client, chatLog, tui, opts, state, agentNames, initialSessionInput, initialSessionAgentId, resolveSessionKey, updateHeader, updateFooter, updateAutocompleteProvider, setActivityStatus, } = context;
-    let refreshSessionInfoPromise = null;
+    const { client, chatLog, tui, opts, state, agentNames, initialSessionInput, initialSessionAgentId, resolveSessionKey, updateHeader, updateFooter, updateAutocompleteProvider, setActivityStatus, clearLocalRunIds, } = context;
+    let refreshSessionInfoPromise = Promise.resolve();
+    let lastSessionDefaults = null;
     const applyAgentsResult = (result) => {
         state.agentDefaultId = normalizeAgentId(result.defaultId);
         state.sessionMainKey = normalizeMainKey(result.mainKey);
@@ -13,8 +14,9 @@ export function createSessionActions(context) {
         }));
         agentNames.clear();
         for (const agent of state.agents) {
-            if (agent.name)
+            if (agent.name) {
                 agentNames.set(agent.id, agent.name);
+            }
         }
         if (!state.initialSessionApplied) {
             if (initialSessionAgentId) {
@@ -50,62 +52,161 @@ export function createSessionActions(context) {
     };
     const updateAgentFromSessionKey = (key) => {
         const parsed = parseAgentSessionKey(key);
-        if (!parsed)
+        if (!parsed) {
             return;
+        }
         const next = normalizeAgentId(parsed.agentId);
         if (next !== state.currentAgentId) {
             state.currentAgentId = next;
         }
     };
-    const refreshSessionInfo = async () => {
-        if (refreshSessionInfoPromise)
-            return refreshSessionInfoPromise;
-        refreshSessionInfoPromise = (async () => {
-            try {
-                const listAgentId = state.currentSessionKey === "global" || state.currentSessionKey === "unknown"
-                    ? undefined
-                    : state.currentAgentId;
-                const result = await client.listSessions({
-                    includeGlobal: false,
-                    includeUnknown: false,
-                    agentId: listAgentId,
-                });
-                const entry = result.sessions.find((row) => {
-                    // Exact match
-                    if (row.key === state.currentSessionKey)
-                        return true;
-                    // Also match canonical keys like "agent:default:main" against "main"
-                    const parsed = parseAgentSessionKey(row.key);
-                    return parsed?.rest === state.currentSessionKey;
-                });
-                state.sessionInfo = {
-                    thinkingLevel: entry?.thinkingLevel,
-                    verboseLevel: entry?.verboseLevel,
-                    reasoningLevel: entry?.reasoningLevel,
-                    model: entry?.model ?? result.defaults?.model ?? undefined,
-                    modelProvider: entry?.modelProvider ?? result.defaults?.modelProvider ?? undefined,
-                    contextTokens: entry?.contextTokens ?? result.defaults?.contextTokens,
-                    inputTokens: entry?.inputTokens ?? null,
-                    outputTokens: entry?.outputTokens ?? null,
-                    totalTokens: entry?.totalTokens ?? null,
-                    responseUsage: entry?.responseUsage,
-                    updatedAt: entry?.updatedAt ?? null,
-                    displayName: entry?.displayName,
-                };
-            }
-            catch (err) {
-                chatLog.addSystem(`sessions list failed: ${String(err)}`);
-            }
-            updateAutocompleteProvider();
-            updateFooter();
-            tui.requestRender();
-        })();
+    const resolveModelSelection = (entry) => {
+        if (entry?.modelProvider || entry?.model) {
+            return {
+                modelProvider: entry.modelProvider ?? state.sessionInfo.modelProvider,
+                model: entry.model ?? state.sessionInfo.model,
+            };
+        }
+        const overrideModel = entry?.modelOverride?.trim();
+        if (overrideModel) {
+            const overrideProvider = entry?.providerOverride?.trim() || state.sessionInfo.modelProvider;
+            return { modelProvider: overrideProvider, model: overrideModel };
+        }
+        return {
+            modelProvider: state.sessionInfo.modelProvider,
+            model: state.sessionInfo.model,
+        };
+    };
+    const applySessionInfo = (params) => {
+        const entry = params.entry ?? undefined;
+        const defaults = params.defaults ?? lastSessionDefaults ?? undefined;
+        const previousDefaults = lastSessionDefaults;
+        const defaultsChanged = params.defaults
+            ? previousDefaults?.model !== params.defaults.model ||
+                previousDefaults?.modelProvider !== params.defaults.modelProvider ||
+                previousDefaults?.contextTokens !== params.defaults.contextTokens
+            : false;
+        if (params.defaults) {
+            lastSessionDefaults = params.defaults;
+        }
+        const entryUpdatedAt = entry?.updatedAt ?? null;
+        const currentUpdatedAt = state.sessionInfo.updatedAt ?? null;
+        const modelChanged = (entry?.modelProvider !== undefined &&
+            entry.modelProvider !== state.sessionInfo.modelProvider) ||
+            (entry?.model !== undefined && entry.model !== state.sessionInfo.model);
+        if (!params.force &&
+            entryUpdatedAt !== null &&
+            currentUpdatedAt !== null &&
+            entryUpdatedAt < currentUpdatedAt &&
+            !defaultsChanged &&
+            !modelChanged) {
+            return;
+        }
+        const next = { ...state.sessionInfo };
+        if (entry?.thinkingLevel !== undefined) {
+            next.thinkingLevel = entry.thinkingLevel;
+        }
+        if (entry?.verboseLevel !== undefined) {
+            next.verboseLevel = entry.verboseLevel;
+        }
+        if (entry?.reasoningLevel !== undefined) {
+            next.reasoningLevel = entry.reasoningLevel;
+        }
+        if (entry?.responseUsage !== undefined) {
+            next.responseUsage = entry.responseUsage;
+        }
+        if (entry?.inputTokens !== undefined) {
+            next.inputTokens = entry.inputTokens;
+        }
+        if (entry?.outputTokens !== undefined) {
+            next.outputTokens = entry.outputTokens;
+        }
+        if (entry?.totalTokens !== undefined) {
+            next.totalTokens = entry.totalTokens;
+        }
+        if (entry?.contextTokens !== undefined || defaults?.contextTokens !== undefined) {
+            next.contextTokens =
+                entry?.contextTokens ?? defaults?.contextTokens ?? state.sessionInfo.contextTokens;
+        }
+        if (entry?.displayName !== undefined) {
+            next.displayName = entry.displayName;
+        }
+        if (entry?.updatedAt !== undefined) {
+            next.updatedAt = entry.updatedAt;
+        }
+        const selection = resolveModelSelection(entry);
+        if (selection.modelProvider !== undefined) {
+            next.modelProvider = selection.modelProvider;
+        }
+        if (selection.model !== undefined) {
+            next.model = selection.model;
+        }
+        state.sessionInfo = next;
+        updateAutocompleteProvider();
+        updateFooter();
+        tui.requestRender();
+    };
+    const runRefreshSessionInfo = async () => {
         try {
-            await refreshSessionInfoPromise;
+            const resolveListAgentId = () => {
+                if (state.currentSessionKey === "global" || state.currentSessionKey === "unknown") {
+                    return undefined;
+                }
+                const parsed = parseAgentSessionKey(state.currentSessionKey);
+                return parsed?.agentId ? normalizeAgentId(parsed.agentId) : state.currentAgentId;
+            };
+            const listAgentId = resolveListAgentId();
+            const result = await client.listSessions({
+                includeGlobal: false,
+                includeUnknown: false,
+                agentId: listAgentId,
+            });
+            const normalizeMatchKey = (key) => parseAgentSessionKey(key)?.rest ?? key;
+            const currentMatchKey = normalizeMatchKey(state.currentSessionKey);
+            const entry = result.sessions.find((row) => {
+                // Exact match
+                if (row.key === state.currentSessionKey) {
+                    return true;
+                }
+                // Also match canonical keys like "agent:default:main" against "main"
+                return normalizeMatchKey(row.key) === currentMatchKey;
+            });
+            if (entry?.key && entry.key !== state.currentSessionKey) {
+                updateAgentFromSessionKey(entry.key);
+                state.currentSessionKey = entry.key;
+                updateHeader();
+            }
+            applySessionInfo({
+                entry,
+                defaults: result.defaults,
+            });
+        }
+        catch (err) {
+            chatLog.addSystem(`sessions list failed: ${String(err)}`);
+        }
+    };
+    const refreshSessionInfo = async () => {
+        refreshSessionInfoPromise = refreshSessionInfoPromise.then(runRefreshSessionInfo, runRefreshSessionInfo);
+        await refreshSessionInfoPromise;
+    };
+    const applySessionInfoFromPatch = (result) => {
+        if (!result?.entry) {
+            return;
         }
-        finally {
-            refreshSessionInfoPromise = null;
+        if (result.key && result.key !== state.currentSessionKey) {
+            updateAgentFromSessionKey(result.key);
+            state.currentSessionKey = result.key;
+            updateHeader();
         }
+        const resolved = result.resolved;
+        const entry = resolved && (resolved.modelProvider || resolved.model)
+            ? {
+                ...result.entry,
+                modelProvider: resolved.modelProvider ?? result.entry.modelProvider,
+                model: resolved.model ?? result.entry.model,
+            }
+            : result.entry;
+        applySessionInfo({ entry, force: true });
     };
     const loadHistory = async () => {
         try {
@@ -116,33 +217,42 @@ export function createSessionActions(context) {
             const record = history;
             state.currentSessionId = typeof record.sessionId === "string" ? record.sessionId : null;
             state.sessionInfo.thinkingLevel = record.thinkingLevel ?? state.sessionInfo.thinkingLevel;
+            state.sessionInfo.verboseLevel = record.verboseLevel ?? state.sessionInfo.verboseLevel;
+            const showTools = (state.sessionInfo.verboseLevel ?? "off") !== "off";
             chatLog.clearAll();
             chatLog.addSystem(`session ${state.currentSessionKey}`);
             for (const entry of record.messages ?? []) {
-                if (!entry || typeof entry !== "object")
+                if (!entry || typeof entry !== "object") {
                     continue;
+                }
                 const message = entry;
                 if (isCommandMessage(message)) {
                     const text = extractTextFromMessage(message);
-                    if (text)
+                    if (text) {
                         chatLog.addSystem(text);
+                    }
                     continue;
                 }
                 if (message.role === "user") {
                     const text = extractTextFromMessage(message);
-                    if (text)
+                    if (text) {
                         chatLog.addUser(text);
+                    }
                     continue;
                 }
                 if (message.role === "assistant") {
                     const text = extractTextFromMessage(message, {
                         includeThinking: state.showThinking,
                     });
-                    if (text)
+                    if (text) {
                         chatLog.finalizeAssistant(text);
+                    }
                     continue;
                 }
                 if (message.role === "toolResult") {
+                    if (!showTools) {
+                        continue;
+                    }
                     const toolCallId = asString(message.toolCallId, "");
                     const toolName = asString(message.toolName, "tool");
                     const component = chatLog.startTool(toolCallId, toolName, {});
@@ -171,6 +281,7 @@ export function createSessionActions(context) {
         state.activeChatRunId = null;
         state.currentSessionId = null;
         state.historyLoaded = false;
+        clearLocalRunIds?.();
         updateHeader();
         updateFooter();
         await loadHistory();
@@ -198,6 +309,7 @@ export function createSessionActions(context) {
         applyAgentsResult,
         refreshAgents,
         refreshSessionInfo,
+        applySessionInfoFromPatch,
         loadHistory,
         setSession,
         abortActive,

package/dist/utils/fetch-timeout.js

@@ -0,0 +1,20 @@
+/**
+ * Fetch wrapper that adds timeout support via AbortController.
+ *
+ * @param url - The URL to fetch
+ * @param init - RequestInit options (headers, method, body, etc.)
+ * @param timeoutMs - Timeout in milliseconds
+ * @param fetchFn - The fetch implementation to use (defaults to global fetch)
+ * @returns The fetch Response
+ * @throws AbortError if the request times out
+ */
+export async function fetchWithTimeout(url, init, timeoutMs, fetchFn = fetch) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.max(1, timeoutMs));
+    try {
+        return await fetchFn(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/utils/normalize-secret-input.js

@@ -0,0 +1,19 @@
+/**
+ * Secret normalization for copy/pasted credentials.
+ *
+ * Common footgun: line breaks (especially `\r`) embedded in API keys/tokens.
+ * We strip line breaks anywhere, then trim whitespace at the ends.
+ *
+ * Intentionally does NOT remove ordinary spaces inside the string to avoid
+ * silently altering "Bearer <token>" style values.
+ */
+export function normalizeSecretInput(value) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    return value.replace(/[\r\n\u2028\u2029]+/g, "").trim();
+}
+export function normalizeOptionalSecretInput(value) {
+    const normalized = normalizeSecretInput(value);
+    return normalized ? normalized : undefined;
+}