@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/auto-reply/thinking.js

@@ -1,9 +1,11 @@
 function normalizeProviderId(provider) {
-    if (!provider)
+    if (!provider) {
         return "";
+    }
     const normalized = provider.trim().toLowerCase();
-    if (normalized === "z.ai" || normalized === "z-ai")
+    if (normalized === "z.ai" || normalized === "z-ai") {
         return "zai";
+    }
     return normalized;
 }
 export function isBinaryThinkingProvider(provider) {
@@ -11,38 +13,52 @@ export function isBinaryThinkingProvider(provider) {
 }
 export const XHIGH_MODEL_REFS = [
     "openai/gpt-5.2",
+    "openai-codex/gpt-5.3-codex",
     "openai-codex/gpt-5.2-codex",
     "openai-codex/gpt-5.1-codex",
+    "github-copilot/gpt-5.2-codex",
+    "github-copilot/gpt-5.2",
 ];
 const XHIGH_MODEL_SET = new Set(XHIGH_MODEL_REFS.map((entry) => entry.toLowerCase()));
 const XHIGH_MODEL_IDS = new Set(XHIGH_MODEL_REFS.map((entry) => entry.split("/")[1]?.toLowerCase()).filter((entry) => Boolean(entry)));
 // Normalize user-provided thinking level strings to the canonical enum.
 export function normalizeThinkLevel(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
-    const key = raw.toLowerCase();
-    if (["off"].includes(key))
+    }
+    const key = raw.trim().toLowerCase();
+    const collapsed = key.replace(/[\s_-]+/g, "");
+    if (collapsed === "xhigh" || collapsed === "extrahigh") {
+        return "xhigh";
+    }
+    if (["off"].includes(key)) {
         return "off";
-    if (["on", "enable", "enabled"].includes(key))
+    }
+    if (["on", "enable", "enabled"].includes(key)) {
         return "low";
-    if (["min", "minimal"].includes(key))
+    }
+    if (["min", "minimal"].includes(key)) {
         return "minimal";
-    if (["low", "thinkhard", "think-hard", "think_hard"].includes(key))
+    }
+    if (["low", "thinkhard", "think-hard", "think_hard"].includes(key)) {
         return "low";
-    if (["mid", "med", "medium", "thinkharder", "think-harder", "harder"].includes(key))
+    }
+    if (["mid", "med", "medium", "thinkharder", "think-harder", "harder"].includes(key)) {
         return "medium";
-    if (["high", "ultra", "ultrathink", "think-hard", "thinkhardest", "highest", "max"].includes(key))
+    }
+    if (["high", "ultra", "ultrathink", "think-hard", "thinkhardest", "highest", "max"].includes(key)) {
         return "high";
-    if (["xhigh", "x-high", "x_high"].includes(key))
-        return "xhigh";
-    if (["think"].includes(key))
+    }
+    if (["think"].includes(key)) {
         return "minimal";
+    }
     return undefined;
 }
 export function supportsXHighThinking(provider, model) {
     const modelKey = model?.trim().toLowerCase();
-    if (!modelKey)
+    if (!modelKey) {
         return false;
+    }
     const providerKey = provider?.trim().toLowerCase();
     if (providerKey) {
         return XHIGH_MODEL_SET.has(`${providerKey}/${modelKey}`);
@@ -51,13 +67,15 @@ export function supportsXHighThinking(provider, model) {
 }
 export function listThinkingLevels(provider, model) {
     const levels = ["off", "minimal", "low", "medium", "high"];
-    if (supportsXHighThinking(provider, model))
+    if (supportsXHighThinking(provider, model)) {
         levels.push("xhigh");
+    }
     return levels;
 }
 export function listThinkingLevelLabels(provider, model) {
-    if (isBinaryThinkingProvider(provider))
+    if (isBinaryThinkingProvider(provider)) {
         return ["off", "on"];
+    }
     return listThinkingLevels(provider, model);
 }
 export function formatThinkingLevels(provider, model, separator = ", ") {
@@ -65,53 +83,69 @@ export function formatThinkingLevels(provider, model, separator = ", ") {
 }
 export function formatXHighModelHint() {
     const refs = [...XHIGH_MODEL_REFS];
-    if (refs.length === 0)
+    if (refs.length === 0) {
         return "unknown model";
-    if (refs.length === 1)
+    }
+    if (refs.length === 1) {
         return refs[0];
-    if (refs.length === 2)
+    }
+    if (refs.length === 2) {
         return `${refs[0]} or ${refs[1]}`;
+    }
     return `${refs.slice(0, -1).join(", ")} or ${refs[refs.length - 1]}`;
 }
 // Normalize verbose flags used to toggle agent verbosity.
 export function normalizeVerboseLevel(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     const key = raw.toLowerCase();
-    if (["off", "false", "no", "0"].includes(key))
+    if (["off", "false", "no", "0"].includes(key)) {
         return "off";
-    if (["full", "all", "everything"].includes(key))
+    }
+    if (["full", "all", "everything"].includes(key)) {
         return "full";
-    if (["on", "minimal", "true", "yes", "1"].includes(key))
+    }
+    if (["on", "minimal", "true", "yes", "1"].includes(key)) {
         return "on";
+    }
     return undefined;
 }
 // Normalize system notice flags used to toggle system notifications.
 export function normalizeNoticeLevel(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     const key = raw.toLowerCase();
-    if (["off", "false", "no", "0"].includes(key))
+    if (["off", "false", "no", "0"].includes(key)) {
         return "off";
-    if (["full", "all", "everything"].includes(key))
+    }
+    if (["full", "all", "everything"].includes(key)) {
         return "full";
-    if (["on", "minimal", "true", "yes", "1"].includes(key))
+    }
+    if (["on", "minimal", "true", "yes", "1"].includes(key)) {
         return "on";
+    }
     return undefined;
 }
 // Normalize response-usage display modes used to toggle per-response usage footers.
 export function normalizeUsageDisplay(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     const key = raw.toLowerCase();
-    if (["off", "false", "no", "0", "disable", "disabled"].includes(key))
+    if (["off", "false", "no", "0", "disable", "disabled"].includes(key)) {
         return "off";
-    if (["on", "true", "yes", "1", "enable", "enabled"].includes(key))
+    }
+    if (["on", "true", "yes", "1", "enable", "enabled"].includes(key)) {
         return "tokens";
-    if (["tokens", "token", "tok", "minimal", "min"].includes(key))
+    }
+    if (["tokens", "token", "tok", "minimal", "min"].includes(key)) {
         return "tokens";
-    if (["full", "session"].includes(key))
+    }
+    if (["full", "session"].includes(key)) {
         return "full";
+    }
     return undefined;
 }
 export function resolveResponseUsageMode(raw) {
@@ -119,36 +153,47 @@ export function resolveResponseUsageMode(raw) {
 }
 // Normalize elevated flags used to toggle elevated bash permissions.
 export function normalizeElevatedLevel(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     const key = raw.toLowerCase();
-    if (["off", "false", "no", "0"].includes(key))
+    if (["off", "false", "no", "0"].includes(key)) {
         return "off";
-    if (["full", "auto", "auto-approve", "autoapprove"].includes(key))
+    }
+    if (["full", "auto", "auto-approve", "autoapprove"].includes(key)) {
         return "full";
-    if (["ask", "prompt", "approval", "approve"].includes(key))
+    }
+    if (["ask", "prompt", "approval", "approve"].includes(key)) {
         return "ask";
-    if (["on", "true", "yes", "1"].includes(key))
+    }
+    if (["on", "true", "yes", "1"].includes(key)) {
         return "on";
+    }
     return undefined;
 }
 export function resolveElevatedMode(level) {
-    if (!level || level === "off")
+    if (!level || level === "off") {
         return "off";
-    if (level === "full")
+    }
+    if (level === "full") {
         return "full";
+    }
     return "ask";
 }
 // Normalize reasoning visibility flags used to toggle reasoning exposure.
 export function normalizeReasoningLevel(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     const key = raw.toLowerCase();
-    if (["off", "false", "no", "0", "hide", "hidden", "disable", "disabled"].includes(key))
+    if (["off", "false", "no", "0", "hide", "hidden", "disable", "disabled"].includes(key)) {
         return "off";
-    if (["on", "true", "yes", "1", "show", "visible", "enable", "enabled"].includes(key))
+    }
+    if (["on", "true", "yes", "1", "show", "visible", "enable", "enabled"].includes(key)) {
         return "on";
-    if (["stream", "streaming", "draft", "live"].includes(key))
+    }
+    if (["stream", "streaming", "draft", "live"].includes(key)) {
         return "stream";
+    }
     return undefined;
 }

package/dist/browser/bridge-server.js

@@ -6,6 +6,19 @@ export async function startBrowserBridgeServer(params) {
     const port = params.port ?? 0;
     const app = express();
     app.use(express.json({ limit: "1mb" }));
+    app.use((req, res, next) => {
+        const ctrl = new AbortController();
+        const abort = () => ctrl.abort(new Error("request aborted"));
+        req.once("aborted", abort);
+        res.once("close", () => {
+            if (!res.writableEnded) {
+                abort();
+            }
+        });
+        // Make the signal available to browser route handlers (best-effort).
+        req.signal = ctrl.signal;
+        next();
+    });
     const authToken = params.authToken?.trim();
     if (authToken) {
         app.use((req, res, next) => {

package/dist/browser/cdp.helpers.js

@@ -1,30 +1,26 @@
 import WebSocket from "ws";
+import { isLoopbackHost } from "../gateway/net.js";
 import { rawDataToString } from "../infra/ws.js";
-export function isLoopbackHost(host) {
-    const h = host.trim().toLowerCase();
-    return (h === "localhost" ||
-        h === "127.0.0.1" ||
-        h === "0.0.0.0" ||
-        h === "[::1]" ||
-        h === "::1" ||
-        h === "[::]" ||
-        h === "::");
-}
+import { getChromeExtensionRelayAuthHeaders } from "./extension-relay.js";
+export { isLoopbackHost };
 export function getHeadersWithAuth(url, headers = {}) {
+    const relayHeaders = getChromeExtensionRelayAuthHeaders(url);
+    const mergedHeaders = { ...relayHeaders, ...headers };
     try {
         const parsed = new URL(url);
-        const hasAuthHeader = Object.keys(headers).some((key) => key.toLowerCase() === "authorization");
-        if (hasAuthHeader)
-            return headers;
+        const hasAuthHeader = Object.keys(mergedHeaders).some((key) => key.toLowerCase() === "authorization");
+        if (hasAuthHeader) {
+            return mergedHeaders;
+        }
         if (parsed.username || parsed.password) {
             const auth = Buffer.from(`${parsed.username}:${parsed.password}`).toString("base64");
-            return { ...headers, Authorization: `Basic ${auth}` };
+            return { ...mergedHeaders, Authorization: `Basic ${auth}` };
         }
     }
     catch {
         // ignore
     }
-    return headers;
+    return mergedHeaders;
 }
 export function appendCdpPath(cdpUrl, path) {
     const url = new URL(cdpUrl);
@@ -36,17 +32,18 @@ export function appendCdpPath(cdpUrl, path) {
 function createCdpSender(ws) {
     let nextId = 1;
     const pending = new Map();
-    const send = (method, params) => {
+    const send = (method, params, sessionId) => {
         const id = nextId++;
-        const msg = { id, method, params };
+        const msg = { id, method, params, sessionId };
         ws.send(JSON.stringify(msg));
         return new Promise((resolve, reject) => {
             pending.set(id, { resolve, reject });
         });
     };
     const closeWithError = (err) => {
-        for (const [, p] of pending)
+        for (const [, p] of pending) {
             p.reject(err);
+        }
         pending.clear();
         try {
             ws.close();
@@ -55,14 +52,19 @@ function createCdpSender(ws) {
             // ignore
         }
     };
+    ws.on("error", (err) => {
+        closeWithError(err instanceof Error ? err : new Error(String(err)));
+    });
     ws.on("message", (data) => {
         try {
             const parsed = JSON.parse(rawDataToString(data));
-            if (typeof parsed.id !== "number")
+            if (typeof parsed.id !== "number") {
                 return;
+            }
             const p = pending.get(parsed.id);
-            if (!p)
+            if (!p) {
                 return;
+            }
             pending.delete(parsed.id);
             if (parsed.error?.message) {
                 p.reject(new Error(parsed.error.message));
@@ -85,8 +87,9 @@ export async function fetchJson(url, timeoutMs = 1500, init) {
     try {
         const headers = getHeadersWithAuth(url, init?.headers || {});
         const res = await fetch(url, { ...init, headers, signal: ctrl.signal });
-        if (!res.ok)
+        if (!res.ok) {
             throw new Error(`HTTP ${res.status}`);
+        }
         return (await res.json());
     }
     finally {
@@ -99,8 +102,9 @@ export async function fetchOk(url, timeoutMs = 1500, init) {
     try {
         const headers = getHeadersWithAuth(url, init?.headers || {});
         const res = await fetch(url, { ...init, headers, signal: ctrl.signal });
-        if (!res.ok)
+        if (!res.ok) {
             throw new Error(`HTTP ${res.status}`);
+        }
     }
     finally {
         clearTimeout(t);
@@ -108,16 +112,26 @@ export async function fetchOk(url, timeoutMs = 1500, init) {
 }
 export async function withCdpSocket(wsUrl, fn, opts) {
     const headers = getHeadersWithAuth(wsUrl, opts?.headers ?? {});
+    const handshakeTimeoutMs = typeof opts?.handshakeTimeoutMs === "number" && Number.isFinite(opts.handshakeTimeoutMs)
+        ? Math.max(1, Math.floor(opts.handshakeTimeoutMs))
+        : 5000;
     const ws = new WebSocket(wsUrl, {
-        handshakeTimeout: 5000,
+        handshakeTimeout: handshakeTimeoutMs,
         ...(Object.keys(headers).length ? { headers } : {}),
     });
     const { send, closeWithError } = createCdpSender(ws);
     const openPromise = new Promise((resolve, reject) => {
         ws.once("open", () => resolve());
         ws.once("error", (err) => reject(err));
+        ws.once("close", () => reject(new Error("CDP socket closed")));
     });
-    await openPromise;
+    try {
+        await openPromise;
+    }
+    catch (err) {
+        closeWithError(err instanceof Error ? err : new Error(String(err)));
+        throw err;
+    }
     try {
         return await fn(send);
     }

package/dist/browser/client-fetch.js

@@ -7,7 +7,7 @@ function isAbsoluteHttp(url) {
 function enhanceBrowserFetchError(url, err, timeoutMs) {
     const hint = isAbsoluteHttp(url)
         ? "If this is a sandboxed session, ensure the sandbox browser is running and try again."
-        : `Start (or restart) the Moltbot gateway (Moltbot.app menubar, or \`${formatCliCommand("poolbot gateway")}\`) and try again.`;
+        : `Start (or restart) the Poolbot gateway (Poolbot.app menubar, or \`${formatCliCommand("poolbot gateway")}\`) and try again.`;
     const msg = String(err);
     const msgLower = msg.toLowerCase();
     const looksLikeTimeout = msgLower.includes("timed out") ||
@@ -23,7 +23,18 @@ function enhanceBrowserFetchError(url, err, timeoutMs) {
 async function fetchHttpJson(url, init) {
     const timeoutMs = init.timeoutMs ?? 5000;
     const ctrl = new AbortController();
-    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    const upstreamSignal = init.signal;
+    let upstreamAbortListener;
+    if (upstreamSignal) {
+        if (upstreamSignal.aborted) {
+            ctrl.abort(upstreamSignal.reason);
+        }
+        else {
+            upstreamAbortListener = () => ctrl.abort(upstreamSignal.reason);
+            upstreamSignal.addEventListener("abort", upstreamAbortListener, { once: true });
+        }
+    }
+    const t = setTimeout(() => ctrl.abort(new Error("timed out")), timeoutMs);
     try {
         const res = await fetch(url, { ...init, signal: ctrl.signal });
         if (!res.ok) {
@@ -34,6 +45,9 @@ async function fetchHttpJson(url, init) {
     }
     finally {
         clearTimeout(t);
+        if (upstreamSignal && upstreamAbortListener) {
+            upstreamSignal.removeEventListener("abort", upstreamAbortListener);
+        }
     }
 }
 export async function fetchBrowserJson(url, init) {
@@ -61,6 +75,29 @@ export async function fetchBrowserJson(url, init) {
                 // keep as string
             }
         }
+        const abortCtrl = new AbortController();
+        const upstreamSignal = init?.signal;
+        let upstreamAbortListener;
+        if (upstreamSignal) {
+            if (upstreamSignal.aborted) {
+                abortCtrl.abort(upstreamSignal.reason);
+            }
+            else {
+                upstreamAbortListener = () => abortCtrl.abort(upstreamSignal.reason);
+                upstreamSignal.addEventListener("abort", upstreamAbortListener, { once: true });
+            }
+        }
+        let abortListener;
+        const abortPromise = abortCtrl.signal.aborted
+            ? Promise.reject(abortCtrl.signal.reason ?? new Error("aborted"))
+            : new Promise((_, reject) => {
+                abortListener = () => reject(abortCtrl.signal.reason ?? new Error("aborted"));
+                abortCtrl.signal.addEventListener("abort", abortListener, { once: true });
+            });
+        let timer;
+        if (timeoutMs) {
+            timer = setTimeout(() => abortCtrl.abort(new Error("timed out")), timeoutMs);
+        }
         const dispatchPromise = dispatcher.dispatch({
             method: init?.method?.toUpperCase() === "DELETE"
                 ? "DELETE"
@@ -70,13 +107,19 @@ export async function fetchBrowserJson(url, init) {
             path: parsed.pathname,
             query,
             body,
+            signal: abortCtrl.signal,
+        });
+        const result = await Promise.race([dispatchPromise, abortPromise]).finally(() => {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            if (abortListener) {
+                abortCtrl.signal.removeEventListener("abort", abortListener);
+            }
+            if (upstreamSignal && upstreamAbortListener) {
+                upstreamSignal.removeEventListener("abort", upstreamAbortListener);
+            }
         });
-        const result = await (timeoutMs
-            ? Promise.race([
-                dispatchPromise,
-                new Promise((_, reject) => setTimeout(() => reject(new Error("timed out")), timeoutMs)),
-            ])
-            : dispatchPromise);
         if (result.status >= 400) {
             const message = result.body && typeof result.body === "object" && "error" in result.body
                 ? String(result.body.error)

package/dist/browser/config.js

@@ -1,17 +1,8 @@
 import { deriveDefaultBrowserCdpPortRange, deriveDefaultBrowserControlPort, DEFAULT_BROWSER_CONTROL_PORT, } from "../config/port-defaults.js";
 import { resolveGatewayPort } from "../config/paths.js";
+import { isLoopbackHost } from "../gateway/net.js";
 import { DEFAULT_CLAWD_BROWSER_COLOR, DEFAULT_CLAWD_BROWSER_ENABLED, DEFAULT_BROWSER_EVALUATE_ENABLED, DEFAULT_BROWSER_DEFAULT_PROFILE_NAME, DEFAULT_CLAWD_BROWSER_PROFILE_NAME, } from "./constants.js";
 import { CDP_PORT_RANGE_START, getUsedPorts } from "./profiles.js";
-function isLoopbackHost(host) {
-    const h = host.trim().toLowerCase();
-    return (h === "localhost" ||
-        h === "127.0.0.1" ||
-        h === "0.0.0.0" ||
-        h === "[::1]" ||
-        h === "::1" ||
-        h === "[::]" ||
-        h === "::");
-}
 function normalizeHexColor(raw) {
     const value = (raw ?? "").trim();
     if (!value)
@@ -62,7 +53,7 @@ function ensureDefaultProfile(profiles, defaultColor, legacyCdpPort, derivedDefa
 /**
  * Ensure a built-in "chrome" profile exists for the Chrome extension relay.
  *
- * Note: this is a Moltbot browser profile (routing config), not a Chrome user profile.
+ * Note: this is a Poolbot browser profile (routing config), not a Chrome user profile.
  * It points at the local relay CDP endpoint (controlPort + 1).
  */
 function ensureDefaultChromeExtensionProfile(profiles, controlPort) {