@poolzin/pool-bot 2026.1.26 → 2026.1.30

package/dist/infra/tls/gateway.js

@@ -36,7 +36,7 @@ async function generateSelfSignedCert(params) {
         "-out",
         params.certPath,
         "-subj",
-        "/CN=clawdbot-gateway",
+        "/CN=poolbot-gateway",
     ]);
     await fs.chmod(params.keyPath, 0o600).catch(() => { });
     await fs.chmod(params.certPath, 0o600).catch(() => { });

package/dist/infra/unhandled-rejections.js

@@ -1,6 +1,81 @@
 import process from "node:process";
 import { formatUncaughtError } from "./errors.js";
 const handlers = new Set();
+/**
+ * Checks if an error is an AbortError.
+ * These are typically intentional cancellations (e.g., during shutdown) and shouldn't crash.
+ */
+export function isAbortError(err) {
+    if (!err || typeof err !== "object")
+        return false;
+    const name = "name" in err ? String(err.name) : "";
+    if (name === "AbortError")
+        return true;
+    // Check for "This operation was aborted" message from Node's undici
+    const message = "message" in err && typeof err.message === "string" ? err.message : "";
+    if (message === "This operation was aborted")
+        return true;
+    return false;
+}
+// Network error codes that indicate transient failures (shouldn't crash the gateway)
+const TRANSIENT_NETWORK_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "ETIMEDOUT",
+    "ESOCKETTIMEDOUT",
+    "ECONNABORTED",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EAI_AGAIN",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_SOCKET",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+]);
+function getErrorCode(err) {
+    if (!err || typeof err !== "object")
+        return undefined;
+    const code = err.code;
+    return typeof code === "string" ? code : undefined;
+}
+function getErrorCause(err) {
+    if (!err || typeof err !== "object")
+        return undefined;
+    return err.cause;
+}
+/**
+ * Checks if an error is a transient network error that shouldn't crash the gateway.
+ * These are typically temporary connectivity issues that will resolve on their own.
+ */
+export function isTransientNetworkError(err) {
+    if (!err)
+        return false;
+    // Check the error itself
+    const code = getErrorCode(err);
+    if (code && TRANSIENT_NETWORK_CODES.has(code))
+        return true;
+    // "fetch failed" TypeError from undici (Node's native fetch)
+    if (err instanceof TypeError && err.message === "fetch failed") {
+        const cause = getErrorCause(err);
+        // The cause often contains the actual network error
+        if (cause)
+            return isTransientNetworkError(cause);
+        // Even without a cause, "fetch failed" is typically a network issue
+        return true;
+    }
+    // Check the cause chain recursively
+    const cause = getErrorCause(err);
+    if (cause && cause !== err) {
+        return isTransientNetworkError(cause);
+    }
+    // AggregateError may wrap multiple causes
+    if (err instanceof AggregateError && err.errors?.length) {
+        return err.errors.some((e) => isTransientNetworkError(e));
+    }
+    return false;
+}
 export function registerUnhandledRejectionHandler(handler) {
     handlers.add(handler);
     return () => {
@@ -14,7 +89,7 @@ export function isUnhandledRejectionHandled(reason) {
                 return true;
         }
         catch (err) {
-            console.error("[clawdbot] Unhandled rejection handler failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+            console.error("[poolbot] Unhandled rejection handler failed:", err instanceof Error ? (err.stack ?? err.message) : err);
         }
     }
     return false;
@@ -23,7 +98,19 @@ export function installUnhandledRejectionHandler() {
     process.on("unhandledRejection", (reason, _promise) => {
         if (isUnhandledRejectionHandled(reason))
             return;
-        console.error("[clawdbot] Unhandled promise rejection:", formatUncaughtError(reason));
+        // AbortError is typically an intentional cancellation (e.g., during shutdown)
+        // Log it but don't crash - these are expected during graceful shutdown
+        if (isAbortError(reason)) {
+            console.warn("[poolbot] Suppressed AbortError:", formatUncaughtError(reason));
+            return;
+        }
+        // Transient network errors (fetch failed, connection reset, etc.) shouldn't crash
+        // These are temporary connectivity issues that will resolve on their own
+        if (isTransientNetworkError(reason)) {
+            console.error("[poolbot] Network error (non-fatal):", formatUncaughtError(reason));
+            return;
+        }
+        console.error("[poolbot] Unhandled promise rejection:", formatUncaughtError(reason));
         process.exit(1);
     });
 }

package/dist/infra/update-check.js

@@ -68,9 +68,7 @@ export async function checkGitUpdateStatus(params) {
     const tag = tagRes && tagRes.code === 0 ? tagRes.stdout.trim() : null;
     const upstreamRes = await runCommandWithTimeout(["git", "-C", root, "rev-parse", "--abbrev-ref", "@{upstream}"], { timeoutMs }).catch(() => null);
     const upstream = upstreamRes && upstreamRes.code === 0 ? upstreamRes.stdout.trim() : null;
-    const dirtyRes = await runCommandWithTimeout(["git", "-C", root, "status", "--porcelain"], {
-        timeoutMs,
-    }).catch(() => null);
+    const dirtyRes = await runCommandWithTimeout(["git", "-C", root, "status", "--porcelain", "--", ":!dist/control-ui/"], { timeoutMs }).catch(() => null);
     const dirty = dirtyRes && dirtyRes.code === 0 ? dirtyRes.stdout.trim().length > 0 : null;
     const fetchOk = params.fetch
         ? await runCommandWithTimeout(["git", "-C", root, "fetch", "--quiet", "--prune"], { timeoutMs })
@@ -216,7 +214,7 @@ export async function fetchNpmTagVersion(params) {
     const timeoutMs = params?.timeoutMs ?? 3500;
     const tag = params.tag;
     try {
-        const res = await fetchWithTimeout(`https://registry.npmjs.org/clawdbot/${encodeURIComponent(tag)}`, timeoutMs);
+        const res = await fetchWithTimeout(`https://registry.npmjs.org/poolbot/${encodeURIComponent(tag)}`, timeoutMs);
         if (!res.ok) {
             return { tag, version: null, error: `HTTP ${res.status}` };
         }

package/dist/infra/update-global.js

@@ -36,7 +36,7 @@ export async function resolveGlobalPackageRoot(manager, runCommand, timeoutMs) {
     const root = await resolveGlobalRoot(manager, runCommand, timeoutMs);
     if (!root)
         return null;
-    return path.join(root, "clawdbot");
+    return path.join(root, "poolbot");
 }
 export async function detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs) {
     const pkgReal = await tryRealpath(pkgRoot);
@@ -52,13 +52,13 @@ export async function detectGlobalInstallManagerForRoot(runCommand, pkgRoot, tim
         if (!globalRoot)
             continue;
         const globalReal = await tryRealpath(globalRoot);
-        const expected = path.join(globalReal, "clawdbot");
+        const expected = path.join(globalReal, "poolbot");
         if (path.resolve(expected) === path.resolve(pkgReal))
             return manager;
     }
     const bunGlobalRoot = resolveBunGlobalRoot();
     const bunGlobalReal = await tryRealpath(bunGlobalRoot);
-    const bunExpected = path.join(bunGlobalReal, "clawdbot");
+    const bunExpected = path.join(bunGlobalReal, "poolbot");
     if (path.resolve(bunExpected) === path.resolve(pkgReal))
         return "bun";
     return null;
@@ -68,11 +68,11 @@ export async function detectGlobalInstallManagerByPresence(runCommand, timeoutMs
         const root = await resolveGlobalRoot(manager, runCommand, timeoutMs);
         if (!root)
             continue;
-        if (await pathExists(path.join(root, "clawdbot")))
+        if (await pathExists(path.join(root, "poolbot")))
             return manager;
     }
     const bunRoot = resolveBunGlobalRoot();
-    if (await pathExists(path.join(bunRoot, "clawdbot")))
+    if (await pathExists(path.join(bunRoot, "poolbot")))
         return "bun";
     return null;
 }

package/dist/infra/update-runner.js

@@ -10,6 +10,8 @@ const DEFAULT_TIMEOUT_MS = 20 * 60_000;
 const MAX_LOG_CHARS = 8000;
 const PREFLIGHT_MAX_COMMITS = 10;
 const START_DIRS = ["cwd", "argv1", "process"];
+const DEFAULT_PACKAGE_NAME = "poolbot";
+const CORE_PACKAGE_NAMES = new Set([DEFAULT_PACKAGE_NAME, "poolbot"]);
 function normalizeDir(value) {
     if (!value)
         return null;
@@ -57,6 +59,17 @@ async function readPackageVersion(root) {
         return null;
     }
 }
+async function readPackageName(root) {
+    try {
+        const raw = await fs.readFile(path.join(root, "package.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        const name = parsed?.name?.trim();
+        return name ? name : null;
+    }
+    catch {
+        return null;
+    }
+}
 async function readBranchName(runCommand, root, timeoutMs) {
     const res = await runCommand(["git", "-C", root, "rev-parse", "--abbrev-ref", "HEAD"], {
         timeoutMs,
@@ -114,7 +127,8 @@ async function findPackageRoot(candidates) {
             try {
                 const raw = await fs.readFile(pkgPath, "utf-8");
                 const parsed = JSON.parse(raw);
-                if (parsed?.name === "clawdbot")
+                const name = parsed?.name?.trim();
+                if (name && CORE_PACKAGE_NAMES.has(name))
                     return current;
             }
             catch {
@@ -198,7 +212,12 @@ function normalizeTag(tag) {
     const trimmed = tag?.trim();
     if (!trimmed)
         return "latest";
-    return trimmed.startsWith("clawdbot@") ? trimmed.slice("clawdbot@".length) : trimmed;
+    if (trimmed.startsWith("poolbot@"))
+        return trimmed.slice("poolbot@".length);
+    if (trimmed.startsWith(`${DEFAULT_PACKAGE_NAME}@`)) {
+        return trimmed.slice(`${DEFAULT_PACKAGE_NAME}@`.length);
+    }
+    return trimmed;
 }
 export async function runGatewayUpdate(opts = {}) {
     const startedAt = Date.now();
@@ -238,7 +257,7 @@ export async function runGatewayUpdate(opts = {}) {
             status: "error",
             mode: "unknown",
             root: gitRoot,
-            reason: "not-clawdbot-root",
+            reason: "not-poolbot-root",
             steps: [],
             durationMs: Date.now() - startedAt,
         };
@@ -254,8 +273,8 @@ export async function runGatewayUpdate(opts = {}) {
         const channel = opts.channel ?? "dev";
         const branch = channel === "dev" ? await readBranchName(runCommand, gitRoot, timeoutMs) : null;
         const needsCheckoutMain = channel === "dev" && branch !== DEV_BRANCH;
-        gitTotalSteps = channel === "dev" ? (needsCheckoutMain ? 10 : 9) : 8;
-        const statusCheck = await runStep(step("clean check", ["git", "-C", gitRoot, "status", "--porcelain"], gitRoot));
+        gitTotalSteps = channel === "dev" ? (needsCheckoutMain ? 11 : 10) : 9;
+        const statusCheck = await runStep(step("clean check", ["git", "-C", gitRoot, "status", "--porcelain", "--", ":!dist/control-ui/"], gitRoot));
         steps.push(statusCheck);
         const hasUncommittedChanges = statusCheck.stdoutTail && statusCheck.stdoutTail.trim().length > 0;
         if (hasUncommittedChanges) {
@@ -351,7 +370,7 @@ export async function runGatewayUpdate(opts = {}) {
                 };
             }
             const manager = await detectPackageManager(gitRoot);
-            const preflightRoot = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-update-preflight-"));
+            const preflightRoot = await fs.mkdtemp(path.join(os.tmpdir(), "poolbot-update-preflight-"));
             const worktreeDir = path.join(preflightRoot, "worktree");
             const worktreeStep = await runStep(step("preflight worktree", ["git", "-C", gitRoot, "worktree", "add", "--detach", worktreeDir, upstreamSha], gitRoot));
             steps.push(worktreeStep);
@@ -485,7 +504,11 @@ export async function runGatewayUpdate(opts = {}) {
         steps.push(buildStep);
         const uiBuildStep = await runStep(step("ui:build", managerScriptArgs(manager, "ui:build"), gitRoot));
         steps.push(uiBuildStep);
-        const doctorStep = await runStep(step("clawdbot doctor", managerScriptArgs(manager, "clawdbot", ["doctor", "--non-interactive"]), gitRoot, { CLAWDBOT_UPDATE_IN_PROGRESS: "1" }));
+        // Restore dist/control-ui/ to committed state to prevent dirty repo after update
+        // (ui:build regenerates assets with new hashes, which would block future updates)
+        const restoreUiStep = await runStep(step("restore control-ui", ["git", "-C", gitRoot, "checkout", "--", "dist/control-ui/"], gitRoot));
+        steps.push(restoreUiStep);
+        const doctorStep = await runStep(step("poolbot doctor", managerScriptArgs(manager, "poolbot", ["doctor", "--non-interactive"]), gitRoot, { CLAWDBOT_UPDATE_IN_PROGRESS: "1" }));
         steps.push(doctorStep);
         const failedStep = steps.find((s) => s.exitCode !== 0);
         const afterShaStep = await runStep(step("git rev-parse HEAD (after)", ["git", "-C", gitRoot, "rev-parse", "HEAD"], gitRoot));
@@ -517,7 +540,8 @@ export async function runGatewayUpdate(opts = {}) {
     const beforeVersion = await readPackageVersion(pkgRoot);
     const globalManager = await detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs);
     if (globalManager) {
-        const spec = `clawdbot@${normalizeTag(opts.tag)}`;
+        const packageName = (await readPackageName(pkgRoot)) ?? DEFAULT_PACKAGE_NAME;
+        const spec = `${packageName}@${normalizeTag(opts.tag)}`;
         const updateStep = await runStep({
             runCommand,
             name: "global update",

package/dist/infra/update-startup.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveStateDir } from "../config/paths.js";
-import { resolveClawdbotPackageRoot } from "./clawdbot-root.js";
+import { resolvePoolBotPackageRoot } from "./poolbot-root.js";
 import { compareSemverStrings, resolveNpmChannelTag, checkUpdateStatus } from "./update-check.js";
 import { normalizeUpdateChannel, DEFAULT_PACKAGE_CHANNEL } from "./update-channels.js";
 import { VERSION } from "../version.js";
@@ -44,7 +44,7 @@ export async function runGatewayUpdateCheck(params) {
         if (now - lastCheckedAt < UPDATE_CHECK_INTERVAL_MS)
             return;
     }
-    const root = await resolveClawdbotPackageRoot({
+    const root = await resolvePoolBotPackageRoot({
         moduleUrl: import.meta.url,
         argv1: process.argv[1],
         cwd: process.cwd(),
@@ -74,7 +74,7 @@ export async function runGatewayUpdateCheck(params) {
     if (cmp != null && cmp < 0) {
         const shouldNotify = state.lastNotifiedVersion !== resolved.version || state.lastNotifiedTag !== tag;
         if (shouldNotify) {
-            params.log.info(`update available (${tag}): v${resolved.version} (current v${VERSION}). Run: ${formatCliCommand("clawdbot update")}`);
+            params.log.info(`update available (${tag}): v${resolved.version} (current v${VERSION}). Run: ${formatCliCommand("poolbot update")}`);
             nextState.lastNotifiedVersion = resolved.version;
             nextState.lastNotifiedTag = tag;
         }

package/dist/infra/warnings.js

@@ -1,4 +1,4 @@
-const warningFilterKey = Symbol.for("clawdbot.warning-filter");
+const warningFilterKey = Symbol.for("poolbot.warning-filter");
 function shouldIgnoreWarning(warning) {
     if (warning.code === "DEP0040" && warning.message?.includes("punycode")) {
         return true;

package/dist/infra/widearea-dns.js

@@ -2,8 +2,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { CONFIG_DIR, ensureDir } from "../utils.js";
-export const WIDE_AREA_DISCOVERY_DOMAIN = "clawdbot.internal.";
-export const WIDE_AREA_ZONE_FILENAME = "clawdbot.internal.db";
+export const WIDE_AREA_DISCOVERY_DOMAIN = "poolbot.internal.";
+export const WIDE_AREA_ZONE_FILENAME = "poolbot.internal.db";
 export function getWideAreaZonePath() {
     return path.join(CONFIG_DIR, "dns", WIDE_AREA_ZONE_FILENAME);
 }
@@ -45,7 +45,7 @@ function extractSerial(zoneText) {
     return Number.isFinite(parsed) ? parsed : null;
 }
 function extractContentHash(zoneText) {
-    const match = zoneText.match(/^\s*;\s*clawdbot-content-hash:\s*(\S+)\s*$/m);
+    const match = zoneText.match(/^\s*;\s*poolbot-content-hash:\s*(\S+)\s*$/m);
     return match?.[1] ?? null;
 }
 function computeContentHash(body) {
@@ -58,9 +58,9 @@ function computeContentHash(body) {
     return (h >>> 0).toString(16).padStart(8, "0");
 }
 function renderZone(opts) {
-    const hostname = os.hostname().split(".")[0] ?? "clawdbot";
-    const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "clawdbot");
-    const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-gateway`, "clawdbot-gw");
+    const hostname = os.hostname().split(".")[0] ?? "poolbot";
+    const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "poolbot");
+    const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-gateway`, "poolbot-gw");
     const txt = [
         `displayName=${opts.displayName.trim() || hostname}`,
         `role=gateway`,
@@ -93,15 +93,15 @@ function renderZone(opts) {
     if (opts.tailnetIPv6) {
         records.push(`${hostLabel} IN AAAA ${opts.tailnetIPv6}`);
     }
-    records.push(`_clawdbot-gw._tcp IN PTR ${instanceLabel}._clawdbot-gw._tcp`);
-    records.push(`${instanceLabel}._clawdbot-gw._tcp IN SRV 0 0 ${opts.gatewayPort} ${hostLabel}`);
-    records.push(`${instanceLabel}._clawdbot-gw._tcp IN TXT ${txt.map(txtQuote).join(" ")}`);
+    records.push(`_poolbot-gw._tcp IN PTR ${instanceLabel}._poolbot-gw._tcp`);
+    records.push(`${instanceLabel}._poolbot-gw._tcp IN SRV 0 0 ${opts.gatewayPort} ${hostLabel}`);
+    records.push(`${instanceLabel}._poolbot-gw._tcp IN TXT ${txt.map(txtQuote).join(" ")}`);
     const contentBody = `${records.join("\n")}\n`;
     const hashBody = `${records
         .map((line) => line === soaLine ? `@ IN SOA ns1 hostmaster SERIAL 7200 3600 1209600 60` : line)
         .join("\n")}\n`;
     const contentHash = computeContentHash(hashBody);
-    return `; clawdbot-content-hash: ${contentHash}\n${contentBody}`;
+    return `; poolbot-content-hash: ${contentHash}\n${contentBody}`;
 }
 export function renderWideAreaGatewayZoneText(opts) {
     return renderZone(opts);

package/dist/line/monitor.js

@@ -1,6 +1,6 @@
-import crypto from "node:crypto";
 import { danger, logVerbose } from "../globals.js";
 import { createLineBot } from "./bot.js";
+import { validateLineSignature } from "./signature.js";
 import { normalizePluginHttpPath } from "../plugins/http-path.js";
 import { registerPluginHttpRoute } from "../plugins/http-registry.js";
 import { replyMessageLine, showLoadingAnimation, getUserDisplayName, createQuickReplyItems, createTextMessageWithQuickReplies, pushTextMessageWithQuickReplies, pushMessageLine, pushMessagesLine, createFlexMessage, createImageMessage, createLocationMessage, } from "./send.js";
@@ -26,10 +26,6 @@ function recordChannelRuntimeState(params) {
 export function getLineRuntimeState(accountId) {
     return runtimeState.get(`line:${accountId}`);
 }
-function validateLineSignature(body, signature, channelSecret) {
-    const hash = crypto.createHmac("SHA256", channelSecret).update(body).digest("base64");
-    return hash === signature;
-}
 async function readRequestBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];

package/dist/line/signature.js

@@ -0,0 +1,11 @@
+import crypto from "node:crypto";
+export function validateLineSignature(body, signature, channelSecret) {
+    const hash = crypto.createHmac("SHA256", channelSecret).update(body).digest("base64");
+    const hashBuffer = Buffer.from(hash);
+    const signatureBuffer = Buffer.from(signature);
+    // Use constant-time comparison to prevent timing attacks.
+    if (hashBuffer.length !== signatureBuffer.length) {
+        return false;
+    }
+    return crypto.timingSafeEqual(hashBuffer, signatureBuffer);
+}

package/dist/line/webhook.js

@@ -1,9 +1,5 @@
-import crypto from "node:crypto";
 import { logVerbose, danger } from "../globals.js";
-function validateSignature(body, signature, channelSecret) {
-    const hash = crypto.createHmac("SHA256", channelSecret).update(body).digest("base64");
-    return hash === signature;
-}
+import { validateLineSignature } from "./signature.js";
 function readRawBody(req) {
     const rawBody = req.rawBody ??
         (typeof req.body === "string" || Buffer.isBuffer(req.body) ? req.body : null);
@@ -36,7 +32,7 @@ export function createLineWebhookMiddleware(options) {
                 res.status(400).json({ error: "Missing raw request body for signature verification" });
                 return;
             }
-            if (!validateSignature(rawBody, signature, channelSecret)) {
+            if (!validateLineSignature(rawBody, signature, channelSecret)) {
                 logVerbose("line: webhook signature validation failed");
                 res.status(401).json({ error: "Invalid signature" });
                 return;

package/dist/logging/logger.js

@@ -7,9 +7,9 @@ import { readLoggingConfig } from "./config.js";
 import { loggingState } from "./state.js";
 // Pin to /tmp so mac Debug UI and docs match; os.tmpdir() can be a per-user
 // randomized path on macOS which made the “Open log” button a no-op.
-export const DEFAULT_LOG_DIR = "/tmp/clawdbot";
-export const DEFAULT_LOG_FILE = path.join(DEFAULT_LOG_DIR, "clawdbot.log"); // legacy single-file path
-const LOG_PREFIX = "clawdbot";
+export const DEFAULT_LOG_DIR = "/tmp/poolbot";
+export const DEFAULT_LOG_FILE = path.join(DEFAULT_LOG_DIR, "poolbot.log"); // legacy single-file path
+const LOG_PREFIX = "poolbot";
 const LOG_SUFFIX = ".log";
 const MAX_LOG_AGE_MS = 24 * 60 * 60 * 1000; // 24h
 const requireConfig = createRequire(import.meta.url);
@@ -61,7 +61,7 @@ function buildLogger(settings) {
         pruneOldRollingLogs(path.dirname(settings.file));
     }
     const logger = new TsLogger({
-        name: "clawdbot",
+        name: "poolbot",
         minLevel: levelToMinLevel(settings.level),
         type: "hidden", // no ansi formatting
     });

package/dist/macos/gateway-daemon.js

@@ -16,7 +16,7 @@ function hasFlag(args, flag) {
 const args = process.argv.slice(2);
 async function main() {
     if (hasFlag(args, "--version") || hasFlag(args, "-v")) {
-        // Match `clawdbot --version` behavior for Swift env/version checks.
+        // Match `poolbot --version` behavior for Swift env/version checks.
         // Keep output a single line.
         console.log(BUNDLED_VERSION);
         process.exit(0);
@@ -173,6 +173,6 @@ async function main() {
     }
 }
 void main().catch((err) => {
-    console.error("[clawdbot] Gateway daemon failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+    console.error("[poolbot] Gateway daemon failed:", err instanceof Error ? (err.stack ?? err.message) : err);
     process.exit(1);
 });

package/dist/macos/relay.js

@@ -37,8 +37,8 @@ async function main() {
     await patchBunLongForProtobuf();
     const { loadDotEnv } = await import("../infra/dotenv.js");
     loadDotEnv({ quiet: true });
-    const { ensureClawdbotCliOnPath } = await import("../infra/path-env.js");
-    ensureClawdbotCliOnPath();
+    const { ensureMoltbotCliOnPath } = await import("../infra/path-env.js");
+    ensureMoltbotCliOnPath();
     const { enableConsoleCapture } = await import("../logging.js");
     enableConsoleCapture();
     const { assertSupportedRuntime } = await import("../infra/runtime-guard.js");
@@ -49,12 +49,12 @@ async function main() {
     const program = buildProgram();
     installUnhandledRejectionHandler();
     process.on("uncaughtException", (error) => {
-        console.error("[clawdbot] Uncaught exception:", formatUncaughtError(error));
+        console.error("[poolbot] Uncaught exception:", formatUncaughtError(error));
         process.exit(1);
     });
     await program.parseAsync(process.argv);
 }
 void main().catch((err) => {
-    console.error("[clawdbot] Relay failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+    console.error("[poolbot] Relay failed:", err instanceof Error ? (err.stack ?? err.message) : err);
     process.exit(1);
 });

package/dist/media/host.js

@@ -18,7 +18,7 @@ export async function ensureMediaHosted(source, opts = {}) {
     const needsServerStart = await isPortFree(port);
     if (needsServerStart && !opts.startServer) {
         await fs.rm(saved.path).catch(() => { });
-        throw new Error(`Media hosting requires the webhook/Funnel server. Start \`${formatCliCommand("clawdbot webhook")}\`/\`${formatCliCommand("clawdbot up")}\` or re-run with --serve-media.`);
+        throw new Error(`Media hosting requires the webhook/Funnel server. Start \`${formatCliCommand("poolbot webhook")}\`/\`${formatCliCommand("poolbot up")}\` or re-run with --serve-media.`);
     }
     if (needsServerStart && opts.startServer) {
         if (!mediaServer) {

package/dist/media/image-ops.js

@@ -91,7 +91,7 @@ function readJpegExifOrientation(buffer) {
     return null;
 }
 async function withTempDir(fn) {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-img-"));
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "poolbot-img-"));
     try {
         return await fn(dir);
     }

package/dist/media/input-files.js

@@ -1,5 +1,5 @@
 import { logWarn } from "../logger.js";
-import { assertPublicHostname } from "../infra/net/ssrf.js";
+import { closeDispatcher, createPinnedDispatcher, resolvePinnedHostname, } from "../infra/net/ssrf.js";
 let canvasModulePromise = null;
 let pdfJsModulePromise = null;
 // Lazy-load optional PDF/image deps so non-PDF paths don't require native installs.
@@ -73,42 +73,50 @@ export async function fetchWithGuard(params) {
             if (!["http:", "https:"].includes(parsedUrl.protocol)) {
                 throw new Error(`Invalid URL protocol: ${parsedUrl.protocol}. Only HTTP/HTTPS allowed.`);
             }
-            await assertPublicHostname(parsedUrl.hostname);
-            const response = await fetch(parsedUrl, {
-                signal: controller.signal,
-                headers: { "User-Agent": "Clawdbot-Gateway/1.0" },
-                redirect: "manual",
-            });
-            if (isRedirectStatus(response.status)) {
-                const location = response.headers.get("location");
-                if (!location) {
-                    throw new Error(`Redirect missing location header (${response.status})`);
+            const pinned = await resolvePinnedHostname(parsedUrl.hostname);
+            const dispatcher = createPinnedDispatcher(pinned);
+            try {
+                const response = await fetch(parsedUrl, {
+                    signal: controller.signal,
+                    headers: { "User-Agent": "Moltbot-Gateway/1.0" },
+                    redirect: "manual",
+                    dispatcher,
+                });
+                if (isRedirectStatus(response.status)) {
+                    const location = response.headers.get("location");
+                    if (!location) {
+                        throw new Error(`Redirect missing location header (${response.status})`);
+                    }
+                    redirectCount += 1;
+                    if (redirectCount > params.maxRedirects) {
+                        throw new Error(`Too many redirects (limit: ${params.maxRedirects})`);
+                    }
+                    void response.body?.cancel();
+                    currentUrl = new URL(location, parsedUrl).toString();
+                    continue;
                 }
-                redirectCount += 1;
-                if (redirectCount > params.maxRedirects) {
-                    throw new Error(`Too many redirects (limit: ${params.maxRedirects})`);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch: ${response.status} ${response.statusText}`);
                 }
-                currentUrl = new URL(location, parsedUrl).toString();
-                continue;
-            }
-            if (!response.ok) {
-                throw new Error(`Failed to fetch: ${response.status} ${response.statusText}`);
-            }
-            const contentLength = response.headers.get("content-length");
-            if (contentLength) {
-                const size = parseInt(contentLength, 10);
-                if (size > params.maxBytes) {
-                    throw new Error(`Content too large: ${size} bytes (limit: ${params.maxBytes} bytes)`);
+                const contentLength = response.headers.get("content-length");
+                if (contentLength) {
+                    const size = parseInt(contentLength, 10);
+                    if (size > params.maxBytes) {
+                        throw new Error(`Content too large: ${size} bytes (limit: ${params.maxBytes} bytes)`);
+                    }
+                }
+                const buffer = Buffer.from(await response.arrayBuffer());
+                if (buffer.byteLength > params.maxBytes) {
+                    throw new Error(`Content too large: ${buffer.byteLength} bytes (limit: ${params.maxBytes} bytes)`);
                 }
+                const contentType = response.headers.get("content-type") || undefined;
+                const parsed = parseContentType(contentType);
+                const mimeType = parsed.mimeType ?? "application/octet-stream";
+                return { buffer, mimeType, contentType };
             }
-            const buffer = Buffer.from(await response.arrayBuffer());
-            if (buffer.byteLength > params.maxBytes) {
-                throw new Error(`Content too large: ${buffer.byteLength} bytes (limit: ${params.maxBytes} bytes)`);
+            finally {
+                await closeDispatcher(dispatcher);
             }
-            const contentType = response.headers.get("content-type") || undefined;
-            const parsed = parseContentType(contentType);
-            const mimeType = parsed.mimeType ?? "application/octet-stream";
-            return { buffer, mimeType, contentType };
         }
     }
     finally {