@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/agents/skills-install-download.js

@@ -1,290 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { extractArchive as extractArchiveSafe } from "../infra/archive.js";
-import { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";
-import { isWithinDir, resolveSafeBaseDir } from "../infra/path-safety.js";
-import { runCommandWithTimeout } from "../process/exec.js";
-import { ensureDir, resolveUserPath } from "../utils.js";
-import { formatInstallFailureMessage } from "./skills-install-output.js";
-import { hasBinary } from "./skills.js";
-import { resolveSkillToolsRootDir } from "./skills/tools-dir.js";
-function isNodeReadableStream(value) {
-    return Boolean(value && typeof value.pipe === "function");
-}
-function isWindowsDrivePath(p) {
-    return /^[a-zA-Z]:[\\/]/.test(p);
-}
-function resolveDownloadTargetDir(entry, spec) {
-    const safeRoot = resolveSkillToolsRootDir(entry);
-    const raw = spec.targetDir?.trim();
-    if (!raw) {
-        return safeRoot;
-    }
-    // Treat non-absolute paths as relative to the per-skill tools root.
-    const resolved = raw.startsWith("~") || path.isAbsolute(raw) || isWindowsDrivePath(raw)
-        ? resolveUserPath(raw)
-        : path.resolve(safeRoot, raw);
-    if (!isWithinDir(safeRoot, resolved)) {
-        throw new Error(`Refusing to install outside the skill tools directory. targetDir="${raw}" resolves to "${resolved}". Allowed root: "${safeRoot}".`);
-    }
-    return resolved;
-}
-function resolveArchiveType(spec, filename) {
-    const explicit = spec.archive?.trim().toLowerCase();
-    if (explicit) {
-        return explicit;
-    }
-    const lower = filename.toLowerCase();
-    if (lower.endsWith(".tar.gz") || lower.endsWith(".tgz")) {
-        return "tar.gz";
-    }
-    if (lower.endsWith(".tar.bz2") || lower.endsWith(".tbz2")) {
-        return "tar.bz2";
-    }
-    if (lower.endsWith(".zip")) {
-        return "zip";
-    }
-    return undefined;
-}
-function normalizeArchiveEntryPath(raw) {
-    return raw.replaceAll("\\", "/");
-}
-function validateArchiveEntryPath(entryPath) {
-    if (!entryPath || entryPath === "." || entryPath === "./") {
-        return;
-    }
-    if (isWindowsDrivePath(entryPath)) {
-        throw new Error(`archive entry uses a drive path: ${entryPath}`);
-    }
-    const normalized = path.posix.normalize(normalizeArchiveEntryPath(entryPath));
-    if (normalized === ".." || normalized.startsWith("../")) {
-        throw new Error(`archive entry escapes targetDir: ${entryPath}`);
-    }
-    if (path.posix.isAbsolute(normalized) || normalized.startsWith("//")) {
-        throw new Error(`archive entry is absolute: ${entryPath}`);
-    }
-}
-function stripArchivePath(entryPath, stripComponents) {
-    const raw = normalizeArchiveEntryPath(entryPath);
-    if (!raw || raw === "." || raw === "./") {
-        return null;
-    }
-    // Important: tar's --strip-components semantics operate on raw path segments,
-    // before any normalization that would collapse "..". We mimic that so we
-    // can detect strip-induced escapes like "a/../b" with stripComponents=1.
-    const parts = raw.split("/").filter((part) => part.length > 0 && part !== ".");
-    const strip = Math.max(0, Math.floor(stripComponents));
-    const stripped = strip === 0 ? parts.join("/") : parts.slice(strip).join("/");
-    const result = path.posix.normalize(stripped);
-    if (!result || result === "." || result === "./") {
-        return null;
-    }
-    return result;
-}
-function validateExtractedPathWithinRoot(params) {
-    const safeBase = resolveSafeBaseDir(params.rootDir);
-    const outPath = path.resolve(params.rootDir, params.relPath);
-    if (!outPath.startsWith(safeBase)) {
-        throw new Error(`archive entry escapes targetDir: ${params.originalPath}`);
-    }
-}
-async function downloadFile(url, destPath, timeoutMs) {
-    const { response, release } = await fetchWithSsrFGuard({
-        url,
-        timeoutMs: Math.max(1_000, timeoutMs),
-    });
-    try {
-        if (!response.ok || !response.body) {
-            throw new Error(`Download failed (${response.status} ${response.statusText})`);
-        }
-        await ensureDir(path.dirname(destPath));
-        const file = fs.createWriteStream(destPath);
-        const body = response.body;
-        const readable = isNodeReadableStream(body)
-            ? body
-            : Readable.fromWeb(body);
-        await pipeline(readable, file);
-        const stat = await fs.promises.stat(destPath);
-        return { bytes: stat.size };
-    }
-    finally {
-        await release();
-    }
-}
-async function extractArchive(params) {
-    const { archivePath, archiveType, targetDir, stripComponents, timeoutMs } = params;
-    const strip = typeof stripComponents === "number" && Number.isFinite(stripComponents)
-        ? Math.max(0, Math.floor(stripComponents))
-        : 0;
-    try {
-        if (archiveType === "zip") {
-            await extractArchiveSafe({
-                archivePath,
-                destDir: targetDir,
-                timeoutMs,
-                kind: "zip",
-                stripComponents: strip,
-            });
-            return { stdout: "", stderr: "", code: 0 };
-        }
-        if (archiveType === "tar.gz") {
-            await extractArchiveSafe({
-                archivePath,
-                destDir: targetDir,
-                timeoutMs,
-                kind: "tar",
-                stripComponents: strip,
-                tarGzip: true,
-            });
-            return { stdout: "", stderr: "", code: 0 };
-        }
-        if (archiveType === "tar.bz2") {
-            if (!hasBinary("tar")) {
-                return { stdout: "", stderr: "tar not found on PATH", code: null };
-            }
-            // Preflight list to prevent zip-slip style traversal before extraction.
-            const listResult = await runCommandWithTimeout(["tar", "tf", archivePath], { timeoutMs });
-            if (listResult.code !== 0) {
-                return {
-                    stdout: listResult.stdout,
-                    stderr: listResult.stderr || "tar list failed",
-                    code: listResult.code,
-                };
-            }
-            const entries = listResult.stdout
-                .split("\n")
-                .map((line) => line.trim())
-                .filter(Boolean);
-            const verboseResult = await runCommandWithTimeout(["tar", "tvf", archivePath], { timeoutMs });
-            if (verboseResult.code !== 0) {
-                return {
-                    stdout: verboseResult.stdout,
-                    stderr: verboseResult.stderr || "tar verbose list failed",
-                    code: verboseResult.code,
-                };
-            }
-            for (const line of verboseResult.stdout.split("\n")) {
-                const trimmed = line.trim();
-                if (!trimmed) {
-                    continue;
-                }
-                const typeChar = trimmed[0];
-                if (typeChar === "l" || typeChar === "h" || trimmed.includes(" -> ")) {
-                    return {
-                        stdout: verboseResult.stdout,
-                        stderr: "tar archive contains link entries; refusing to extract for safety",
-                        code: 1,
-                    };
-                }
-            }
-            for (const entry of entries) {
-                validateArchiveEntryPath(entry);
-                const relPath = stripArchivePath(entry, strip);
-                if (!relPath) {
-                    continue;
-                }
-                validateArchiveEntryPath(relPath);
-                validateExtractedPathWithinRoot({ rootDir: targetDir, relPath, originalPath: entry });
-            }
-            const argv = ["tar", "xf", archivePath, "-C", targetDir];
-            if (strip > 0) {
-                argv.push("--strip-components", String(strip));
-            }
-            return await runCommandWithTimeout(argv, { timeoutMs });
-        }
-        return { stdout: "", stderr: `unsupported archive type: ${archiveType}`, code: null };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { stdout: "", stderr: message, code: 1 };
-    }
-}
-export async function installDownloadSpec(params) {
-    const { entry, spec, timeoutMs } = params;
-    const url = spec.url?.trim();
-    if (!url) {
-        return {
-            ok: false,
-            message: "missing download url",
-            stdout: "",
-            stderr: "",
-            code: null,
-        };
-    }
-    let filename = "";
-    try {
-        const parsed = new URL(url);
-        filename = path.basename(parsed.pathname);
-    }
-    catch {
-        filename = path.basename(url);
-    }
-    if (!filename) {
-        filename = "download";
-    }
-    let targetDir = "";
-    try {
-        targetDir = resolveDownloadTargetDir(entry, spec);
-        await ensureDir(targetDir);
-        const stat = await fs.promises.lstat(targetDir);
-        if (stat.isSymbolicLink()) {
-            throw new Error(`targetDir is a symlink: ${targetDir}`);
-        }
-        if (!stat.isDirectory()) {
-            throw new Error(`targetDir is not a directory: ${targetDir}`);
-        }
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { ok: false, message, stdout: "", stderr: message, code: null };
-    }
-    const archivePath = path.join(targetDir, filename);
-    let downloaded = 0;
-    try {
-        const result = await downloadFile(url, archivePath, timeoutMs);
-        downloaded = result.bytes;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { ok: false, message, stdout: "", stderr: message, code: null };
-    }
-    const archiveType = resolveArchiveType(spec, filename);
-    const shouldExtract = spec.extract ?? Boolean(archiveType);
-    if (!shouldExtract) {
-        return {
-            ok: true,
-            message: `Downloaded to ${archivePath}`,
-            stdout: `downloaded=${downloaded}`,
-            stderr: "",
-            code: 0,
-        };
-    }
-    if (!archiveType) {
-        return {
-            ok: false,
-            message: "extract requested but archive type could not be detected",
-            stdout: "",
-            stderr: "",
-            code: null,
-        };
-    }
-    const extractResult = await extractArchive({
-        archivePath,
-        archiveType,
-        targetDir,
-        stripComponents: spec.stripComponents,
-        timeoutMs,
-    });
-    const success = extractResult.code === 0;
-    return {
-        ok: success,
-        message: success
-            ? `Downloaded and extracted to ${targetDir}`
-            : formatInstallFailureMessage(extractResult),
-        stdout: extractResult.stdout.trim(),
-        stderr: extractResult.stderr.trim(),
-        code: extractResult.code,
-    };
-}

package/dist/agents/skills-install-output.js

@@ -1,30 +0,0 @@
-function summarizeInstallOutput(text) {
-    const raw = text.trim();
-    if (!raw) {
-        return undefined;
-    }
-    const lines = raw
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean);
-    if (lines.length === 0) {
-        return undefined;
-    }
-    const preferred = lines.find((line) => /^error\b/i.test(line)) ??
-        lines.find((line) => /\b(err!|error:|failed)\b/i.test(line)) ??
-        lines.at(-1);
-    if (!preferred) {
-        return undefined;
-    }
-    const normalized = preferred.replace(/\s+/g, " ").trim();
-    const maxLen = 200;
-    return normalized.length > maxLen ? `${normalized.slice(0, maxLen - 1)}…` : normalized;
-}
-export function formatInstallFailureMessage(result) {
-    const code = typeof result.code === "number" ? `exit ${result.code}` : "unknown exit";
-    const summary = summarizeInstallOutput(result.stderr) ?? summarizeInstallOutput(result.stdout);
-    if (!summary) {
-        return `Install failed (${code})`;
-    }
-    return `Install failed (${code}): ${summary}`;
-}

package/dist/agents/skills-install.download-test-utils.js

@@ -1,36 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-export function setTempStateDir(workspaceDir) {
-    const stateDir = path.join(workspaceDir, "state");
-    process.env.POOLBOT_STATE_DIR = stateDir;
-    return stateDir;
-}
-export async function writeDownloadSkill(params) {
-    const skillDir = path.join(params.workspaceDir, "skills", params.name);
-    await fs.mkdir(skillDir, { recursive: true });
-    const meta = {
-        openclaw: {
-            install: [
-                {
-                    id: params.installId,
-                    kind: "download",
-                    url: params.url,
-                    archive: params.archive,
-                    extract: true,
-                    stripComponents: params.stripComponents,
-                    targetDir: params.targetDir,
-                },
-            ],
-        },
-    };
-    await fs.writeFile(path.join(skillDir, "SKILL.md"), `---
-name: ${params.name}
-description: test skill
-metadata: ${JSON.stringify(meta)}
----
-
-# ${params.name}
-`, "utf-8");
-    await fs.writeFile(path.join(skillDir, "runner.js"), "export {};\n", "utf-8");
-    return skillDir;
-}

package/dist/agents/skills.test-helpers.js

@@ -1,13 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-export async function writeSkill(params) {
-    const { dir, name, description, body } = params;
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(path.join(dir, "SKILL.md"), `---
-name: ${name}
-description: ${description}
----
-
-${body ?? `# ${name}\n`}
-`, "utf-8");
-}

package/dist/agents/subagent-announce-reliability.js

@@ -1,160 +0,0 @@
-/**
- * Subagent Announce Chain Delivery Reliability
- *
- * Implements:
- * - Retry budget with exponential backoff
- * - Dedupe of announce completions
- * - Delivery params validation
- * - Session model override persistence
- *
- * OpenClaw #32384, #30951
- */
-import { createSubsystemLogger } from "../logging/subsystem.js";
-const log = createSubsystemLogger("subagent-announce");
-/**
- * Default retry budget: 3 attempts with exponential backoff
- */
-export const DEFAULT_ANNOUNCE_RETRY_BUDGET = {
-    maxRetries: 3,
-    baseDelayMs: 1000,
-    maxDelayMs: 10_000,
-    backoffMultiplier: 2,
-};
-/**
- * In-memory store for announce delivery states
- */
-const announceStates = new Map();
-/**
- * Cleanup old announce states every 30 minutes
- */
-setInterval(() => {
-    const now = Date.now();
-    const maxAge = 30 * 60 * 1000; // 30 minutes
-    for (const [id, state] of announceStates.entries()) {
-        if (now - state.lastAttemptAt > maxAge) {
-            announceStates.delete(id);
-        }
-    }
-}, 30 * 60 * 1000).unref();
-/**
- * Initialize or get announce delivery state
- */
-export function getOrCreateAnnounceState(announceId) {
-    const existing = announceStates.get(announceId);
-    if (existing) {
-        return existing;
-    }
-    const newState = {
-        announceId,
-        attempts: 0,
-        lastAttemptAt: 0,
-        delivered: false,
-        retriesExhausted: false,
-    };
-    announceStates.set(announceId, newState);
-    return newState;
-}
-/**
- * Record a delivery attempt and check if retry is allowed
- */
-export function recordDeliveryAttempt(params) {
-    const { announceId, success, error, budget = DEFAULT_ANNOUNCE_RETRY_BUDGET } = params;
-    const state = getOrCreateAnnounceState(announceId);
-    state.attempts += 1;
-    state.lastAttemptAt = Date.now();
-    if (success) {
-        state.delivered = true;
-        state.lastError = undefined;
-        return { canRetry: false, delayMs: 0, attemptsRemaining: 0 };
-    }
-    state.lastError = error;
-    const attemptsRemaining = Math.max(0, budget.maxRetries - state.attempts);
-    state.retriesExhausted = attemptsRemaining === 0;
-    if (!state.retriesExhausted) {
-        // Calculate exponential backoff delay
-        const exponentialDelay = budget.baseDelayMs * Math.pow(budget.backoffMultiplier, state.attempts - 1);
-        const delayMs = Math.min(exponentialDelay, budget.maxDelayMs);
-        log.warn(`Announce delivery attempt ${state.attempts}/${budget.maxRetries} failed, retrying in ${delayMs}ms`, { announceId, error });
-        return { canRetry: true, delayMs, attemptsRemaining };
-    }
-    log.error(`Announce delivery failed after ${state.attempts} attempts (retries exhausted)`, {
-        announceId,
-        error,
-    });
-    return { canRetry: false, delayMs: 0, attemptsRemaining: 0 };
-}
-/**
- * Check if an announce completion is duplicate (dedupe)
- * OpenClaw #32384 - prevents duplicate announce deliveries
- */
-const completedAnnounces = new Map();
-export function isAnnounceDuplicate(announceId) {
-    return completedAnnounces.has(announceId);
-}
-export function markAnnounceComplete(announceId) {
-    completedAnnounces.set(announceId, Date.now());
-}
-/**
- * Cleanup completed announces every hour
- */
-setInterval(() => {
-    const now = Date.now();
-    const maxAge = 60 * 60 * 1000; // 1 hour
-    for (const [id, timestamp] of completedAnnounces.entries()) {
-        if (now - timestamp > maxAge) {
-            completedAnnounces.delete(id);
-        }
-    }
-}, 60 * 60 * 1000).unref();
-/**
- * Validate announce delivery parameters
- */
-export function validateAnnounceDeliveryParams(params) {
-    const { sessionKey, prompt, origin } = params;
-    if (!sessionKey || !sessionKey.trim()) {
-        return { valid: false, reason: "Missing or empty sessionKey" };
-    }
-    if (!prompt || !prompt.trim()) {
-        return { valid: false, reason: "Missing or empty prompt" };
-    }
-    // Origin is optional but if provided should be an object
-    if (origin !== undefined && origin !== null && typeof origin !== "object") {
-        return { valid: false, reason: "Origin must be an object if provided" };
-    }
-    return { valid: true };
-}
-const modelOverrides = new Map();
-/**
- * Set a session model override
- */
-export function setSessionModelOverride(params) {
-    const { sessionKey, model, ttlMs } = params;
-    const override = {
-        sessionKey,
-        model,
-        setAt: Date.now(),
-        expiresAt: ttlMs ? Date.now() + ttlMs : undefined,
-    };
-    modelOverrides.set(sessionKey, override);
-    return override;
-}
-/**
- * Get session model override (if not expired)
- */
-export function getSessionModelOverride(sessionKey) {
-    const override = modelOverrides.get(sessionKey);
-    if (!override) {
-        return undefined;
-    }
-    if (override.expiresAt && Date.now() > override.expiresAt) {
-        modelOverrides.delete(sessionKey);
-        return undefined;
-    }
-    return override;
-}
-/**
- * Clear session model override
- */
-export function clearSessionModelOverride(sessionKey) {
-    return modelOverrides.delete(sessionKey);
-}

package/dist/agents/subagent-registry.mocks.shared.js

@@ -1,12 +0,0 @@
-import { vi } from "vitest";
-const noop = () => { };
-vi.mock("../gateway/call.js", () => ({
-    callGateway: vi.fn(async () => ({
-        status: "ok",
-        startedAt: 111,
-        endedAt: 222,
-    })),
-}));
-vi.mock("../infra/agent-events.js", () => ({
-    onAgentEvent: vi.fn(() => noop),
-}));

package/dist/agents/test-helpers/assistant-message-fixtures.js

@@ -1,29 +0,0 @@
-const ZERO_USAGE = {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    totalTokens: 0,
-    cost: {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        total: 0,
-    },
-};
-export function makeAssistantMessageFixture(overrides = {}) {
-    const errorText = typeof overrides.errorMessage === "string" ? overrides.errorMessage : "error";
-    return {
-        role: "assistant",
-        api: "openai-responses",
-        provider: "openai",
-        model: "test-model",
-        usage: ZERO_USAGE,
-        timestamp: 0,
-        stopReason: "error",
-        errorMessage: errorText,
-        content: [{ type: "text", text: errorText }],
-        ...overrides,
-    };
-}

package/dist/agents/test-helpers/fast-coding-tools.js

@@ -1 +0,0 @@
-import "./fast-tool-stubs.js";

package/dist/agents/test-helpers/fast-core-tools.js

@@ -1,8 +0,0 @@
-import { vi } from "vitest";
-import { stubTool } from "./fast-tool-stubs.js";
-vi.mock("../tools/browser-tool.js", () => ({
-    createBrowserTool: () => stubTool("browser"),
-}));
-vi.mock("../tools/canvas-tool.js", () => ({
-    createCanvasTool: () => stubTool("canvas"),
-}));

package/dist/agents/test-helpers/fast-tool-stubs.js

@@ -1,18 +0,0 @@
-import { vi } from "vitest";
-export const stubTool = (name) => ({
-    name,
-    description: `${name} stub`,
-    parameters: { type: "object", properties: {} },
-    execute: vi.fn(),
-});
-vi.mock("../tools/image-tool.js", () => ({
-    createImageTool: () => stubTool("image"),
-}));
-vi.mock("../tools/web-tools.js", () => ({
-    createWebSearchTool: () => null,
-    createWebFetchTool: () => null,
-}));
-vi.mock("../../plugins/tools.js", () => ({
-    resolvePluginTools: () => [],
-    getPluginToolMeta: () => undefined,
-}));

package/dist/agents/test-helpers/host-sandbox-fs-bridge.js

@@ -1,74 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { resolveSandboxPath } from "../sandbox-paths.js";
-export function createSandboxFsBridgeFromResolver(resolvePath) {
-    return {
-        resolvePath: ({ filePath, cwd }) => resolvePath(filePath, cwd),
-        readFile: async ({ filePath, cwd }) => {
-            const target = resolvePath(filePath, cwd);
-            return fs.readFile(target.hostPath);
-        },
-        writeFile: async ({ filePath, cwd, data, mkdir = true }) => {
-            const target = resolvePath(filePath, cwd);
-            if (mkdir) {
-                await fs.mkdir(path.dirname(target.hostPath), { recursive: true });
-            }
-            const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
-            await fs.writeFile(target.hostPath, buffer);
-        },
-        mkdirp: async ({ filePath, cwd }) => {
-            const target = resolvePath(filePath, cwd);
-            await fs.mkdir(target.hostPath, { recursive: true });
-        },
-        remove: async ({ filePath, cwd, recursive, force }) => {
-            const target = resolvePath(filePath, cwd);
-            await fs.rm(target.hostPath, {
-                recursive: recursive ?? false,
-                force: force ?? false,
-            });
-        },
-        rename: async ({ from, to, cwd }) => {
-            const source = resolvePath(from, cwd);
-            const target = resolvePath(to, cwd);
-            await fs.mkdir(path.dirname(target.hostPath), { recursive: true });
-            await fs.rename(source.hostPath, target.hostPath);
-        },
-        stat: async ({ filePath, cwd }) => {
-            try {
-                const target = resolvePath(filePath, cwd);
-                const stats = await fs.stat(target.hostPath);
-                return {
-                    type: stats.isDirectory() ? "directory" : stats.isFile() ? "file" : "other",
-                    size: stats.size,
-                    mtimeMs: stats.mtimeMs,
-                };
-            }
-            catch (error) {
-                if (error.code === "ENOENT") {
-                    return null;
-                }
-                throw error;
-            }
-        },
-    };
-}
-export function createHostSandboxFsBridge(rootDir) {
-    const root = path.resolve(rootDir);
-    const resolvePath = (filePath, cwd) => {
-        const resolved = resolveSandboxPath({
-            filePath,
-            cwd: cwd ?? root,
-            root,
-        });
-        const relativePath = resolved.relative
-            ? resolved.relative.split(path.sep).filter(Boolean).join(path.posix.sep)
-            : "";
-        const containerPath = relativePath ? path.posix.join("/workspace", relativePath) : "/workspace";
-        return {
-            hostPath: resolved.resolved,
-            relativePath,
-            containerPath,
-        };
-    };
-    return createSandboxFsBridgeFromResolver(resolvePath);
-}