@orkify/cli 1.0.0-beta.5

package/dist/cli/commands/up.js

@@ -0,0 +1,125 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { resolve } from 'node:path';
+import { DEFAULT_LOG_MAX_AGE, DEFAULT_LOG_MAX_FILES, DEFAULT_LOG_MAX_SIZE, IPCMessageType, ProcessStatus, } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+import { parseCronSpecs, parseLogSize, parseMemorySize, parseWorkers, sleep } from '../parse.js';
+import { formatProcessTable } from './list.js';
+function isAllOnline(processes, name, expectedWorkers) {
+    const proc = processes.find((p) => p.name === name);
+    if (!proc)
+        return false;
+    if (proc.status === ProcessStatus.ERRORED)
+        return true; // Don't wait forever on errors
+    if (expectedWorkers <= 1) {
+        return proc.status === ProcessStatus.ONLINE;
+    }
+    const onlineWorkers = proc.workers.filter((w) => w.status === ProcessStatus.ONLINE).length;
+    return onlineWorkers >= expectedWorkers;
+}
+async function waitForReady(name, expectedWorkers) {
+    const isTTY = process.stdout.isTTY;
+    let prevLines = 0;
+    const maxWait = 30_000;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+        const listResponse = await daemonClient.request(IPCMessageType.LIST);
+        if (!listResponse.success)
+            break;
+        const processes = listResponse.data;
+        const tableStr = formatProcessTable(processes);
+        if (isTTY && prevLines > 0) {
+            process.stdout.write(`\x1B[${prevLines}A\x1B[J`);
+        }
+        process.stdout.write(tableStr + '\n');
+        prevLines = tableStr.split('\n').length;
+        if (isAllOnline(processes, name, expectedWorkers))
+            return;
+        // Non-TTY: print once and stop (can't overwrite)
+        if (!isTTY)
+            return;
+        await sleep(300);
+    }
+}
+export const upCommand = new Command('up')
+    .description('Start a process in daemon mode')
+    .argument('<script>', 'Script file to run')
+    .option('-n, --name <name>', 'Process name')
+    .option('-w, --workers <number>', 'Number of workers (0 = CPU cores, -1 = CPUs-1)', '1')
+    .option('--watch', 'Watch for file changes and reload')
+    .option('--watch-paths <paths...>', 'Specific paths to watch')
+    .option('--cwd <path>', 'Working directory')
+    .option('--node-args <args>', 'Node.js arguments (space-separated, quoted)')
+    .option('--args <args>', 'Script arguments (space-separated, quoted)')
+    .option('--kill-timeout <ms>', 'Kill timeout in milliseconds', '5000')
+    .option('--max-restarts <count>', 'Maximum restart attempts', '10')
+    .option('--min-uptime <ms>', 'Minimum uptime before restart counts', '1000')
+    .option('--restart-delay <ms>', 'Delay between restarts', '100')
+    .option('--sticky', 'Enable sticky sessions for Socket.IO')
+    .option('--port <port>', 'Port for sticky session routing (required with --sticky)')
+    .option('--reload-retries <count>', 'Retries per worker slot during reload (0-3)', '3')
+    .option('--health-check <path>', 'Health check endpoint path (e.g. /health)')
+    .option('--log-max-size <size>', 'Max log file size before rotation (e.g. 100M, 500K, 1G)', String(DEFAULT_LOG_MAX_SIZE))
+    .option('--log-max-files <count>', 'Rotated log files to keep (0 = no rotation)', String(DEFAULT_LOG_MAX_FILES))
+    .option('--log-max-age <days>', 'Delete rotated log files older than N days (0 = no age limit)', String(DEFAULT_LOG_MAX_AGE / (24 * 60 * 60 * 1000)))
+    .option('--restart-on-mem <size>', 'Restart when RSS exceeds threshold (e.g. 512M, 1G)')
+    .option('--restart-on-memory <size>', 'Alias for --restart-on-mem')
+    .option('--cron <spec...>', 'Cron job: "schedule path" (repeatable, e.g. "*/2 * * * * /api/cron/heartbeat-check")')
+    .action(async (script, options) => {
+    try {
+        // Validate script path
+        if (!script || script.trim() === '') {
+            console.error(chalk.red('✗ Error: Script path is required'));
+            process.exit(1);
+        }
+        const restartOnMemRaw = options.restartOnMem || options.restartOnMemory;
+        const cronJobs = options.cron ? parseCronSpecs(options.cron) : [];
+        const payload = {
+            script: resolve(options.cwd || process.cwd(), script),
+            name: options.name,
+            workers: parseWorkers(options.workers),
+            watch: options.watch || false,
+            watchPaths: options.watchPaths,
+            cwd: options.cwd || process.cwd(),
+            // Pass current process.env to daemon - includes vars from Node's --env-file
+            env: process.env,
+            nodeArgs: options.nodeArgs ? options.nodeArgs.split(/\s+/) : [],
+            args: options.args ? options.args.split(/\s+/) : [],
+            killTimeout: parseInt(options.killTimeout, 10),
+            maxRestarts: parseInt(options.maxRestarts, 10),
+            minUptime: parseInt(options.minUptime, 10),
+            restartDelay: parseInt(options.restartDelay, 10),
+            sticky: options.sticky || false,
+            port: options.port ? parseInt(options.port, 10) : undefined,
+            reloadRetries: parseInt(options.reloadRetries, 10),
+            healthCheck: options.healthCheck,
+            logMaxSize: parseLogSize(options.logMaxSize),
+            logMaxFiles: parseInt(options.logMaxFiles, 10),
+            logMaxAge: parseInt(options.logMaxAge, 10) * 24 * 60 * 60 * 1000,
+            restartOnMemory: restartOnMemRaw ? parseMemorySize(restartOnMemRaw) : undefined,
+            cron: cronJobs.length > 0 ? cronJobs : undefined,
+        };
+        const response = await daemonClient.request(IPCMessageType.UP, payload);
+        if (response.success) {
+            const info = response.data;
+            console.log(chalk.green(`✓ Process "${info.name}" started`));
+            console.log(`  Mode: ${info.execMode} | Workers: ${info.workerCount}`);
+            if (info.sticky) {
+                console.log(`  Sticky sessions: enabled`);
+            }
+            await waitForReady(info.name, info.workerCount);
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to start: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=up.js.map

package/dist/cli/crash-recovery.d.ts

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

package/dist/cli/crash-recovery.js

@@ -0,0 +1,67 @@
+import { IPCMessageType } from '../constants.js';
+import { DaemonClient } from '../ipc/DaemonClient.js';
+import { restoreDaemon } from '../ipc/restoreDaemon.js';
+/**
+ * Wait for a process to exit by polling kill(pid, 0).
+ */
+async function waitForPidDead(pid, maxWait) {
+    const deadline = Date.now() + maxWait;
+    while (Date.now() < deadline) {
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            return; // Process is dead
+        }
+        await new Promise((r) => setTimeout(r, 50));
+    }
+}
+async function main() {
+    const raw = process.env.ORKIFY_CRASH_RECOVERY;
+    if (!raw)
+        process.exit(0);
+    const { env, configs, mcpOptions, daemonPid } = JSON.parse(raw);
+    if (env.ORKIFY_API_KEY)
+        process.env.ORKIFY_API_KEY = env.ORKIFY_API_KEY;
+    if (env.ORKIFY_API_HOST)
+        process.env.ORKIFY_API_HOST = env.ORKIFY_API_HOST;
+    // Wait for the old daemon process to fully exit before starting a new one.
+    // The PID file is already removed by cleanup(), but on Windows the named pipe
+    // stays open until the process exits — causing the new daemon to fail to bind.
+    if (daemonPid) {
+        await waitForPidDead(daemonPid, 10_000);
+    }
+    const client = new DaemonClient();
+    try {
+        const response = await restoreDaemon(client, configs);
+        if (response.success) {
+            console.log('Crash recovery: processes restored');
+        }
+        else {
+            console.error('Crash recovery: restore failed:', response.error);
+        }
+        // Restore MCP HTTP server if it was running
+        if (mcpOptions) {
+            try {
+                const mcpResponse = await client.request(IPCMessageType.MCP_START, mcpOptions);
+                if (mcpResponse.success) {
+                    console.log('Crash recovery: MCP HTTP server restored');
+                }
+                else {
+                    console.error('Crash recovery: MCP restore failed:', mcpResponse.error);
+                }
+            }
+            catch (err) {
+                console.error('Crash recovery: MCP restore error:', err.message);
+            }
+        }
+    }
+    finally {
+        client.disconnect();
+    }
+}
+main().catch((err) => {
+    console.error('Crash recovery error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=crash-recovery.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { autostartCommand } from './commands/autostart.js';
+import { crashTestCommand } from './commands/crash-test.js';
+import { daemonReloadCommand } from './commands/daemon-reload.js';
+import { deleteCommand } from './commands/delete.js';
+import { deployCommand } from './commands/deploy.js';
+import { downCommand } from './commands/down.js';
+import { flushCommand } from './commands/flush.js';
+import { killCommand } from './commands/kill.js';
+import { listCommand } from './commands/list.js';
+import { logsCommand } from './commands/logs.js';
+import { mcpCommand } from './commands/mcp.js';
+import { reloadCommand } from './commands/reload.js';
+import { restartCommand } from './commands/restart.js';
+import { restoreCommand } from './commands/restore.js';
+import { runCommand } from './commands/run.js';
+import { snapCommand } from './commands/snap.js';
+import { upCommand } from './commands/up.js';
+const program = new Command();
+program
+    .name('orkify')
+    .description('Modern JS process orchestration and deployment for your own infrastructure')
+    .version(JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '../../package.json'), 'utf-8')).version);
+program.addCommand(upCommand);
+program.addCommand(downCommand);
+program.addCommand(runCommand);
+program.addCommand(restartCommand);
+program.addCommand(reloadCommand);
+program.addCommand(listCommand);
+program.addCommand(logsCommand);
+program.addCommand(deleteCommand);
+program.addCommand(flushCommand);
+program.addCommand(snapCommand);
+program.addCommand(restoreCommand);
+program.addCommand(killCommand);
+program.addCommand(daemonReloadCommand);
+program.addCommand(deployCommand);
+program.addCommand(mcpCommand);
+program.addCommand(autostartCommand);
+program.addCommand(crashTestCommand);
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/cli/parse.d.ts

@@ -0,0 +1,28 @@
+import type { CronJob } from '../types/index.js';
+/**
+ * Parse human-readable size for log rotation config.
+ * Falls back to DEFAULT_LOG_MAX_SIZE on invalid input.
+ * Enforces MIN_LOG_MAX_SIZE minimum.
+ */
+export declare function parseLogSize(value: string): number;
+/**
+ * Parse human-readable size for memory threshold.
+ * Exits process on invalid input (CLI validation).
+ */
+export declare function parseMemorySize(value: string): number;
+/**
+ * Parse workers option:
+ * - "0" → CPU cores
+ * - negative number → CPU cores minus that value (-1 = CPUs - 1)
+ * - positive number → that many workers
+ */
+export declare function parseWorkers(value: string): number;
+/**
+ * Parse --cron spec strings into CronJob objects.
+ * Each spec is "schedule path" where schedule is a 5-part cron expression
+ * and path is the last whitespace-separated token.
+ * Exits process on validation failure.
+ */
+export declare function parseCronSpecs(specs: string[]): CronJob[];
+export declare function sleep(ms: number): Promise<void>;
+//# sourceMappingURL=parse.d.ts.map

package/dist/cli/parse.js

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+import { cpus } from 'node:os';
+import { DEFAULT_LOG_MAX_SIZE, MIN_LOG_MAX_SIZE } from '../constants.js';
+import { validateCronPath, validateCronSchedule } from '../cron/CronScheduler.js';
+/**
+ * Core byte parser. Supports: 100M, 500K, 1G, 1.5G, or raw byte count.
+ * Returns null if the string is not a valid size.
+ */
+function parseSizeBytes(value) {
+    const match = value.match(/^(\d+(?:\.\d+)?)\s*([kmg]?)b?$/i);
+    if (!match) {
+        const num = parseInt(value, 10);
+        return isNaN(num) ? null : num;
+    }
+    const num = parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    switch (unit) {
+        case 'k':
+            return Math.round(num * 1024);
+        case 'm':
+            return Math.round(num * 1024 * 1024);
+        case 'g':
+            return Math.round(num * 1024 * 1024 * 1024);
+        default:
+            return Math.round(num);
+    }
+}
+/**
+ * Parse human-readable size for log rotation config.
+ * Falls back to DEFAULT_LOG_MAX_SIZE on invalid input.
+ * Enforces MIN_LOG_MAX_SIZE minimum.
+ */
+export function parseLogSize(value) {
+    return Math.max(parseSizeBytes(value) ?? DEFAULT_LOG_MAX_SIZE, MIN_LOG_MAX_SIZE);
+}
+/**
+ * Parse human-readable size for memory threshold.
+ * Exits process on invalid input (CLI validation).
+ */
+export function parseMemorySize(value) {
+    const bytes = parseSizeBytes(value);
+    if (bytes === null || bytes <= 0) {
+        console.error(`Invalid memory size: ${value}`);
+        process.exit(1);
+    }
+    return bytes;
+}
+/**
+ * Parse workers option:
+ * - "0" → CPU cores
+ * - negative number → CPU cores minus that value (-1 = CPUs - 1)
+ * - positive number → that many workers
+ */
+export function parseWorkers(value) {
+    const num = parseInt(value, 10);
+    if (isNaN(num))
+        return 1;
+    if (num === 0)
+        return cpus().length;
+    if (num < 0)
+        return Math.max(1, cpus().length + num);
+    return num;
+}
+/**
+ * Parse --cron spec strings into CronJob objects.
+ * Each spec is "schedule path" where schedule is a 5-part cron expression
+ * and path is the last whitespace-separated token.
+ * Exits process on validation failure.
+ */
+export function parseCronSpecs(specs) {
+    const cronJobs = [];
+    for (const spec of specs) {
+        const tokens = spec.trim().split(/\s+/);
+        if (tokens.length < 6) {
+            console.error(chalk.red(`✗ Invalid --cron spec: "${spec}" (need 5-part schedule + path)`));
+            process.exit(1);
+        }
+        const path = tokens[tokens.length - 1];
+        const schedule = tokens.slice(0, -1).join(' ');
+        const pathError = validateCronPath(path);
+        if (pathError) {
+            console.error(chalk.red(`✗ Invalid --cron: ${pathError}`));
+            process.exit(1);
+        }
+        const scheduleError = validateCronSchedule(schedule);
+        if (scheduleError) {
+            console.error(chalk.red(`✗ Invalid --cron: ${scheduleError}`));
+            process.exit(1);
+        }
+        cronJobs.push({ schedule, path });
+    }
+    return cronJobs;
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=parse.js.map

package/dist/cluster/ClusterWrapper.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * ClusterWrapper - Primary process that manages worker lifecycle
+ *
+ * This script is spawned by ManagedProcess when running in cluster mode.
+ * It uses Node's cluster module to fork workers that share the same port.
+ *
+ * Environment variables expected:
+ * - ORKIFY_SCRIPT: Path to the user's script
+ * - ORKIFY_WORKERS: Number of workers to spawn
+ * - ORKIFY_PROCESS_NAME: Process name for logging
+ * - ORKIFY_PROCESS_ID: Process ID in ORKIFY
+ * - ORKIFY_KILL_TIMEOUT: Timeout for graceful shutdown
+ * - ORKIFY_STICKY: Whether to use sticky sessions
+ * - ORKIFY_ARGS: JSON-encoded array of arguments to pass to the user script
+ */
+export {};
+//# sourceMappingURL=ClusterWrapper.d.ts.map