@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/infra/jsonl-socket.js

@@ -0,0 +1,52 @@
+import net from "node:net";
+export async function requestJsonlSocket(params) {
+    const { socketPath, payload, timeoutMs, accept } = params;
+    return await new Promise((resolve) => {
+        const client = new net.Socket();
+        let settled = false;
+        let buffer = "";
+        const finish = (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            try {
+                client.destroy();
+            }
+            catch {
+                // ignore
+            }
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        client.on("error", () => finish(null));
+        client.connect(socketPath, () => {
+            client.write(`${payload}\n`);
+        });
+        client.on("data", (data) => {
+            buffer += data.toString("utf8");
+            let idx = buffer.indexOf("\n");
+            while (idx !== -1) {
+                const line = buffer.slice(0, idx).trim();
+                buffer = buffer.slice(idx + 1);
+                idx = buffer.indexOf("\n");
+                if (!line) {
+                    continue;
+                }
+                try {
+                    const msg = JSON.parse(line);
+                    const result = accept(msg);
+                    if (result === undefined) {
+                        continue;
+                    }
+                    clearTimeout(timer);
+                    finish(result);
+                    return;
+                }
+                catch {
+                    // ignore
+                }
+            }
+        });
+    });
+}

package/dist/infra/map-size.js

@@ -0,0 +1,14 @@
+export function pruneMapToMaxSize(map, maxSize) {
+    const limit = Math.max(0, Math.floor(maxSize));
+    if (limit <= 0) {
+        map.clear();
+        return;
+    }
+    while (map.size > limit) {
+        const oldest = map.keys().next();
+        if (oldest.done) {
+            break;
+        }
+        map.delete(oldest.value);
+    }
+}

package/dist/infra/net/hostname.js

@@ -0,0 +1,7 @@
+export function normalizeHostname(hostname) {
+    const normalized = hostname.trim().toLowerCase().replace(/\.$/, "");
+    if (normalized.startsWith("[") && normalized.endsWith("]")) {
+        return normalized.slice(1, -1);
+    }
+    return normalized;
+}

package/dist/infra/npm-registry-spec.js

@@ -0,0 +1,39 @@
+export function validateRegistryNpmSpec(rawSpec) {
+    const spec = rawSpec.trim();
+    if (!spec) {
+        return "missing npm spec";
+    }
+    if (/\s/.test(spec)) {
+        return "unsupported npm spec: whitespace is not allowed";
+    }
+    // Registry-only: no URLs, git, file, or alias protocols.
+    // Keep strict: this runs on the gateway host.
+    if (spec.includes("://")) {
+        return "unsupported npm spec: URLs are not allowed";
+    }
+    if (spec.includes("#")) {
+        return "unsupported npm spec: git refs are not allowed";
+    }
+    if (spec.includes(":")) {
+        return "unsupported npm spec: protocol specs are not allowed";
+    }
+    const at = spec.lastIndexOf("@");
+    const hasVersion = at > 0;
+    const name = hasVersion ? spec.slice(0, at) : spec;
+    const version = hasVersion ? spec.slice(at + 1) : "";
+    const unscopedName = /^[a-z0-9][a-z0-9-._~]*$/;
+    const scopedName = /^@[a-z0-9][a-z0-9-._~]*\/[a-z0-9][a-z0-9-._~]*$/;
+    const isValidName = name.startsWith("@") ? scopedName.test(name) : unscopedName.test(name);
+    if (!isValidName) {
+        return "unsupported npm spec: expected <name> or <name>@<version> from the npm registry";
+    }
+    if (hasVersion) {
+        if (!version) {
+            return "unsupported npm spec: missing version/tag after @";
+        }
+        if (/[\\/]/.test(version)) {
+            return "unsupported npm spec: invalid version/tag";
+        }
+    }
+    return null;
+}

package/dist/infra/openclaw-root.js

@@ -0,0 +1,109 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const CORE_PACKAGE_NAMES = new Set(["poolbot"]);
+async function readPackageName(dir) {
+    try {
+        const raw = await fs.readFile(path.join(dir, "package.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.name === "string" ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readPackageNameSync(dir) {
+    try {
+        const raw = fsSync.readFileSync(path.join(dir, "package.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.name === "string" ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+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 && CORE_PACKAGE_NAMES.has(name)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return null;
+}
+function findPackageRootSync(startDir, maxDepth = 12) {
+    let current = path.resolve(startDir);
+    for (let i = 0; i < maxDepth; i += 1) {
+        const name = readPackageNameSync(current);
+        if (name && CORE_PACKAGE_NAMES.has(name)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return null;
+}
+function candidateDirsFromArgv1(argv1) {
+    const normalized = path.resolve(argv1);
+    const candidates = [path.dirname(normalized)];
+    // Resolve symlinks for version managers (nvm, fnm, n, Homebrew/Linuxbrew)
+    // that create symlinks in bin/ pointing to the real package location.
+    try {
+        const resolved = fsSync.realpathSync(normalized);
+        if (resolved !== normalized) {
+            candidates.push(path.dirname(resolved));
+        }
+    }
+    catch {
+        // realpathSync throws if path doesn't exist; keep original candidates
+    }
+    const parts = normalized.split(path.sep);
+    const binIndex = parts.lastIndexOf(".bin");
+    if (binIndex > 0 && parts[binIndex - 1] === "node_modules") {
+        const binName = path.basename(normalized);
+        const nodeModulesDir = parts.slice(0, binIndex).join(path.sep);
+        candidates.push(path.join(nodeModulesDir, binName));
+    }
+    return candidates;
+}
+export async function resolveOpenClawPackageRoot(opts) {
+    for (const candidate of buildCandidates(opts)) {
+        const found = await findPackageRoot(candidate);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+export function resolveOpenClawPackageRootSync(opts) {
+    for (const candidate of buildCandidates(opts)) {
+        const found = findPackageRootSync(candidate);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+function buildCandidates(opts) {
+    const candidates = [];
+    if (opts.moduleUrl) {
+        candidates.push(path.dirname(fileURLToPath(opts.moduleUrl)));
+    }
+    if (opts.argv1) {
+        candidates.push(...candidateDirsFromArgv1(opts.argv1));
+    }
+    if (opts.cwd) {
+        candidates.push(opts.cwd);
+    }
+    return candidates;
+}

package/dist/infra/outbound/delivery-queue.js

@@ -0,0 +1,214 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "../../config/paths.js";
+const QUEUE_DIRNAME = "delivery-queue";
+const FAILED_DIRNAME = "failed";
+const MAX_RETRIES = 5;
+/** Backoff delays in milliseconds indexed by retry count (1-based). */
+const BACKOFF_MS = [
+    5_000, // retry 1: 5s
+    25_000, // retry 2: 25s
+    120_000, // retry 3: 2m
+    600_000, // retry 4: 10m
+];
+function resolveQueueDir(stateDir) {
+    const base = stateDir ?? resolveStateDir();
+    return path.join(base, QUEUE_DIRNAME);
+}
+function resolveFailedDir(stateDir) {
+    return path.join(resolveQueueDir(stateDir), FAILED_DIRNAME);
+}
+/** Ensure the queue directory (and failed/ subdirectory) exist. */
+export async function ensureQueueDir(stateDir) {
+    const queueDir = resolveQueueDir(stateDir);
+    await fs.promises.mkdir(queueDir, { recursive: true, mode: 0o700 });
+    await fs.promises.mkdir(resolveFailedDir(stateDir), { recursive: true, mode: 0o700 });
+    return queueDir;
+}
+export async function enqueueDelivery(params, stateDir) {
+    const queueDir = await ensureQueueDir(stateDir);
+    const id = crypto.randomUUID();
+    const entry = {
+        id,
+        enqueuedAt: Date.now(),
+        channel: params.channel,
+        to: params.to,
+        accountId: params.accountId,
+        payloads: params.payloads,
+        threadId: params.threadId,
+        replyToId: params.replyToId,
+        bestEffort: params.bestEffort,
+        gifPlayback: params.gifPlayback,
+        silent: params.silent,
+        mirror: params.mirror,
+        retryCount: 0,
+    };
+    const filePath = path.join(queueDir, `${id}.json`);
+    const tmp = `${filePath}.${process.pid}.tmp`;
+    const json = JSON.stringify(entry, null, 2);
+    await fs.promises.writeFile(tmp, json, { encoding: "utf-8", mode: 0o600 });
+    await fs.promises.rename(tmp, filePath);
+    return id;
+}
+/** Remove a successfully delivered entry from the queue. */
+export async function ackDelivery(id, stateDir) {
+    const filePath = path.join(resolveQueueDir(stateDir), `${id}.json`);
+    try {
+        await fs.promises.unlink(filePath);
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : null;
+        if (code !== "ENOENT") {
+            throw err;
+        }
+        // Already removed — no-op.
+    }
+}
+/** Update a queue entry after a failed delivery attempt. */
+export async function failDelivery(id, error, stateDir) {
+    const filePath = path.join(resolveQueueDir(stateDir), `${id}.json`);
+    const raw = await fs.promises.readFile(filePath, "utf-8");
+    const entry = JSON.parse(raw);
+    entry.retryCount += 1;
+    entry.lastError = error;
+    const tmp = `${filePath}.${process.pid}.tmp`;
+    await fs.promises.writeFile(tmp, JSON.stringify(entry, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+    await fs.promises.rename(tmp, filePath);
+}
+/** Load all pending delivery entries from the queue directory. */
+export async function loadPendingDeliveries(stateDir) {
+    const queueDir = resolveQueueDir(stateDir);
+    let files;
+    try {
+        files = await fs.promises.readdir(queueDir);
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err
+            ? String(err.code)
+            : null;
+        if (code === "ENOENT") {
+            return [];
+        }
+        throw err;
+    }
+    const entries = [];
+    for (const file of files) {
+        if (!file.endsWith(".json")) {
+            continue;
+        }
+        const filePath = path.join(queueDir, file);
+        try {
+            const stat = await fs.promises.stat(filePath);
+            if (!stat.isFile()) {
+                continue;
+            }
+            const raw = await fs.promises.readFile(filePath, "utf-8");
+            entries.push(JSON.parse(raw));
+        }
+        catch {
+            // Skip malformed or inaccessible entries.
+        }
+    }
+    return entries;
+}
+/** Move a queue entry to the failed/ subdirectory. */
+export async function moveToFailed(id, stateDir) {
+    const queueDir = resolveQueueDir(stateDir);
+    const failedDir = resolveFailedDir(stateDir);
+    await fs.promises.mkdir(failedDir, { recursive: true, mode: 0o700 });
+    const src = path.join(queueDir, `${id}.json`);
+    const dest = path.join(failedDir, `${id}.json`);
+    await fs.promises.rename(src, dest);
+}
+/** Compute the backoff delay in ms for a given retry count. */
+export function computeBackoffMs(retryCount) {
+    if (retryCount <= 0) {
+        return 0;
+    }
+    return BACKOFF_MS[Math.min(retryCount - 1, BACKOFF_MS.length - 1)] ?? BACKOFF_MS.at(-1) ?? 0;
+}
+/**
+ * On gateway startup, scan the delivery queue and retry any pending entries.
+ * Uses exponential backoff and moves entries that exceed MAX_RETRIES to failed/.
+ */
+export async function recoverPendingDeliveries(opts) {
+    const pending = await loadPendingDeliveries(opts.stateDir);
+    if (pending.length === 0) {
+        return { recovered: 0, failed: 0, skipped: 0 };
+    }
+    // Process oldest first.
+    pending.sort((a, b) => a.enqueuedAt - b.enqueuedAt);
+    opts.log.info(`Found ${pending.length} pending delivery entries — starting recovery`);
+    const delayFn = opts.delay ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const deadline = Date.now() + (opts.maxRecoveryMs ?? 60_000);
+    let recovered = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const entry of pending) {
+        const now = Date.now();
+        if (now >= deadline) {
+            const deferred = pending.length - recovered - failed - skipped;
+            opts.log.warn(`Recovery time budget exceeded — ${deferred} entries deferred to next restart`);
+            break;
+        }
+        if (entry.retryCount >= MAX_RETRIES) {
+            opts.log.warn(`Delivery ${entry.id} exceeded max retries (${entry.retryCount}/${MAX_RETRIES}) — moving to failed/`);
+            try {
+                await moveToFailed(entry.id, opts.stateDir);
+            }
+            catch (err) {
+                opts.log.error(`Failed to move entry ${entry.id} to failed/: ${String(err)}`);
+            }
+            skipped += 1;
+            continue;
+        }
+        const backoff = computeBackoffMs(entry.retryCount + 1);
+        if (backoff > 0) {
+            if (now + backoff >= deadline) {
+                const deferred = pending.length - recovered - failed - skipped;
+                opts.log.warn(`Recovery time budget exceeded — ${deferred} entries deferred to next restart`);
+                break;
+            }
+            opts.log.info(`Waiting ${backoff}ms before retrying delivery ${entry.id}`);
+            await delayFn(backoff);
+        }
+        try {
+            await opts.deliver({
+                cfg: opts.cfg,
+                channel: entry.channel,
+                to: entry.to,
+                accountId: entry.accountId,
+                payloads: entry.payloads,
+                threadId: entry.threadId,
+                replyToId: entry.replyToId,
+                bestEffort: entry.bestEffort,
+                gifPlayback: entry.gifPlayback,
+                silent: entry.silent,
+                mirror: entry.mirror,
+                skipQueue: true, // Prevent re-enqueueing during recovery
+            });
+            await ackDelivery(entry.id, opts.stateDir);
+            recovered += 1;
+            opts.log.info(`Recovered delivery ${entry.id} to ${entry.channel}:${entry.to}`);
+        }
+        catch (err) {
+            try {
+                await failDelivery(entry.id, err instanceof Error ? err.message : String(err), opts.stateDir);
+            }
+            catch {
+                // Best-effort update.
+            }
+            failed += 1;
+            opts.log.warn(`Retry failed for delivery ${entry.id}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    opts.log.info(`Delivery recovery complete: ${recovered} recovered, ${failed} failed, ${skipped} skipped (max retries)`);
+    return { recovered, failed, skipped };
+}
+export { MAX_RETRIES };

package/dist/infra/outbound/identity.js

@@ -0,0 +1,23 @@
+import { resolveAgentAvatar } from "../../agents/identity-avatar.js";
+import { resolveAgentIdentity } from "../../agents/identity.js";
+export function normalizeOutboundIdentity(identity) {
+    if (!identity) {
+        return undefined;
+    }
+    const name = identity.name?.trim() || undefined;
+    const avatarUrl = identity.avatarUrl?.trim() || undefined;
+    const emoji = identity.emoji?.trim() || undefined;
+    if (!name && !avatarUrl && !emoji) {
+        return undefined;
+    }
+    return { name, avatarUrl, emoji };
+}
+export function resolveAgentOutboundIdentity(cfg, agentId) {
+    const agentIdentity = resolveAgentIdentity(cfg, agentId);
+    const avatar = resolveAgentAvatar(cfg, agentId);
+    return normalizeOutboundIdentity({
+        name: agentIdentity?.name,
+        emoji: agentIdentity?.emoji,
+        avatarUrl: avatar.kind === "remote" ? avatar.url : undefined,
+    });
+}