@orkify/cli 1.0.0-beta.5

package/dist/cli/commands/mcp.js

@@ -0,0 +1,151 @@
+import chalk from 'chalk';
+import { Command, Option } from 'commander';
+import { IPCMessageType, MCP_DEFAULT_PORT } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+import { appendKeyToConfig, generateToken, loadMcpConfig, TOOL_NAMES, warnIfConfigInsecure, } from '../../mcp/auth.js';
+import { startMcpServer } from '../../mcp/server.js';
+export const mcpCommand = new Command('mcp')
+    .description('Start MCP server for AI tool integration (e.g., Claude Code)')
+    .addOption(new Option('--simple-http', 'Use HTTP transport with local key auth'))
+    .addOption(new Option('--advanced-http', 'Use HTTP transport with remote dashboard-managed keys'))
+    .addOption(new Option('--port <port>', 'HTTP port').default(MCP_DEFAULT_PORT).argParser(Number))
+    .addOption(new Option('--bind <address>', 'HTTP bind address').default('127.0.0.1'))
+    .addOption(new Option('--cors [origin]', 'Enable CORS ("*" for any origin, a specific URL, or comma-separated URLs)').preset('*'))
+    .action(async (opts) => {
+    try {
+        if (opts.simpleHttp && opts.advancedHttp) {
+            console.error(chalk.red('✗ --simple-http and --advanced-http are mutually exclusive'));
+            process.exit(1);
+        }
+        if (opts.simpleHttp || opts.advancedHttp) {
+            const transport = opts.advancedHttp ? 'advanced-http' : 'simple-http';
+            if (opts.simpleHttp)
+                warnIfConfigInsecure();
+            // Delegate to daemon via IPC
+            const payload = {
+                transport: transport,
+                port: opts.port,
+                bind: opts.bind,
+                cors: opts.cors,
+            };
+            const response = await daemonClient.request(IPCMessageType.MCP_START, payload);
+            if (!response.success) {
+                console.error(chalk.red(`✗ ${response.error}`));
+                process.exit(1);
+            }
+            const data = response.data;
+            if (data.waitingForConfig) {
+                console.log(chalk.green(`✓ MCP advanced-http registered — server will start after first config sync`));
+            }
+            else if (data.started) {
+                console.log(chalk.green(`✓ MCP HTTP server started on http://${data.bind}:${data.port}/mcp`));
+            }
+            else {
+                console.log(chalk.yellow(`MCP HTTP server already running on http://${data.bind}:${data.port}/mcp`));
+            }
+        }
+        else {
+            warnIfConfigInsecure();
+            await startMcpServer();
+        }
+    }
+    catch (err) {
+        // Use stderr for errors (stdout is reserved for MCP protocol)
+        console.error('MCP server error:', err.message);
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+mcpCommand
+    .command('stop')
+    .description('Stop the MCP HTTP server')
+    .action(async () => {
+    try {
+        const response = await daemonClient.request(IPCMessageType.MCP_STOP);
+        if (!response.success) {
+            console.error(chalk.red(`✗ ${response.error}`));
+            process.exit(1);
+        }
+        const data = response.data;
+        if (data.stopped) {
+            console.log(chalk.green('✓ MCP HTTP server stopped'));
+        }
+        else {
+            console.log(chalk.yellow('MCP HTTP server is not running'));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+mcpCommand
+    .command('status')
+    .description('Show MCP HTTP server status')
+    .action(async () => {
+    try {
+        const response = await daemonClient.request(IPCMessageType.MCP_STATUS);
+        if (!response.success) {
+            console.error(chalk.red(`✗ ${response.error}`));
+            process.exit(1);
+        }
+        const data = response.data;
+        if (data.running) {
+            console.log(chalk.green(`MCP server running (${data.transport}) on http://${data.bind}:${data.port}/mcp`));
+            if (data.cors)
+                console.log(`  CORS: ${data.cors}`);
+        }
+        else {
+            console.log('MCP HTTP server is not running');
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+mcpCommand
+    .command('keygen')
+    .description('Generate a new MCP API key and add it to ~/.orkify/mcp.yml')
+    .option('--name <name>', 'Key name for identification', 'default')
+    .option('--tools <tools>', 'Comma-separated list of allowed tools (default: all)')
+    .option('--allowed-ips <ips>', 'Comma-separated list of allowed IPs or CIDRs')
+    .action((opts) => {
+    const tools = opts.tools ? opts.tools.split(',').map((t) => t.trim()) : ['*'];
+    // Validate tool names (skip wildcard)
+    for (const tool of tools) {
+        if (tool !== '*' && !TOOL_NAMES.includes(tool)) {
+            console.error(`Unknown tool: "${tool}". Valid tools: ${TOOL_NAMES.join(', ')}`);
+            process.exit(1);
+        }
+    }
+    // Warn about duplicate names
+    try {
+        const existing = loadMcpConfig();
+        if (existing.keys.some((k) => k.name === opts.name)) {
+            console.error(`Warning: a key named "${opts.name}" already exists — creating a second entry`);
+        }
+    }
+    catch {
+        // Config unreadable — appendKeyToConfig will handle it
+    }
+    const token = generateToken();
+    const key = { name: opts.name, token, tools };
+    if (opts.allowedIps) {
+        key.allowedIps = opts.allowedIps.split(',').map((ip) => ip.trim());
+    }
+    appendKeyToConfig(key);
+    // Print token to stdout for piping; info to stderr
+    const extras = key.allowedIps ? `, allowedIps: ${key.allowedIps.join(', ')}` : '';
+    console.error(`Key "${opts.name}" added to mcp.yml (tools: ${tools.join(', ')}${extras})`);
+    console.log(token);
+});
+//# sourceMappingURL=mcp.js.map

package/dist/cli/commands/reload.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const reloadCommand: Command;
+//# sourceMappingURL=reload.d.ts.map

package/dist/cli/commands/reload.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { IPCMessageType } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+import { formatProcessTable } from './list.js';
+export const reloadCommand = new Command('reload')
+    .description('Zero-downtime reload - rolling restart of workers')
+    .argument('<target>', 'Process name, id, or "all"')
+    .action(async (target) => {
+    try {
+        const payload = {
+            target: target === 'all' ? 'all' : isNaN(Number(target)) ? target : Number(target),
+        };
+        console.log(chalk.blue(`⟳ Starting graceful reload...`));
+        const response = await daemonClient.request(IPCMessageType.RELOAD, payload);
+        if (response.success) {
+            const results = response.data;
+            if (results.length === 0) {
+                console.error(chalk.red(`✗ Process not found`));
+                process.exit(1);
+            }
+            for (const info of results) {
+                const staleWorkers = info.workers.filter((w) => w.stale);
+                if (staleWorkers.length > 0) {
+                    console.log(chalk.yellow(`⚠ Process "${info.name}" reload partially failed`));
+                    console.log(chalk.yellow(`  Stale workers: ${staleWorkers.map((w) => w.id).join(', ')} (old code still running)`));
+                }
+                else if (info.execMode === 'fork') {
+                    console.log(chalk.green(`✓ Process "${info.name}" restarted`));
+                    console.log(chalk.dim(`  Fork mode does not support zero-downtime reload — performed a restart`));
+                }
+                else {
+                    console.log(chalk.green(`✓ Process "${info.name}" reloaded`));
+                }
+            }
+            const listResponse = await daemonClient.request(IPCMessageType.LIST);
+            if (listResponse.success) {
+                console.log(formatProcessTable(listResponse.data));
+            }
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to reload: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=reload.js.map

package/dist/cli/commands/restart.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const restartCommand: Command;
+//# sourceMappingURL=restart.d.ts.map

package/dist/cli/commands/restart.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { IPCMessageType } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+import { formatProcessTable } from './list.js';
+export const restartCommand = new Command('restart')
+    .description('Restart process(es) - hard restart (kill + start)')
+    .argument('<target>', 'Process name, id, or "all"')
+    .action(async (target) => {
+    try {
+        const payload = {
+            target: target === 'all' ? 'all' : isNaN(Number(target)) ? target : Number(target),
+        };
+        const response = await daemonClient.request(IPCMessageType.RESTART, payload);
+        if (response.success) {
+            const results = response.data;
+            if (results.length === 0) {
+                console.log(chalk.gray('No processes to restart'));
+            }
+            else {
+                for (const info of results) {
+                    console.log(chalk.green(`↻ Process "${info.name}" restarted`));
+                }
+                const listResponse = await daemonClient.request(IPCMessageType.LIST);
+                if (listResponse.success) {
+                    console.log(formatProcessTable(listResponse.data));
+                }
+            }
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to restart: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=restart.js.map

package/dist/cli/commands/restore.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const restoreCommand: Command;
+//# sourceMappingURL=restore.d.ts.map

package/dist/cli/commands/restore.js

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEPLOY_META_FILE, IPC_DEPLOY_TIMEOUT, IPCMessageType, ORKIFY_DEPLOYS_DIR, TELEMETRY_DEFAULT_API_HOST, } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+export const restoreCommand = new Command('restore')
+    .description('Restore previously saved process list')
+    .argument('[file]', 'Path to snapshot file (default: ~/.orkify/snapshot.yml)')
+    .option('--no-remote', 'Skip remote deploy restore and force local snapshot restore')
+    .action(async (file, opts) => {
+    try {
+        // Deploy-aware restore: check for API key + deploy metadata
+        if (opts.remote) {
+            const apiKey = process.env.ORKIFY_API_KEY;
+            const metaPath = join(ORKIFY_DEPLOYS_DIR, 'current', DEPLOY_META_FILE);
+            if (apiKey && existsSync(metaPath)) {
+                try {
+                    const meta = JSON.parse(readFileSync(metaPath, 'utf-8'));
+                    const apiHost = process.env.ORKIFY_API_HOST || TELEMETRY_DEFAULT_API_HOST;
+                    const url = `${apiHost}/api/v1/deploy/restore?artifactId=${encodeURIComponent(meta.artifactId)}`;
+                    const res = await fetch(url, {
+                        headers: { Authorization: `Bearer ${apiKey}` },
+                    });
+                    if (!res.ok) {
+                        console.error(chalk.yellow(`⚠ Remote restore failed (${res.status}), falling back to snapshot`));
+                    }
+                    else {
+                        const payload = (await res.json());
+                        const response = await daemonClient.request(IPCMessageType.DEPLOY_RESTORE, payload, IPC_DEPLOY_TIMEOUT);
+                        if (response.success) {
+                            const data = response.data;
+                            if ('deployed' in data) {
+                                console.log(chalk.green(`✓ Deployed version ${data.version} from remote`));
+                            }
+                            else {
+                                const count = data.started.length + data.reloaded.length;
+                                if (count === 0) {
+                                    console.log(chalk.gray('No processes to restore'));
+                                }
+                                else {
+                                    console.log(chalk.green(`✓ Restored from local deploy:`));
+                                    for (const name of data.started) {
+                                        console.log(`  - ${name} (started)`);
+                                    }
+                                    for (const name of data.reloaded) {
+                                        console.log(`  - ${name} (reloaded)`);
+                                    }
+                                }
+                            }
+                            return;
+                        }
+                        console.error(chalk.yellow(`⚠ Deploy restore failed: ${response.error}, falling back to snapshot`));
+                    }
+                }
+                catch (err) {
+                    console.error(chalk.yellow(`⚠ Deploy restore error: ${err.message}, falling back to snapshot`));
+                }
+            }
+        }
+        // Snapshot restore (default / fallback)
+        const payload = { file };
+        const response = await daemonClient.request(IPCMessageType.RESTORE, payload);
+        if (response.success) {
+            const results = response.data;
+            if (results.length === 0) {
+                console.log(chalk.gray('No processes to restore'));
+                return;
+            }
+            console.log(chalk.green(`✓ Restored ${results.length} process(es):`));
+            for (const info of results) {
+                console.log(`  - ${info.name} (${info.workers.length} worker(s))`);
+            }
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to restore: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=restore.js.map

package/dist/cli/commands/run.d.ts

@@ -0,0 +1,8 @@
+import { Command } from 'commander';
+/**
+ * Run command - runs process in foreground with full daemon features
+ * Designed for container environments like Docker/Kubernetes
+ * Ideal for Docker/Kubernetes where process runs as PID 1
+ */
+export declare const runCommand: Command;
+//# sourceMappingURL=run.d.ts.map

package/dist/cli/commands/run.js

@@ -0,0 +1,212 @@
+import chalk from 'chalk';
+import { Command, Option } from 'commander';
+import { resolve } from 'node:path';
+import { DEFAULT_LOG_MAX_AGE, DEFAULT_LOG_MAX_FILES, DEFAULT_LOG_MAX_SIZE, MCP_DEFAULT_PORT, } from '../../constants.js';
+import { startDaemon } from '../../daemon/startDaemon.js';
+import { parseCronSpecs, parseLogSize, parseMemorySize, parseWorkers } from '../parse.js';
+/**
+ * Run command - runs process in foreground with full daemon features
+ * Designed for container environments like Docker/Kubernetes
+ * Ideal for Docker/Kubernetes where process runs as PID 1
+ */
+export const runCommand = new Command('run')
+    .description('Run a process in foreground (for containers) with full daemon features')
+    .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('--cwd <path>', 'Working directory')
+    .option('--node-args <args>', 'Node.js arguments (space-separated, quoted)')
+    .option('--args <args>', 'Script arguments (space-separated, quoted)')
+    .option('--sticky', 'Enable sticky sessions for Socket.IO')
+    .option('--port <port>', 'Port for sticky session routing (required with --sticky)')
+    .option('--kill-timeout <ms>', 'Time to wait for graceful shutdown before SIGKILL', '5000')
+    .option('--reload-retries <count>', 'Retries per worker slot during reload (0-3)', '3')
+    .option('--max-restarts <count>', 'Maximum restart attempts (default 0 in run mode)', '0')
+    .option('--min-uptime <ms>', 'Minimum uptime before restart counts', '1000')
+    .option('--restart-delay <ms>', 'Delay between restarts', '100')
+    .option('--watch', 'Watch for file changes and reload')
+    .option('--watch-paths <paths...>', 'Specific paths to watch')
+    .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")')
+    .option('--mcp-simple-http', 'Start MCP HTTP server (local key auth)')
+    .option('--mcp-port <port>', 'MCP HTTP port', String(MCP_DEFAULT_PORT))
+    .option('--mcp-bind <address>', 'MCP bind address', '127.0.0.1')
+    .addOption(new Option('--mcp-cors [origin]', 'MCP CORS setting ("*" if no origin given)').preset('*'))
+    .option('--silent', 'Suppress startup messages')
+    .action(async (script, options) => {
+    const cwd = options.cwd || process.cwd();
+    const scriptPath = resolve(cwd, script);
+    const workerCount = parseWorkers(options.workers);
+    const name = options.name ||
+        script
+            .split('/')
+            .pop()
+            ?.replace(/\.[^.]+$/, '') ||
+        'app';
+    const silent = options.silent || false;
+    // Start daemon stack in-process (foreground mode).
+    // startDaemon() acquires an exclusive PID lock — if another daemon
+    // or orkify-run instance is active, it throws.
+    let ctx;
+    try {
+        ctx = await startDaemon({ foreground: true, skipTimestampPrefix: true });
+    }
+    catch (err) {
+        const msg = err.message;
+        if (msg.includes('already running')) {
+            console.error(chalk.red(`✗ ${msg}\n` + '  Stop it first with `orkify kill` or wait for it to exit.'));
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to initialize daemon: ${msg}`));
+        }
+        process.exit(1);
+    }
+    try {
+        await ctx.startServer();
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Failed to start IPC server: ${err.message}`));
+        ctx.cleanup();
+        process.exit(1);
+    }
+    // Start MCP HTTP server if requested
+    if (options.mcpSimpleHttp) {
+        try {
+            const mcpPayload = {
+                transport: 'simple-http',
+                port: parseInt(options.mcpPort, 10),
+                bind: options.mcpBind,
+                cors: options.mcpCors,
+            };
+            await ctx.startMcpHttp(mcpPayload);
+            if (!silent) {
+                console.log(chalk.cyan(`[orkify] MCP HTTP server → ${options.mcpBind}:${options.mcpPort}`));
+            }
+        }
+        catch (err) {
+            console.error(chalk.yellow(`[orkify] MCP HTTP server failed: ${err.message}`));
+        }
+    }
+    // Parse --cron specs
+    const cronJobs = options.cron ? parseCronSpecs(options.cron) : [];
+    // Build UpPayload and start the process via orchestrator
+    const restartOnMemRaw = options.restartOnMem || options.restartOnMemory;
+    const payload = {
+        script: scriptPath,
+        name,
+        workers: workerCount,
+        watch: options.watch || false,
+        watchPaths: options.watchPaths,
+        cwd,
+        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,
+    };
+    let info;
+    try {
+        info = await ctx.orchestrator.up(payload);
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Failed to start process: ${err.message}`));
+        await ctx.gracefulShutdown();
+        process.exit(1);
+    }
+    // Register cron jobs with the scheduler
+    if (payload.cron?.length) {
+        ctx.cronScheduler.register(info.name, payload.cron);
+    }
+    if (!silent) {
+        console.log(chalk.cyan(`[orkify] Starting ${info.name} in foreground mode`));
+        if (workerCount > 1) {
+            console.log(chalk.cyan(`[orkify] Cluster mode: ${workerCount} workers`));
+        }
+        if (options.sticky) {
+            console.log(chalk.cyan(`[orkify] Sticky sessions: port ${options.port}`));
+        }
+        if (ctx.telemetry) {
+            console.log(chalk.cyan(`[orkify] Telemetry enabled`));
+        }
+    }
+    // Forward process output to stdout/stderr (foreground mode shows output directly)
+    ctx.orchestrator.on('log', (data) => {
+        if (data.type === 'err') {
+            process.stderr.write(data.data);
+        }
+        else {
+            process.stdout.write(data.data);
+        }
+    });
+    // Track exit code from the primary process
+    let exitCode = 0;
+    let shuttingDown = false;
+    async function shutdown(code) {
+        if (shuttingDown)
+            return undefined;
+        shuttingDown = true;
+        await ctx.gracefulShutdown();
+        process.exit(code);
+    }
+    // Wait for primary process to reach terminal state
+    const managedProcess = ctx.orchestrator.getProcess(info.name);
+    if (managedProcess) {
+        managedProcess.on('process:finished', (data) => {
+            if (shuttingDown)
+                return;
+            if (data.signal) {
+                const signalNum = data.signal === 'SIGTERM'
+                    ? 15
+                    : data.signal === 'SIGINT'
+                        ? 2
+                        : data.signal === 'SIGHUP'
+                            ? 1
+                            : 9;
+                exitCode = 128 + signalNum;
+            }
+            else {
+                exitCode = data.code ?? 0;
+            }
+            if (!silent && exitCode !== 0) {
+                console.log(chalk.red(`[orkify] Process exited with code ${exitCode}`));
+            }
+            // Use setTimeout to let any pending I/O flush
+            setTimeout(() => void shutdown(exitCode), 100);
+        });
+    }
+    // Signal handlers
+    const handleSignal = (signal) => {
+        if (!silent) {
+            console.log(chalk.yellow(`\n[orkify] Received ${signal}, shutting down...`));
+        }
+        void shutdown(0);
+    };
+    process.on('SIGINT', () => handleSignal('SIGINT'));
+    process.on('SIGTERM', () => handleSignal('SIGTERM'));
+    process.on('SIGHUP', () => handleSignal('SIGHUP'));
+    process.on('uncaughtException', async (err) => {
+        console.error('Uncaught exception:', err);
+        await shutdown(1);
+    });
+    process.on('unhandledRejection', async (reason) => {
+        console.error('Unhandled rejection:', reason);
+        await shutdown(1);
+    });
+});
+//# sourceMappingURL=run.js.map

package/dist/cli/commands/snap.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const snapCommand: Command;
+//# sourceMappingURL=snap.d.ts.map

package/dist/cli/commands/snap.js

@@ -0,0 +1,30 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { IPCMessageType, SNAPSHOT_FILE } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+export const snapCommand = new Command('snap')
+    .description('Snapshot current process list for later restoration')
+    .argument('[file]', 'Path to snapshot file (default: ~/.orkify/snapshot.yml)')
+    .option('--no-env', 'Do not save environment variables in snapshot file')
+    .action(async (file, options) => {
+    try {
+        const payload = { noEnv: !options.env, file };
+        const response = await daemonClient.request(IPCMessageType.SNAP, payload);
+        if (response.success) {
+            console.log(chalk.green(`✓ Snapshot saved`));
+            console.log(chalk.gray(`  File: ${file || SNAPSHOT_FILE}`));
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to save snapshot: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=snap.js.map

package/dist/cli/commands/up.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const upCommand: Command;
+//# sourceMappingURL=up.d.ts.map