@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/cron/normalize.js

@@ -1,55 +1,298 @@
 import { sanitizeAgentId } from "../routing/session-key.js";
+import { isRecord } from "../utils.js";
 import { parseAbsoluteTimeMs } from "./parse.js";
 import { migrateLegacyCronPayload } from "./payload-migration.js";
+import { inferLegacyName } from "./service/normalize.js";
 const DEFAULT_OPTIONS = {
     applyDefaults: false,
 };
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function coerceSchedule(schedule) {
     const next = { ...schedule };
-    const kind = typeof schedule.kind === "string" ? schedule.kind : undefined;
+    const rawKind = typeof schedule.kind === "string" ? schedule.kind.trim().toLowerCase() : "";
+    const kind = rawKind === "at" || rawKind === "every" || rawKind === "cron" ? rawKind : undefined;
     const atMsRaw = schedule.atMs;
     const atRaw = schedule.at;
-    const parsedAtMs = typeof atMsRaw === "string"
-        ? parseAbsoluteTimeMs(atMsRaw)
-        : typeof atRaw === "string"
-            ? parseAbsoluteTimeMs(atRaw)
-            : null;
-    if (!kind) {
+    const atString = typeof atRaw === "string" ? atRaw.trim() : "";
+    const parsedAtMs = typeof atMsRaw === "number"
+        ? atMsRaw
+        : typeof atMsRaw === "string"
+            ? parseAbsoluteTimeMs(atMsRaw)
+            : atString
+                ? parseAbsoluteTimeMs(atString)
+                : null;
+    if (kind) {
+        next.kind = kind;
+    }
+    else {
         if (typeof schedule.atMs === "number" ||
             typeof schedule.at === "string" ||
-            typeof schedule.atMs === "string")
+            typeof schedule.atMs === "string") {
             next.kind = "at";
-        else if (typeof schedule.everyMs === "number")
+        }
+        else if (typeof schedule.everyMs === "number") {
             next.kind = "every";
-        else if (typeof schedule.expr === "string")
+        }
+        else if (typeof schedule.expr === "string") {
             next.kind = "cron";
+        }
+    }
+    if (atString) {
+        next.at = parsedAtMs !== null ? new Date(parsedAtMs).toISOString() : atString;
     }
-    if (typeof schedule.atMs !== "number" && parsedAtMs !== null) {
-        next.atMs = parsedAtMs;
+    else if (parsedAtMs !== null) {
+        next.at = new Date(parsedAtMs).toISOString();
+    }
+    if ("atMs" in next) {
+        delete next.atMs;
     }
-    if ("at" in next)
-        delete next.at;
     return next;
 }
 function coercePayload(payload) {
     const next = { ...payload };
     // Back-compat: older configs used `provider` for delivery channel.
     migrateLegacyCronPayload(next);
+    const kindRaw = typeof next.kind === "string" ? next.kind.trim().toLowerCase() : "";
+    if (kindRaw === "agentturn") {
+        next.kind = "agentTurn";
+    }
+    else if (kindRaw === "systemevent") {
+        next.kind = "systemEvent";
+    }
+    else if (kindRaw) {
+        next.kind = kindRaw;
+    }
+    if (!next.kind) {
+        const hasMessage = typeof next.message === "string" && next.message.trim().length > 0;
+        const hasText = typeof next.text === "string" && next.text.trim().length > 0;
+        if (hasMessage) {
+            next.kind = "agentTurn";
+        }
+        else if (hasText) {
+            next.kind = "systemEvent";
+        }
+    }
+    if (typeof next.message === "string") {
+        const trimmed = next.message.trim();
+        if (trimmed) {
+            next.message = trimmed;
+        }
+    }
+    if (typeof next.text === "string") {
+        const trimmed = next.text.trim();
+        if (trimmed) {
+            next.text = trimmed;
+        }
+    }
+    if ("model" in next) {
+        if (typeof next.model === "string") {
+            const trimmed = next.model.trim();
+            if (trimmed) {
+                next.model = trimmed;
+            }
+            else {
+                delete next.model;
+            }
+        }
+        else {
+            delete next.model;
+        }
+    }
+    if ("thinking" in next) {
+        if (typeof next.thinking === "string") {
+            const trimmed = next.thinking.trim();
+            if (trimmed) {
+                next.thinking = trimmed;
+            }
+            else {
+                delete next.thinking;
+            }
+        }
+        else {
+            delete next.thinking;
+        }
+    }
+    if ("timeoutSeconds" in next) {
+        if (typeof next.timeoutSeconds === "number" && Number.isFinite(next.timeoutSeconds)) {
+            next.timeoutSeconds = Math.max(1, Math.floor(next.timeoutSeconds));
+        }
+        else {
+            delete next.timeoutSeconds;
+        }
+    }
+    if ("allowUnsafeExternalContent" in next &&
+        typeof next.allowUnsafeExternalContent !== "boolean") {
+        delete next.allowUnsafeExternalContent;
+    }
     return next;
 }
+function coerceDelivery(delivery) {
+    const next = { ...delivery };
+    if (typeof delivery.mode === "string") {
+        const mode = delivery.mode.trim().toLowerCase();
+        if (mode === "deliver") {
+            next.mode = "announce";
+        }
+        else if (mode === "announce" || mode === "none") {
+            next.mode = mode;
+        }
+        else {
+            delete next.mode;
+        }
+    }
+    else if ("mode" in next) {
+        delete next.mode;
+    }
+    if (typeof delivery.channel === "string") {
+        const trimmed = delivery.channel.trim().toLowerCase();
+        if (trimmed) {
+            next.channel = trimmed;
+        }
+        else {
+            delete next.channel;
+        }
+    }
+    if (typeof delivery.to === "string") {
+        const trimmed = delivery.to.trim();
+        if (trimmed) {
+            next.to = trimmed;
+        }
+        else {
+            delete next.to;
+        }
+    }
+    return next;
+}
+function hasLegacyDeliveryHints(payload) {
+    if (typeof payload.deliver === "boolean") {
+        return true;
+    }
+    if (typeof payload.bestEffortDeliver === "boolean") {
+        return true;
+    }
+    if (typeof payload.to === "string" && payload.to.trim()) {
+        return true;
+    }
+    return false;
+}
+function buildDeliveryFromLegacyPayload(payload) {
+    const deliver = payload.deliver;
+    const mode = deliver === false ? "none" : "announce";
+    const channelRaw = typeof payload.channel === "string" ? payload.channel.trim().toLowerCase() : "";
+    const toRaw = typeof payload.to === "string" ? payload.to.trim() : "";
+    const next = { mode };
+    if (channelRaw) {
+        next.channel = channelRaw;
+    }
+    if (toRaw) {
+        next.to = toRaw;
+    }
+    if (typeof payload.bestEffortDeliver === "boolean") {
+        next.bestEffort = payload.bestEffortDeliver;
+    }
+    return next;
+}
+function stripLegacyDeliveryFields(payload) {
+    if ("deliver" in payload) {
+        delete payload.deliver;
+    }
+    if ("channel" in payload) {
+        delete payload.channel;
+    }
+    if ("to" in payload) {
+        delete payload.to;
+    }
+    if ("bestEffortDeliver" in payload) {
+        delete payload.bestEffortDeliver;
+    }
+}
 function unwrapJob(raw) {
-    if (isRecord(raw.data))
+    if (isRecord(raw.data)) {
         return raw.data;
-    if (isRecord(raw.job))
+    }
+    if (isRecord(raw.job)) {
         return raw.job;
+    }
     return raw;
 }
+function normalizeSessionTarget(raw) {
+    if (typeof raw !== "string") {
+        return undefined;
+    }
+    const trimmed = raw.trim().toLowerCase();
+    if (trimmed === "main" || trimmed === "isolated") {
+        return trimmed;
+    }
+    return undefined;
+}
+function normalizeWakeMode(raw) {
+    if (typeof raw !== "string") {
+        return undefined;
+    }
+    const trimmed = raw.trim().toLowerCase();
+    if (trimmed === "now" || trimmed === "next-heartbeat") {
+        return trimmed;
+    }
+    return undefined;
+}
+function copyTopLevelAgentTurnFields(next, payload) {
+    const copyString = (field) => {
+        if (typeof payload[field] === "string" && payload[field].trim()) {
+            return;
+        }
+        const value = next[field];
+        if (typeof value === "string" && value.trim()) {
+            payload[field] = value.trim();
+        }
+    };
+    copyString("model");
+    copyString("thinking");
+    if (typeof payload.timeoutSeconds !== "number" && typeof next.timeoutSeconds === "number") {
+        payload.timeoutSeconds = next.timeoutSeconds;
+    }
+    if (typeof payload.allowUnsafeExternalContent !== "boolean" &&
+        typeof next.allowUnsafeExternalContent === "boolean") {
+        payload.allowUnsafeExternalContent = next.allowUnsafeExternalContent;
+    }
+}
+function copyTopLevelLegacyDeliveryFields(next, payload) {
+    if (typeof payload.deliver !== "boolean" && typeof next.deliver === "boolean") {
+        payload.deliver = next.deliver;
+    }
+    if (typeof payload.channel !== "string" &&
+        typeof next.channel === "string" &&
+        next.channel.trim()) {
+        payload.channel = next.channel.trim();
+    }
+    if (typeof payload.to !== "string" && typeof next.to === "string" && next.to.trim()) {
+        payload.to = next.to.trim();
+    }
+    if (typeof payload.bestEffortDeliver !== "boolean" &&
+        typeof next.bestEffortDeliver === "boolean") {
+        payload.bestEffortDeliver = next.bestEffortDeliver;
+    }
+    if (typeof payload.provider !== "string" &&
+        typeof next.provider === "string" &&
+        next.provider.trim()) {
+        payload.provider = next.provider.trim();
+    }
+}
+function stripLegacyTopLevelFields(next) {
+    delete next.model;
+    delete next.thinking;
+    delete next.timeoutSeconds;
+    delete next.allowUnsafeExternalContent;
+    delete next.message;
+    delete next.text;
+    delete next.deliver;
+    delete next.channel;
+    delete next.to;
+    delete next.bestEffortDeliver;
+    delete next.provider;
+}
 export function normalizeCronJobInput(raw, options = DEFAULT_OPTIONS) {
-    if (!isRecord(raw))
+    if (!isRecord(raw)) {
         return null;
+    }
     const base = unwrapJob(raw);
     const next = { ...base };
     if ("agentId" in base) {
@@ -59,10 +302,12 @@ export function normalizeCronJobInput(raw, options = DEFAULT_OPTIONS) {
         }
         else if (typeof agentId === "string") {
             const trimmed = agentId.trim();
-            if (trimmed)
+            if (trimmed) {
                 next.agentId = sanitizeAgentId(trimmed);
-            else
+            }
+            else {
                 delete next.agentId;
+            }
         }
     }
     if ("enabled" in base) {
@@ -72,27 +317,110 @@ export function normalizeCronJobInput(raw, options = DEFAULT_OPTIONS) {
         }
         else if (typeof enabled === "string") {
             const trimmed = enabled.trim().toLowerCase();
-            if (trimmed === "true")
+            if (trimmed === "true") {
                 next.enabled = true;
-            if (trimmed === "false")
+            }
+            if (trimmed === "false") {
                 next.enabled = false;
+            }
+        }
+    }
+    if ("sessionTarget" in base) {
+        const normalized = normalizeSessionTarget(base.sessionTarget);
+        if (normalized) {
+            next.sessionTarget = normalized;
+        }
+        else {
+            delete next.sessionTarget;
+        }
+    }
+    if ("wakeMode" in base) {
+        const normalized = normalizeWakeMode(base.wakeMode);
+        if (normalized) {
+            next.wakeMode = normalized;
+        }
+        else {
+            delete next.wakeMode;
         }
     }
     if (isRecord(base.schedule)) {
         next.schedule = coerceSchedule(base.schedule);
     }
+    if (!("payload" in next) || !isRecord(next.payload)) {
+        const message = typeof next.message === "string" ? next.message.trim() : "";
+        const text = typeof next.text === "string" ? next.text.trim() : "";
+        if (message) {
+            next.payload = { kind: "agentTurn", message };
+        }
+        else if (text) {
+            next.payload = { kind: "systemEvent", text };
+        }
+    }
     if (isRecord(base.payload)) {
         next.payload = coercePayload(base.payload);
     }
+    if (isRecord(base.delivery)) {
+        next.delivery = coerceDelivery(base.delivery);
+    }
+    if ("isolation" in next) {
+        delete next.isolation;
+    }
+    const payload = isRecord(next.payload) ? next.payload : null;
+    if (payload && payload.kind === "agentTurn") {
+        copyTopLevelAgentTurnFields(next, payload);
+        copyTopLevelLegacyDeliveryFields(next, payload);
+    }
+    stripLegacyTopLevelFields(next);
     if (options.applyDefaults) {
-        if (!next.wakeMode)
-            next.wakeMode = "next-heartbeat";
+        if (!next.wakeMode) {
+            next.wakeMode = "now";
+        }
+        if (typeof next.enabled !== "boolean") {
+            next.enabled = true;
+        }
+        if ((typeof next.name !== "string" || !next.name.trim()) &&
+            isRecord(next.schedule) &&
+            isRecord(next.payload)) {
+            next.name = inferLegacyName({
+                schedule: next.schedule,
+                payload: next.payload,
+            });
+        }
+        else if (typeof next.name === "string") {
+            const trimmed = next.name.trim();
+            if (trimmed) {
+                next.name = trimmed;
+            }
+        }
         if (!next.sessionTarget && isRecord(next.payload)) {
             const kind = typeof next.payload.kind === "string" ? next.payload.kind : "";
-            if (kind === "systemEvent")
+            if (kind === "systemEvent") {
                 next.sessionTarget = "main";
-            if (kind === "agentTurn")
+            }
+            if (kind === "agentTurn") {
                 next.sessionTarget = "isolated";
+            }
+        }
+        if ("schedule" in next &&
+            isRecord(next.schedule) &&
+            next.schedule.kind === "at" &&
+            !("deleteAfterRun" in next)) {
+            next.deleteAfterRun = true;
+        }
+        const payload = isRecord(next.payload) ? next.payload : null;
+        const payloadKind = payload && typeof payload.kind === "string" ? payload.kind : "";
+        const sessionTarget = typeof next.sessionTarget === "string" ? next.sessionTarget : "";
+        const isIsolatedAgentTurn = sessionTarget === "isolated" || (sessionTarget === "" && payloadKind === "agentTurn");
+        const hasDelivery = "delivery" in next && next.delivery !== undefined;
+        const hasLegacyDelivery = payload ? hasLegacyDeliveryHints(payload) : false;
+        if (!hasDelivery && isIsolatedAgentTurn && payloadKind === "agentTurn") {
+            if (payload && hasLegacyDelivery) {
+                next.delivery = buildDeliveryFromLegacyPayload(payload);
+                stripLegacyDeliveryFields(payload);
+            }
+            else {
+                next.delivery = { mode: "announce" };
+            }
         }
     }
     return next;

package/dist/cron/parse.js

@@ -2,22 +2,27 @@ const ISO_TZ_RE = /(Z|[+-]\d{2}:?\d{2})$/i;
 const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const ISO_DATE_TIME_RE = /^\d{4}-\d{2}-\d{2}T/;
 function normalizeUtcIso(raw) {
-    if (ISO_TZ_RE.test(raw))
+    if (ISO_TZ_RE.test(raw)) {
         return raw;
-    if (ISO_DATE_RE.test(raw))
+    }
+    if (ISO_DATE_RE.test(raw)) {
         return `${raw}T00:00:00Z`;
-    if (ISO_DATE_TIME_RE.test(raw))
+    }
+    if (ISO_DATE_TIME_RE.test(raw)) {
         return `${raw}Z`;
+    }
     return raw;
 }
 export function parseAbsoluteTimeMs(input) {
     const raw = input.trim();
-    if (!raw)
+    if (!raw) {
         return null;
+    }
     if (/^\d+$/.test(raw)) {
         const n = Number(raw);
-        if (Number.isFinite(n) && n > 0)
+        if (Number.isFinite(n) && n > 0) {
             return Math.floor(n);
+        }
     }
     const parsed = Date.parse(normalizeUtcIso(raw));
     return Number.isFinite(parsed) ? parsed : null;

package/dist/cron/run-log.js

@@ -8,8 +8,9 @@ export function resolveCronRunLogPath(params) {
 const writesByPath = new Map();
 async function pruneIfNeeded(filePath, opts) {
     const stat = await fs.stat(filePath).catch(() => null);
-    if (!stat || stat.size <= opts.maxBytes)
+    if (!stat || stat.size <= opts.maxBytes) {
         return;
+    }
     const raw = await fs.readFile(filePath, "utf-8").catch(() => "");
     const lines = raw
         .split("\n")
@@ -40,31 +41,55 @@ export async function readCronRunLogEntries(filePath, opts) {
     const limit = Math.max(1, Math.min(5000, Math.floor(opts?.limit ?? 200)));
     const jobId = opts?.jobId?.trim() || undefined;
     const raw = await fs.readFile(path.resolve(filePath), "utf-8").catch(() => "");
-    if (!raw.trim())
+    if (!raw.trim()) {
         return [];
+    }
     const parsed = [];
     const lines = raw.split("\n");
     for (let i = lines.length - 1; i >= 0 && parsed.length < limit; i--) {
         const line = lines[i]?.trim();
-        if (!line)
+        if (!line) {
             continue;
+        }
         try {
             const obj = JSON.parse(line);
-            if (!obj || typeof obj !== "object")
+            if (!obj || typeof obj !== "object") {
                 continue;
-            if (obj.action !== "finished")
+            }
+            if (obj.action !== "finished") {
                 continue;
-            if (typeof obj.jobId !== "string" || obj.jobId.trim().length === 0)
+            }
+            if (typeof obj.jobId !== "string" || obj.jobId.trim().length === 0) {
                 continue;
-            if (typeof obj.ts !== "number" || !Number.isFinite(obj.ts))
+            }
+            if (typeof obj.ts !== "number" || !Number.isFinite(obj.ts)) {
                 continue;
-            if (jobId && obj.jobId !== jobId)
+            }
+            if (jobId && obj.jobId !== jobId) {
                 continue;
-            parsed.push(obj);
+            }
+            const entry = {
+                ts: obj.ts,
+                jobId: obj.jobId,
+                action: "finished",
+                status: obj.status,
+                error: obj.error,
+                summary: obj.summary,
+                runAtMs: obj.runAtMs,
+                durationMs: obj.durationMs,
+                nextRunAtMs: obj.nextRunAtMs,
+            };
+            if (typeof obj.sessionId === "string" && obj.sessionId.trim().length > 0) {
+                entry.sessionId = obj.sessionId;
+            }
+            if (typeof obj.sessionKey === "string" && obj.sessionKey.trim().length > 0) {
+                entry.sessionKey = obj.sessionKey;
+            }
+            parsed.push(entry);
         }
         catch {
             // ignore invalid lines
         }
     }
-    return parsed.reverse();
+    return parsed.toReversed();
 }

package/dist/cron/schedule.js

@@ -1,24 +1,59 @@
 import { Cron } from "croner";
+import { parseAbsoluteTimeMs } from "./parse.js";
+function resolveCronTimezone(tz) {
+    const trimmed = typeof tz === "string" ? tz.trim() : "";
+    if (trimmed) {
+        return trimmed;
+    }
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
 export function computeNextRunAtMs(schedule, nowMs) {
     if (schedule.kind === "at") {
-        return schedule.atMs > nowMs ? schedule.atMs : undefined;
+        // Handle both canonical `at` (string) and legacy `atMs` (number) fields.
+        // The store migration should convert atMs→at, but be defensive in case
+        // the migration hasn't run yet or was bypassed.
+        const sched = schedule;
+        const atMs = typeof sched.atMs === "number" && Number.isFinite(sched.atMs) && sched.atMs > 0
+            ? sched.atMs
+            : typeof sched.atMs === "string"
+                ? parseAbsoluteTimeMs(sched.atMs)
+                : typeof sched.at === "string"
+                    ? parseAbsoluteTimeMs(sched.at)
+                    : null;
+        if (atMs === null) {
+            return undefined;
+        }
+        return atMs > nowMs ? atMs : undefined;
     }
     if (schedule.kind === "every") {
         const everyMs = Math.max(1, Math.floor(schedule.everyMs));
         const anchor = Math.max(0, Math.floor(schedule.anchorMs ?? nowMs));
-        if (nowMs < anchor)
+        if (nowMs < anchor) {
             return anchor;
+        }
         const elapsed = nowMs - anchor;
         const steps = Math.max(1, Math.floor((elapsed + everyMs - 1) / everyMs));
         return anchor + steps * everyMs;
     }
     const expr = schedule.expr.trim();
-    if (!expr)
+    if (!expr) {
         return undefined;
+    }
     const cron = new Cron(expr, {
-        timezone: schedule.tz?.trim() || undefined,
+        timezone: resolveCronTimezone(schedule.tz),
         catch: false,
     });
-    const next = cron.nextRun(new Date(nowMs));
-    return next ? next.getTime() : undefined;
+    // Cron operates at second granularity, so floor nowMs to the start of the
+    // current second.  This prevents the lookback from landing inside a matching
+    // second — if nowMs is e.g. 12:00:00.500 and the pattern fires at second 0,
+    // a 1ms lookback (12:00:00.499) is still *within* that second, causing
+    // croner to skip ahead to the next occurrence (e.g. the following day).
+    // Flooring first ensures the lookback always falls in the *previous* second.
+    const nowSecondMs = Math.floor(nowMs / 1000) * 1000;
+    const next = cron.nextRun(new Date(nowSecondMs - 1));
+    if (!next) {
+        return undefined;
+    }
+    const nextMs = next.getTime();
+    return Number.isFinite(nextMs) && nextMs >= nowSecondMs ? nextMs : undefined;
 }