@a5c-ai/genty-runtime 5.1.1-staging.0007199a1cb2

package/dist/daemon/loop.js

@@ -0,0 +1,387 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: Daemon Loop — main event loop with concurrent run pool.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDaemonLoop = runDaemonLoop;
+exports.readDaemonLoopStatus = readDaemonLoopStatus;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const types_1 = require("./types");
+const fileWatcher_1 = require("./fileWatcher");
+const webhookListener_1 = require("./webhookListener");
+const timerScheduler_1 = require("./timerScheduler");
+const daemonLog_1 = require("./daemonLog");
+const durableQueue_1 = require("./durableQueue");
+async function runDaemonLoop(config, options) {
+    const maxConcurrent = config.maxConcurrentRuns ?? 4;
+    const handles = [];
+    const activeRuns = new Set();
+    const queue = [];
+    const admission = createAdmissionController(config.triggerAdmission);
+    const retryTimers = new Set();
+    const durableQueue = options?.logDir
+        ? await durableQueue_1.DurableTriggerQueue.open(options.logDir, options.queue)
+        : null;
+    let statusWriteChain = Promise.resolve();
+    function scheduleStatusWrite() {
+        statusWriteChain = statusWriteChain.then(() => writeLoopStatus()).catch(() => {
+            // Status persistence is best-effort and must not surface as an
+            // unhandled rejection during trigger dispatch or shutdown races.
+        });
+    }
+    function scheduleRetryDrain(delayMs) {
+        const timer = setTimeout(() => {
+            retryTimers.delete(timer);
+            void drainQueue();
+        }, Math.max(0, delayMs));
+        retryTimers.add(timer);
+    }
+    async function drainQueue() {
+        if (durableQueue) {
+            while (activeRuns.size < maxConcurrent) {
+                const [next] = await durableQueue.claimDue(1);
+                if (!next)
+                    break;
+                dispatchDurableTrigger(next);
+            }
+            scheduleStatusWrite();
+            return;
+        }
+        while (queue.length > 0 && activeRuns.size < maxConcurrent) {
+            const next = queue.shift();
+            dispatchTrigger(next);
+        }
+        scheduleStatusWrite();
+    }
+    function dispatchTrigger(trigger) {
+        if (options?.onTrigger) {
+            return Promise.resolve(options.onTrigger(trigger)).then(() => { });
+        }
+    }
+    function dispatchDurableTrigger(record) {
+        const promise = Promise.resolve()
+            .then(() => dispatchTrigger(record.trigger))
+            .then(async () => {
+            await durableQueue?.ack(record.id);
+        }, async (error) => {
+            await durableQueue?.fail(record.id, error);
+            await (0, daemonLog_1.appendDaemonLog)(options.logDir, {
+                timestamp: new Date().toISOString(),
+                event: "TRIGGER_FAILED",
+                data: { eventId: record.id, error: error instanceof Error ? error.message : String(error) },
+            }).catch(() => { });
+            const snapshot = (await durableQueue?.snapshot()) ?? [];
+            const failed = snapshot.find((event) => event.id === record.id && event.nextAttemptAt);
+            if (failed?.nextAttemptAt) {
+                scheduleRetryDrain(Date.parse(failed.nextAttemptAt) - Date.now());
+            }
+        })
+            .finally(() => {
+            activeRuns.delete(promise);
+            void drainQueue();
+        });
+        activeRuns.add(promise);
+    }
+    function dispatchMemoryTrigger(trigger) {
+        const promise = Promise.resolve()
+            .then(() => dispatchTrigger(trigger))
+            .catch((error) => {
+            if (options?.logDir) {
+                void (0, daemonLog_1.appendDaemonLog)(options.logDir, {
+                    timestamp: new Date().toISOString(),
+                    event: "TRIGGER_FAILED",
+                    data: { error: error instanceof Error ? error.message : String(error) },
+                }).catch(() => { });
+            }
+        })
+            .finally(() => {
+            activeRuns.delete(promise);
+            void drainQueue();
+        });
+        activeRuns.add(promise);
+    }
+    async function writeLoopStatus() {
+        if (!options?.logDir)
+            return;
+        const statusPath = path.join(options.logDir, "daemon.status.json");
+        const status = {
+            activeRuns: durableQueue?.counts().active ?? activeRuns.size,
+            pendingRuns: durableQueue?.counts().pending ?? queue.length,
+            deadLetterRuns: durableQueue?.counts().deadLetter,
+            rejectedTriggers: admission.stats.rejected,
+            duplicateTriggers: admission.stats.duplicates,
+            rateLimitedTriggers: admission.stats.rateLimited,
+            updatedAt: new Date().toISOString(),
+        };
+        const tmpPath = `${statusPath}.tmp-${process.pid}-${Date.now()}`;
+        await node_fs_1.promises.writeFile(tmpPath, JSON.stringify(status), "utf-8");
+        await node_fs_1.promises.rename(tmpPath, statusPath);
+    }
+    const triggerCallback = async (trigger) => {
+        // Log the activation
+        if (options?.logDir) {
+            const data = (0, types_1.isAutomationTriggerEvent)(trigger)
+                ? {
+                    type: "automation",
+                    ruleId: trigger.rule.id,
+                    triggerType: trigger.rule.trigger.type,
+                    projectId: trigger.rule.target.projectId,
+                    boardProjectId: trigger.rule.target.boardProjectId,
+                }
+                : {
+                    type: trigger.type,
+                    processId: trigger.processId,
+                    entrypoint: trigger.entrypoint,
+                };
+            void (0, daemonLog_1.appendDaemonLog)(options.logDir, {
+                timestamp: new Date().toISOString(),
+                event: "TRIGGER_ACTIVATED",
+                data,
+            }).catch(() => {
+                // Activation logging is best-effort and should never interrupt the loop.
+            });
+        }
+        const admissionResult = admission.evaluate(trigger, {
+            activeRuns: activeRuns.size,
+            pendingRuns: durableQueue?.counts().pending ?? queue.length,
+            maxConcurrent,
+        });
+        if (admissionResult.status === "rejected" || admissionResult.status === "duplicate") {
+            if (options?.logDir) {
+                void (0, daemonLog_1.appendDaemonLog)(options.logDir, {
+                    timestamp: new Date().toISOString(),
+                    event: admissionResult.status === "duplicate" ? "TRIGGER_DUPLICATE" : "TRIGGER_REJECTED",
+                    data: {
+                        reason: admissionResult.reason,
+                        retryAfterMs: admissionResult.retryAfterMs,
+                        queueDepth: admissionResult.queueDepth,
+                        fingerprint: admissionResult.fingerprint,
+                    },
+                }).catch(() => { });
+            }
+            scheduleStatusWrite();
+            return admissionResult;
+        }
+        if (durableQueue) {
+            await durableQueue.enqueue(trigger).then(() => drainQueue()).catch((error) => {
+                void (0, daemonLog_1.appendDaemonLog)(options.logDir, {
+                    timestamp: new Date().toISOString(),
+                    event: "TRIGGER_QUEUE_ERROR",
+                    data: { error: error instanceof Error ? error.message : String(error) },
+                }).catch(() => { });
+            });
+            scheduleStatusWrite();
+            return admissionResult;
+        }
+        if (activeRuns.size >= maxConcurrent) {
+            queue.push(trigger);
+            scheduleStatusWrite();
+            return admissionResult.status === "accepted"
+                ? { ...admissionResult, status: "deferred", queueDepth: queue.length }
+                : admissionResult;
+        }
+        dispatchMemoryTrigger(trigger);
+        scheduleStatusWrite();
+        return admissionResult;
+    };
+    // Set up file triggers
+    const fileTriggers = config.triggers
+        .filter(types_1.isFileTriggerConfig);
+    if (fileTriggers.length > 0) {
+        const handle = (0, fileWatcher_1.createFileWatcher)(fileTriggers, triggerCallback);
+        handles.push(handle);
+    }
+    // Set up webhook triggers
+    const webhookTriggers = config.triggers.filter(types_1.isWebhookAutomationRule);
+    for (const rule of webhookTriggers) {
+        try {
+            const handle = await (0, webhookListener_1.createWebhookListener)({
+                rule,
+                onTrigger: triggerCallback,
+            });
+            handles.push(handle);
+        }
+        catch {
+            // Port in use or other error — skip
+        }
+    }
+    // Set up timer/cron triggers
+    const timerTriggers = config.triggers.filter(types_1.isTimerAutomationRule);
+    if (timerTriggers.length > 0) {
+        const handle = (0, timerScheduler_1.createTimerScheduler)(timerTriggers, triggerCallback);
+        handles.push(handle);
+    }
+    await drainQueue();
+    // Wait for abort signal
+    if (options?.signal) {
+        await new Promise((resolve) => {
+            if (options.signal.aborted) {
+                resolve();
+                return;
+            }
+            options.signal.addEventListener("abort", () => resolve(), { once: true });
+        });
+    }
+    // Cleanup all handles
+    for (const handle of handles) {
+        if (handle.dispose)
+            handle.dispose();
+        if (handle.close)
+            await handle.close();
+    }
+    for (const timer of retryTimers) {
+        clearTimeout(timer);
+    }
+    // Wait for active runs to finish
+    if (activeRuns.size > 0) {
+        await Promise.allSettled([...activeRuns]);
+    }
+    // Wait for any in-flight status writes then write final status
+    await statusWriteChain;
+    try {
+        await writeLoopStatus();
+    }
+    catch { /* directory may be gone in tests */ }
+}
+function createAdmissionController(config) {
+    const seen = new Map();
+    const rateWindow = [];
+    const stats = {
+        rejected: 0,
+        duplicates: 0,
+        rateLimited: 0,
+    };
+    return {
+        stats,
+        evaluate(trigger, state) {
+            const now = Date.now();
+            const fingerprint = fingerprintTrigger(trigger);
+            const dedupeWindowMs = config?.dedupeWindowMs ?? 0;
+            if (dedupeWindowMs > 0) {
+                for (const [key, expiresAt] of seen) {
+                    if (expiresAt <= now)
+                        seen.delete(key);
+                }
+                const existing = seen.get(fingerprint);
+                if (existing && existing > now) {
+                    stats.duplicates += 1;
+                    return {
+                        status: "duplicate",
+                        reason: "dedupe-window",
+                        retryAfterMs: existing - now,
+                        queueDepth: state.pendingRuns,
+                        fingerprint,
+                    };
+                }
+            }
+            const rateLimit = config?.rateLimit;
+            if (rateLimit) {
+                while (rateWindow.length > 0 && rateWindow[0] <= now - rateLimit.windowMs) {
+                    rateWindow.shift();
+                }
+                if (rateWindow.length >= rateLimit.maxTriggers) {
+                    stats.rejected += 1;
+                    stats.rateLimited += 1;
+                    return {
+                        status: "rejected",
+                        reason: "rate-limit",
+                        retryAfterMs: Math.max(0, rateWindow[0] + rateLimit.windowMs - now),
+                        queueDepth: state.pendingRuns,
+                        fingerprint,
+                    };
+                }
+            }
+            const maxPendingRuns = config?.maxPendingRuns;
+            if (maxPendingRuns !== undefined && state.pendingRuns >= maxPendingRuns && state.activeRuns >= state.maxConcurrent) {
+                stats.rejected += 1;
+                return {
+                    status: "rejected",
+                    reason: "queue-full",
+                    queueDepth: state.pendingRuns,
+                    fingerprint,
+                };
+            }
+            if (dedupeWindowMs > 0) {
+                seen.set(fingerprint, now + dedupeWindowMs);
+            }
+            if (rateLimit) {
+                rateWindow.push(now);
+            }
+            return {
+                status: state.activeRuns >= state.maxConcurrent ? "deferred" : "accepted",
+                queueDepth: state.pendingRuns,
+                fingerprint,
+            };
+        },
+    };
+}
+function fingerprintTrigger(trigger) {
+    if (trigger.type === "file") {
+        const path = typeof trigger.inputs?.path === "string" ? trigger.inputs.path : "";
+        return path ? `file:path:${path}` : `file:${trigger.processId}:${trigger.entrypoint}`;
+    }
+    const deliveryId = typeof trigger.inputs?.deliveryId === "string" ? trigger.inputs.deliveryId : "";
+    const sourceEvent = trigger.rule.trigger.type === "webhook" ? trigger.rule.trigger.sourceEvent ?? "" : "";
+    const inputs = stableStringify(trigger.inputs ?? {});
+    return `automation:${trigger.rule.trigger.type}:${trigger.rule.id}:${deliveryId}:${sourceEvent}:${inputs}`;
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+        .join(",")}}`;
+}
+/**
+ * Read the daemon loop's runtime status from its status file.
+ * Returns null if the file doesn't exist or is unreadable.
+ */
+async function readDaemonLoopStatus(daemonDir) {
+    try {
+        const statusPath = path.join(daemonDir, "daemon.status.json");
+        const content = await node_fs_1.promises.readFile(statusPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/daemon/timerScheduler.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GAP-REMOTE-001: Timer Scheduler — cron-expression-based trigger scheduling.
+ *
+ * Supports a subset of cron syntax: minute, hour, day-of-month, month, day-of-week.
+ * Uses setInterval to check the cron expression against current time.
+ */
+import type { TimerAutomationRule } from "@a5c-ai/comm-adapter";
+import type { TriggerCallback } from "./types";
+export interface TimerSchedulerHandle {
+    dispose(): void;
+}
+export declare function createTimerScheduler(triggers: TimerAutomationRule[], onTrigger: TriggerCallback): TimerSchedulerHandle;
+//# sourceMappingURL=timerScheduler.d.ts.map

package/dist/daemon/timerScheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timerScheduler.d.ts","sourceRoot":"","sources":["../../src/daemon/timerScheduler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,MAAM,WAAW,oBAAoB;IACnC,OAAO,IAAI,IAAI,CAAC;CACjB;AAkLD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,SAAS,EAAE,eAAe,GACzB,oBAAoB,CA0CtB"}

package/dist/daemon/timerScheduler.js

@@ -0,0 +1,212 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: Timer Scheduler — cron-expression-based trigger scheduling.
+ *
+ * Supports a subset of cron syntax: minute, hour, day-of-month, month, day-of-week.
+ * Uses setInterval to check the cron expression against current time.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTimerScheduler = createTimerScheduler;
+const CRON_MACROS = {
+    "@yearly": "0 0 1 1 *",
+    "@annually": "0 0 1 1 *",
+    "@monthly": "0 0 1 * *",
+    "@weekly": "0 0 * * 0",
+    "@daily": "0 0 * * *",
+    "@midnight": "0 0 * * *",
+    "@hourly": "0 * * * *",
+};
+const MONTH_NAMES = {
+    JAN: 1,
+    FEB: 2,
+    MAR: 3,
+    APR: 4,
+    MAY: 5,
+    JUN: 6,
+    JUL: 7,
+    AUG: 8,
+    SEP: 9,
+    OCT: 10,
+    NOV: 11,
+    DEC: 12,
+};
+const DAY_NAMES = {
+    SUN: 0,
+    MON: 1,
+    TUE: 2,
+    WED: 3,
+    THU: 4,
+    FRI: 5,
+    SAT: 6,
+};
+function normalizeCronField(field, names) {
+    if (!names)
+        return field;
+    return field.replace(/[A-Za-z]{3}/g, (name) => String(names[name.toUpperCase()] ?? name));
+}
+function parseCronField(field, min, max, names) {
+    field = normalizeCronField(field, names);
+    if (field === "*")
+        return null; // matches all
+    const values = [];
+    for (const part of field.split(",")) {
+        const trimmed = part.trim();
+        // Step syntax: */N or M-N/S
+        if (trimmed.includes("/")) {
+            const [rangeStr, stepStr] = trimmed.split("/");
+            const step = parseInt(stepStr, 10);
+            if (isNaN(step) || step <= 0)
+                return [];
+            let start = min;
+            let end = max;
+            if (rangeStr !== "*") {
+                if (rangeStr.includes("-")) {
+                    const [rMin, rMax] = rangeStr.split("-").map((s) => parseInt(s, 10));
+                    if (isNaN(rMin) || isNaN(rMax))
+                        return [];
+                    start = rMin;
+                    end = rMax;
+                }
+                else {
+                    start = parseInt(rangeStr, 10);
+                    if (isNaN(start))
+                        return [];
+                }
+            }
+            if (start < min || end > max || start > end)
+                return [];
+            for (let i = start; i <= end; i += step) {
+                values.push(max === 6 && i === 7 ? 0 : i);
+            }
+        }
+        // Range syntax: M-N
+        else if (trimmed.includes("-")) {
+            const [rMin, rMax] = trimmed.split("-").map((s) => parseInt(s, 10));
+            if (isNaN(rMin) || isNaN(rMax) || rMin < min || rMax > max || rMin > rMax)
+                return [];
+            for (let i = rMin; i <= rMax; i++) {
+                values.push(max === 6 && i === 7 ? 0 : i);
+            }
+        }
+        // Simple number
+        else {
+            const num = parseInt(trimmed, 10);
+            const normalized = max === 6 && num === 7 ? 0 : num;
+            if (isNaN(num) || normalized < min || normalized > max)
+                return [];
+            values.push(normalized);
+        }
+    }
+    return values.length > 0 ? [...new Set(values)] : [];
+}
+function parseCron(expression, timezone) {
+    expression = expression.trim();
+    if (expression === "@reboot") {
+        return {
+            macro: "reboot",
+            minutes: [],
+            hours: [],
+            daysOfMonth: [],
+            months: [],
+            daysOfWeek: [],
+            timezone,
+        };
+    }
+    expression = CRON_MACROS[expression] ?? expression;
+    const fields = expression.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return null;
+    return {
+        minutes: parseCronField(fields[0], 0, 59),
+        hours: parseCronField(fields[1], 0, 23),
+        daysOfMonth: parseCronField(fields[2], 1, 31),
+        months: parseCronField(fields[3], 1, 12, MONTH_NAMES),
+        daysOfWeek: parseCronField(fields[4], 0, 7, DAY_NAMES)?.map((day) => day === 7 ? 0 : day) ?? null,
+        timezone,
+    };
+}
+function getCronDateParts(date, timezone) {
+    if (!timezone) {
+        return {
+            minute: date.getMinutes(),
+            hour: date.getHours(),
+            dayOfMonth: date.getDate(),
+            month: date.getMonth() + 1,
+            dayOfWeek: date.getDay(),
+        };
+    }
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        hourCycle: "h23",
+    }).formatToParts(date);
+    const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+    const year = Number(values.year);
+    const month = Number(values.month);
+    const dayOfMonth = Number(values.day);
+    return {
+        minute: Number(values.minute),
+        hour: Number(values.hour),
+        dayOfMonth,
+        month,
+        dayOfWeek: new Date(Date.UTC(year, month - 1, dayOfMonth)).getUTCDay(),
+    };
+}
+function matchesCron(parsed, date) {
+    const { minute, hour, dayOfMonth, month, dayOfWeek } = getCronDateParts(date, parsed.timezone);
+    if (parsed.minutes && !parsed.minutes.includes(minute))
+        return false;
+    if (parsed.hours && !parsed.hours.includes(hour))
+        return false;
+    if (parsed.daysOfMonth && !parsed.daysOfMonth.includes(dayOfMonth))
+        return false;
+    if (parsed.months && !parsed.months.includes(month))
+        return false;
+    if (parsed.daysOfWeek && !parsed.daysOfWeek.includes(dayOfWeek))
+        return false;
+    return true;
+}
+function createTimerScheduler(triggers, onTrigger) {
+    const parsedTriggers = triggers
+        .map((t) => ({ trigger: t, parsed: parseCron(t.trigger.cron, t.trigger.timezone) }))
+        .filter((t) => t.parsed !== null);
+    for (const { trigger, parsed } of parsedTriggers) {
+        if (parsed.macro === "reboot") {
+            queueMicrotask(() => {
+                void onTrigger({
+                    type: "automation",
+                    rule: trigger,
+                    inputs: { scheduledBy: "@reboot" },
+                });
+            });
+        }
+    }
+    let lastMinute = -1;
+    const interval = setInterval(() => {
+        const now = new Date();
+        const currentMinute = now.getMinutes() + now.getHours() * 60;
+        // Only check once per minute
+        if (currentMinute === lastMinute)
+            return;
+        lastMinute = currentMinute;
+        for (const { trigger, parsed } of parsedTriggers) {
+            if (parsed.macro === "reboot")
+                continue;
+            if (matchesCron(parsed, now)) {
+                void onTrigger({
+                    type: "automation",
+                    rule: trigger,
+                });
+            }
+        }
+    }, 30_000); // Check every 30 seconds
+    return {
+        dispose() {
+            clearInterval(interval);
+        },
+    };
+}