@orkify/cli 1.0.0-beta.5

package/dist/cron/CronScheduler.js

@@ -0,0 +1,149 @@
+import { CronExpressionParser } from 'cron-parser';
+const DEFAULT_TIMEOUT = 30_000;
+const TICK_INTERVAL = 30_000;
+const MIN_INTERVAL_MS = 60_000;
+const MAX_INTERVAL_MS = 24 * 60 * 60_000;
+/**
+ * Validate a cron schedule string. Returns null if valid,
+ * or an error message if invalid, sub-minute, or > 24h.
+ */
+export function validateCronSchedule(schedule) {
+    try {
+        const expr = CronExpressionParser.parse(schedule);
+        const first = expr.next().toDate();
+        const second = expr.next().toDate();
+        const intervalMs = second.getTime() - first.getTime();
+        if (intervalMs < MIN_INTERVAL_MS) {
+            return `schedule "${schedule}" fires every ${Math.round(intervalMs / 1000)}s — minimum interval is 60s`;
+        }
+        if (intervalMs > MAX_INTERVAL_MS) {
+            const hours = Math.round(intervalMs / 3_600_000);
+            return `schedule "${schedule}" fires every ${hours}h — maximum interval is 24h`;
+        }
+        return null;
+    }
+    catch {
+        return `invalid cron expression: "${schedule}"`;
+    }
+}
+/**
+ * Validate a cron job path. Must be a clean local route path
+ * (e.g. "/api/cron/heartbeat-check") — no URLs, hosts, or query strings.
+ */
+export function validateCronPath(path) {
+    if (!path.startsWith('/')) {
+        return `path "${path}" must start with /`;
+    }
+    if (/[:\\?#@]/.test(path)) {
+        return `path "${path}" must be a plain route path (no ":", "?", "#", or "@")`;
+    }
+    if (path.includes('..')) {
+        return `path "${path}" must not contain ".."`;
+    }
+    return null;
+}
+export class CronScheduler {
+    orchestrator;
+    jobs = [];
+    timer = null;
+    constructor(orchestrator) {
+        this.orchestrator = orchestrator;
+        this.timer = setInterval(() => this.tick(), TICK_INTERVAL);
+        this.timer.unref();
+    }
+    register(processName, jobs) {
+        // Remove any existing jobs for this process first
+        this.unregister(processName);
+        for (const job of jobs) {
+            const pathError = validateCronPath(job.path);
+            if (pathError) {
+                console.error(`[cron] ${processName} — ${pathError}, skipping`);
+                continue;
+            }
+            const error = validateCronSchedule(job.schedule);
+            if (error) {
+                console.error(`[cron] ${processName}${job.path} — ${error}, skipping`);
+                continue;
+            }
+            // Safe: validateCronSchedule above guarantees a valid schedule
+            const nextRun = this.computeNextRun(job.schedule);
+            this.jobs.push({
+                job,
+                processName,
+                nextRun,
+                running: false,
+            });
+            console.log(`[cron] Registered ${processName} ${job.method ?? 'GET'} ${job.path} schedule="${job.schedule}" next=${nextRun.toISOString()}`);
+        }
+    }
+    unregister(processName) {
+        const before = this.jobs.length;
+        this.jobs = this.jobs.filter((s) => s.processName !== processName);
+        if (this.jobs.length < before) {
+            console.log(`[cron] Unregistered all jobs for ${processName}`);
+        }
+    }
+    shutdown() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.jobs = [];
+    }
+    tick() {
+        const now = Date.now();
+        for (const state of this.jobs) {
+            if (state.running)
+                continue;
+            if (now < state.nextRun.getTime())
+                continue;
+            this.dispatch(state);
+        }
+    }
+    dispatch(state) {
+        const { job, processName } = state;
+        // Look up process port and secret
+        const processList = this.orchestrator.list();
+        const proc = processList.find((p) => p.name === processName);
+        const port = proc?.port;
+        const cronSecret = this.orchestrator.getCronSecret(processName);
+        if (!port) {
+            console.log(`[cron] ${processName}${job.path} — no port detected, skipping`);
+            state.nextRun = this.computeNextRun(job.schedule) ?? new Date(Date.now() + 60_000);
+            return;
+        }
+        const method = job.method ?? 'GET';
+        const timeout = job.timeout ?? DEFAULT_TIMEOUT;
+        const headers = {};
+        if (cronSecret) {
+            headers['Authorization'] = `Bearer ${cronSecret}`;
+        }
+        state.running = true;
+        fetch(`http://localhost:${port}${job.path}`, {
+            method,
+            headers,
+            signal: AbortSignal.timeout(timeout),
+        })
+            .then((res) => {
+            console.log(`[cron] ${processName} ${method} ${job.path} → ${res.status}`);
+        })
+            .catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`[cron] ${processName} ${method} ${job.path} — error: ${message}`);
+        })
+            .finally(() => {
+            state.running = false;
+            state.nextRun = this.computeNextRun(job.schedule) ?? new Date(Date.now() + 60_000);
+        });
+    }
+    computeNextRun(schedule) {
+        try {
+            const expr = CronExpressionParser.parse(schedule);
+            return expr.next().toDate();
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=CronScheduler.js.map

package/dist/daemon/GracefulManager.d.ts

@@ -0,0 +1,8 @@
+import { EventEmitter } from 'node:events';
+import type { ManagedProcess } from './ManagedProcess.js';
+export declare class GracefulManager extends EventEmitter {
+    private reloadInProgress;
+    reload(container: ManagedProcess): Promise<void>;
+    isReloading(processId: number): boolean;
+}
+//# sourceMappingURL=GracefulManager.d.ts.map

package/dist/daemon/GracefulManager.js

@@ -0,0 +1,29 @@
+import { EventEmitter } from 'node:events';
+export class GracefulManager extends EventEmitter {
+    reloadInProgress = new Map();
+    async reload(container) {
+        const processId = container.id;
+        if (this.reloadInProgress.get(processId)) {
+            throw new Error(`Reload already in progress for process ${container.config.name}`);
+        }
+        this.reloadInProgress.set(processId, true);
+        this.emit('reload:start', {
+            processName: container.config.name,
+            processId: container.id,
+        });
+        try {
+            await container.reload();
+            this.emit('reload:complete', {
+                processName: container.config.name,
+                processId: container.id,
+            });
+        }
+        finally {
+            this.reloadInProgress.delete(processId);
+        }
+    }
+    isReloading(processId) {
+        return this.reloadInProgress.get(processId) || false;
+    }
+}
+//# sourceMappingURL=GracefulManager.js.map

package/dist/daemon/ManagedProcess.d.ts

@@ -0,0 +1,71 @@
+import { EventEmitter } from 'node:events';
+import type { ProcessConfig, ProcessInfo } from '../types/index.js';
+export declare class ManagedProcess extends EventEmitter {
+    readonly id: number;
+    readonly config: ProcessConfig;
+    private forkProcess;
+    private clusterPrimary;
+    private clusterWorkers;
+    private slotRestarts;
+    private slotCrashes;
+    private launchTimers;
+    private outWriter;
+    private errWriter;
+    private watcher;
+    private isShuttingDown;
+    private isReloading;
+    private statsInterval;
+    private forkRestarts;
+    private forkCrashes;
+    private forkCreatedAt;
+    private forkReady;
+    private forkLaunchTimer;
+    private detectedPort;
+    readonly cronSecret: string | undefined;
+    private primaryRestarts;
+    private lastMemoryRestart;
+    private workerMemoryCooldowns;
+    private memoryRestartingWorkers;
+    private recentStderr;
+    private static readonly STDERR_BUFFER_SIZE;
+    private forkStats;
+    constructor(id: number, config: ProcessConfig);
+    private setupLogStreams;
+    start(): Promise<void>;
+    private startFork;
+    private startForkLaunchTimer;
+    private clearForkLaunchTimer;
+    private setupForkHandlers;
+    private startCluster;
+    private setupClusterHandlers;
+    private waitForPrimaryReady;
+    private updateWorkerState;
+    private startLaunchTimer;
+    private clearLaunchTimer;
+    private clearAllLaunchTimers;
+    private checkHealth;
+    private handleLog;
+    private setupWatcher;
+    private startStatsCollection;
+    private collectStats;
+    private checkMemoryThreshold;
+    private memoryRestartFork;
+    private memoryRestartWorker;
+    stop(opts?: {
+        persistCache?: boolean;
+    }): Promise<void>;
+    flushLogs(): Promise<void>;
+    /**
+     * Immediately SIGKILL all child processes without waiting for graceful shutdown.
+     */
+    forceKill(): void;
+    private stopFork;
+    private stopCluster;
+    restart(): Promise<void>;
+    reload(): Promise<void>;
+    getInfo(): ProcessInfo;
+    private getStatus;
+    getWorkerCount(): number;
+    isRunning(): boolean;
+}
+//# sourceMappingURL=ManagedProcess.d.ts.map