@orkify/cli 1.0.0-beta.5

package/dist/daemon/Orchestrator.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from 'node:events';
+import type { McpStartPayload, ProcessConfig, ProcessInfo, ReconcileResult, UpPayload } from '../types/index.js';
+import { ManagedProcess } from './ManagedProcess.js';
+export declare class Orchestrator extends EventEmitter {
+    private processes;
+    private nameToId;
+    private nextProcessId;
+    private gracefulManager;
+    private stateStore;
+    private startedAt;
+    constructor();
+    up(payload: UpPayload): Promise<ProcessInfo>;
+    down(target: 'all' | number | string): Promise<ProcessInfo[]>;
+    restart(target: 'all' | number | string): Promise<ProcessInfo[]>;
+    reload(target: 'all' | number | string): Promise<ProcessInfo[]>;
+    delete(target: 'all' | number | string): Promise<ProcessInfo[]>;
+    flushLogs(target: 'all' | number | string): Promise<void>;
+    list(): ProcessInfo[];
+    getRunningConfigs(): ProcessConfig[];
+    snap(options?: {
+        noEnv?: boolean;
+        file?: string;
+        mcpOptions?: McpStartPayload;
+    }): Promise<void>;
+    restoreFromMemory(configs: ProcessConfig[]): Promise<ProcessInfo[]>;
+    restoreFromSnapshot(file?: string): Promise<{
+        processes: ProcessInfo[];
+        configs: ProcessConfig[];
+        mcpState?: McpStartPayload;
+    }>;
+    shutdown(opts?: {
+        persistCache?: boolean;
+    }): Promise<void>;
+    /**
+     * Immediately SIGKILL all child processes without waiting for graceful shutdown.
+     */
+    forceShutdown(): void;
+    reconcile(configs: ProcessConfig[], env?: Record<string, string>): Promise<ReconcileResult>;
+    private configChanged;
+    private resolveTarget;
+    getProcess(target: number | string): ManagedProcess | undefined;
+    getCronSecret(name: string): string | undefined;
+    getProcessByName(name: string): ManagedProcess | undefined;
+    getDaemonStatus(): {
+        pid: number;
+        uptime: number;
+        processCount: number;
+        workerCount: number;
+    };
+}
+//# sourceMappingURL=Orchestrator.d.ts.map

package/dist/daemon/Orchestrator.js

@@ -0,0 +1,416 @@
+import { randomBytes } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { existsSync } from 'node:fs';
+import { cpus } from 'node:os';
+import { basename, resolve } from 'node:path';
+import { DEFAULT_LOG_MAX_AGE, DEFAULT_LOG_MAX_FILES, DEFAULT_LOG_MAX_SIZE, DEFAULT_MAX_RESTARTS, DEFAULT_MIN_UPTIME, DEFAULT_RELOAD_RETRIES, DEFAULT_RESTART_DELAY, DEFAULT_WORKERS, ExecMode, KILL_TIMEOUT, } from '../constants.js';
+import { detectFramework } from '../detect/framework.js';
+import { StateStore } from '../state/StateStore.js';
+import { GracefulManager } from './GracefulManager.js';
+import { ManagedProcess } from './ManagedProcess.js';
+export class Orchestrator extends EventEmitter {
+    processes = new Map();
+    nameToId = new Map();
+    nextProcessId = 0;
+    gracefulManager;
+    stateStore;
+    startedAt;
+    constructor() {
+        super();
+        this.gracefulManager = new GracefulManager();
+        this.stateStore = new StateStore();
+        this.startedAt = Date.now();
+    }
+    async up(payload) {
+        const script = resolve(payload.cwd || process.cwd(), payload.script);
+        if (!existsSync(script)) {
+            throw new Error(`Script not found: ${script}`);
+        }
+        const name = payload.name || basename(script, '.js');
+        // Check if process with same name exists
+        if (this.nameToId.has(name)) {
+            // Safe: .has() guard above guarantees a defined value
+            const existingId = this.nameToId.get(name);
+            const existing = this.processes.get(existingId);
+            // Allow re-using the name if the existing process is stopped
+            if (existing && !existing.isRunning()) {
+                this.processes.delete(existingId);
+                this.nameToId.delete(name);
+            }
+            else {
+                throw new Error(`Process "${name}" already exists`);
+            }
+        }
+        const rawWorkers = payload.workers ?? DEFAULT_WORKERS;
+        const workerCount = rawWorkers === 0 ? cpus().length : rawWorkers;
+        const execMode = workerCount > 1 ? ExecMode.CLUSTER : ExecMode.FORK;
+        const cwd = payload.cwd || process.cwd();
+        const config = {
+            name,
+            script,
+            cwd,
+            workerCount,
+            execMode,
+            watch: payload.watch || false,
+            watchPaths: payload.watchPaths,
+            env: payload.env || {},
+            nodeArgs: payload.nodeArgs || [],
+            args: payload.args || [],
+            killTimeout: payload.killTimeout || KILL_TIMEOUT,
+            maxRestarts: payload.maxRestarts ?? DEFAULT_MAX_RESTARTS,
+            minUptime: payload.minUptime ?? DEFAULT_MIN_UPTIME,
+            restartDelay: payload.restartDelay ?? DEFAULT_RESTART_DELAY,
+            sticky: payload.sticky || false,
+            port: payload.port,
+            reloadRetries: payload.reloadRetries ?? DEFAULT_RELOAD_RETRIES,
+            healthCheck: payload.healthCheck,
+            logMaxSize: payload.logMaxSize ?? DEFAULT_LOG_MAX_SIZE,
+            logMaxFiles: payload.logMaxFiles ?? DEFAULT_LOG_MAX_FILES,
+            logMaxAge: payload.logMaxAge ?? DEFAULT_LOG_MAX_AGE,
+            restartOnMemory: payload.restartOnMemory,
+            cron: payload.cron,
+            framework: payload.framework ?? detectFramework(cwd),
+        };
+        // Auto-generate a stable encryption key for Next.js Server Actions
+        if (config.framework === 'nextjs' && !config.env.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY) {
+            config.env.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY = randomBytes(32).toString('hex');
+        }
+        const processId = this.nextProcessId++;
+        const container = new ManagedProcess(processId, config);
+        // Set up event forwarding
+        container.on('log', (data) => {
+            this.emit('log', { processName: name, ...data });
+        });
+        container.on('worker:ready', (workerId) => {
+            this.emit('worker:ready', { processName: name, workerId });
+        });
+        container.on('worker:exit', (data) => {
+            this.emit('worker:exit', { processName: name, ...data });
+        });
+        container.on('worker:maxRestarts', (workerId) => {
+            this.emit('worker:maxRestarts', { processName: name, workerId });
+        });
+        container.on('worker:memoryRestart', (data) => {
+            this.emit('worker:memoryRestart', { processName: name, ...data });
+        });
+        container.on('worker:error:captured', (data) => {
+            this.emit('worker:error:captured', { processName: name, ...data });
+        });
+        container.on('watch:reload', () => {
+            this.reload(name).catch((err) => {
+                console.error(`Watch reload failed for ${name}:`, err.message);
+            });
+        });
+        this.processes.set(processId, container);
+        this.nameToId.set(name, processId);
+        try {
+            await container.start();
+        }
+        catch (err) {
+            this.processes.delete(processId);
+            this.nameToId.delete(name);
+            throw err;
+        }
+        this.emit('process:start', { processName: name, processId });
+        return container.getInfo();
+    }
+    async down(target) {
+        const containers = this.resolveTarget(target);
+        const results = [];
+        for (const container of containers) {
+            try {
+                await container.stop();
+                this.emit('process:stop', { processName: container.config.name, processId: container.id });
+                results.push(container.getInfo());
+            }
+            catch (err) {
+                console.error(`Failed to stop process "${container.config.name}":`, err.message);
+            }
+        }
+        return results;
+    }
+    async restart(target) {
+        const containers = this.resolveTarget(target);
+        const results = [];
+        for (const container of containers) {
+            try {
+                await container.restart();
+                results.push(container.getInfo());
+            }
+            catch (err) {
+                console.error(`Failed to restart process "${container.config.name}":`, err.message);
+            }
+        }
+        return results;
+    }
+    async reload(target) {
+        const containers = this.resolveTarget(target);
+        const results = [];
+        for (const container of containers) {
+            try {
+                this.emit('reload:start', { processName: container.config.name, processId: container.id });
+                await this.gracefulManager.reload(container);
+                this.emit('reload:complete', {
+                    processName: container.config.name,
+                    processId: container.id,
+                });
+                results.push(container.getInfo());
+            }
+            catch (err) {
+                console.error(`Failed to reload process "${container.config.name}":`, err.message);
+            }
+        }
+        return results;
+    }
+    async delete(target) {
+        const containers = this.resolveTarget(target);
+        const results = [];
+        for (const container of containers) {
+            try {
+                await container.stop();
+            }
+            catch (err) {
+                console.error(`Failed to stop process "${container.config.name}" during delete:`, err.message);
+            }
+            results.push(container.getInfo());
+            this.processes.delete(container.id);
+            this.nameToId.delete(container.config.name);
+        }
+        return results;
+    }
+    async flushLogs(target) {
+        const containers = this.resolveTarget(target);
+        await Promise.all(containers.map((c) => c.flushLogs()));
+    }
+    list() {
+        return Array.from(this.processes.values()).map((p) => p.getInfo());
+    }
+    getRunningConfigs() {
+        return Array.from(this.processes.values())
+            .filter((p) => p.isRunning())
+            .map((p) => p.config);
+    }
+    async snap(options) {
+        let configs = this.getRunningConfigs();
+        if (options?.noEnv) {
+            configs = configs.map((c) => ({ ...c, env: {} }));
+        }
+        const store = options?.file ? new StateStore(options.file) : this.stateStore;
+        await store.save(configs, options?.mcpOptions);
+    }
+    async restoreFromMemory(configs) {
+        const results = [];
+        for (const config of configs) {
+            if (this.nameToId.has(config.name)) {
+                continue;
+            }
+            try {
+                const info = await this.up({
+                    script: config.script,
+                    name: config.name,
+                    workers: config.workerCount,
+                    watch: config.watch,
+                    watchPaths: config.watchPaths,
+                    cwd: config.cwd,
+                    env: config.env,
+                    nodeArgs: config.nodeArgs,
+                    args: config.args,
+                    killTimeout: config.killTimeout,
+                    maxRestarts: config.maxRestarts,
+                    minUptime: config.minUptime,
+                    restartDelay: config.restartDelay,
+                    sticky: config.sticky,
+                    port: config.port,
+                    reloadRetries: config.reloadRetries,
+                    healthCheck: config.healthCheck,
+                    logMaxSize: config.logMaxSize,
+                    logMaxFiles: config.logMaxFiles,
+                    logMaxAge: config.logMaxAge,
+                    restartOnMemory: config.restartOnMemory,
+                    cron: config.cron,
+                    framework: config.framework,
+                });
+                results.push(info);
+            }
+            catch (err) {
+                console.error(`Failed to restore process "${config.name}":`, err.message);
+            }
+        }
+        return results;
+    }
+    async restoreFromSnapshot(file) {
+        const store = file ? new StateStore(file) : this.stateStore;
+        const state = await store.loadFull();
+        const processes = await this.restoreFromMemory(state.processes);
+        return { processes, configs: state.processes, mcpState: state.mcp };
+    }
+    async shutdown(opts) {
+        // Stop all processes in parallel for faster shutdown
+        await Promise.all(Array.from(this.processes.values()).map((container) => container.stop({ persistCache: opts?.persistCache }).catch((err) => {
+            console.error(`Failed to stop process "${container.config.name}" during shutdown:`, err.message);
+        })));
+        this.processes.clear();
+        this.nameToId.clear();
+    }
+    /**
+     * Immediately SIGKILL all child processes without waiting for graceful shutdown.
+     */
+    forceShutdown() {
+        for (const container of this.processes.values()) {
+            container.forceKill();
+        }
+        this.processes.clear();
+        this.nameToId.clear();
+    }
+    async reconcile(configs, env) {
+        const result = { started: [], reloaded: [], deleted: [] };
+        // Build name→config maps
+        const targetByName = new Map();
+        for (const config of configs) {
+            targetByName.set(config.name, config);
+        }
+        const runningNames = new Set(this.nameToId.keys());
+        // Delete processes not in target configs
+        for (const name of runningNames) {
+            if (!targetByName.has(name)) {
+                await this.delete(name);
+                result.deleted.push(name);
+            }
+        }
+        // Start new, reload unchanged, replace changed
+        for (const config of configs) {
+            const mergedEnv = { ...config.env, ...env };
+            const payload = {
+                script: config.script,
+                name: config.name,
+                workers: config.workerCount,
+                watch: config.watch,
+                watchPaths: config.watchPaths,
+                cwd: config.cwd,
+                env: mergedEnv,
+                nodeArgs: config.nodeArgs,
+                args: config.args,
+                killTimeout: config.killTimeout,
+                maxRestarts: config.maxRestarts,
+                minUptime: config.minUptime,
+                restartDelay: config.restartDelay,
+                sticky: config.sticky,
+                port: config.port,
+                reloadRetries: config.reloadRetries,
+                healthCheck: config.healthCheck,
+                logMaxSize: config.logMaxSize,
+                logMaxFiles: config.logMaxFiles,
+                logMaxAge: config.logMaxAge,
+                restartOnMemory: config.restartOnMemory,
+                cron: config.cron,
+                framework: config.framework,
+            };
+            if (!runningNames.has(config.name)) {
+                // New process
+                await this.up(payload);
+                result.started.push(config.name);
+            }
+            else {
+                const existing = this.getProcessByName(config.name);
+                if (existing && this.configChanged(existing.config, config)) {
+                    // Config changed — full restart
+                    await this.delete(config.name);
+                    await this.up(payload);
+                    result.started.push(config.name);
+                }
+                else {
+                    // Config unchanged — zero-downtime reload
+                    await this.reload(config.name);
+                    result.reloaded.push(config.name);
+                }
+            }
+        }
+        return result;
+    }
+    configChanged(running, target) {
+        // Compare config fields that matter (ignore env and cwd which vary between deploys)
+        const keys = [
+            'script',
+            'workerCount',
+            'nodeArgs',
+            'args',
+            'sticky',
+            'port',
+            'healthCheck',
+            'reloadRetries',
+            'watch',
+            'watchPaths',
+            'killTimeout',
+            'maxRestarts',
+            'minUptime',
+            'restartDelay',
+            'restartOnMemory',
+        ];
+        for (const key of keys) {
+            const a = running[key];
+            const b = target[key];
+            if (Array.isArray(a) && Array.isArray(b)) {
+                if (a.length !== b.length || a.some((v, i) => v !== b[i]))
+                    return true;
+            }
+            else if (a !== b) {
+                return true;
+            }
+        }
+        // Deep-compare cron (array of objects, not simple primitives)
+        if (JSON.stringify(running.cron ?? []) !== JSON.stringify(target.cron ?? []))
+            return true;
+        return false;
+    }
+    resolveTarget(target) {
+        if (target === 'all') {
+            return Array.from(this.processes.values());
+        }
+        if (typeof target === 'number') {
+            const container = this.processes.get(target);
+            if (!container) {
+                throw new Error(`Process with id ${target} not found`);
+            }
+            return [container];
+        }
+        // Try by name first
+        const id = this.nameToId.get(target);
+        if (id !== undefined) {
+            const container = this.processes.get(id);
+            if (container) {
+                return [container];
+            }
+        }
+        // Try parsing as number
+        const numId = parseInt(target, 10);
+        if (!isNaN(numId)) {
+            const container = this.processes.get(numId);
+            if (container) {
+                return [container];
+            }
+        }
+        throw new Error(`Process "${target}" not found`);
+    }
+    getProcess(target) {
+        const containers = this.resolveTarget(target);
+        return containers[0];
+    }
+    getCronSecret(name) {
+        return this.getProcessByName(name)?.cronSecret;
+    }
+    getProcessByName(name) {
+        const id = this.nameToId.get(name);
+        if (id === undefined)
+            return undefined;
+        return this.processes.get(id);
+    }
+    getDaemonStatus() {
+        return {
+            pid: process.pid,
+            uptime: Date.now() - this.startedAt,
+            processCount: this.processes.size,
+            workerCount: Array.from(this.processes.values()).reduce((sum, p) => sum + p.getWorkerCount(), 0),
+        };
+    }
+}
+//# sourceMappingURL=Orchestrator.js.map

package/dist/daemon/RotatingWriter.d.ts

@@ -0,0 +1,27 @@
+export declare class RotatingWriter {
+    private fd;
+    private bytesWritten;
+    private lastRotationDate;
+    private rotating;
+    private compressionChain;
+    readonly filePath: string;
+    private readonly maxSize;
+    private readonly maxFiles;
+    private readonly maxAge;
+    private cachedDateString;
+    private cachedDateAt;
+    constructor(filePath: string, maxSize: number, maxFiles: number, maxAge?: number);
+    write(data: string): void;
+    private rotate;
+    private compressAndPrune;
+    flush(): Promise<void>;
+    end(): void;
+    /** Wait for all pending compressions to complete. */
+    drain(): Promise<void>;
+    private todayString;
+    private computeDateString;
+    /** Parse epoch ms from archive filename like `app.stdout.log-20260217T143052.123.gz` */
+    private parseArchiveTimestamp;
+    private formatTimestamp;
+}
+//# sourceMappingURL=RotatingWriter.d.ts.map