@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/agents/bash-process-registry.test-helpers.js

@@ -1,29 +0,0 @@
-export function createProcessSessionFixture(params) {
-    const session = {
-        id: params.id,
-        command: params.command ?? "test",
-        startedAt: params.startedAt ?? Date.now(),
-        cwd: params.cwd ?? "/tmp",
-        maxOutputChars: params.maxOutputChars ?? 10_000,
-        pendingMaxOutputChars: params.pendingMaxOutputChars ?? 30_000,
-        totalOutputChars: 0,
-        pendingStdout: [],
-        pendingStderr: [],
-        pendingStdoutChars: 0,
-        pendingStderrChars: 0,
-        aggregated: "",
-        tail: "",
-        exited: false,
-        exitCode: undefined,
-        exitSignal: undefined,
-        truncated: false,
-        backgrounded: params.backgrounded ?? false,
-    };
-    if (params.pid !== undefined) {
-        session.pid = params.pid;
-    }
-    if (params.child) {
-        session.child = params.child;
-    }
-    return session;
-}

package/dist/agents/bash-tools.exec-approval-request.js

@@ -1,20 +0,0 @@
-import { DEFAULT_APPROVAL_REQUEST_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, } from "./bash-tools.exec-runtime.js";
-import { callGatewayTool } from "./tools/gateway.js";
-export async function requestExecApprovalDecision(params) {
-    const decisionResult = await callGatewayTool("exec.approval.request", { timeoutMs: DEFAULT_APPROVAL_REQUEST_TIMEOUT_MS }, {
-        id: params.id,
-        command: params.command,
-        cwd: params.cwd,
-        host: params.host,
-        security: params.security,
-        ask: params.ask,
-        agentId: params.agentId,
-        resolvedPath: params.resolvedPath,
-        sessionKey: params.sessionKey,
-        timeoutMs: DEFAULT_APPROVAL_TIMEOUT_MS,
-    });
-    const decisionValue = decisionResult && typeof decisionResult === "object"
-        ? decisionResult.decision
-        : undefined;
-    return typeof decisionValue === "string" ? decisionValue : null;
-}

package/dist/agents/bash-tools.exec-host-gateway.js

@@ -1,240 +0,0 @@
-import crypto from "node:crypto";
-import { addAllowlistEntry, buildSafeBinsShellCommand, buildSafeShellCommand, evaluateShellAllowlist, maxAsk, minSecurity, recordAllowlistUse, requiresExecApproval, resolveAllowAlwaysPatterns, resolveExecApprovals, } from "../infra/exec-approvals.js";
-import { markBackgrounded, tail } from "./bash-process-registry.js";
-import { requestExecApprovalDecision } from "./bash-tools.exec-approval-request.js";
-import { DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_NOTIFY_TAIL_CHARS, createApprovalSlug, emitExecSystemEvent, normalizeNotifyOutput, runExecProcess, } from "./bash-tools.exec-runtime.js";
-export async function processGatewayAllowlist(params) {
-    const approvals = resolveExecApprovals(params.agentId, {
-        security: params.security,
-        ask: params.ask,
-    });
-    const hostSecurity = minSecurity(params.security, approvals.agent.security);
-    const hostAsk = maxAsk(params.ask, approvals.agent.ask);
-    const askFallback = approvals.agent.askFallback;
-    if (hostSecurity === "deny") {
-        throw new Error("exec denied: host=gateway security=deny");
-    }
-    const allowlistEval = evaluateShellAllowlist({
-        command: params.command,
-        allowlist: approvals.allowlist,
-        safeBins: params.safeBins,
-        cwd: params.workdir,
-        env: params.env,
-        platform: process.platform,
-        trustedSafeBinDirs: params.trustedSafeBinDirs,
-    });
-    const allowlistMatches = allowlistEval.allowlistMatches;
-    const analysisOk = allowlistEval.analysisOk;
-    const allowlistSatisfied = hostSecurity === "allowlist" && analysisOk ? allowlistEval.allowlistSatisfied : false;
-    const hasHeredocSegment = allowlistEval.segments.some((segment) => segment.argv.some((token) => token.startsWith("<<")));
-    const requiresHeredocApproval = hostSecurity === "allowlist" && analysisOk && allowlistSatisfied && hasHeredocSegment;
-    const requiresAsk = requiresExecApproval({
-        ask: hostAsk,
-        security: hostSecurity,
-        analysisOk,
-        allowlistSatisfied,
-    }) || requiresHeredocApproval;
-    if (requiresHeredocApproval) {
-        params.warnings.push("Warning: heredoc execution requires explicit approval in allowlist mode.");
-    }
-    if (requiresAsk) {
-        const approvalId = crypto.randomUUID();
-        const approvalSlug = createApprovalSlug(approvalId);
-        const expiresAtMs = Date.now() + DEFAULT_APPROVAL_TIMEOUT_MS;
-        const contextKey = `exec:${approvalId}`;
-        const resolvedPath = allowlistEval.segments[0]?.resolution?.resolvedPath;
-        const noticeSeconds = Math.max(1, Math.round(params.approvalRunningNoticeMs / 1000));
-        const effectiveTimeout = typeof params.timeoutSec === "number" ? params.timeoutSec : params.defaultTimeoutSec;
-        const warningText = params.warnings.length ? `${params.warnings.join("\n")}\n\n` : "";
-        void (async () => {
-            let decision = null;
-            try {
-                decision = await requestExecApprovalDecision({
-                    id: approvalId,
-                    command: params.command,
-                    cwd: params.workdir,
-                    host: "gateway",
-                    security: hostSecurity,
-                    ask: hostAsk,
-                    agentId: params.agentId,
-                    resolvedPath,
-                    sessionKey: params.sessionKey,
-                });
-            }
-            catch {
-                emitExecSystemEvent(`Exec denied (gateway id=${approvalId}, approval-request-failed): ${params.command}`, {
-                    sessionKey: params.notifySessionKey,
-                    contextKey,
-                });
-                return;
-            }
-            let approvedByAsk = false;
-            let deniedReason = null;
-            if (decision === "deny") {
-                deniedReason = "user-denied";
-            }
-            else if (!decision) {
-                if (askFallback === "full") {
-                    approvedByAsk = true;
-                }
-                else if (askFallback === "allowlist") {
-                    if (!analysisOk || !allowlistSatisfied) {
-                        deniedReason = "approval-timeout (allowlist-miss)";
-                    }
-                    else {
-                        approvedByAsk = true;
-                    }
-                }
-                else {
-                    deniedReason = "approval-timeout";
-                }
-            }
-            else if (decision === "allow-once") {
-                approvedByAsk = true;
-            }
-            else if (decision === "allow-always") {
-                approvedByAsk = true;
-                if (hostSecurity === "allowlist") {
-                    const patterns = resolveAllowAlwaysPatterns({
-                        segments: allowlistEval.segments,
-                        cwd: params.workdir,
-                        env: params.env,
-                        platform: process.platform,
-                    });
-                    for (const pattern of patterns) {
-                        if (pattern) {
-                            addAllowlistEntry(approvals.file, params.agentId, pattern);
-                        }
-                    }
-                }
-            }
-            if (hostSecurity === "allowlist" && (!analysisOk || !allowlistSatisfied) && !approvedByAsk) {
-                deniedReason = deniedReason ?? "allowlist-miss";
-            }
-            if (deniedReason) {
-                emitExecSystemEvent(`Exec denied (gateway id=${approvalId}, ${deniedReason}): ${params.command}`, {
-                    sessionKey: params.notifySessionKey,
-                    contextKey,
-                });
-                return;
-            }
-            if (allowlistMatches.length > 0) {
-                const seen = new Set();
-                for (const match of allowlistMatches) {
-                    if (seen.has(match.pattern)) {
-                        continue;
-                    }
-                    seen.add(match.pattern);
-                    recordAllowlistUse(approvals.file, params.agentId, match, params.command, resolvedPath ?? undefined);
-                }
-            }
-            let run = null;
-            try {
-                run = await runExecProcess({
-                    command: params.command,
-                    workdir: params.workdir,
-                    env: params.env,
-                    sandbox: undefined,
-                    containerWorkdir: null,
-                    usePty: params.pty,
-                    warnings: params.warnings,
-                    maxOutput: params.maxOutput,
-                    pendingMaxOutput: params.pendingMaxOutput,
-                    notifyOnExit: false,
-                    notifyOnExitEmptySuccess: false,
-                    scopeKey: params.scopeKey,
-                    sessionKey: params.notifySessionKey,
-                    timeoutSec: effectiveTimeout,
-                });
-            }
-            catch {
-                emitExecSystemEvent(`Exec denied (gateway id=${approvalId}, spawn-failed): ${params.command}`, {
-                    sessionKey: params.notifySessionKey,
-                    contextKey,
-                });
-                return;
-            }
-            markBackgrounded(run.session);
-            let runningTimer = null;
-            if (params.approvalRunningNoticeMs > 0) {
-                runningTimer = setTimeout(() => {
-                    emitExecSystemEvent(`Exec running (gateway id=${approvalId}, session=${run?.session.id}, >${noticeSeconds}s): ${params.command}`, { sessionKey: params.notifySessionKey, contextKey });
-                }, params.approvalRunningNoticeMs);
-            }
-            const outcome = await run.promise;
-            if (runningTimer) {
-                clearTimeout(runningTimer);
-            }
-            const output = normalizeNotifyOutput(tail(outcome.aggregated || "", DEFAULT_NOTIFY_TAIL_CHARS));
-            const exitLabel = outcome.timedOut ? "timeout" : `code ${outcome.exitCode ?? "?"}`;
-            const summary = output
-                ? `Exec finished (gateway id=${approvalId}, session=${run.session.id}, ${exitLabel})\n${output}`
-                : `Exec finished (gateway id=${approvalId}, session=${run.session.id}, ${exitLabel})`;
-            emitExecSystemEvent(summary, { sessionKey: params.notifySessionKey, contextKey });
-        })();
-        return {
-            pendingResult: {
-                content: [
-                    {
-                        type: "text",
-                        text: `${warningText}Approval required (id ${approvalSlug}). ` +
-                            "Approve to run; updates will arrive after completion.",
-                    },
-                ],
-                details: {
-                    status: "approval-pending",
-                    approvalId,
-                    approvalSlug,
-                    expiresAtMs,
-                    host: "gateway",
-                    command: params.command,
-                    cwd: params.workdir,
-                },
-            },
-        };
-    }
-    if (hostSecurity === "allowlist" && (!analysisOk || !allowlistSatisfied)) {
-        throw new Error("exec denied: allowlist miss");
-    }
-    let execCommandOverride;
-    // If allowlist uses safeBins, sanitize only those stdin-only segments:
-    // disable glob/var expansion by forcing argv tokens to be literal via single-quoting.
-    if (hostSecurity === "allowlist" &&
-        analysisOk &&
-        allowlistSatisfied &&
-        allowlistEval.segmentSatisfiedBy.some((by) => by === "safeBins")) {
-        const safe = buildSafeBinsShellCommand({
-            command: params.command,
-            segments: allowlistEval.segments,
-            segmentSatisfiedBy: allowlistEval.segmentSatisfiedBy,
-            platform: process.platform,
-        });
-        if (!safe.ok || !safe.command) {
-            // Fallback: quote everything (safe, but may change glob behavior).
-            const fallback = buildSafeShellCommand({
-                command: params.command,
-                platform: process.platform,
-            });
-            if (!fallback.ok || !fallback.command) {
-                throw new Error(`exec denied: safeBins sanitize failed (${safe.reason ?? "unknown"})`);
-            }
-            params.warnings.push("Warning: safeBins hardening used fallback quoting due to parser mismatch.");
-            execCommandOverride = fallback.command;
-        }
-        else {
-            params.warnings.push("Warning: safeBins hardening disabled glob/variable expansion for stdin-only segments.");
-            execCommandOverride = safe.command;
-        }
-    }
-    if (allowlistMatches.length > 0) {
-        const seen = new Set();
-        for (const match of allowlistMatches) {
-            if (seen.has(match.pattern)) {
-                continue;
-            }
-            seen.add(match.pattern);
-            recordAllowlistUse(approvals.file, params.agentId, match, params.command, allowlistEval.segments[0]?.resolution?.resolvedPath);
-        }
-    }
-    return { execCommandOverride };
-}

package/dist/agents/bash-tools.exec-host-node.js

@@ -1,235 +0,0 @@
-import crypto from "node:crypto";
-import { evaluateShellAllowlist, maxAsk, minSecurity, requiresExecApproval, resolveExecApprovals, resolveExecApprovalsFromFile, } from "../infra/exec-approvals.js";
-import { buildNodeShellCommand } from "../infra/node-shell.js";
-import { requestExecApprovalDecision } from "./bash-tools.exec-approval-request.js";
-import { DEFAULT_APPROVAL_TIMEOUT_MS, createApprovalSlug, emitExecSystemEvent, } from "./bash-tools.exec-runtime.js";
-import { callGatewayTool } from "./tools/gateway.js";
-import { listNodes, resolveNodeIdFromList } from "./tools/nodes-utils.js";
-export async function executeNodeHostCommand(params) {
-    const approvals = resolveExecApprovals(params.agentId, {
-        security: params.security,
-        ask: params.ask,
-    });
-    const hostSecurity = minSecurity(params.security, approvals.agent.security);
-    const hostAsk = maxAsk(params.ask, approvals.agent.ask);
-    const askFallback = approvals.agent.askFallback;
-    if (hostSecurity === "deny") {
-        throw new Error("exec denied: host=node security=deny");
-    }
-    if (params.boundNode && params.requestedNode && params.boundNode !== params.requestedNode) {
-        throw new Error(`exec node not allowed (bound to ${params.boundNode})`);
-    }
-    const nodeQuery = params.boundNode || params.requestedNode;
-    const nodes = await listNodes({});
-    if (nodes.length === 0) {
-        throw new Error("exec host=node requires a paired node (none available). This requires a companion app or node host.");
-    }
-    let nodeId;
-    try {
-        nodeId = resolveNodeIdFromList(nodes, nodeQuery, !nodeQuery);
-    }
-    catch (err) {
-        if (!nodeQuery && String(err).includes("node required")) {
-            throw new Error("exec host=node requires a node id when multiple nodes are available (set tools.exec.node or exec.node).", { cause: err });
-        }
-        throw err;
-    }
-    const nodeInfo = nodes.find((entry) => entry.nodeId === nodeId);
-    const supportsSystemRun = Array.isArray(nodeInfo?.commands)
-        ? nodeInfo?.commands?.includes("system.run")
-        : false;
-    if (!supportsSystemRun) {
-        throw new Error("exec host=node requires a node that supports system.run (companion app or node host).");
-    }
-    const argv = buildNodeShellCommand(params.command, nodeInfo?.platform);
-    const nodeEnv = params.requestedEnv ? { ...params.requestedEnv } : undefined;
-    const baseAllowlistEval = evaluateShellAllowlist({
-        command: params.command,
-        allowlist: [],
-        safeBins: new Set(),
-        cwd: params.workdir,
-        env: params.env,
-        platform: nodeInfo?.platform,
-        trustedSafeBinDirs: params.trustedSafeBinDirs,
-    });
-    let analysisOk = baseAllowlistEval.analysisOk;
-    let allowlistSatisfied = false;
-    if (hostAsk === "on-miss" && hostSecurity === "allowlist" && analysisOk) {
-        try {
-            const approvalsSnapshot = await callGatewayTool("exec.approvals.node.get", { timeoutMs: 10_000 }, { nodeId });
-            const approvalsFile = approvalsSnapshot && typeof approvalsSnapshot === "object"
-                ? approvalsSnapshot.file
-                : undefined;
-            if (approvalsFile && typeof approvalsFile === "object") {
-                const resolved = resolveExecApprovalsFromFile({
-                    file: approvalsFile,
-                    agentId: params.agentId,
-                    overrides: { security: "allowlist" },
-                });
-                // Allowlist-only precheck; safe bins are node-local and may diverge.
-                const allowlistEval = evaluateShellAllowlist({
-                    command: params.command,
-                    allowlist: resolved.allowlist,
-                    safeBins: new Set(),
-                    cwd: params.workdir,
-                    env: params.env,
-                    platform: nodeInfo?.platform,
-                    trustedSafeBinDirs: params.trustedSafeBinDirs,
-                });
-                allowlistSatisfied = allowlistEval.allowlistSatisfied;
-                analysisOk = allowlistEval.analysisOk;
-            }
-        }
-        catch {
-            // Fall back to requiring approval if node approvals cannot be fetched.
-        }
-    }
-    const requiresAsk = requiresExecApproval({
-        ask: hostAsk,
-        security: hostSecurity,
-        analysisOk,
-        allowlistSatisfied,
-    });
-    const invokeTimeoutMs = Math.max(10_000, (typeof params.timeoutSec === "number" ? params.timeoutSec : params.defaultTimeoutSec) * 1000 +
-        5_000);
-    const buildInvokeParams = (approvedByAsk, approvalDecision, runId) => ({
-        nodeId,
-        command: "system.run",
-        params: {
-            command: argv,
-            rawCommand: params.command,
-            cwd: params.workdir,
-            env: nodeEnv,
-            timeoutMs: typeof params.timeoutSec === "number" ? params.timeoutSec * 1000 : undefined,
-            agentId: params.agentId,
-            sessionKey: params.sessionKey,
-            approved: approvedByAsk,
-            approvalDecision: approvalDecision ?? undefined,
-            runId: runId ?? undefined,
-        },
-        idempotencyKey: crypto.randomUUID(),
-    });
-    if (requiresAsk) {
-        const approvalId = crypto.randomUUID();
-        const approvalSlug = createApprovalSlug(approvalId);
-        const expiresAtMs = Date.now() + DEFAULT_APPROVAL_TIMEOUT_MS;
-        const contextKey = `exec:${approvalId}`;
-        const noticeSeconds = Math.max(1, Math.round(params.approvalRunningNoticeMs / 1000));
-        const warningText = params.warnings.length ? `${params.warnings.join("\n")}\n\n` : "";
-        void (async () => {
-            let decision = null;
-            try {
-                decision = await requestExecApprovalDecision({
-                    id: approvalId,
-                    command: params.command,
-                    cwd: params.workdir,
-                    host: "node",
-                    security: hostSecurity,
-                    ask: hostAsk,
-                    agentId: params.agentId,
-                    sessionKey: params.sessionKey,
-                });
-            }
-            catch {
-                emitExecSystemEvent(`Exec denied (node=${nodeId} id=${approvalId}, approval-request-failed): ${params.command}`, { sessionKey: params.notifySessionKey, contextKey });
-                return;
-            }
-            let approvedByAsk = false;
-            let approvalDecision = null;
-            let deniedReason = null;
-            if (decision === "deny") {
-                deniedReason = "user-denied";
-            }
-            else if (!decision) {
-                if (askFallback === "full") {
-                    approvedByAsk = true;
-                    approvalDecision = "allow-once";
-                }
-                else if (askFallback === "allowlist") {
-                    // Defer allowlist enforcement to the node host.
-                }
-                else {
-                    deniedReason = "approval-timeout";
-                }
-            }
-            else if (decision === "allow-once") {
-                approvedByAsk = true;
-                approvalDecision = "allow-once";
-            }
-            else if (decision === "allow-always") {
-                approvedByAsk = true;
-                approvalDecision = "allow-always";
-            }
-            if (deniedReason) {
-                emitExecSystemEvent(`Exec denied (node=${nodeId} id=${approvalId}, ${deniedReason}): ${params.command}`, {
-                    sessionKey: params.notifySessionKey,
-                    contextKey,
-                });
-                return;
-            }
-            let runningTimer = null;
-            if (params.approvalRunningNoticeMs > 0) {
-                runningTimer = setTimeout(() => {
-                    emitExecSystemEvent(`Exec running (node=${nodeId} id=${approvalId}, >${noticeSeconds}s): ${params.command}`, { sessionKey: params.notifySessionKey, contextKey });
-                }, params.approvalRunningNoticeMs);
-            }
-            try {
-                await callGatewayTool("node.invoke", { timeoutMs: invokeTimeoutMs }, buildInvokeParams(approvedByAsk, approvalDecision, approvalId));
-            }
-            catch {
-                emitExecSystemEvent(`Exec denied (node=${nodeId} id=${approvalId}, invoke-failed): ${params.command}`, {
-                    sessionKey: params.notifySessionKey,
-                    contextKey,
-                });
-            }
-            finally {
-                if (runningTimer) {
-                    clearTimeout(runningTimer);
-                }
-            }
-        })();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `${warningText}Approval required (id ${approvalSlug}). ` +
-                        "Approve to run; updates will arrive after completion.",
-                },
-            ],
-            details: {
-                status: "approval-pending",
-                approvalId,
-                approvalSlug,
-                expiresAtMs,
-                host: "node",
-                command: params.command,
-                cwd: params.workdir,
-                nodeId,
-            },
-        };
-    }
-    const startedAt = Date.now();
-    const raw = await callGatewayTool("node.invoke", { timeoutMs: invokeTimeoutMs }, buildInvokeParams(false, null));
-    const payload = raw && typeof raw === "object" ? raw.payload : undefined;
-    const payloadObj = payload && typeof payload === "object" ? payload : {};
-    const stdout = typeof payloadObj.stdout === "string" ? payloadObj.stdout : "";
-    const stderr = typeof payloadObj.stderr === "string" ? payloadObj.stderr : "";
-    const errorText = typeof payloadObj.error === "string" ? payloadObj.error : "";
-    const success = typeof payloadObj.success === "boolean" ? payloadObj.success : false;
-    const exitCode = typeof payloadObj.exitCode === "number" ? payloadObj.exitCode : null;
-    return {
-        content: [
-            {
-                type: "text",
-                text: stdout || stderr || errorText || "",
-            },
-        ],
-        details: {
-            status: success ? "completed" : "failed",
-            exitCode,
-            durationMs: Date.now() - startedAt,
-            aggregated: [stdout, stderr, errorText].filter(Boolean).join("\n"),
-            cwd: params.workdir,
-        },
-    };
-}