@orkify/cli 1.0.0-beta.5

package/dist/cli/commands/down.js

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { IPCMessageType } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+export const downCommand = new Command('down')
+    .description('Stop process(es)')
+    .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.DOWN, payload);
+        if (response.success) {
+            const results = response.data;
+            for (const info of results) {
+                console.log(chalk.yellow(`⏹ Process "${info.name}" stopped`));
+            }
+            if (results.length === 0) {
+                console.log(chalk.gray('No processes to stop'));
+            }
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to stop: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=down.js.map

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

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

package/dist/cli/commands/flush.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { IPCMessageType } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+export const flushCommand = new Command('flush')
+    .description('Truncate log files and remove rotated archives')
+    .argument('[target]', 'Process name or id (default: all)', 'all')
+    .action(async (target) => {
+    try {
+        const payload = { target };
+        const response = await daemonClient.request(IPCMessageType.FLUSH, payload);
+        if (response.success) {
+            console.log(chalk.green(`✓ Logs flushed for ${target === 'all' ? 'all processes' : `"${target}"`}`));
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to flush logs: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=flush.js.map

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

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

package/dist/cli/commands/kill.js

@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { IPCMessageType } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+export const killCommand = new Command('kill')
+    .description('Kill the ORKIFY daemon')
+    .option('-f, --force', 'Skip graceful shutdown and SIGKILL all processes immediately')
+    .action(async (opts) => {
+    try {
+        const response = await daemonClient.request(IPCMessageType.KILL_DAEMON, {
+            force: opts.force === true,
+        });
+        if (response.success) {
+            console.log(chalk.yellow('⏹ ORKIFY daemon killed'));
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to kill daemon: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        const message = err.message;
+        if (message.includes('ECONNREFUSED') || message.includes('ENOENT')) {
+            console.log(chalk.gray('Daemon is not running'));
+        }
+        else {
+            console.error(chalk.red(`✗ Error: ${message}`));
+            process.exit(1);
+        }
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=kill.js.map

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

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import type { ProcessInfo } from '../../types/index.js';
+export declare function formatProcessTable(processes: ProcessInfo[], options?: {
+    cache?: boolean;
+    showUser?: string;
+    verbose?: boolean;
+}): string;
+export declare function renderProcessTable(processes: ProcessInfo[], options?: {
+    cache?: boolean;
+    showUser?: string;
+    verbose?: boolean;
+}): void;
+export declare const listCommand: Command;
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/commands/list.js

@@ -0,0 +1,361 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { Command } from 'commander';
+import { IPCMessageType, ProcessStatus } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+import { isElevated, listAllUsers } from '../../ipc/MultiUserClient.js';
+import { sleep } from '../parse.js';
+function formatUptime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}
+function formatMemory(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+function formatCpu(cpu) {
+    return `${cpu.toFixed(1)}%`;
+}
+function getStatusColor(status, stale) {
+    const label = stale && status === ProcessStatus.ONLINE ? `${status} (stale)` : status;
+    switch (status) {
+        case ProcessStatus.ONLINE:
+            return stale ? chalk.yellow(label) : chalk.green(label);
+        case ProcessStatus.STOPPING:
+            return chalk.yellow(label);
+        case ProcessStatus.STOPPED:
+            return chalk.gray(label);
+        case ProcessStatus.ERRORED:
+            return chalk.red(label);
+        case ProcessStatus.LAUNCHING:
+            return chalk.blue(label);
+        default:
+            return label;
+    }
+}
+function joinTreeViewLines(tableStr) {
+    const lines = tableStr.split('\n');
+    for (let i = 1; i < lines.length - 1; i++) {
+        const line = lines[i];
+        if (!line.includes('┼'))
+            continue;
+        // Check if the row below is a worker row (contains tree characters)
+        const below = lines[i + 1];
+        if (!below || (!/├─/.test(below) && !/└─/.test(below)))
+            continue;
+        // Find the tree character position in the row below to locate the ID column
+        const treePos = below.search(/[├└]─/);
+        if (treePos === -1)
+            continue;
+        // Find all ┼ positions in the border line
+        const crosses = [...line.matchAll(/┼/g)].map((m) => m.index);
+        // The ID column ends at the first ┼ after the tree character position
+        const idColEnd = crosses.find((pos) => pos > treePos);
+        if (idColEnd === undefined)
+            continue;
+        // The ID column starts after the previous separator (├ at pos 0, or a preceding ┼)
+        const idColEndIdx = crosses.indexOf(idColEnd);
+        const idColStart = idColEndIdx === 0 ? 0 : (crosses[idColEndIdx - 1] ?? 0);
+        // Build the tree trunk continuation for the ID column segment
+        // " │" at tree trunk position + spaces + "├" reconnecting to horizontal border
+        const contentStart = idColStart + 1;
+        const contentWidth = idColEnd - contentStart;
+        const treeTrunk = ' │' + ' '.repeat(contentWidth - 2);
+        // For the first column, change the left border ├ to │ (vertical continuation)
+        const left = idColStart === 0 ? '│' : line.slice(0, contentStart);
+        lines[i] = left + treeTrunk + '├' + line.slice(idColEnd + 1);
+    }
+    return lines.join('\n');
+}
+function formatNumber(n) {
+    return n.toLocaleString('en-US');
+}
+export function formatProcessTable(processes, options) {
+    const includeUser = options?.showUser !== undefined;
+    const verbose = options?.verbose ?? false;
+    const showCache = options?.cache ?? false;
+    // Only show cache columns if --cache flag is set AND at least one worker has cache data
+    const hasCacheData = showCache && processes.some((p) => p.workers.some((w) => w.cacheSize !== undefined));
+    const headers = [
+        ...(includeUser ? [chalk.cyan('user')] : []),
+        chalk.cyan('id'),
+        chalk.cyan('name'),
+        chalk.cyan('mode'),
+        ...(verbose ? [chalk.cyan('pid')] : []),
+        chalk.cyan('↺'),
+        chalk.cyan('✘'),
+        chalk.cyan('status'),
+        chalk.cyan('port'),
+        chalk.cyan('cpu'),
+        chalk.cyan('mem'),
+        ...(hasCacheData
+            ? [chalk.cyan('size'), chalk.cyan('hits'), chalk.cyan('misses'), chalk.cyan('hit%')]
+            : []),
+        chalk.cyan('uptime'),
+    ];
+    const table = new Table({
+        head: headers,
+        style: {
+            head: [],
+            border: [],
+        },
+    });
+    for (const proc of processes) {
+        const userCol = includeUser ? [chalk.blue(options?.showUser)] : [];
+        // For cluster mode, show each worker
+        if (proc.workers.length > 1) {
+            // Summary row
+            const totalMem = proc.workers.reduce((sum, w) => sum + w.memory, 0);
+            const avgCpu = proc.workers.reduce((sum, w) => sum + w.cpu, 0) / proc.workers.length;
+            const totalRestarts = proc.workers.reduce((sum, w) => sum + w.restarts, 0);
+            const totalCrashes = proc.workers.reduce((sum, w) => sum + w.crashes, 0);
+            const hasStale = proc.workers.some((w) => w.stale);
+            // Cache aggregates for cluster summary
+            const cacheWorkers = proc.workers.filter((w) => w.cacheSize !== undefined);
+            const totalCacheSize = cacheWorkers.reduce((s, w) => s + (w.cacheSize ?? 0), 0);
+            const totalCacheHits = cacheWorkers.reduce((s, w) => s + (w.cacheHits ?? 0), 0);
+            const totalCacheMisses = cacheWorkers.reduce((s, w) => s + (w.cacheMisses ?? 0), 0);
+            const totalCacheReqs = totalCacheHits + totalCacheMisses;
+            const aggHitRate = totalCacheReqs > 0 ? (totalCacheHits / totalCacheReqs) * 100 : 0;
+            table.push([
+                ...userCol,
+                proc.id,
+                chalk.bold(proc.name),
+                proc.execMode,
+                ...(verbose ? [proc.pid ?? '-'] : []),
+                totalRestarts,
+                totalCrashes || chalk.gray(0),
+                getStatusColor(proc.status, hasStale),
+                proc.port ?? chalk.gray('-'),
+                formatCpu(avgCpu),
+                formatMemory(totalMem),
+                ...(hasCacheData
+                    ? cacheWorkers.length > 0
+                        ? [
+                            formatNumber(totalCacheSize),
+                            formatNumber(totalCacheHits),
+                            formatNumber(totalCacheMisses),
+                            `${aggHitRate.toFixed(1)}%`,
+                        ]
+                        : [chalk.gray('-'), chalk.gray('-'), chalk.gray('-'), chalk.gray('-')]
+                    : []),
+                '-',
+            ]);
+            // Worker rows
+            for (let i = 0; i < proc.workers.length; i++) {
+                const worker = proc.workers[i];
+                const isLast = i === proc.workers.length - 1;
+                const prefix = isLast ? '└─' : '├─';
+                table.push([
+                    ...(includeUser ? [''] : []),
+                    `${prefix} ${worker.id}`,
+                    chalk.gray(`worker ${worker.id}`),
+                    '',
+                    ...(verbose ? [worker.pid || '-'] : []),
+                    worker.restarts,
+                    worker.crashes || chalk.gray(0),
+                    getStatusColor(worker.status, worker.stale),
+                    '',
+                    formatCpu(worker.cpu),
+                    formatMemory(worker.memory),
+                    ...(hasCacheData
+                        ? worker.cacheSize !== undefined
+                            ? [
+                                formatNumber(worker.cacheSize),
+                                formatNumber(worker.cacheHits ?? 0),
+                                formatNumber(worker.cacheMisses ?? 0),
+                                `${(worker.cacheHitRate ?? 0).toFixed(1)}%`,
+                            ]
+                            : [chalk.gray('-'), chalk.gray('-'), chalk.gray('-'), chalk.gray('-')]
+                        : []),
+                    formatUptime(worker.uptime),
+                ]);
+            }
+        }
+        else {
+            // Single process
+            const worker = proc.workers[0];
+            table.push([
+                ...userCol,
+                proc.id,
+                proc.name,
+                proc.execMode,
+                ...(verbose ? [worker?.pid || '-'] : []),
+                worker?.restarts || 0,
+                worker?.crashes || chalk.gray(0),
+                getStatusColor(proc.status),
+                proc.port ?? chalk.gray('-'),
+                formatCpu(worker?.cpu || 0),
+                formatMemory(worker?.memory || 0),
+                ...(hasCacheData
+                    ? worker?.cacheSize !== undefined
+                        ? [
+                            formatNumber(worker.cacheSize),
+                            formatNumber(worker.cacheHits ?? 0),
+                            formatNumber(worker.cacheMisses ?? 0),
+                            `${(worker.cacheHitRate ?? 0).toFixed(1)}%`,
+                        ]
+                        : [chalk.gray('-'), chalk.gray('-'), chalk.gray('-'), chalk.gray('-')]
+                    : []),
+                worker ? formatUptime(worker.uptime) : '-',
+            ]);
+        }
+    }
+    return joinTreeViewLines(table.toString());
+}
+export function renderProcessTable(processes, options) {
+    console.log(formatProcessTable(processes, options));
+}
+async function followList(verbose, cache) {
+    // Test daemon connectivity before entering the loop
+    try {
+        await daemonClient.request(IPCMessageType.LIST);
+    }
+    catch (err) {
+        const message = err.message;
+        if (message.includes('ECONNREFUSED') || message.includes('ENOENT')) {
+            console.log(chalk.gray('No processes running (daemon not started)'));
+        }
+        else {
+            console.error(chalk.red(`✗ Error: ${message}`));
+        }
+        return;
+    }
+    let prevLines = 0;
+    let stopped = false;
+    let forceExit = false;
+    const onSigint = () => {
+        if (stopped) {
+            forceExit = true;
+            return;
+        }
+        stopped = true;
+    };
+    process.on('SIGINT', onSigint);
+    while (!stopped && !forceExit) {
+        try {
+            const response = await daemonClient.request(IPCMessageType.LIST);
+            if (!response.success)
+                break;
+            const processes = response.data;
+            const tableStr = processes.length === 0
+                ? chalk.gray('No processes running')
+                : formatProcessTable(processes, { verbose, cache });
+            if (process.stdout.isTTY && prevLines > 0) {
+                process.stdout.write(`\x1B[${prevLines}A\x1B[J`);
+            }
+            process.stdout.write(tableStr + '\n');
+            prevLines = tableStr.split('\n').length;
+        }
+        catch {
+            break;
+        }
+        await sleep(1000);
+    }
+    process.removeListener('SIGINT', onSigint);
+}
+export const listCommand = new Command('list')
+    .alias('ls')
+    .alias('status')
+    .description('List all processes')
+    .option('-v, --verbose', 'Show additional details including PIDs')
+    .option('-c, --cache', 'Show cache statistics (size, hits, misses, hit rate)')
+    .option('-f, --follow', 'Live-update the process table (Ctrl+C to stop)')
+    .option('--all-users', 'List processes from all users (requires sudo on Unix)')
+    .action(async (options) => {
+    if (options.allUsers) {
+        // Check for elevated privileges on Unix
+        if (process.platform !== 'win32' && !isElevated()) {
+            console.error(chalk.red('✗ This command requires elevated privileges'));
+            console.error(chalk.red('  Run with: sudo orkify list --all-users'));
+            process.exit(1);
+        }
+        // List processes from all users
+        const result = await listAllUsers();
+        // Show warnings first
+        for (const warning of result.warnings) {
+            console.log(chalk.yellow(`⚠ ${warning}`));
+        }
+        if (result.users.length === 0 && result.inaccessibleUsers.length === 0) {
+            if (result.warnings.length === 0) {
+                console.log(chalk.gray('No processes running on this system'));
+            }
+        }
+        else {
+            // Show accessible processes
+            let totalProcesses = 0;
+            for (const userList of result.users) {
+                if (userList.processes.length > 0) {
+                    totalProcesses += userList.processes.length;
+                    renderProcessTable(userList.processes, {
+                        showUser: userList.user,
+                        verbose: options.verbose,
+                    });
+                }
+            }
+            if (totalProcesses === 0 && result.inaccessibleUsers.length === 0) {
+                console.log(chalk.gray('No processes running'));
+            }
+        }
+        // Show errors at the end (important - results may be incomplete)
+        if (result.inaccessibleUsers.length > 0) {
+            console.log('');
+            console.error(chalk.red(`✗ Could not access processes for: ${result.inaccessibleUsers.join(', ')}`));
+            process.exit(1);
+        }
+        return;
+    }
+    // Follow mode — live-updating table
+    if (options.follow) {
+        await followList(options.verbose ?? false, options.cache ?? false);
+        daemonClient.disconnect();
+        return;
+    }
+    // Normal single-user list
+    try {
+        const response = await daemonClient.request(IPCMessageType.LIST);
+        if (response.success) {
+            const processes = response.data;
+            if (processes.length === 0) {
+                console.log(chalk.gray('No processes running'));
+                return;
+            }
+            renderProcessTable(processes, { verbose: options.verbose, cache: options.cache });
+            if (options.cache &&
+                !processes.some((p) => p.workers.some((w) => w.cacheSize !== undefined))) {
+                console.log(chalk.gray('\nNo active cache detected. Import orkify/cache in your app to enable cache statistics.'));
+            }
+        }
+        else {
+            console.error(chalk.red(`✗ Failed to list: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        const message = err.message;
+        if (message.includes('ECONNREFUSED') || message.includes('ENOENT')) {
+            console.log(chalk.gray('No processes running (daemon not started)'));
+        }
+        else {
+            console.error(chalk.red(`✗ Error: ${message}`));
+            process.exit(1);
+        }
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=list.js.map

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

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

package/dist/cli/commands/logs.js

@@ -0,0 +1,107 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { createReadStream, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { LOGS_DIR } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+export const logsCommand = new Command('logs')
+    .description('Stream logs from process(es)')
+    .argument('[name]', 'Process name (optional, shows all if omitted)')
+    .option('-n, --lines <number>', 'Number of lines to show', '100')
+    .option('-f, --follow', 'Follow log output (stream new logs)')
+    .option('--err', 'Show error logs only')
+    .option('--out', 'Show stdout logs only')
+    .action(async (name, options) => {
+    try {
+        const lines = parseInt(options.lines, 10);
+        // If not following, just read from log files
+        if (!options.follow) {
+            await showLogFile(name, lines, options.err, options.out);
+            return;
+        }
+        // Follow mode: subscribe to live logs
+        console.log(chalk.blue('Streaming logs... (Ctrl+C to stop)\n'));
+        const unsubscribe = await daemonClient.streamLogs(name, (data) => {
+            const logData = data;
+            const prefix = logData.processName
+                ? chalk.cyan(`[${logData.processName}:${logData.workerId}]`)
+                : chalk.cyan(`[worker:${logData.workerId}]`);
+            const output = logData.type === 'err' ? chalk.red(logData.data) : logData.data;
+            process.stdout.write(`${prefix} ${output}`);
+        });
+        // Keep the process running until interrupted
+        process.on('SIGINT', () => {
+            unsubscribe();
+            daemonClient.disconnect();
+            process.exit(0);
+        });
+        // Keep alive
+        await new Promise(() => { });
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+});
+async function showLogFile(name, lines, errOnly, outOnly) {
+    if (!existsSync(LOGS_DIR)) {
+        console.log(chalk.gray('No logs found'));
+        return;
+    }
+    const files = [];
+    if (name) {
+        if (!errOnly) {
+            const outFile = join(LOGS_DIR, `${name}.stdout.log`);
+            if (existsSync(outFile))
+                files.push(outFile);
+        }
+        if (!outOnly) {
+            const errFile = join(LOGS_DIR, `${name}.stderr.log`);
+            if (existsSync(errFile))
+                files.push(errFile);
+        }
+    }
+    else {
+        // Show all log files
+        const { readdirSync } = await import('node:fs');
+        const allFiles = readdirSync(LOGS_DIR);
+        for (const file of allFiles) {
+            if (errOnly && !file.endsWith('.stderr.log'))
+                continue;
+            if (outOnly && !file.endsWith('.stdout.log'))
+                continue;
+            if (!file.endsWith('.stdout.log') && !file.endsWith('.stderr.log'))
+                continue;
+            files.push(join(LOGS_DIR, file));
+        }
+    }
+    if (files.length === 0) {
+        console.log(chalk.gray('No logs found'));
+        return;
+    }
+    for (const file of files) {
+        await tailFile(file, lines);
+    }
+}
+async function tailFile(filePath, lines) {
+    return new Promise((resolve, reject) => {
+        const buffer = [];
+        const stream = createReadStream(filePath, { encoding: 'utf8' });
+        const rl = createInterface({ input: stream });
+        rl.on('line', (line) => {
+            buffer.push(line);
+            if (buffer.length > lines) {
+                buffer.shift();
+            }
+        });
+        rl.on('close', () => {
+            for (const line of buffer) {
+                console.log(line);
+            }
+            resolve();
+        });
+        rl.on('error', reject);
+    });
+}
+//# sourceMappingURL=logs.js.map

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

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