@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/discord/targets.js

@@ -1,8 +1,10 @@
 import { buildMessagingTarget, ensureTargetId, requireTargetKind, } from "../channels/targets.js";
+import { listDiscordDirectoryPeersLive } from "./directory-live.js";
 export function parseDiscordTarget(raw, options = {}) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     const mentionMatch = trimmed.match(/^<@!?(\d+)>$/);
     if (mentionMatch) {
         return buildMessagingTarget("user", mentionMatch[1], trimmed);
@@ -41,3 +43,84 @@ export function resolveDiscordChannelId(raw) {
     const target = parseDiscordTarget(raw, { defaultKind: "channel" });
     return requireTargetKind({ platform: "Discord", target, kind: "channel" });
 }
+/**
+ * Resolve a Discord username to user ID using the directory lookup.
+ * This enables sending DMs by username instead of requiring explicit user IDs.
+ *
+ * @param raw - The username or raw target string (e.g., "john.doe")
+ * @param options - Directory configuration params (cfg, accountId, limit)
+ * @param parseOptions - Messaging target parsing options (defaults, ambiguity message)
+ * @returns Parsed MessagingTarget with user ID, or undefined if not found
+ */
+export async function resolveDiscordTarget(raw, options, parseOptions = {}) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const likelyUsername = isLikelyUsername(trimmed);
+    const shouldLookup = isExplicitUserLookup(trimmed, parseOptions) || likelyUsername;
+    // Parse directly if it's already a known format. Use a safe parse so ambiguous
+    // numeric targets don't throw when we still want to attempt username lookup.
+    const directParse = safeParseDiscordTarget(trimmed, parseOptions);
+    if (directParse && directParse.kind !== "channel" && !likelyUsername) {
+        return directParse;
+    }
+    if (!shouldLookup) {
+        return directParse ?? parseDiscordTarget(trimmed, parseOptions);
+    }
+    // Try to resolve as a username via directory lookup
+    try {
+        const directoryEntries = await listDiscordDirectoryPeersLive({
+            ...options,
+            query: trimmed,
+            limit: 1,
+        });
+        const match = directoryEntries[0];
+        if (match && match.kind === "user") {
+            // Extract user ID from the directory entry (format: "user:<id>")
+            const userId = match.id.replace(/^user:/, "");
+            return buildMessagingTarget("user", userId, trimmed);
+        }
+    }
+    catch {
+        // Directory lookup failed - fall through to parse as-is
+        // This preserves existing behavior for channel names
+    }
+    // Fallback to original parsing (for channels, etc.)
+    return parseDiscordTarget(trimmed, parseOptions);
+}
+function safeParseDiscordTarget(input, options) {
+    try {
+        return parseDiscordTarget(input, options);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isExplicitUserLookup(input, options) {
+    if (/^<@!?(\d+)>$/.test(input)) {
+        return true;
+    }
+    if (/^(user:|discord:)/.test(input)) {
+        return true;
+    }
+    if (input.startsWith("@")) {
+        return true;
+    }
+    if (/^\d+$/.test(input)) {
+        return options.defaultKind === "user";
+    }
+    return false;
+}
+/**
+ * Check if a string looks like a Discord username (not a mention, prefix, or ID).
+ * Usernames typically don't start with special characters except underscore.
+ */
+function isLikelyUsername(input) {
+    // Skip if it's already a known format
+    if (/^(user:|channel:|discord:|@|<@!?)|[\d]+$/.test(input)) {
+        return false;
+    }
+    // Likely a username if it doesn't match known patterns
+    return true;
+}

package/dist/entry.js

@@ -3,32 +3,38 @@ import { spawn } from "node:child_process";
 import path from "node:path";
 import process from "node:process";
 import { applyCliProfileEnv, parseCliProfileArgs } from "./cli/profile.js";
-import { isTruthyEnvValue } from "./infra/env.js";
+import { isTruthyEnvValue, normalizeEnv } from "./infra/env.js";
 import { installProcessWarningFilter } from "./infra/warnings.js";
 import { attachChildProcessBridge } from "./process/child-process-bridge.js";
 process.title = "poolbot";
 installProcessWarningFilter();
+normalizeEnv();
 if (process.argv.includes("--no-color")) {
     process.env.NO_COLOR = "1";
     process.env.FORCE_COLOR = "0";
 }
 const EXPERIMENTAL_WARNING_FLAG = "--disable-warning=ExperimentalWarning";
-function hasExperimentalWarningSuppressed(nodeOptions) {
-    if (!nodeOptions)
-        return false;
-    return nodeOptions.includes(EXPERIMENTAL_WARNING_FLAG) || nodeOptions.includes("--no-warnings");
+function hasExperimentalWarningSuppressed() {
+    const nodeOptions = process.env.NODE_OPTIONS ?? "";
+    if (nodeOptions.includes(EXPERIMENTAL_WARNING_FLAG) || nodeOptions.includes("--no-warnings"))
+        return true;
+    for (const arg of process.execArgv) {
+        if (arg === EXPERIMENTAL_WARNING_FLAG || arg === "--no-warnings")
+            return true;
+    }
+    return false;
 }
 function ensureExperimentalWarningSuppressed() {
     if (isTruthyEnvValue(process.env.CLAWDBOT_NO_RESPAWN))
         return false;
     if (isTruthyEnvValue(process.env.CLAWDBOT_NODE_OPTIONS_READY))
         return false;
-    const nodeOptions = process.env.NODE_OPTIONS ?? "";
-    if (hasExperimentalWarningSuppressed(nodeOptions))
+    if (hasExperimentalWarningSuppressed())
         return false;
+    // Respawn guard (and keep recursion bounded if something goes wrong).
     process.env.CLAWDBOT_NODE_OPTIONS_READY = "1";
-    process.env.NODE_OPTIONS = `${nodeOptions} ${EXPERIMENTAL_WARNING_FLAG}`.trim();
-    const child = spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
+    // Pass flag as a Node CLI option, not via NODE_OPTIONS (--disable-warning is disallowed in NODE_OPTIONS).
+    const child = spawn(process.execPath, [EXPERIMENTAL_WARNING_FLAG, ...process.execArgv, ...process.argv.slice(1)], {
         stdio: "inherit",
         env: process.env,
     });

package/dist/extensionAPI.js

@@ -0,0 +1,8 @@
+export { resolveAgentDir, resolveAgentWorkspaceDir } from "./agents/agent-scope.js";
+export { DEFAULT_MODEL, DEFAULT_PROVIDER } from "./agents/defaults.js";
+export { resolveAgentIdentity } from "./agents/identity.js";
+export { resolveThinkingDefault } from "./agents/model-selection.js";
+export { runEmbeddedPiAgent } from "./agents/pi-embedded.js";
+export { resolveAgentTimeoutMs } from "./agents/timeout.js";
+export { ensureAgentWorkspace } from "./agents/workspace.js";
+export { resolveStorePath, loadSessionStore, saveSessionStore, resolveSessionFilePath, } from "./config/sessions.js";

package/dist/gateway/control-ui.js

@@ -204,7 +204,14 @@ export function handleControlUiHttpRequest(req, res, opts) {
         if (!pathname.startsWith(`${basePath}/`))
             return false;
     }
-    const root = resolveControlUiRoot();
+    const root = (() => {
+        if (opts?.root) {
+            if (opts.root.kind === "resolved")
+                return opts.root.path;
+            return null;
+        }
+        return resolveControlUiRoot();
+    })();
     if (!root) {
         res.statusCode = 503;
         res.setHeader("Content-Type", "text/plain; charset=utf-8");

package/dist/gateway/hooks-mapping.js

@@ -87,6 +87,7 @@ function normalizeHookMapping(mapping, index, transformsDir) {
         action,
         wakeMode,
         name: mapping.name,
+        agentId: mapping.agentId?.trim() || undefined,
         sessionKey: mapping.sessionKey,
         messageTemplate: mapping.messageTemplate,
         textTemplate: mapping.textTemplate,
@@ -131,6 +132,7 @@ function buildActionFromMapping(mapping, ctx) {
             kind: "agent",
             message,
             name: renderOptional(mapping.name, ctx),
+            agentId: mapping.agentId,
             wakeMode: mapping.wakeMode ?? "now",
             sessionKey: renderOptional(mapping.sessionKey, ctx),
             deliver: mapping.deliver,
@@ -162,6 +164,7 @@ function mergeAction(base, override, defaultAction) {
         message,
         wakeMode,
         name: override.name ?? baseAgent?.name,
+        agentId: override.agentId ?? baseAgent?.agentId,
         sessionKey: override.sessionKey ?? baseAgent?.sessionKey,
         deliver: typeof override.deliver === "boolean" ? override.deliver : baseAgent?.deliver,
         allowUnsafeExternalContent: typeof override.allowUnsafeExternalContent === "boolean"

package/dist/gateway/hooks.js

@@ -1,5 +1,7 @@
 import { randomUUID } from "node:crypto";
+import { listAgentIds, resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { listChannelPlugins } from "../channels/plugins/index.js";
+import { normalizeAgentId } from "../routing/session-key.js";
 import { normalizeMessageChannel } from "../utils/message-channel.js";
 import { resolveHookMappings } from "./hooks-mapping.js";
 const DEFAULT_HOOKS_PATH = "/hooks";
@@ -21,13 +23,48 @@ export function resolveHooksConfig(cfg) {
         ? cfg.hooks.maxBodyBytes
         : DEFAULT_HOOKS_MAX_BODY_BYTES;
     const mappings = resolveHookMappings(cfg.hooks);
+    const defaultAgentId = resolveDefaultAgentId(cfg);
+    const knownAgentIds = resolveKnownAgentIds(cfg, defaultAgentId);
+    const allowedAgentIds = resolveAllowedAgentIds(cfg.hooks?.allowedAgentIds);
     return {
         basePath: trimmed,
         token,
         maxBodyBytes,
         mappings,
+        agentPolicy: {
+            defaultAgentId,
+            knownAgentIds,
+            allowedAgentIds,
+        },
     };
 }
+function resolveKnownAgentIds(cfg, defaultAgentId) {
+    const known = new Set(listAgentIds(cfg));
+    known.add(defaultAgentId);
+    return known;
+}
+function resolveAllowedAgentIds(raw) {
+    if (!Array.isArray(raw)) {
+        return undefined;
+    }
+    const allowed = new Set();
+    let hasWildcard = false;
+    for (const entry of raw) {
+        const trimmed = entry.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (trimmed === "*") {
+            hasWildcard = true;
+            break;
+        }
+        allowed.add(normalizeAgentId(trimmed));
+    }
+    if (hasWildcard) {
+        return undefined;
+    }
+    return allowed;
+}
 export function extractHookToken(req, url) {
     const auth = typeof req.headers.authorization === "string" ? req.headers.authorization.trim() : "";
     if (auth.toLowerCase().startsWith("bearer ")) {
@@ -120,12 +157,39 @@ export function resolveHookChannel(raw) {
 export function resolveHookDeliver(raw) {
     return raw !== false;
 }
+export function resolveHookTargetAgentId(hooksConfig, agentId) {
+    const raw = agentId?.trim();
+    if (!raw) {
+        return undefined;
+    }
+    const normalized = normalizeAgentId(raw);
+    if (hooksConfig.agentPolicy.knownAgentIds.has(normalized)) {
+        return normalized;
+    }
+    return hooksConfig.agentPolicy.defaultAgentId;
+}
+export function isHookAgentAllowed(hooksConfig, agentId) {
+    // Keep backwards compatibility for callers that omit agentId.
+    const raw = agentId?.trim();
+    if (!raw) {
+        return true;
+    }
+    const allowed = hooksConfig.agentPolicy.allowedAgentIds;
+    if (allowed === undefined) {
+        return true;
+    }
+    const resolved = resolveHookTargetAgentId(hooksConfig, raw);
+    return resolved ? allowed.has(resolved) : false;
+}
+export const getHookAgentPolicyError = () => "agentId is not allowed by hooks.allowedAgentIds";
 export function normalizeAgentPayload(payload, opts) {
     const message = typeof payload.message === "string" ? payload.message.trim() : "";
     if (!message)
         return { ok: false, error: "message required" };
     const nameRaw = payload.name;
     const name = typeof nameRaw === "string" && nameRaw.trim() ? nameRaw.trim() : "Hook";
+    const agentIdRaw = payload.agentId;
+    const agentId = typeof agentIdRaw === "string" && agentIdRaw.trim() ? agentIdRaw.trim() : undefined;
     const wakeMode = payload.wakeMode === "next-heartbeat" ? "next-heartbeat" : "now";
     const sessionKeyRaw = payload.sessionKey;
     const idFactory = opts?.idFactory ?? randomUUID;
@@ -154,6 +218,7 @@ export function normalizeAgentPayload(payload, opts) {
         value: {
             message,
             name,
+            agentId,
             wakeMode,
             sessionKey,
             deliver,

package/dist/gateway/live-image-probe.js

@@ -1,69 +1,4 @@
-import { deflateSync } from "node:zlib";
-const CRC_TABLE = (() => {
-    const table = new Uint32Array(256);
-    for (let i = 0; i < 256; i += 1) {
-        let c = i;
-        for (let k = 0; k < 8; k += 1) {
-            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-        }
-        table[i] = c >>> 0;
-    }
-    return table;
-})();
-function crc32(buf) {
-    let crc = 0xffffffff;
-    for (let i = 0; i < buf.length; i += 1) {
-        crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
-    }
-    return (crc ^ 0xffffffff) >>> 0;
-}
-function pngChunk(type, data) {
-    const typeBuf = Buffer.from(type, "ascii");
-    const len = Buffer.alloc(4);
-    len.writeUInt32BE(data.length, 0);
-    const crc = crc32(Buffer.concat([typeBuf, data]));
-    const crcBuf = Buffer.alloc(4);
-    crcBuf.writeUInt32BE(crc, 0);
-    return Buffer.concat([len, typeBuf, data, crcBuf]);
-}
-function encodePngRgba(buffer, width, height) {
-    const stride = width * 4;
-    const raw = Buffer.alloc((stride + 1) * height);
-    for (let row = 0; row < height; row += 1) {
-        const rawOffset = row * (stride + 1);
-        raw[rawOffset] = 0; // filter: none
-        buffer.copy(raw, rawOffset + 1, row * stride, row * stride + stride);
-    }
-    const compressed = deflateSync(raw);
-    const signature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-    const ihdr = Buffer.alloc(13);
-    ihdr.writeUInt32BE(width, 0);
-    ihdr.writeUInt32BE(height, 4);
-    ihdr[8] = 8; // bit depth
-    ihdr[9] = 6; // color type RGBA
-    ihdr[10] = 0; // compression
-    ihdr[11] = 0; // filter
-    ihdr[12] = 0; // interlace
-    return Buffer.concat([
-        signature,
-        pngChunk("IHDR", ihdr),
-        pngChunk("IDAT", compressed),
-        pngChunk("IEND", Buffer.alloc(0)),
-    ]);
-}
-function fillPixel(buf, x, y, width, r, g, b, a = 255) {
-    if (x < 0 || y < 0)
-        return;
-    if (x >= width)
-        return;
-    const idx = (y * width + x) * 4;
-    if (idx < 0 || idx + 3 >= buf.length)
-        return;
-    buf[idx] = r;
-    buf[idx + 1] = g;
-    buf[idx + 2] = b;
-    buf[idx + 3] = a;
-}
+import { encodePngRgba, fillPixel } from "../media/png-encode.js";
 const GLYPH_ROWS_5X7 = {
     "0": [0b01110, 0b10001, 0b10011, 0b10101, 0b11001, 0b10001, 0b01110],
     "1": [0b00100, 0b01100, 0b00100, 0b00100, 0b00100, 0b00100, 0b01110],

package/dist/gateway/net.js

@@ -1,83 +1,125 @@
 import net from "node:net";
+import os from "node:os";
 import { pickPrimaryTailnetIPv4, pickPrimaryTailnetIPv6 } from "../infra/tailnet.js";
+/**
+ * Pick the primary non-internal IPv4 address (LAN IP).
+ * Prefers common interface names (en0, eth0) then falls back to any external IPv4.
+ */
+export function pickPrimaryLanIPv4() {
+    const nets = os.networkInterfaces();
+    const preferredNames = ["en0", "eth0"];
+    for (const name of preferredNames) {
+        const list = nets[name];
+        const entry = list?.find((n) => n.family === "IPv4" && !n.internal);
+        if (entry?.address) {
+            return entry.address;
+        }
+    }
+    for (const list of Object.values(nets)) {
+        const entry = list?.find((n) => n.family === "IPv4" && !n.internal);
+        if (entry?.address) {
+            return entry.address;
+        }
+    }
+    return undefined;
+}
 export function isLoopbackAddress(ip) {
-    if (!ip)
+    if (!ip) {
         return false;
-    if (ip === "127.0.0.1")
+    }
+    if (ip === "127.0.0.1") {
         return true;
-    if (ip.startsWith("127."))
+    }
+    if (ip.startsWith("127.")) {
         return true;
-    if (ip === "::1")
+    }
+    if (ip === "::1") {
         return true;
-    if (ip.startsWith("::ffff:127."))
+    }
+    if (ip.startsWith("::ffff:127.")) {
         return true;
+    }
     return false;
 }
 function normalizeIPv4MappedAddress(ip) {
-    if (ip.startsWith("::ffff:"))
+    if (ip.startsWith("::ffff:")) {
         return ip.slice("::ffff:".length);
+    }
     return ip;
 }
 function normalizeIp(ip) {
     const trimmed = ip?.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     return normalizeIPv4MappedAddress(trimmed.toLowerCase());
 }
 function stripOptionalPort(ip) {
     if (ip.startsWith("[")) {
         const end = ip.indexOf("]");
-        if (end !== -1)
+        if (end !== -1) {
             return ip.slice(1, end);
+        }
     }
-    if (net.isIP(ip))
+    if (net.isIP(ip)) {
         return ip;
+    }
     const lastColon = ip.lastIndexOf(":");
     if (lastColon > -1 && ip.includes(".") && ip.indexOf(":") === lastColon) {
         const candidate = ip.slice(0, lastColon);
-        if (net.isIP(candidate) === 4)
+        if (net.isIP(candidate) === 4) {
             return candidate;
+        }
     }
     return ip;
 }
 export function parseForwardedForClientIp(forwardedFor) {
     const raw = forwardedFor?.split(",")[0]?.trim();
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     return normalizeIp(stripOptionalPort(raw));
 }
 function parseRealIp(realIp) {
     const raw = realIp?.trim();
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     return normalizeIp(stripOptionalPort(raw));
 }
 export function isTrustedProxyAddress(ip, trustedProxies) {
     const normalized = normalizeIp(ip);
-    if (!normalized || !trustedProxies || trustedProxies.length === 0)
+    if (!normalized || !trustedProxies || trustedProxies.length === 0) {
         return false;
+    }
     return trustedProxies.some((proxy) => normalizeIp(proxy) === normalized);
 }
 export function resolveGatewayClientIp(params) {
     const remote = normalizeIp(params.remoteAddr);
-    if (!remote)
+    if (!remote) {
         return undefined;
-    if (!isTrustedProxyAddress(remote, params.trustedProxies))
+    }
+    if (!isTrustedProxyAddress(remote, params.trustedProxies)) {
         return remote;
+    }
     return parseForwardedForClientIp(params.forwardedFor) ?? parseRealIp(params.realIp) ?? remote;
 }
 export function isLocalGatewayAddress(ip) {
-    if (isLoopbackAddress(ip))
+    if (isLoopbackAddress(ip)) {
         return true;
-    if (!ip)
+    }
+    if (!ip) {
         return false;
+    }
     const normalized = normalizeIPv4MappedAddress(ip.trim().toLowerCase());
     const tailnetIPv4 = pickPrimaryTailnetIPv4();
-    if (tailnetIPv4 && normalized === tailnetIPv4.toLowerCase())
+    if (tailnetIPv4 && normalized === tailnetIPv4.toLowerCase()) {
         return true;
+    }
     const tailnetIPv6 = pickPrimaryTailnetIPv6();
-    if (tailnetIPv6 && ip.trim().toLowerCase() === tailnetIPv6.toLowerCase())
+    if (tailnetIPv6 && ip.trim().toLowerCase() === tailnetIPv6.toLowerCase()) {
         return true;
+    }
     return false;
 }
 /**
@@ -96,16 +138,19 @@ export async function resolveGatewayBindHost(bind, customHost) {
     const mode = bind ?? "loopback";
     if (mode === "loopback") {
         // 127.0.0.1 rarely fails, but handle gracefully
-        if (await canBindToHost("127.0.0.1"))
+        if (await canBindToHost("127.0.0.1")) {
             return "127.0.0.1";
+        }
         return "0.0.0.0"; // extreme fallback
     }
     if (mode === "tailnet") {
         const tailnetIP = pickPrimaryTailnetIPv4();
-        if (tailnetIP && (await canBindToHost(tailnetIP)))
+        if (tailnetIP && (await canBindToHost(tailnetIP))) {
             return tailnetIP;
-        if (await canBindToHost("127.0.0.1"))
+        }
+        if (await canBindToHost("127.0.0.1")) {
             return "127.0.0.1";
+        }
         return "0.0.0.0";
     }
     if (mode === "lan") {
@@ -113,16 +158,19 @@ export async function resolveGatewayBindHost(bind, customHost) {
     }
     if (mode === "custom") {
         const host = customHost?.trim();
-        if (!host)
-            return "0.0.0.0"; // invalid config → fall back to all
-        if (isValidIPv4(host) && (await canBindToHost(host)))
+        if (!host) {
+            return "0.0.0.0";
+        } // invalid config → fall back to all
+        if (isValidIPv4(host) && (await canBindToHost(host))) {
             return host;
+        }
         // Custom IP failed → fall back to LAN
         return "0.0.0.0";
     }
     if (mode === "auto") {
-        if (await canBindToHost("127.0.0.1"))
+        if (await canBindToHost("127.0.0.1")) {
             return "127.0.0.1";
+        }
         return "0.0.0.0";
     }
     return "0.0.0.0";
@@ -149,11 +197,13 @@ export async function canBindToHost(host) {
     });
 }
 export async function resolveGatewayListenHosts(bindHost, opts) {
-    if (bindHost !== "127.0.0.1")
+    if (bindHost !== "127.0.0.1") {
         return [bindHost];
+    }
     const canBind = opts?.canBindToHost ?? canBindToHost;
-    if (await canBind("::1"))
+    if (await canBind("::1")) {
         return [bindHost, "::1"];
+    }
     return [bindHost];
 }
 /**
@@ -162,15 +212,30 @@ export async function resolveGatewayListenHosts(bindHost, opts) {
  * @param host - The string to validate
  * @returns True if valid IPv4 format
  */
-function isValidIPv4(host) {
+export function isValidIPv4(host) {
     const parts = host.split(".");
-    if (parts.length !== 4)
+    if (parts.length !== 4) {
         return false;
+    }
     return parts.every((part) => {
         const n = parseInt(part, 10);
         return !Number.isNaN(n) && n >= 0 && n <= 255 && part === String(n);
     });
 }
+/**
+ * Check if a hostname or IP refers to the local machine.
+ * Handles: localhost, 127.x.x.x, ::1, [::1], ::ffff:127.x.x.x
+ * Note: 0.0.0.0 and :: are NOT loopback - they bind to all interfaces.
+ */
 export function isLoopbackHost(host) {
-    return isLoopbackAddress(host);
+    if (!host) {
+        return false;
+    }
+    const h = host.trim().toLowerCase();
+    if (h === "localhost") {
+        return true;
+    }
+    // Handle bracketed IPv6 addresses like [::1]
+    const unbracket = h.startsWith("[") && h.endsWith("]") ? h.slice(1, -1) : h;
+    return isLoopbackAddress(unbracket);
 }