@poolzin/pool-bot 2026.3.4 → 2026.3.6

package/dist/gateway/server-channels.js

@@ -1,8 +1,16 @@
 import { resolveChannelDefaultAccountId } from "../channels/plugins/helpers.js";
 import { getChannelPlugin, listChannelPlugins } from "../channels/plugins/index.js";
+import { computeBackoff, sleepWithAbort } from "../infra/backoff.js";
 import { formatErrorMessage } from "../infra/errors.js";
 import { resetDirectoryCache } from "../infra/outbound/target-resolver.js";
 import { DEFAULT_ACCOUNT_ID } from "../routing/session-key.js";
+const CHANNEL_RESTART_POLICY = {
+    initialMs: 5_000,
+    maxMs: 5 * 60_000,
+    factor: 2,
+    jitter: 0.1,
+};
+const MAX_RESTART_ATTEMPTS = 10;
 function createRuntimeStore() {
     return {
         aborts: new Map(),
@@ -11,8 +19,9 @@ function createRuntimeStore() {
     };
 }
 function isAccountEnabled(account) {
-    if (!account || typeof account !== "object")
+    if (!account || typeof account !== "object") {
         return true;
+    }
     const enabled = account.enabled;
     return enabled !== false;
 }
@@ -25,15 +34,18 @@ function cloneDefaultRuntime(channelId, accountId) {
 }
 // Channel docking: lifecycle hooks (`plugin.gateway`) flow through this manager.
 export function createChannelManager(opts) {
-    const { loadConfig, channelLogs, channelRuntimeEnvs } = opts;
+    const { loadConfig, channelLogs, channelRuntimeEnvs, channelRuntime } = opts;
     const channelStores = new Map();
+    // Tracks restart attempts per channel:account. Reset on successful start.
     const restartAttempts = new Map();
+    // Tracks accounts that were manually stopped so we don't auto-restart them.
     const manuallyStopped = new Set();
     const restartKey = (channelId, accountId) => `${channelId}:${accountId}`;
     const getStore = (channelId) => {
         const existing = channelStores.get(channelId);
-        if (existing)
+        if (existing) {
             return existing;
+        }
         const next = createRuntimeStore();
         channelStores.set(channelId, next);
         return next;
@@ -49,20 +61,24 @@ export function createChannelManager(opts) {
         store.runtimes.set(accountId, next);
         return next;
     };
-    const startChannel = async (channelId, accountId) => {
+    const startChannelInternal = async (channelId, accountId, opts = {}) => {
         const plugin = getChannelPlugin(channelId);
         const startAccount = plugin?.gateway?.startAccount;
-        if (!startAccount)
+        if (!startAccount) {
             return;
+        }
+        const { preserveRestartAttempts = false, preserveManualStop = false } = opts;
         const cfg = loadConfig();
         resetDirectoryCache({ channel: channelId, accountId });
         const store = getStore(channelId);
         const accountIds = accountId ? [accountId] : plugin.config.listAccountIds(cfg);
-        if (accountIds.length === 0)
+        if (accountIds.length === 0) {
             return;
+        }
         await Promise.all(accountIds.map(async (id) => {
-            if (store.tasks.has(id))
+            if (store.tasks.has(id)) {
                 return;
+            }
             const account = plugin.config.resolveAccount(cfg, id);
             const enabled = plugin.config.isEnabled
                 ? plugin.config.isEnabled(account, cfg)
@@ -70,6 +86,8 @@ export function createChannelManager(opts) {
             if (!enabled) {
                 setRuntime(channelId, id, {
                     accountId: id,
+                    enabled: false,
+                    configured: true,
                     running: false,
                     lastError: plugin.config.disabledReason?.(account, cfg) ?? "disabled",
                 });
@@ -82,18 +100,30 @@ export function createChannelManager(opts) {
             if (!configured) {
                 setRuntime(channelId, id, {
                     accountId: id,
+                    enabled: true,
+                    configured: false,
                     running: false,
                     lastError: plugin.config.unconfiguredReason?.(account, cfg) ?? "not configured",
                 });
                 return;
             }
+            const rKey = restartKey(channelId, id);
+            if (!preserveManualStop) {
+                manuallyStopped.delete(rKey);
+            }
             const abort = new AbortController();
             store.aborts.set(id, abort);
+            if (!preserveRestartAttempts) {
+                restartAttempts.delete(rKey);
+            }
             setRuntime(channelId, id, {
                 accountId: id,
+                enabled: true,
+                configured: true,
                 running: true,
                 lastStartAt: Date.now(),
                 lastError: null,
+                reconnectAttempts: preserveRestartAttempts ? (restartAttempts.get(rKey) ?? 0) : 0,
             });
             const log = channelLogs[channelId];
             const task = startAccount({
@@ -105,29 +135,79 @@ export function createChannelManager(opts) {
                 log,
                 getStatus: () => getRuntime(channelId, id),
                 setStatus: (next) => setRuntime(channelId, id, next),
+                ...(channelRuntime ? { channelRuntime } : {}),
             });
-            const tracked = Promise.resolve(task)
+            const trackedPromise = Promise.resolve(task)
                 .catch((err) => {
                 const message = formatErrorMessage(err);
                 setRuntime(channelId, id, { accountId: id, lastError: message });
                 log.error?.(`[${id}] channel exited: ${message}`);
             })
                 .finally(() => {
-                store.aborts.delete(id);
-                store.tasks.delete(id);
                 setRuntime(channelId, id, {
                     accountId: id,
                     running: false,
                     lastStopAt: Date.now(),
                 });
+            })
+                .then(async () => {
+                if (manuallyStopped.has(rKey)) {
+                    return;
+                }
+                const attempt = (restartAttempts.get(rKey) ?? 0) + 1;
+                restartAttempts.set(rKey, attempt);
+                if (attempt > MAX_RESTART_ATTEMPTS) {
+                    log.error?.(`[${id}] giving up after ${MAX_RESTART_ATTEMPTS} restart attempts`);
+                    return;
+                }
+                const delayMs = computeBackoff(CHANNEL_RESTART_POLICY, attempt);
+                log.info?.(`[${id}] auto-restart attempt ${attempt}/${MAX_RESTART_ATTEMPTS} in ${Math.round(delayMs / 1000)}s`);
+                setRuntime(channelId, id, {
+                    accountId: id,
+                    reconnectAttempts: attempt,
+                });
+                try {
+                    await sleepWithAbort(delayMs, abort.signal);
+                    if (manuallyStopped.has(rKey)) {
+                        return;
+                    }
+                    if (store.tasks.get(id) === trackedPromise) {
+                        store.tasks.delete(id);
+                    }
+                    if (store.aborts.get(id) === abort) {
+                        store.aborts.delete(id);
+                    }
+                    await startChannelInternal(channelId, id, {
+                        preserveRestartAttempts: true,
+                        preserveManualStop: true,
+                    });
+                }
+                catch {
+                    // abort or startup failure — next crash will retry
+                }
+            })
+                .finally(() => {
+                if (store.tasks.get(id) === trackedPromise) {
+                    store.tasks.delete(id);
+                }
+                if (store.aborts.get(id) === abort) {
+                    store.aborts.delete(id);
+                }
             });
-            store.tasks.set(id, tracked);
+            store.tasks.set(id, trackedPromise);
         }));
     };
+    const startChannel = async (channelId, accountId) => {
+        await startChannelInternal(channelId, accountId);
+    };
     const stopChannel = async (channelId, accountId) => {
         const plugin = getChannelPlugin(channelId);
-        const cfg = loadConfig();
         const store = getStore(channelId);
+        // Fast path: nothing running and no explicit plugin shutdown hook to run.
+        if (!plugin?.gateway?.stopAccount && store.aborts.size === 0 && store.tasks.size === 0) {
+            return;
+        }
+        const cfg = loadConfig();
         const knownIds = new Set([
             ...store.aborts.keys(),
             ...store.tasks.keys(),
@@ -140,8 +220,10 @@ export function createChannelManager(opts) {
         await Promise.all(Array.from(knownIds.values()).map(async (id) => {
             const abort = store.aborts.get(id);
             const task = store.tasks.get(id);
-            if (!abort && !task && !plugin?.gateway?.stopAccount)
+            if (!abort && !task && !plugin?.gateway?.stopAccount) {
                 return;
+            }
+            manuallyStopped.add(restartKey(channelId, id));
             abort?.abort();
             if (plugin?.gateway?.stopAccount) {
                 const account = plugin.config.resolveAccount(cfg, id);
@@ -178,8 +260,9 @@ export function createChannelManager(opts) {
     };
     const markChannelLoggedOut = (channelId, cleared, accountId) => {
         const plugin = getChannelPlugin(channelId);
-        if (!plugin)
+        if (!plugin) {
             return;
+        }
         const cfg = loadConfig();
         const resolvedId = accountId ??
             resolveChannelDefaultAccountId({
@@ -219,6 +302,8 @@ export function createChannelManager(opts) {
                 const configured = described?.configured;
                 const current = store.runtimes.get(id) ?? cloneDefaultRuntime(plugin.id, id);
                 const next = { ...current, accountId: id };
+                next.enabled = enabled;
+                next.configured = typeof configured === "boolean" ? configured : (next.configured ?? true);
                 if (!next.running) {
                     if (!enabled) {
                         next.lastError ??= plugin.config.disabledReason?.(account, cfg) ?? "disabled";

package/dist/gateway/server-cron.js

@@ -224,6 +224,95 @@ export function buildGatewayCronService(params) {
                         }
                     })();
                 }
+                // --- onFailure alert ---
+                if (evt.status === "error" && job?.onFailure && job.onFailure.mode !== "none") {
+                    if (job.onFailure.mode === "webhook") {
+                        const failureUrl = normalizeHttpWebhookUrl(job.onFailure.to);
+                        if (failureUrl) {
+                            const failureHeaders = {
+                                "Content-Type": "application/json",
+                            };
+                            if (webhookToken) {
+                                failureHeaders.Authorization = `Bearer ${webhookToken}`;
+                            }
+                            const failureAbort = new AbortController();
+                            const failureTimeout = setTimeout(() => {
+                                failureAbort.abort();
+                            }, CRON_WEBHOOK_TIMEOUT_MS);
+                            void (async () => {
+                                try {
+                                    const result = await fetchWithSsrFGuard({
+                                        url: failureUrl,
+                                        init: {
+                                            method: "POST",
+                                            headers: failureHeaders,
+                                            body: JSON.stringify({ ...evt, alertKind: "onFailure" }),
+                                            signal: failureAbort.signal,
+                                        },
+                                    });
+                                    await result.release();
+                                }
+                                catch (err) {
+                                    if (job.onFailure?.bestEffort) {
+                                        cronLogger.debug({
+                                            err: formatErrorMessage(err),
+                                            jobId: evt.jobId,
+                                            webhookUrl: redactWebhookUrl(failureUrl),
+                                        }, "cron: onFailure webhook silenced (bestEffort)");
+                                    }
+                                    else if (err instanceof SsrFBlockedError) {
+                                        cronLogger.warn({
+                                            reason: formatErrorMessage(err),
+                                            jobId: evt.jobId,
+                                            webhookUrl: redactWebhookUrl(failureUrl),
+                                        }, "cron: onFailure webhook blocked by SSRF guard");
+                                    }
+                                    else {
+                                        cronLogger.warn({
+                                            err: formatErrorMessage(err),
+                                            jobId: evt.jobId,
+                                            webhookUrl: redactWebhookUrl(failureUrl),
+                                        }, "cron: onFailure webhook delivery failed");
+                                    }
+                                }
+                                finally {
+                                    clearTimeout(failureTimeout);
+                                }
+                            })();
+                        }
+                        else {
+                            cronLogger.warn({ jobId: evt.jobId, onFailureTo: job.onFailure.to }, "cron: skipped onFailure webhook, onFailure.to must be a valid http(s) URL");
+                        }
+                    }
+                    else if (job.onFailure.mode === "announce") {
+                        const failureMsg = `[Cron failure] Job "${job.name ?? job.id}" failed: ${evt.error ?? "unknown error"}`;
+                        try {
+                            const { agentId, cfg: runtimeConfig } = resolveCronAgent(job.agentId);
+                            const sessionKey = resolveCronSessionKey({
+                                runtimeConfig,
+                                agentId,
+                                requestedSessionKey: job.sessionKey,
+                            });
+                            enqueueSystemEvent(failureMsg, {
+                                sessionKey,
+                                contextKey: `cron:${job.id}:onFailure`,
+                            });
+                            requestHeartbeatNow({
+                                reason: `cron:${job.id}:onFailure`,
+                                agentId,
+                                sessionKey,
+                            });
+                        }
+                        catch (err) {
+                            if (job.onFailure.bestEffort) {
+                                cronLogger.debug({ err: formatErrorMessage(err), jobId: evt.jobId }, "cron: onFailure announce silenced (bestEffort)");
+                            }
+                            else {
+                                cronLogger.warn({ err: formatErrorMessage(err), jobId: evt.jobId }, "cron: onFailure announce failed");
+                            }
+                        }
+                    }
+                }
                 const logPath = resolveCronRunLogPath({
                     storePath,
                     jobId: evt.jobId,

package/dist/gateway/server-health-probes.js

@@ -0,0 +1,55 @@
+/**
+ * HTTP health probe endpoints for container orchestrators (Docker, Kubernetes).
+ *
+ * Paths:
+ *   /health, /healthz — Liveness probe. Returns 200 if the process is running.
+ *   /ready, /readyz   — Readiness probe. Returns 200 when the gateway has a
+ *                        cached health snapshot (channels probed at least once),
+ *                        503 otherwise.
+ *
+ * These endpoints run *before* any authentication so orchestrators can probe
+ * without credentials.
+ */
+import { sendJson } from "./http-common.js";
+import { getHealthCache } from "./server/health-state.js";
+const LIVENESS_PATHS = new Set(["/health", "/healthz"]);
+const READINESS_PATHS = new Set(["/ready", "/readyz"]);
+/**
+ * Attempt to handle an HTTP health probe request.
+ *
+ * @returns `true` if the request was handled (caller should stop processing),
+ *          `false` if the path is not a health probe.
+ */
+export function handleHealthProbe(req, res) {
+    const url = req.url ?? "/";
+    // Fast path: skip URL parsing for the common non-probe case.
+    if (!url.startsWith("/health") && !url.startsWith("/ready")) {
+        return false;
+    }
+    const pathname = new URL(url, "http://localhost").pathname;
+    if (LIVENESS_PATHS.has(pathname)) {
+        sendJson(res, 200, {
+            status: "ok",
+            uptime: Math.round(process.uptime()),
+        });
+        return true;
+    }
+    if (READINESS_PATHS.has(pathname)) {
+        const cached = getHealthCache();
+        if (cached) {
+            sendJson(res, 200, {
+                status: "ok",
+                uptime: Math.round(process.uptime()),
+                ts: cached.ts,
+            });
+        }
+        else {
+            sendJson(res, 503, {
+                status: "unavailable",
+                reason: "health snapshot not yet available",
+            });
+        }
+        return true;
+    }
+    return false;
+}

package/dist/gateway/server-http.js

@@ -15,6 +15,7 @@ import { getBearerToken } from "./http-utils.js";
 import { handleOpenAiHttpRequest } from "./openai-http.js";
 import { handleOpenResponsesHttpRequest } from "./openresponses-http.js";
 import { GATEWAY_CLIENT_MODES, normalizeGatewayClientMode } from "./protocol/client-info.js";
+import { handleHealthProbe } from "./server-health-probes.js";
 import { handleToolsInvokeHttpRequest } from "./tools-invoke-http.js";
 const HOOK_AUTH_FAILURE_LIMIT = 20;
 const HOOK_AUTH_FAILURE_WINDOW_MS = 60_000;
@@ -344,6 +345,10 @@ export function createGatewayHttpServer(opts) {
         if (String(req.headers.upgrade ?? "").toLowerCase() === "websocket") {
             return;
         }
+        // HTTP health probes run before auth so orchestrators can probe without credentials.
+        if (handleHealthProbe(req, res)) {
+            return;
+        }
         try {
             const configSnapshot = loadConfig();
             const trustedProxies = configSnapshot.gateway?.trustedProxies ?? [];

package/dist/hooks/bundled/session-memory/handler.js

@@ -9,6 +9,7 @@ import os from "node:os";
 import path from "node:path";
 import { resolveAgentWorkspaceDir } from "../../../agents/agent-scope.js";
 import { resolveStateDir } from "../../../config/paths.js";
+import { writeFileWithinRoot } from "../../../infra/fs-safe.js";
 import { createSubsystemLogger } from "../../../logging/subsystem.js";
 import { resolveAgentIdFromSessionKey } from "../../../routing/session-key.js";
 import { hasInterSessionUserProvenance } from "../../../sessions/input-provenance.js";
@@ -249,8 +250,13 @@ const saveSessionToMemory = async (event) => {
             entryParts.push("## Conversation Summary", "", sessionContent, "");
         }
         const entry = entryParts.join("\n");
-        // Write to new memory file
-        await fs.writeFile(memoryFilePath, entry, "utf-8");
+        // Write under memory root with alias-safe file validation.
+        await writeFileWithinRoot({
+            rootDir: memoryDir,
+            relativePath: filename,
+            data: entry,
+            encoding: "utf-8",
+        });
         log.debug("Memory file written successfully");
         // Log completion (but don't send user-visible confirmation - it's internal housekeeping)
         const relPath = memoryFilePath.replace(os.homedir(), "~");

package/dist/infra/abort-signal.js

@@ -0,0 +1,12 @@
+export async function waitForAbortSignal(signal) {
+    if (!signal || signal.aborted) {
+        return;
+    }
+    await new Promise((resolve) => {
+        const onAbort = () => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/infra/boundary-file-read.js

@@ -0,0 +1,118 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveBoundaryPath, resolveBoundaryPathSync, } from "./boundary-path.js";
+import { openVerifiedFileSync, } from "./safe-open-sync.js";
+export function canUseBoundaryFileOpen(ioFs) {
+    return (typeof ioFs.openSync === "function" &&
+        typeof ioFs.closeSync === "function" &&
+        typeof ioFs.fstatSync === "function" &&
+        typeof ioFs.lstatSync === "function" &&
+        typeof ioFs.realpathSync === "function" &&
+        typeof ioFs.readFileSync === "function" &&
+        typeof ioFs.constants === "object" &&
+        ioFs.constants !== null);
+}
+export function openBoundaryFileSync(params) {
+    const ioFs = params.ioFs ?? fs;
+    const resolved = resolveBoundaryFilePathGeneric({
+        absolutePath: params.absolutePath,
+        resolve: (absolutePath) => resolveBoundaryPathSync({
+            absolutePath,
+            rootPath: params.rootPath,
+            rootCanonicalPath: params.rootRealPath,
+            boundaryLabel: params.boundaryLabel,
+            skipLexicalRootCheck: params.skipLexicalRootCheck,
+        }),
+    });
+    if (resolved instanceof Promise) {
+        return toBoundaryValidationError(new Error("Unexpected async boundary resolution"));
+    }
+    return finalizeBoundaryFileOpen({
+        resolved,
+        maxBytes: params.maxBytes,
+        rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType,
+        ioFs,
+    });
+}
+function openBoundaryFileResolved(params) {
+    const opened = openVerifiedFileSync({
+        filePath: params.absolutePath,
+        resolvedPath: params.resolvedPath,
+        rejectHardlinks: params.rejectHardlinks ?? true,
+        maxBytes: params.maxBytes,
+        allowedType: params.allowedType,
+        ioFs: params.ioFs,
+    });
+    if (!opened.ok) {
+        return opened;
+    }
+    return {
+        ok: true,
+        path: opened.path,
+        fd: opened.fd,
+        stat: opened.stat,
+        rootRealPath: params.rootRealPath,
+    };
+}
+function finalizeBoundaryFileOpen(params) {
+    if ("ok" in params.resolved) {
+        return params.resolved;
+    }
+    return openBoundaryFileResolved({
+        absolutePath: params.resolved.absolutePath,
+        resolvedPath: params.resolved.resolvedPath,
+        rootRealPath: params.resolved.rootRealPath,
+        maxBytes: params.maxBytes,
+        rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType,
+        ioFs: params.ioFs,
+    });
+}
+export async function openBoundaryFile(params) {
+    const ioFs = params.ioFs ?? fs;
+    const maybeResolved = resolveBoundaryFilePathGeneric({
+        absolutePath: params.absolutePath,
+        resolve: (absolutePath) => resolveBoundaryPath({
+            absolutePath,
+            rootPath: params.rootPath,
+            rootCanonicalPath: params.rootRealPath,
+            boundaryLabel: params.boundaryLabel,
+            policy: params.aliasPolicy,
+            skipLexicalRootCheck: params.skipLexicalRootCheck,
+        }),
+    });
+    const resolved = maybeResolved instanceof Promise ? await maybeResolved : maybeResolved;
+    return finalizeBoundaryFileOpen({
+        resolved,
+        maxBytes: params.maxBytes,
+        rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType,
+        ioFs,
+    });
+}
+function toBoundaryValidationError(error) {
+    return { ok: false, reason: "validation", error };
+}
+function mapResolvedBoundaryPath(absolutePath, resolved) {
+    return {
+        absolutePath,
+        resolvedPath: resolved.canonicalPath,
+        rootRealPath: resolved.rootCanonicalPath,
+    };
+}
+function resolveBoundaryFilePathGeneric(params) {
+    const absolutePath = path.resolve(params.absolutePath);
+    try {
+        const resolved = params.resolve(absolutePath);
+        if (resolved instanceof Promise) {
+            return resolved
+                .then((value) => mapResolvedBoundaryPath(absolutePath, value))
+                .catch((error) => toBoundaryValidationError(error));
+        }
+        return mapResolvedBoundaryPath(absolutePath, resolved);
+    }
+    catch (error) {
+        return toBoundaryValidationError(error);
+    }
+}