@poolzin/pool-bot 2026.2.17 → 2026.2.18

package/dist/shared/config-eval.js

@@ -0,0 +1,117 @@
+import fs from "node:fs";
+import path from "node:path";
+export function isTruthy(value) {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return value !== 0;
+    }
+    if (typeof value === "string") {
+        return value.trim().length > 0;
+    }
+    return true;
+}
+export function resolveConfigPath(config, pathStr) {
+    const parts = pathStr.split(".").filter(Boolean);
+    let current = config;
+    for (const part of parts) {
+        if (typeof current !== "object" || current === null) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+export function isConfigPathTruthyWithDefaults(config, pathStr, defaults) {
+    const value = resolveConfigPath(config, pathStr);
+    if (value === undefined && pathStr in defaults) {
+        return defaults[pathStr] ?? false;
+    }
+    return isTruthy(value);
+}
+export function evaluateRuntimeRequires(params) {
+    const requires = params.requires;
+    if (!requires) {
+        return true;
+    }
+    const requiredBins = requires.bins ?? [];
+    if (requiredBins.length > 0) {
+        for (const bin of requiredBins) {
+            if (params.hasBin(bin)) {
+                continue;
+            }
+            if (params.hasRemoteBin?.(bin)) {
+                continue;
+            }
+            return false;
+        }
+    }
+    const requiredAnyBins = requires.anyBins ?? [];
+    if (requiredAnyBins.length > 0) {
+        const anyFound = requiredAnyBins.some((bin) => params.hasBin(bin));
+        if (!anyFound && !params.hasAnyRemoteBin?.(requiredAnyBins)) {
+            return false;
+        }
+    }
+    const requiredEnv = requires.env ?? [];
+    if (requiredEnv.length > 0) {
+        for (const envName of requiredEnv) {
+            if (!params.hasEnv(envName)) {
+                return false;
+            }
+        }
+    }
+    const requiredConfig = requires.config ?? [];
+    if (requiredConfig.length > 0) {
+        for (const configPath of requiredConfig) {
+            if (!params.isConfigPathTruthy(configPath)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+export function resolveRuntimePlatform() {
+    return process.platform;
+}
+function windowsPathExtensions() {
+    const raw = process.env.PATHEXT;
+    const list = raw !== undefined ? raw.split(";").map((v) => v.trim()) : [".EXE", ".CMD", ".BAT", ".COM"];
+    return ["", ...list.filter(Boolean)];
+}
+let cachedHasBinaryPath;
+let cachedHasBinaryPathExt;
+const hasBinaryCache = new Map();
+export function hasBinary(bin) {
+    const pathEnv = process.env.PATH ?? "";
+    const pathExt = process.platform === "win32" ? (process.env.PATHEXT ?? "") : "";
+    if (cachedHasBinaryPath !== pathEnv || cachedHasBinaryPathExt !== pathExt) {
+        cachedHasBinaryPath = pathEnv;
+        cachedHasBinaryPathExt = pathExt;
+        hasBinaryCache.clear();
+    }
+    if (hasBinaryCache.has(bin)) {
+        return hasBinaryCache.get(bin);
+    }
+    const parts = pathEnv.split(path.delimiter).filter(Boolean);
+    const extensions = process.platform === "win32" ? windowsPathExtensions() : [""];
+    for (const part of parts) {
+        for (const ext of extensions) {
+            const candidate = path.join(part, bin + ext);
+            try {
+                fs.accessSync(candidate, fs.constants.X_OK);
+                hasBinaryCache.set(bin, true);
+                return true;
+            }
+            catch {
+                // keep scanning
+            }
+        }
+    }
+    hasBinaryCache.set(bin, false);
+    return false;
+}

package/dist/shared/device-auth.js

@@ -0,0 +1,16 @@
+export function normalizeDeviceAuthRole(role) {
+    return role.trim();
+}
+export function normalizeDeviceAuthScopes(scopes) {
+    if (!Array.isArray(scopes)) {
+        return [];
+    }
+    const out = new Set();
+    for (const scope of scopes) {
+        const trimmed = scope.trim();
+        if (trimmed) {
+            out.add(trimmed);
+        }
+    }
+    return [...out].toSorted();
+}

package/dist/shared/entry-metadata.js

@@ -0,0 +1,9 @@
+export function resolveEmojiAndHomepage(params) {
+    const emoji = params.metadata?.emoji ?? params.frontmatter?.emoji;
+    const homepageRaw = params.metadata?.homepage ??
+        params.frontmatter?.homepage ??
+        params.frontmatter?.website ??
+        params.frontmatter?.url;
+    const homepage = homepageRaw?.trim() ? homepageRaw.trim() : undefined;
+    return { ...(emoji ? { emoji } : {}), ...(homepage ? { homepage } : {}) };
+}

package/dist/shared/entry-status.js

@@ -0,0 +1,25 @@
+import { resolveEmojiAndHomepage } from "./entry-metadata.js";
+import { evaluateRequirementsFromMetadataWithRemote, } from "./requirements.js";
+export function evaluateEntryMetadataRequirements(params) {
+    const { emoji, homepage } = resolveEmojiAndHomepage({
+        metadata: params.metadata,
+        frontmatter: params.frontmatter,
+    });
+    const { required, missing, eligible, configChecks } = evaluateRequirementsFromMetadataWithRemote({
+        always: params.always,
+        metadata: params.metadata ?? undefined,
+        hasLocalBin: params.hasLocalBin,
+        localPlatform: params.localPlatform,
+        remote: params.remote,
+        isEnvSatisfied: params.isEnvSatisfied,
+        isConfigSatisfied: params.isConfigSatisfied,
+    });
+    return {
+        ...(emoji ? { emoji } : {}),
+        ...(homepage ? { homepage } : {}),
+        required,
+        missing,
+        requirementsSatisfied: eligible,
+        configChecks,
+    };
+}

package/dist/shared/frontmatter.js

@@ -0,0 +1,98 @@
+import JSON5 from "json5";
+import { LEGACY_MANIFEST_KEYS, MANIFEST_KEY } from "../compat/legacy-names.js";
+import { parseBooleanValue } from "../utils/boolean.js";
+export function normalizeStringList(input) {
+    if (!input) {
+        return [];
+    }
+    if (Array.isArray(input)) {
+        return input.map((value) => String(value).trim()).filter(Boolean);
+    }
+    if (typeof input === "string") {
+        return input
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean);
+    }
+    return [];
+}
+export function getFrontmatterString(frontmatter, key) {
+    const raw = frontmatter[key];
+    return typeof raw === "string" ? raw : undefined;
+}
+export function parseFrontmatterBool(value, fallback) {
+    const parsed = parseBooleanValue(value);
+    return parsed === undefined ? fallback : parsed;
+}
+export function resolveOpenClawManifestBlock(params) {
+    const raw = getFrontmatterString(params.frontmatter, params.key ?? "metadata");
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON5.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return undefined;
+        }
+        const manifestKeys = [MANIFEST_KEY, ...LEGACY_MANIFEST_KEYS];
+        for (const key of manifestKeys) {
+            const candidate = parsed[key];
+            if (candidate && typeof candidate === "object") {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveOpenClawManifestRequires(metadataObj) {
+    const requiresRaw = typeof metadataObj.requires === "object" && metadataObj.requires !== null
+        ? metadataObj.requires
+        : undefined;
+    if (!requiresRaw) {
+        return undefined;
+    }
+    return {
+        bins: normalizeStringList(requiresRaw.bins),
+        anyBins: normalizeStringList(requiresRaw.anyBins),
+        env: normalizeStringList(requiresRaw.env),
+        config: normalizeStringList(requiresRaw.config),
+    };
+}
+export function resolveOpenClawManifestInstall(metadataObj, parseInstallSpec) {
+    const installRaw = Array.isArray(metadataObj.install) ? metadataObj.install : [];
+    return installRaw
+        .map((entry) => parseInstallSpec(entry))
+        .filter((entry) => Boolean(entry));
+}
+export function resolveOpenClawManifestOs(metadataObj) {
+    return normalizeStringList(metadataObj.os);
+}
+export function parseOpenClawManifestInstallBase(input, allowedKinds) {
+    if (!input || typeof input !== "object") {
+        return undefined;
+    }
+    const raw = input;
+    const kindRaw = typeof raw.kind === "string" ? raw.kind : typeof raw.type === "string" ? raw.type : "";
+    const kind = kindRaw.trim().toLowerCase();
+    if (!allowedKinds.includes(kind)) {
+        return undefined;
+    }
+    const spec = {
+        raw,
+        kind,
+    };
+    if (typeof raw.id === "string") {
+        spec.id = raw.id;
+    }
+    if (typeof raw.label === "string") {
+        spec.label = raw.label;
+    }
+    const bins = normalizeStringList(raw.bins);
+    if (bins.length > 0) {
+        spec.bins = bins;
+    }
+    return spec;
+}

package/dist/shared/model-param-b.js

@@ -0,0 +1,19 @@
+export function inferParamBFromIdOrName(text) {
+    const raw = text.toLowerCase();
+    const matches = raw.matchAll(/(?:^|[^a-z0-9])[a-z]?(\d+(?:\.\d+)?)b(?:[^a-z0-9]|$)/g);
+    let best = null;
+    for (const match of matches) {
+        const numRaw = match[1];
+        if (!numRaw) {
+            continue;
+        }
+        const value = Number(numRaw);
+        if (!Number.isFinite(value) || value <= 0) {
+            continue;
+        }
+        if (best === null || value > best) {
+            best = value;
+        }
+    }
+    return best;
+}

package/dist/shared/net/ipv4.js

@@ -0,0 +1,17 @@
+export function validateIPv4AddressInput(value) {
+    if (!value) {
+        return "IP address is required for custom bind mode";
+    }
+    const trimmed = value.trim();
+    const parts = trimmed.split(".");
+    if (parts.length !== 4) {
+        return "Invalid IPv4 address (e.g., 192.168.1.100)";
+    }
+    if (parts.every((part) => {
+        const n = parseInt(part, 10);
+        return !Number.isNaN(n) && n >= 0 && n <= 255 && part === String(n);
+    })) {
+        return undefined;
+    }
+    return "Invalid IPv4 address (each octet must be 0-255)";
+}

package/dist/shared/node-match.js

@@ -0,0 +1,53 @@
+export function normalizeNodeKey(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+}
+function listKnownNodes(nodes) {
+    return nodes
+        .map((n) => n.displayName || n.remoteIp || n.nodeId)
+        .filter(Boolean)
+        .join(", ");
+}
+export function resolveNodeMatches(nodes, query) {
+    const q = query.trim();
+    if (!q) {
+        return [];
+    }
+    const qNorm = normalizeNodeKey(q);
+    return nodes.filter((n) => {
+        if (n.nodeId === q) {
+            return true;
+        }
+        if (typeof n.remoteIp === "string" && n.remoteIp === q) {
+            return true;
+        }
+        const name = typeof n.displayName === "string" ? n.displayName : "";
+        if (name && normalizeNodeKey(name) === qNorm) {
+            return true;
+        }
+        if (q.length >= 6 && n.nodeId.startsWith(q)) {
+            return true;
+        }
+        return false;
+    });
+}
+export function resolveNodeIdFromCandidates(nodes, query) {
+    const q = query.trim();
+    if (!q) {
+        throw new Error("node required");
+    }
+    const matches = resolveNodeMatches(nodes, q);
+    if (matches.length === 1) {
+        return matches[0]?.nodeId ?? "";
+    }
+    if (matches.length === 0) {
+        const known = listKnownNodes(nodes);
+        throw new Error(`unknown node: ${q}${known ? ` (known: ${known})` : ""}`);
+    }
+    throw new Error(`ambiguous node: ${q} (matches: ${matches
+        .map((n) => n.displayName || n.remoteIp || n.nodeId)
+        .join(", ")})`);
+}

package/dist/shared/requirements.js

@@ -0,0 +1,128 @@
+export function resolveMissingBins(params) {
+    const remote = params.hasRemoteBin;
+    return params.required.filter((bin) => {
+        if (params.hasLocalBin(bin)) {
+            return false;
+        }
+        if (remote?.(bin)) {
+            return false;
+        }
+        return true;
+    });
+}
+export function resolveMissingAnyBins(params) {
+    if (params.required.length === 0) {
+        return [];
+    }
+    if (params.required.some((bin) => params.hasLocalBin(bin))) {
+        return [];
+    }
+    if (params.hasRemoteAnyBin?.(params.required)) {
+        return [];
+    }
+    return params.required;
+}
+export function resolveMissingOs(params) {
+    if (params.required.length === 0) {
+        return [];
+    }
+    if (params.required.includes(params.localPlatform)) {
+        return [];
+    }
+    if (params.remotePlatforms?.some((platform) => params.required.includes(platform))) {
+        return [];
+    }
+    return params.required;
+}
+export function resolveMissingEnv(params) {
+    const missing = [];
+    for (const envName of params.required) {
+        if (params.isSatisfied(envName)) {
+            continue;
+        }
+        missing.push(envName);
+    }
+    return missing;
+}
+export function buildConfigChecks(params) {
+    return params.required.map((pathStr) => {
+        const satisfied = params.isSatisfied(pathStr);
+        return { path: pathStr, satisfied };
+    });
+}
+export function evaluateRequirements(params) {
+    const missingBins = resolveMissingBins({
+        required: params.required.bins,
+        hasLocalBin: params.hasLocalBin,
+        hasRemoteBin: params.hasRemoteBin,
+    });
+    const missingAnyBins = resolveMissingAnyBins({
+        required: params.required.anyBins,
+        hasLocalBin: params.hasLocalBin,
+        hasRemoteAnyBin: params.hasRemoteAnyBin,
+    });
+    const missingOs = resolveMissingOs({
+        required: params.required.os,
+        localPlatform: params.localPlatform,
+        remotePlatforms: params.remotePlatforms,
+    });
+    const missingEnv = resolveMissingEnv({
+        required: params.required.env,
+        isSatisfied: params.isEnvSatisfied,
+    });
+    const configChecks = buildConfigChecks({
+        required: params.required.config,
+        isSatisfied: params.isConfigSatisfied,
+    });
+    const missingConfig = configChecks.filter((check) => !check.satisfied).map((check) => check.path);
+    const missing = params.always
+        ? { bins: [], anyBins: [], env: [], config: [], os: [] }
+        : {
+            bins: missingBins,
+            anyBins: missingAnyBins,
+            env: missingEnv,
+            config: missingConfig,
+            os: missingOs,
+        };
+    const eligible = params.always ||
+        (missing.bins.length === 0 &&
+            missing.anyBins.length === 0 &&
+            missing.env.length === 0 &&
+            missing.config.length === 0 &&
+            missing.os.length === 0);
+    return { missing, eligible, configChecks };
+}
+export function evaluateRequirementsFromMetadata(params) {
+    const required = {
+        bins: params.metadata?.requires?.bins ?? [],
+        anyBins: params.metadata?.requires?.anyBins ?? [],
+        env: params.metadata?.requires?.env ?? [],
+        config: params.metadata?.requires?.config ?? [],
+        os: params.metadata?.os ?? [],
+    };
+    const result = evaluateRequirements({
+        always: params.always,
+        required,
+        hasLocalBin: params.hasLocalBin,
+        hasRemoteBin: params.hasRemoteBin,
+        hasRemoteAnyBin: params.hasRemoteAnyBin,
+        localPlatform: params.localPlatform,
+        remotePlatforms: params.remotePlatforms,
+        isEnvSatisfied: params.isEnvSatisfied,
+        isConfigSatisfied: params.isConfigSatisfied,
+    });
+    return { required, ...result };
+}
+export function evaluateRequirementsFromMetadataWithRemote(params) {
+    return evaluateRequirementsFromMetadata({
+        always: params.always,
+        metadata: params.metadata,
+        hasLocalBin: params.hasLocalBin,
+        hasRemoteBin: params.remote?.hasBin,
+        hasRemoteAnyBin: params.remote?.hasAnyBin,
+        localPlatform: params.localPlatform,
+        remotePlatforms: params.remote?.platforms,
+        isEnvSatisfied: params.isEnvSatisfied,
+        isConfigSatisfied: params.isConfigSatisfied,
+    });
+}

package/dist/shared/subagents-format.js

@@ -0,0 +1,84 @@
+export function formatDurationCompact(valueMs) {
+    if (!valueMs || !Number.isFinite(valueMs) || valueMs <= 0) {
+        return "n/a";
+    }
+    const minutes = Math.max(1, Math.round(valueMs / 60_000));
+    if (minutes < 60) {
+        return `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const minutesRemainder = minutes % 60;
+    if (hours < 24) {
+        return minutesRemainder > 0 ? `${hours}h${minutesRemainder}m` : `${hours}h`;
+    }
+    const days = Math.floor(hours / 24);
+    const hoursRemainder = hours % 24;
+    return hoursRemainder > 0 ? `${days}d${hoursRemainder}h` : `${days}d`;
+}
+export function formatTokenShort(value) {
+    if (!value || !Number.isFinite(value) || value <= 0) {
+        return undefined;
+    }
+    const n = Math.floor(value);
+    if (n < 1_000) {
+        return `${n}`;
+    }
+    if (n < 10_000) {
+        return `${(n / 1_000).toFixed(1).replace(/\\.0$/, "")}k`;
+    }
+    if (n < 1_000_000) {
+        return `${Math.round(n / 1_000)}k`;
+    }
+    return `${(n / 1_000_000).toFixed(1).replace(/\\.0$/, "")}m`;
+}
+export function truncateLine(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength).trimEnd()}...`;
+}
+export function resolveTotalTokens(entry) {
+    if (!entry || typeof entry !== "object") {
+        return undefined;
+    }
+    if (typeof entry.totalTokens === "number" && Number.isFinite(entry.totalTokens)) {
+        return entry.totalTokens;
+    }
+    const input = typeof entry.inputTokens === "number" ? entry.inputTokens : 0;
+    const output = typeof entry.outputTokens === "number" ? entry.outputTokens : 0;
+    const total = input + output;
+    return total > 0 ? total : undefined;
+}
+export function resolveIoTokens(entry) {
+    if (!entry || typeof entry !== "object") {
+        return undefined;
+    }
+    const input = typeof entry.inputTokens === "number" && Number.isFinite(entry.inputTokens)
+        ? entry.inputTokens
+        : 0;
+    const output = typeof entry.outputTokens === "number" && Number.isFinite(entry.outputTokens)
+        ? entry.outputTokens
+        : 0;
+    const total = input + output;
+    if (total <= 0) {
+        return undefined;
+    }
+    return { input, output, total };
+}
+export function formatTokenUsageDisplay(entry) {
+    const io = resolveIoTokens(entry);
+    const promptCache = resolveTotalTokens(entry);
+    const parts = [];
+    if (io) {
+        const input = formatTokenShort(io.input) ?? "0";
+        const output = formatTokenShort(io.output) ?? "0";
+        parts.push(`tokens ${formatTokenShort(io.total)} (in ${input} / out ${output})`);
+    }
+    else if (typeof promptCache === "number" && promptCache > 0) {
+        parts.push(`tokens ${formatTokenShort(promptCache)} prompt/cache`);
+    }
+    if (typeof promptCache === "number" && io && promptCache > io.total) {
+        parts.push(`prompt/cache ${formatTokenShort(promptCache)}`);
+    }
+    return parts.join(", ");
+}

package/dist/shared/usage-aggregates.js

@@ -0,0 +1,28 @@
+export function buildUsageAggregateTail(params) {
+    return {
+        byChannel: Array.from(params.byChannelMap.entries())
+            .map(([channel, totals]) => ({ channel, totals }))
+            .toSorted((a, b) => b.totals.totalCost - a.totals.totalCost),
+        latency: params.latencyTotals.count > 0
+            ? {
+                count: params.latencyTotals.count,
+                avgMs: params.latencyTotals.sum / params.latencyTotals.count,
+                minMs: params.latencyTotals.min === Number.POSITIVE_INFINITY ? 0 : params.latencyTotals.min,
+                maxMs: params.latencyTotals.max,
+                p95Ms: params.latencyTotals.p95Max,
+            }
+            : undefined,
+        dailyLatency: Array.from(params.dailyLatencyMap.values())
+            .map((entry) => ({
+            date: entry.date,
+            count: entry.count,
+            avgMs: entry.count ? entry.sum / entry.count : 0,
+            minMs: entry.min === Number.POSITIVE_INFINITY ? 0 : entry.min,
+            maxMs: entry.max,
+            p95Ms: entry.p95Max,
+        }))
+            .toSorted((a, b) => a.date.localeCompare(b.date)),
+        modelDaily: Array.from(params.modelDailyMap.values()).toSorted((a, b) => a.date.localeCompare(b.date) || b.cost - a.cost),
+        daily: Array.from(params.dailyMap.values()).toSorted((a, b) => a.date.localeCompare(b.date)),
+    };
+}

package/dist/signal/monitor/mentions.js

@@ -0,0 +1,45 @@
+const OBJECT_REPLACEMENT = "\uFFFC";
+function isValidMention(mention) {
+    if (!mention) {
+        return false;
+    }
+    if (!(mention.uuid || mention.number)) {
+        return false;
+    }
+    if (typeof mention.start !== "number" || Number.isNaN(mention.start)) {
+        return false;
+    }
+    if (typeof mention.length !== "number" || Number.isNaN(mention.length)) {
+        return false;
+    }
+    return mention.length > 0;
+}
+function clampBounds(start, length, textLength) {
+    const safeStart = Math.max(0, Math.trunc(start));
+    const safeLength = Math.max(0, Math.trunc(length));
+    const safeEnd = Math.min(textLength, safeStart + safeLength);
+    return { start: safeStart, end: safeEnd };
+}
+export function renderSignalMentions(message, mentions) {
+    if (!message || !mentions?.length) {
+        return message;
+    }
+    let normalized = message;
+    const candidates = mentions.filter(isValidMention).toSorted((a, b) => b.start - a.start);
+    for (const mention of candidates) {
+        const identifier = mention.uuid ?? mention.number;
+        if (!identifier) {
+            continue;
+        }
+        const { start, end } = clampBounds(mention.start, mention.length, normalized.length);
+        if (start >= end) {
+            continue;
+        }
+        const slice = normalized.slice(start, end);
+        if (!slice.includes(OBJECT_REPLACEMENT)) {
+            continue;
+        }
+        normalized = normalized.slice(0, start) + `@${identifier}` + normalized.slice(end);
+    }
+    return normalized;
+}

package/dist/signal/rpc-context.js

@@ -0,0 +1,19 @@
+import { loadConfig } from "../config/config.js";
+import { resolveSignalAccount } from "./accounts.js";
+export function resolveSignalRpcContext(opts, accountInfo) {
+    const hasBaseUrl = Boolean(opts.baseUrl?.trim());
+    const hasAccount = Boolean(opts.account?.trim());
+    const resolvedAccount = accountInfo ||
+        (!hasBaseUrl || !hasAccount
+            ? resolveSignalAccount({
+                cfg: loadConfig(),
+                accountId: opts.accountId,
+            })
+            : undefined);
+    const baseUrl = opts.baseUrl?.trim() || resolvedAccount?.baseUrl;
+    if (!baseUrl) {
+        throw new Error("Signal base URL is required");
+    }
+    const account = opts.account?.trim() || resolvedAccount?.config.account?.trim();
+    return { baseUrl, account };
+}