@orkify/cli 1.0.0-beta.5

package/dist/daemon/RotatingWriter.js

@@ -0,0 +1,264 @@
+import { closeSync, createReadStream, createWriteStream, existsSync, mkdirSync, openSync, readdirSync, renameSync, statSync, truncateSync, unlinkSync, writeSync, } from 'node:fs';
+import { readdir, unlink } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { createGzip } from 'node:zlib';
+export class RotatingWriter {
+    fd;
+    bytesWritten;
+    lastRotationDate;
+    rotating = false;
+    compressionChain = Promise.resolve();
+    filePath;
+    maxSize;
+    maxFiles;
+    maxAge;
+    // Cache todayString() — only recompute once per second
+    cachedDateString;
+    cachedDateAt = 0;
+    constructor(filePath, maxSize, maxFiles, maxAge = 0) {
+        this.filePath = filePath;
+        this.maxSize = maxSize;
+        this.maxFiles = maxFiles;
+        this.maxAge = maxAge;
+        // Ensure parent directory exists (handles restarts after dir deletion)
+        mkdirSync(dirname(filePath), { recursive: true });
+        // Seed bytesWritten from existing file
+        try {
+            this.bytesWritten = statSync(filePath).size;
+        }
+        catch {
+            this.bytesWritten = 0;
+        }
+        this.cachedDateString = this.computeDateString();
+        this.cachedDateAt = Date.now();
+        this.lastRotationDate = this.cachedDateString;
+        // Open file descriptor in append mode (creates file if it doesn't exist)
+        this.fd = openSync(filePath, 'a');
+    }
+    write(data) {
+        try {
+            writeSync(this.fd, data);
+        }
+        catch (err) {
+            // Self-heal a closed fd (e.g., from a failed rotation on a full disk)
+            if (err.code === 'EBADF') {
+                try {
+                    mkdirSync(dirname(this.filePath), { recursive: true });
+                    this.fd = openSync(this.filePath, 'a');
+                    writeSync(this.fd, data);
+                }
+                catch {
+                    return;
+                }
+            }
+            else {
+                console.error(`Log write error (${this.filePath}):`, err.message);
+                return;
+            }
+        }
+        this.bytesWritten += Buffer.byteLength(data);
+        if (this.maxFiles > 0 && !this.rotating) {
+            const today = this.todayString();
+            if (this.bytesWritten >= this.maxSize || today !== this.lastRotationDate) {
+                this.rotate();
+            }
+        }
+    }
+    rotate() {
+        try {
+            this.rotating = true;
+            const now = new Date();
+            const timestamp = this.formatTimestamp(now);
+            const rotatedPath = `${this.filePath}-${timestamp}`;
+            // Close the current fd so all data is flushed to the inode
+            closeSync(this.fd);
+            // Rename the file — the data stays with the inode
+            renameSync(this.filePath, rotatedPath);
+            // Open a new fd at the original path
+            this.fd = openSync(this.filePath, 'a');
+            this.bytesWritten = 0;
+            this.lastRotationDate = this.todayString();
+            this.rotating = false;
+            // Chain compressions so they run sequentially and drain() awaits all of them
+            this.compressionChain = this.compressionChain
+                .then(() => this.compressAndPrune(rotatedPath))
+                .catch((err) => {
+                console.error(`Log compression error (${rotatedPath}):`, err.message);
+            });
+        }
+        catch (err) {
+            this.rotating = false;
+            console.error(`Log rotation error (${this.filePath}):`, err.message);
+            // Try to re-open fd if it was closed
+            try {
+                this.fd = openSync(this.filePath, 'a');
+            }
+            catch {
+                // Nothing more we can do
+            }
+        }
+    }
+    async compressAndPrune(uncompressedPath) {
+        // Skip if already compressed by a previous call's prune step.
+        // Without this guard, createWriteStream truncates the valid .gz to 0 bytes
+        // before createReadStream fails with ENOENT, corrupting the archive.
+        if (existsSync(uncompressedPath)) {
+            const gzPath = `${uncompressedPath}.gz`;
+            try {
+                await pipeline(createReadStream(uncompressedPath), createGzip(), createWriteStream(gzPath));
+                unlinkSync(uncompressedPath);
+            }
+            catch (err) {
+                console.error(`Log compression error (${uncompressedPath}):`, err.message);
+                // Leave uncompressed file — bare files are cleaned up on next prune cycle
+            }
+        }
+        // Prune old archives and bare files left by failed compressions
+        try {
+            const dir = dirname(this.filePath);
+            const base = basename(this.filePath);
+            const files = await readdir(dir);
+            // Compress bare timestamped files left by failed/interrupted compressions.
+            // If a .gz already exists for the same timestamp (corrupt from crash), replace it.
+            const bareFiles = files.filter((f) => f.startsWith(`${base}-`) && !f.endsWith('.gz'));
+            for (const bare of bareFiles) {
+                const barePath = join(dir, bare);
+                if (!existsSync(barePath))
+                    continue;
+                const bareGzPath = `${barePath}.gz`;
+                try {
+                    await pipeline(createReadStream(barePath), createGzip(), createWriteStream(bareGzPath));
+                    await unlink(barePath);
+                }
+                catch {
+                    // If compression fails, delete the bare file to prevent infinite retries
+                    try {
+                        await unlink(barePath);
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+            }
+            // Prune .gz archives by age and count
+            const archives = files.filter((f) => f.startsWith(`${base}-`) && f.endsWith('.gz')).sort();
+            // Delete archives older than maxAge
+            if (this.maxAge > 0) {
+                const cutoff = Date.now() - this.maxAge;
+                for (let i = archives.length - 1; i >= 0; i--) {
+                    const ts = this.parseArchiveTimestamp(archives[i], base);
+                    if (ts > 0 && ts < cutoff) {
+                        try {
+                            await unlink(join(dir, archives[i]));
+                            archives.splice(i, 1);
+                        }
+                        catch {
+                            // Ignore
+                        }
+                    }
+                }
+            }
+            // Delete oldest archives if count exceeds maxFiles
+            while (archives.length > this.maxFiles) {
+                const oldest = archives.shift();
+                try {
+                    await unlink(join(dir, oldest));
+                }
+                catch {
+                    // Ignore individual delete errors
+                }
+            }
+        }
+        catch {
+            // Ignore prune errors
+        }
+    }
+    async flush() {
+        // Wait for any in-flight compression to finish before cleaning up
+        await this.compressionChain;
+        try {
+            closeSync(this.fd);
+        }
+        catch {
+            // fd may already be closed
+        }
+        try {
+            truncateSync(this.filePath, 0);
+        }
+        catch {
+            // File may not exist
+        }
+        // Remove all rotated files (compressed and bare)
+        const dir = dirname(this.filePath);
+        const base = basename(this.filePath);
+        try {
+            const files = readdirSync(dir);
+            for (const f of files) {
+                if (f.startsWith(`${base}-`)) {
+                    try {
+                        unlinkSync(join(dir, f));
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore
+        }
+        this.fd = openSync(this.filePath, 'a');
+        this.bytesWritten = 0;
+    }
+    end() {
+        try {
+            closeSync(this.fd);
+        }
+        catch {
+            // fd may already be closed
+        }
+    }
+    /** Wait for all pending compressions to complete. */
+    async drain() {
+        await this.compressionChain;
+    }
+    todayString() {
+        const now = Date.now();
+        // Recompute at most once per second
+        if (now - this.cachedDateAt >= 1000) {
+            this.cachedDateString = this.computeDateString();
+            this.cachedDateAt = now;
+        }
+        return this.cachedDateString;
+    }
+    computeDateString() {
+        const now = new Date();
+        return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+    }
+    /** Parse epoch ms from archive filename like `app.stdout.log-20260217T143052.123.gz` */
+    parseArchiveTimestamp(filename, base) {
+        // Extract timestamp portion: after `{base}-` and before `.gz`
+        const prefix = `${base}-`;
+        if (!filename.startsWith(prefix) || !filename.endsWith('.gz'))
+            return 0;
+        const ts = filename.slice(prefix.length, -3); // remove prefix and .gz
+        // Format: YYYYMMDDTHHMMSS.mmm
+        const match = ts.match(/^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(?:\.(\d{3}))?$/);
+        if (!match)
+            return 0;
+        const [, y, mo, d, h, mi, s, ms] = match;
+        return new Date(+y, +mo - 1, +d, +h, +mi, +s, +(ms || 0)).getTime();
+    }
+    formatTimestamp(date) {
+        const y = date.getFullYear();
+        const m = String(date.getMonth() + 1).padStart(2, '0');
+        const d = String(date.getDate()).padStart(2, '0');
+        const h = String(date.getHours()).padStart(2, '0');
+        const min = String(date.getMinutes()).padStart(2, '0');
+        const sec = String(date.getSeconds()).padStart(2, '0');
+        const milli = String(date.getMilliseconds()).padStart(3, '0');
+        return `${y}${m}${d}T${h}${min}${sec}.${milli}`;
+    }
+}
+//# sourceMappingURL=RotatingWriter.js.map

package/dist/daemon/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/daemon/index.js

@@ -0,0 +1,106 @@
+import { spawn as spawnChild } from 'node:child_process';
+import { openSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DAEMON_LOG_FILE } from '../constants.js';
+import { startDaemon } from './startDaemon.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ctx = await startDaemon({ foreground: false });
+const { orchestrator, gracefulShutdown, cleanup } = ctx;
+/**
+ * Spawn a detached crash-recovery process that will start a new daemon
+ * and restore all running process configs. Only runs once — if this daemon
+ * was itself started by crash recovery (ORKIFY_CRASH_RECOVERY is set),
+ * we skip to prevent infinite crash loops.
+ */
+function crashRecovery() {
+    if (process.env.ORKIFY_CRASH_RECOVERY) {
+        console.error('Skipping crash recovery — this daemon was started by crash recovery');
+        return;
+    }
+    try {
+        const configs = orchestrator.getRunningConfigs();
+        const mcpOptions = ctx.getMcpOptions();
+        if (configs.length === 0 && !mcpOptions) {
+            console.error('Crash recovery: no running processes to restore');
+            return;
+        }
+        const env = {};
+        if (process.env.ORKIFY_API_KEY)
+            env.ORKIFY_API_KEY = process.env.ORKIFY_API_KEY;
+        if (process.env.ORKIFY_API_HOST)
+            env.ORKIFY_API_HOST = process.env.ORKIFY_API_HOST;
+        const payload = JSON.stringify({
+            env,
+            configs,
+            mcpOptions: mcpOptions ?? undefined,
+            daemonPid: process.pid,
+        });
+        const recoveryScript = join(__dirname, '..', 'cli', 'crash-recovery.js');
+        // Remove PID file and socket now so the recovery script doesn't have to
+        // wait for gracefulShutdown() — which may hang in a crashing process.
+        cleanup();
+        ctx.markSkipServerStop();
+        const logFd = openSync(DAEMON_LOG_FILE, 'a');
+        const child = spawnChild(process.execPath, [recoveryScript], {
+            detached: true,
+            stdio: ['ignore', logFd, logFd],
+            env: { ...process.env, ORKIFY_CRASH_RECOVERY: payload },
+        });
+        child.unref();
+        console.error(`Crash recovery: spawned recovery process (PID: ${child.pid})`);
+    }
+    catch (err) {
+        console.error('Crash recovery: failed to spawn recovery process:', err.message);
+    }
+}
+// SIGUSR2 handler for crash testing (Unix only) — triggers an uncaught exception
+// which exercises the crashRecovery → gracefulShutdown → exit path.
+if (process.platform !== 'win32') {
+    process.on('SIGUSR2', () => {
+        throw new Error('SIGUSR2 crash trigger');
+    });
+}
+process.on('SIGTERM', async () => {
+    await gracefulShutdown();
+    process.exit(0);
+});
+process.on('SIGINT', async () => {
+    await gracefulShutdown();
+    process.exit(0);
+});
+process.on('uncaughtException', async (err) => {
+    console.error('Uncaught exception:', err);
+    crashRecovery();
+    await gracefulShutdown();
+    process.exit(1);
+});
+process.on('unhandledRejection', async (reason) => {
+    console.error('Unhandled rejection:', reason);
+    crashRecovery();
+    await gracefulShutdown();
+    process.exit(1);
+});
+// Start the server
+ctx
+    .startServer()
+    .then(() => {
+    console.log(`ORKIFY daemon started (PID: ${process.pid})`);
+    // If this daemon was started by crash recovery, re-enable crash recovery
+    // after a stability window. If it crashes again within 60s it's likely
+    // the same root cause — the guard in crashRecovery() prevents a loop.
+    if (process.env.ORKIFY_CRASH_RECOVERY) {
+        const stabilityTimer = setTimeout(() => {
+            delete process.env.ORKIFY_CRASH_RECOVERY;
+            console.log('Crash recovery re-enabled after stability window');
+        }, 60_000);
+        stabilityTimer.unref();
+    }
+})
+    .catch((err) => {
+    console.error('Failed to start daemon:', err);
+    cleanup();
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/daemon/startDaemon.d.ts

@@ -0,0 +1,30 @@
+import type { McpStartPayload } from '../types/index.js';
+import { CronScheduler } from '../cron/CronScheduler.js';
+import { DaemonServer } from '../ipc/DaemonServer.js';
+import { TelemetryReporter } from '../telemetry/TelemetryReporter.js';
+import { Orchestrator } from './Orchestrator.js';
+export interface DaemonOptions {
+    /** Skip crash recovery, adjust KILL_DAEMON behavior (no process.exit) */
+    foreground?: boolean;
+    /** Don't monkey-patch console.log with timestamp prefixes */
+    skipTimestampPrefix?: boolean;
+}
+export interface DaemonContext {
+    orchestrator: Orchestrator;
+    cronScheduler: CronScheduler;
+    server: DaemonServer;
+    telemetry: null | TelemetryReporter;
+    startMcpHttp: (opts: McpStartPayload) => Promise<void>;
+    getMcpOptions: () => McpStartPayload | null;
+    gracefulShutdown: (opts?: {
+        persistCache?: boolean;
+    }) => Promise<void>;
+    /** Bind IPC socket and start listening */
+    startServer: () => Promise<void>;
+    cleanup: () => void;
+    /** Mark that server.stop()/cleanup() should be skipped during shutdown
+     * (e.g. because crash recovery already cleaned up the socket). */
+    markSkipServerStop: () => void;
+}
+export declare function startDaemon(options?: DaemonOptions): Promise<DaemonContext>;
+//# sourceMappingURL=startDaemon.d.ts.map