@poolzin/pool-bot 2026.1.26 → 2026.1.30

package/dist/infra/bonjour.js

@@ -16,11 +16,11 @@ function isDisabledByEnv() {
 }
 function safeServiceName(name) {
     const trimmed = name.trim();
-    return trimmed.length > 0 ? trimmed : "Clawdbot";
+    return trimmed.length > 0 ? trimmed : "Moltbot";
 }
 function prettifyInstanceName(name) {
     const normalized = name.trim().replace(/\s+/g, " ");
-    return normalized.replace(/\s+\(Clawdbot\)\s*$/i, "").trim() || normalized;
+    return normalized.replace(/\s+\(Moltbot\)\s*$/i, "").trim() || normalized;
 }
 function serviceSummary(label, svc) {
     let fqdn = "unknown";
@@ -60,10 +60,10 @@ export async function startGatewayBonjourAdvertiser(opts) {
         .hostname()
         .replace(/\.local$/i, "")
         .split(".")[0]
-        .trim() || "clawdbot";
+        .trim() || "poolbot";
     const instanceName = typeof opts.instanceName === "string" && opts.instanceName.trim()
         ? opts.instanceName.trim()
-        : `${hostname} (Clawdbot)`;
+        : `${hostname} (Moltbot)`;
     const displayName = prettifyInstanceName(instanceName);
     const txtBase = {
         role: "gateway",
@@ -83,22 +83,29 @@ export async function startGatewayBonjourAdvertiser(opts) {
     if (typeof opts.tailnetDns === "string" && opts.tailnetDns.trim()) {
         txtBase.tailnetDns = opts.tailnetDns.trim();
     }
-    if (typeof opts.cliPath === "string" && opts.cliPath.trim()) {
+    // In minimal mode, omit cliPath to avoid exposing filesystem structure.
+    // This info can be obtained via the authenticated WebSocket if needed.
+    if (!opts.minimal && typeof opts.cliPath === "string" && opts.cliPath.trim()) {
         txtBase.cliPath = opts.cliPath.trim();
     }
     const services = [];
+    // Build TXT record for the gateway service.
+    // In minimal mode, omit sshPort to avoid advertising SSH availability.
+    const gatewayTxt = {
+        ...txtBase,
+        transport: "gateway",
+    };
+    if (!opts.minimal) {
+        gatewayTxt.sshPort = String(opts.sshPort ?? 22);
+    }
     const gateway = responder.createService({
         name: safeServiceName(instanceName),
-        type: "clawdbot-gw",
+        type: "poolbot-gw",
         protocol: "tcp" /* Protocol.TCP */,
         port: opts.gatewayPort,
         domain: "local",
         hostname,
-        txt: {
-            ...txtBase,
-            sshPort: String(opts.sshPort ?? 22),
-            transport: "gateway",
-        },
+        txt: gatewayTxt,
     });
     services.push({
         label: "gateway",
@@ -108,7 +115,7 @@ export async function startGatewayBonjourAdvertiser(opts) {
     if (services.length > 0) {
         ciaoCancellationRejectionHandler = registerUnhandledRejectionHandler(ignoreCiaoCancellationRejection);
     }
-    logDebug(`bonjour: starting (hostname=${hostname}, instance=${JSON.stringify(safeServiceName(instanceName))}, gatewayPort=${opts.gatewayPort}, sshPort=${opts.sshPort ?? 22})`);
+    logDebug(`bonjour: starting (hostname=${hostname}, instance=${JSON.stringify(safeServiceName(instanceName))}, gatewayPort=${opts.gatewayPort}${opts.minimal ? ", minimal=true" : `, sshPort=${opts.sshPort ?? 22}`})`);
     for (const { label, svc } of services) {
         try {
             svc.on("name-change", (name) => {

package/dist/infra/device-identity.js

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-const DEFAULT_DIR = path.join(os.homedir(), ".clawdbot", "identity");
+const DEFAULT_DIR = path.join(os.homedir(), ".poolbot", "identity");
 const DEFAULT_FILE = path.join(DEFAULT_DIR, "device.json");
 function ensureDir(filePath) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });

package/dist/infra/dotenv.js

@@ -6,7 +6,7 @@ export function loadDotEnv(opts) {
     const quiet = opts?.quiet ?? true;
     // Load from process CWD first (dotenv default).
     dotenv.config({ quiet });
-    // Then load global fallback: ~/.clawdbot/.env (or CLAWDBOT_STATE_DIR/.env),
+    // Then load global fallback: ~/.poolbot/.env (or CLAWDBOT_STATE_DIR/.env),
     // without overriding any env vars already present.
     const globalEnvPath = path.join(resolveConfigDir(process.env), ".env");
     if (!fs.existsSync(globalEnvPath))

package/dist/infra/exec-approvals.js

@@ -8,8 +8,8 @@ const DEFAULT_SECURITY = "deny";
 const DEFAULT_ASK = "on-miss";
 const DEFAULT_ASK_FALLBACK = "deny";
 const DEFAULT_AUTO_ALLOW_SKILLS = false;
-const DEFAULT_SOCKET = "~/.clawdbot/exec-approvals.sock";
-const DEFAULT_FILE = "~/.clawdbot/exec-approvals.json";
+const DEFAULT_SOCKET = "~/.poolbot/exec-approvals.sock";
+const DEFAULT_FILE = "~/.poolbot/exec-approvals.json";
 export const DEFAULT_SAFE_BINS = ["jq", "grep", "cut", "sort", "uniq", "head", "tail", "tr", "wc"];
 function hashExecApprovalsRaw(raw) {
     return crypto

package/dist/infra/fs-safe.js

@@ -0,0 +1,76 @@
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+export class SafeOpenError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SafeOpenError";
+    }
+}
+const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
+const ensureTrailingSep = (value) => (value.endsWith(path.sep) ? value : value + path.sep);
+const isNodeError = (err) => Boolean(err && typeof err === "object" && "code" in err);
+const isNotFoundError = (err) => isNodeError(err) && typeof err.code === "string" && NOT_FOUND_CODES.has(err.code);
+const isSymlinkOpenError = (err) => isNodeError(err) && (err.code === "ELOOP" || err.code === "EINVAL" || err.code === "ENOTSUP");
+export async function openFileWithinRoot(params) {
+    let rootReal;
+    try {
+        rootReal = await fs.realpath(params.rootDir);
+    }
+    catch (err) {
+        if (isNotFoundError(err)) {
+            throw new SafeOpenError("not-found", "root dir not found");
+        }
+        throw err;
+    }
+    const rootWithSep = ensureTrailingSep(rootReal);
+    const resolved = path.resolve(rootWithSep, params.relativePath);
+    if (!resolved.startsWith(rootWithSep)) {
+        throw new SafeOpenError("invalid-path", "path escapes root");
+    }
+    const supportsNoFollow = process.platform !== "win32" && "O_NOFOLLOW" in fsConstants;
+    const flags = fsConstants.O_RDONLY | (supportsNoFollow ? fsConstants.O_NOFOLLOW : 0);
+    let handle;
+    try {
+        handle = await fs.open(resolved, flags);
+    }
+    catch (err) {
+        if (isNotFoundError(err)) {
+            throw new SafeOpenError("not-found", "file not found");
+        }
+        if (isSymlinkOpenError(err)) {
+            throw new SafeOpenError("invalid-path", "symlink open blocked");
+        }
+        throw err;
+    }
+    try {
+        const lstat = await fs.lstat(resolved).catch(() => null);
+        if (lstat?.isSymbolicLink()) {
+            throw new SafeOpenError("invalid-path", "symlink not allowed");
+        }
+        const realPath = await fs.realpath(resolved);
+        if (!realPath.startsWith(rootWithSep)) {
+            throw new SafeOpenError("invalid-path", "path escapes root");
+        }
+        const stat = await handle.stat();
+        if (!stat.isFile()) {
+            throw new SafeOpenError("invalid-path", "not a file");
+        }
+        const realStat = await fs.stat(realPath);
+        if (stat.ino !== realStat.ino || stat.dev !== realStat.dev) {
+            throw new SafeOpenError("invalid-path", "path mismatch");
+        }
+        return { handle, realPath, stat };
+    }
+    catch (err) {
+        await handle.close().catch(() => { });
+        if (err instanceof SafeOpenError)
+            throw err;
+        if (isNotFoundError(err)) {
+            throw new SafeOpenError("not-found", "file not found");
+        }
+        throw err;
+    }
+}

package/dist/infra/gateway-lock.js

@@ -50,7 +50,7 @@ function isGatewayArgv(args) {
         return true;
     }
     const exe = normalized[0] ?? "";
-    return exe.endsWith("/clawdbot") || exe === "clawdbot";
+    return exe.endsWith("/poolbot") || exe === "poolbot";
 }
 function readLinuxCmdline(pid) {
     try {

package/dist/infra/heartbeat-visibility.js

@@ -3,8 +3,22 @@ const DEFAULT_VISIBILITY = {
     showAlerts: true, // Show content messages
     useIndicator: true, // Emit indicator events
 };
+/**
+ * Resolve heartbeat visibility settings for a channel.
+ * Supports both deliverable channels (telegram, signal, etc.) and webchat.
+ * For webchat, uses channels.defaults.heartbeat since webchat doesn't have per-channel config.
+ */
 export function resolveHeartbeatVisibility(params) {
     const { cfg, channel, accountId } = params;
+    // Webchat uses channel defaults only (no per-channel or per-account config)
+    if (channel === "webchat") {
+        const channelDefaults = cfg.channels?.defaults?.heartbeat;
+        return {
+            showOk: channelDefaults?.showOk ?? DEFAULT_VISIBILITY.showOk,
+            showAlerts: channelDefaults?.showAlerts ?? DEFAULT_VISIBILITY.showAlerts,
+            useIndicator: channelDefaults?.useIndicator ?? DEFAULT_VISIBILITY.useIndicator,
+        };
+    }
     // Layer 1: Global channel defaults
     const channelDefaults = cfg.channels?.defaults?.heartbeat;
     // Layer 2: Per-channel config (at channel root level)

package/dist/infra/heartbeat-wake.js

@@ -30,10 +30,10 @@ function schedule(coalesceMs) {
                 schedule(DEFAULT_RETRY_MS);
             }
         }
-        catch (err) {
+        catch {
+            // Error is already logged by the heartbeat runner; schedule a retry.
             pendingReason = reason ?? "retry";
             schedule(DEFAULT_RETRY_MS);
-            throw err;
         }
         finally {
             running = false;

package/dist/infra/machine-name.js

@@ -20,7 +20,7 @@ function fallbackHostName() {
     return (os
         .hostname()
         .replace(/\.local$/i, "")
-        .trim() || "clawdbot");
+        .trim() || "poolbot");
 }
 export async function getMachineDisplayName() {
     if (cachedPromise)

package/dist/infra/net/ssrf.js

@@ -1,4 +1,6 @@
 import { lookup as dnsLookup } from "node:dns/promises";
+import { lookup as dnsLookupCb } from "node:dns";
+import { Agent } from "undici";
 export class SsrFBlockedError extends Error {
     constructor(message) {
         super(message);
@@ -100,7 +102,45 @@ export function isBlockedHostname(hostname) {
         normalized.endsWith(".local") ||
         normalized.endsWith(".internal"));
 }
-export async function assertPublicHostname(hostname, lookupFn = dnsLookup) {
+export function createPinnedLookup(params) {
+    const normalizedHost = normalizeHostname(params.hostname);
+    const fallback = params.fallback ?? dnsLookupCb;
+    const fallbackLookup = fallback;
+    const fallbackWithOptions = fallback;
+    const records = params.addresses.map((address) => ({
+        address,
+        family: address.includes(":") ? 6 : 4,
+    }));
+    let index = 0;
+    return ((host, options, callback) => {
+        const cb = typeof options === "function" ? options : callback;
+        if (!cb)
+            return;
+        const normalized = normalizeHostname(host);
+        if (!normalized || normalized !== normalizedHost) {
+            if (typeof options === "function" || options === undefined) {
+                return fallbackLookup(host, cb);
+            }
+            return fallbackWithOptions(host, options, cb);
+        }
+        const opts = typeof options === "object" && options !== null
+            ? options
+            : {};
+        const requestedFamily = typeof options === "number" ? options : typeof opts.family === "number" ? opts.family : 0;
+        const candidates = requestedFamily === 4 || requestedFamily === 6
+            ? records.filter((entry) => entry.family === requestedFamily)
+            : records;
+        const usable = candidates.length > 0 ? candidates : records;
+        if (opts.all) {
+            cb(null, usable);
+            return;
+        }
+        const chosen = usable[index % usable.length];
+        index += 1;
+        cb(null, chosen.address, chosen.family);
+    });
+}
+export async function resolvePinnedHostname(hostname, lookupFn = dnsLookup) {
     const normalized = normalizeHostname(hostname);
     if (!normalized) {
         throw new Error("Invalid hostname");
@@ -120,4 +160,40 @@ export async function assertPublicHostname(hostname, lookupFn = dnsLookup) {
             throw new SsrFBlockedError("Blocked: resolves to private/internal IP address");
         }
     }
+    const addresses = Array.from(new Set(results.map((entry) => entry.address)));
+    if (addresses.length === 0) {
+        throw new Error(`Unable to resolve hostname: ${hostname}`);
+    }
+    return {
+        hostname: normalized,
+        addresses,
+        lookup: createPinnedLookup({ hostname: normalized, addresses }),
+    };
+}
+export function createPinnedDispatcher(pinned) {
+    return new Agent({
+        connect: {
+            lookup: pinned.lookup,
+        },
+    });
+}
+export async function closeDispatcher(dispatcher) {
+    if (!dispatcher)
+        return;
+    const candidate = dispatcher;
+    try {
+        if (typeof candidate.close === "function") {
+            await candidate.close();
+            return;
+        }
+        if (typeof candidate.destroy === "function") {
+            candidate.destroy();
+        }
+    }
+    catch {
+        // ignore dispatcher cleanup errors
+    }
+}
+export async function assertPublicHostname(hostname, lookupFn = dnsLookup) {
+    await resolvePinnedHostname(hostname, lookupFn);
 }

package/dist/infra/outbound/message-action-spec.js

@@ -25,6 +25,7 @@ export const MESSAGE_ACTION_TARGET_MODE = {
     "thread-reply": "to",
     search: "none",
     sticker: "to",
+    "sticker-search": "none",
     "member-info": "none",
     "role-info": "none",
     "emoji-list": "none",

package/dist/infra/outbound/targets.js

@@ -55,7 +55,7 @@ export function resolveOutboundTarget(params) {
     if (params.channel === INTERNAL_MESSAGE_CHANNEL) {
         return {
             ok: false,
-            error: new Error(`Delivering to WebChat is not supported via \`${formatCliCommand("clawdbot agent")}\`; use WhatsApp/Telegram or run with --deliver=false.`),
+            error: new Error(`Delivering to WebChat is not supported via \`${formatCliCommand("poolbot agent")}\`; use WhatsApp/Telegram or run with --deliver=false.`),
         };
     }
     const plugin = getChannelPlugin(params.channel);

package/dist/infra/path-env.js

@@ -42,20 +42,20 @@ function candidateBinDirs(opts) {
     const homeDir = opts.homeDir ?? os.homedir();
     const platform = opts.platform ?? process.platform;
     const candidates = [];
-    // Bundled macOS app: `clawdbot` lives next to the executable (process.execPath).
+    // Bundled macOS app: `poolbot` lives next to the executable (process.execPath).
     try {
         const execDir = path.dirname(execPath);
-        const siblingClawdbot = path.join(execDir, "clawdbot");
-        if (isExecutable(siblingClawdbot))
+        const siblingMoltbot = path.join(execDir, "poolbot");
+        if (isExecutable(siblingMoltbot))
             candidates.push(execDir);
     }
     catch {
         // ignore
     }
-    // Project-local installs (best effort): if a `node_modules/.bin/clawdbot` exists near cwd,
+    // Project-local installs (best effort): if a `node_modules/.bin/poolbot` exists near cwd,
     // include it. This helps when running under launchd or other minimal PATH environments.
     const localBinDir = path.join(cwd, "node_modules", ".bin");
-    if (isExecutable(path.join(localBinDir, "clawdbot")))
+    if (isExecutable(path.join(localBinDir, "poolbot")))
         candidates.push(localBinDir);
     const miseDataDir = process.env.MISE_DATA_DIR ?? path.join(homeDir, ".local", "share", "mise");
     const miseShims = path.join(miseDataDir, "shims");
@@ -76,10 +76,10 @@ function candidateBinDirs(opts) {
     return candidates.filter(isDirectory);
 }
 /**
- * Best-effort PATH bootstrap so skills that require the `clawdbot` CLI can run
+ * Best-effort PATH bootstrap so skills that require the `poolbot` CLI can run
  * under launchd/minimal environments (and inside the macOS app bundle).
  */
-export function ensureClawdbotCliOnPath(opts = {}) {
+export function ensureMoltbotCliOnPath(opts = {}) {
     if (isTruthyEnvValue(process.env.CLAWDBOT_PATH_BOOTSTRAPPED))
         return;
     process.env.CLAWDBOT_PATH_BOOTSTRAPPED = "1";

package/dist/infra/{clawdbot-root.js → poolbot-root.js}

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+const CORE_PACKAGE_NAMES = new Set(["poolbot", "poolbot"]);
 async function readPackageName(dir) {
     try {
         const raw = await fs.readFile(path.join(dir, "package.json"), "utf-8");
@@ -15,7 +16,7 @@ async function findPackageRoot(startDir, maxDepth = 12) {
     let current = path.resolve(startDir);
     for (let i = 0; i < maxDepth; i += 1) {
         const name = await readPackageName(current);
-        if (name === "clawdbot")
+        if (name && CORE_PACKAGE_NAMES.has(name))
             return current;
         const parent = path.dirname(current);
         if (parent === current)
@@ -36,7 +37,7 @@ function candidateDirsFromArgv1(argv1) {
     }
     return candidates;
 }
-export async function resolveClawdbotPackageRoot(opts) {
+export async function resolvePoolBotPackageRoot(opts) {
     const candidates = [];
     if (opts.moduleUrl) {
         candidates.push(path.dirname(fileURLToPath(opts.moduleUrl)));

package/dist/infra/ports-format.js

@@ -1,7 +1,7 @@
 import { formatCliCommand } from "../cli/command-format.js";
 export function classifyPortListener(listener, port) {
     const raw = `${listener.commandLine ?? ""} ${listener.command ?? ""}`.trim().toLowerCase();
-    if (raw.includes("clawdbot"))
+    if (raw.includes("poolbot"))
         return "gateway";
     if (raw.includes("ssh")) {
         const portToken = String(port);
@@ -18,7 +18,7 @@ export function buildPortHints(listeners, port) {
     const kinds = new Set(listeners.map((listener) => classifyPortListener(listener, port)));
     const hints = [];
     if (kinds.has("gateway")) {
-        hints.push(`Gateway already running locally. Stop it (${formatCliCommand("clawdbot gateway stop")}) or use a different port.`);
+        hints.push(`Gateway already running locally. Stop it (${formatCliCommand("poolbot gateway stop")}) or use a different port.`);
     }
     if (kinds.has("ssh")) {
         hints.push("SSH tunnel already bound to this port. Close the tunnel or use a different local port in -L.");

package/dist/infra/ports.js

@@ -52,8 +52,8 @@ export async function handlePortError(err, port, context, runtime = defaultRunti
         if (details) {
             runtime.error(info("Port listener details:"));
             runtime.error(details);
-            if (/clawdbot|src\/index\.ts|dist\/index\.js/.test(details)) {
-                runtime.error(warn("It looks like another clawdbot instance is already running. Stop it or pick a different port."));
+            if (/poolbot|src\/index\.ts|dist\/index\.js/.test(details)) {
+                runtime.error(warn("It looks like another poolbot instance is already running. Stop it or pick a different port."));
             }
         }
         runtime.error(info("Resolve by stopping the process using the port or passing --port <free-port>."));

package/dist/infra/provider-usage.auth.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { CLAUDE_CLI_PROFILE_ID, ensureAuthProfileStore, listProfilesForProvider, resolveApiKeyForProfile, resolveAuthProfileOrder, } from "../agents/auth-profiles.js";
+import { ensureAuthProfileStore, listProfilesForProvider, resolveApiKeyForProfile, resolveAuthProfileOrder, } from "../agents/auth-profiles.js";
 import { getCustomProviderApiKey, resolveEnvApiKey } from "../agents/model-auth.js";
 import { normalizeProviderId } from "../agents/model-selection.js";
 import { loadConfig } from "../config/config.js";
@@ -89,9 +89,7 @@ async function resolveOAuthToken(params) {
         store,
         provider: params.provider,
     });
-    // Claude Code CLI creds are the only Anthropic tokens that reliably include the
-    // `user:profile` scope required for the OAuth usage endpoint.
-    const candidates = params.provider === "anthropic" ? [CLAUDE_CLI_PROFILE_ID, ...order] : order;
+    const candidates = order;
     const deduped = [];
     for (const entry of candidates) {
         if (!deduped.includes(entry))

package/dist/infra/provider-usage.fetch.claude.js

@@ -62,7 +62,7 @@ export async function fetchClaudeUsage(token, timeoutMs, fetchFn) {
     const res = await fetchJson("https://api.anthropic.com/api/oauth/usage", {
         headers: {
             Authorization: `Bearer ${token}`,
-            "User-Agent": "clawdbot",
+            "User-Agent": "poolbot",
             Accept: "application/json",
             "anthropic-version": "2023-06-01",
             "anthropic-beta": "oauth-2025-04-20",

package/dist/infra/provider-usage.fetch.minimax.js

@@ -260,7 +260,7 @@ export async function fetchMinimaxUsage(apiKey, timeoutMs, fetchFn) {
         headers: {
             Authorization: `Bearer ${apiKey}`,
             "Content-Type": "application/json",
-            "MM-API-Source": "Clawdbot",
+            "MM-API-Source": "Moltbot",
         },
     }, timeoutMs, fetchFn);
     if (!res.ok) {

package/dist/infra/restart-sentinel.js

@@ -4,7 +4,7 @@ import { formatCliCommand } from "../cli/command-format.js";
 import { resolveStateDir } from "../config/paths.js";
 const SENTINEL_FILENAME = "restart-sentinel.json";
 export function formatDoctorNonInteractiveHint(env = process.env) {
-    return `Run: ${formatCliCommand("clawdbot doctor --non-interactive", env)}`;
+    return `Run: ${formatCliCommand("poolbot doctor --non-interactive", env)}`;
 }
 export function resolveRestartSentinelPath(env = process.env) {
     return path.join(resolveStateDir(env), SENTINEL_FILENAME);

package/dist/infra/restart.js

@@ -71,7 +71,7 @@ function normalizeSystemdUnit(raw, profile) {
     }
     return unit.endsWith(".service") ? unit : `${unit}.service`;
 }
-export function triggerClawdbotRestart() {
+export function triggerMoltbotRestart() {
     if (process.env.VITEST || process.env.NODE_ENV === "test") {
         return { ok: true, method: "supervisor", detail: "test mode" };
     }

package/dist/infra/retry-policy.js

@@ -53,10 +53,13 @@ export function createTelegramRetryRunner(params) {
         ...params.configRetry,
         ...params.retry,
     });
+    const shouldRetry = params.shouldRetry
+        ? (err) => params.shouldRetry?.(err) || TELEGRAM_RETRY_RE.test(formatErrorMessage(err))
+        : (err) => TELEGRAM_RETRY_RE.test(formatErrorMessage(err));
     return (fn, label) => retryAsync(fn, {
         ...retryConfig,
         label,
-        shouldRetry: (err) => TELEGRAM_RETRY_RE.test(formatErrorMessage(err)),
+        shouldRetry,
         retryAfterMs: getTelegramRetryAfterMs,
         onRetry: params.verbose
             ? (info) => {

package/dist/infra/runtime-guard.js

@@ -50,11 +50,11 @@ export function assertSupportedRuntime(runtime = defaultRuntime, details = detec
     const runtimeLabel = details.kind === "unknown" ? "unknown runtime" : `${details.kind} ${versionLabel}`;
     const execLabel = details.execPath ?? "unknown";
     runtime.error([
-        "clawdbot requires Node >=22.0.0.",
+        "poolbot requires Node >=22.0.0.",
         `Detected: ${runtimeLabel} (exec: ${execLabel}).`,
         `PATH searched: ${details.pathEnv}`,
         "Install Node: https://nodejs.org/en/download",
-        "Upgrade Node and re-run clawdbot.",
+        "Upgrade Node and re-run poolbot.",
     ].join("\n"));
     runtime.exit(1);
 }

package/dist/infra/shell-env.js

@@ -53,7 +53,7 @@ export function loadShellEnvFallback(opts) {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger.warn(`[clawdbot] shell env fallback failed: ${msg}`);
+        logger.warn(`[poolbot] shell env fallback failed: ${msg}`);
         lastAppliedKeys = [];
         return { ok: false, error: msg, applied: [] };
     }

package/dist/infra/skills-remote.js

@@ -139,11 +139,11 @@ function listWorkspaceDirs(cfg) {
 function collectRequiredBins(entries, targetPlatform) {
     const bins = new Set();
     for (const entry of entries) {
-        const os = entry.clawdbot?.os ?? [];
+        const os = entry.metadata?.os ?? [];
         if (os.length > 0 && !os.includes(targetPlatform))
             continue;
-        const required = entry.clawdbot?.requires?.bins ?? [];
-        const anyBins = entry.clawdbot?.requires?.anyBins ?? [];
+        const required = entry.metadata?.requires?.bins ?? [];
+        const anyBins = entry.metadata?.requires?.anyBins ?? [];
         for (const bin of required) {
             if (bin.trim())
                 bins.add(bin.trim());

package/dist/infra/tailscale.js

@@ -173,6 +173,7 @@ export async function ensureTailscaledInstalled(exec = runExec, prompt = promptY
     logVerbose("Installing tailscaled via Homebrew…");
     await exec("brew", ["install", "tailscale"]);
 }
+const whoisCache = new Map();
 function extractExecErrorText(err) {
     const errOutput = err;
     const stdout = typeof errOutput.stdout === "string" ? errOutput.stdout : "";
@@ -262,7 +263,7 @@ export async function ensureFunnel(port, exec = runExec, runtime = defaultRuntim
             console.error(warn("Tailscale client/server version mismatch detected; try updating tailscale/tailscaled."));
         }
         runtime.error("Failed to enable Tailscale Funnel. Is it allowed on your tailnet?");
-        runtime.error(info(`Tip: Funnel is optional for CLAWDBOT. You can keep running the web gateway without it: \`${formatCliCommand("clawdbot gateway")}\``));
+        runtime.error(info(`Tip: Funnel is optional for Moltbot. You can keep running the web gateway without it: \`${formatCliCommand("poolbot gateway")}\``));
         if (shouldLogVerbose()) {
             const rich = isRich();
             if (stdout.trim()) {
@@ -304,3 +305,64 @@ export async function disableTailscaleFunnel(exec = runExec) {
         timeoutMs: 15_000,
     });
 }
+function getString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function parseWhoisIdentity(payload) {
+    const userProfile = readRecord(payload.UserProfile) ?? readRecord(payload.userProfile) ?? readRecord(payload.User);
+    const login = getString(userProfile?.LoginName) ??
+        getString(userProfile?.Login) ??
+        getString(userProfile?.login) ??
+        getString(payload.LoginName) ??
+        getString(payload.login);
+    if (!login)
+        return null;
+    const name = getString(userProfile?.DisplayName) ??
+        getString(userProfile?.Name) ??
+        getString(userProfile?.displayName) ??
+        getString(payload.DisplayName) ??
+        getString(payload.name);
+    return { login, name };
+}
+function readCachedWhois(ip, now) {
+    const cached = whoisCache.get(ip);
+    if (!cached)
+        return undefined;
+    if (cached.expiresAt <= now) {
+        whoisCache.delete(ip);
+        return undefined;
+    }
+    return cached.value;
+}
+function writeCachedWhois(ip, value, ttlMs) {
+    whoisCache.set(ip, { value, expiresAt: Date.now() + ttlMs });
+}
+export async function readTailscaleWhoisIdentity(ip, exec = runExec, opts) {
+    const normalized = ip.trim();
+    if (!normalized)
+        return null;
+    const now = Date.now();
+    const cached = readCachedWhois(normalized, now);
+    if (cached !== undefined)
+        return cached;
+    const cacheTtlMs = opts?.cacheTtlMs ?? 60_000;
+    const errorTtlMs = opts?.errorTtlMs ?? 5_000;
+    try {
+        const tailscaleBin = await getTailscaleBinary();
+        const { stdout } = await exec(tailscaleBin, ["whois", "--json", normalized], {
+            timeoutMs: opts?.timeoutMs ?? 5_000,
+            maxBuffer: 200_000,
+        });
+        const parsed = stdout ? parsePossiblyNoisyJsonObject(stdout) : {};
+        const identity = parseWhoisIdentity(parsed);
+        writeCachedWhois(normalized, identity, cacheTtlMs);
+        return identity;
+    }
+    catch {
+        writeCachedWhois(normalized, null, errorTtlMs);
+        return null;
+    }
+}