@orkify/cli 1.0.0-beta.5

package/bin/orkify

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import('../dist/cli/index.js');

package/boot/systemd/orkify@.service

@@ -0,0 +1,30 @@
+# orkify process manager — systemd template unit
+#
+# Install:
+#   sudo cp orkify@.service /etc/systemd/system/
+#   sudo systemctl daemon-reload
+#   sudo systemctl enable orkify@<username>
+#
+# The service restores the process snapshot on boot and kills the daemon on stop.
+# Make sure to run `orkify snap` at least once so there is a snapshot to restore.
+#
+# Update ExecStart/ExecStop paths to match your installation:
+#   which orkify
+
+[Unit]
+Description=orkify process manager (%i)
+Documentation=https://github.com/orkify/orkify
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+User=%i
+EnvironmentFile=-/etc/orkify/env
+ExecStart=/usr/local/bin/orkify restore
+ExecReload=/usr/local/bin/orkify daemon-reload
+ExecStop=/usr/local/bin/orkify kill
+
+[Install]
+WantedBy=multi-user.target

package/dist/agent-name.d.ts

@@ -0,0 +1,4 @@
+export declare function getAgentName(): string;
+/** Reset cached value — for testing only */
+export declare function _resetAgentNameCache(): void;
+//# sourceMappingURL=agent-name.d.ts.map

package/dist/agent-name.js

@@ -0,0 +1,42 @@
+import { randomBytes } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { hostname } from 'node:os';
+import { AGENT_NAME_FILE, ORKIFY_HOME } from './constants.js';
+let cached;
+export function getAgentName() {
+    if (cached)
+        return cached;
+    // 1. Env var override (containers)
+    const envName = process.env.ORKIFY_AGENT_NAME;
+    if (envName) {
+        cached = envName;
+        return cached;
+    }
+    // 2. Read persisted file
+    try {
+        const name = readFileSync(AGENT_NAME_FILE, 'utf8').trim();
+        if (name) {
+            cached = name;
+            return cached;
+        }
+    }
+    catch {
+        // File doesn't exist yet — generate below
+    }
+    // 3. Generate: hostname-6hex
+    const name = `${hostname()}-${randomBytes(3).toString('hex')}`;
+    try {
+        mkdirSync(ORKIFY_HOME, { recursive: true });
+        writeFileSync(AGENT_NAME_FILE, name + '\n', 'utf8');
+    }
+    catch {
+        // Best-effort persist — don't crash if write fails
+    }
+    cached = name;
+    return cached;
+}
+/** Reset cached value — for testing only */
+export function _resetAgentNameCache() {
+    cached = undefined;
+}
+//# sourceMappingURL=agent-name.js.map

package/dist/alerts/AlertEvaluator.d.ts

@@ -0,0 +1,14 @@
+import type { ConfigStore } from '../config/ConfigStore.js';
+import type { TelemetryAlertEvent, TelemetryMetricsSnapshot } from '../types/index.js';
+export declare class AlertEvaluator {
+    private configStore;
+    private states;
+    private buffer;
+    private knownRuleIds;
+    private host;
+    constructor(configStore: ConfigStore);
+    evaluate(snapshots: TelemetryMetricsSnapshot[]): void;
+    drainAlerts(): TelemetryAlertEvent[];
+    restoreAlerts(alerts: TelemetryAlertEvent[]): void;
+}
+//# sourceMappingURL=AlertEvaluator.d.ts.map

package/dist/alerts/AlertEvaluator.js

@@ -0,0 +1,135 @@
+import { hostname } from 'node:os';
+const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
+export class AlertEvaluator {
+    configStore;
+    states = new Map();
+    buffer = [];
+    knownRuleIds = new Set();
+    host = hostname();
+    constructor(configStore) {
+        this.configStore = configStore;
+    }
+    evaluate(snapshots) {
+        const rules = this.configStore.getAlertRules().filter((r) => r.is_enabled);
+        const now = Date.now();
+        // Track current rule IDs to prune stale states
+        const currentRuleIds = new Set(rules.map((r) => r.id));
+        // Prune states for removed rules
+        if (!setsEqual(currentRuleIds, this.knownRuleIds)) {
+            for (const key of this.states.keys()) {
+                const ruleId = key.split(':')[0];
+                if (!currentRuleIds.has(ruleId)) {
+                    this.states.delete(key);
+                }
+            }
+            this.knownRuleIds = currentRuleIds;
+        }
+        // Build lookup of current process:worker combos for pruning
+        const activeKeys = new Set();
+        for (const rule of rules) {
+            const { metric, threshold, duration } = rule.condition;
+            // Heartbeat rules are server-evaluated — skip on CLI
+            if (metric === 'heartbeat')
+                continue;
+            for (const snapshot of snapshots) {
+                for (const worker of snapshot.workers) {
+                    const key = `${rule.id}:${snapshot.processName}:${worker.id}`;
+                    activeKeys.add(key);
+                    const value = metric === 'cpu' ? worker.cpu : worker.memory;
+                    let state = this.states.get(key);
+                    if (!state) {
+                        state = { consecutiveViolations: 0, triggered: false, cooldownUntil: 0 };
+                        this.states.set(key, state);
+                    }
+                    if (value > threshold) {
+                        state.consecutiveViolations++;
+                        if (!state.triggered &&
+                            state.consecutiveViolations >= duration &&
+                            now >= state.cooldownUntil) {
+                            state.triggered = true;
+                            state.cooldownUntil = now + COOLDOWN_MS;
+                            this.buffer.push({
+                                type: 'alert:triggered',
+                                rule_id: rule.id,
+                                rule_name: rule.name,
+                                metric,
+                                value,
+                                threshold,
+                                process_name: snapshot.processName,
+                                worker_id: worker.id,
+                                hostname: this.host,
+                                timestamp: now,
+                            });
+                        }
+                    }
+                    else {
+                        if (state.triggered) {
+                            this.buffer.push({
+                                type: 'alert:resolved',
+                                rule_id: rule.id,
+                                rule_name: rule.name,
+                                metric,
+                                value,
+                                threshold,
+                                process_name: snapshot.processName,
+                                worker_id: worker.id,
+                                hostname: this.host,
+                                timestamp: now,
+                            });
+                        }
+                        state.consecutiveViolations = 0;
+                        state.triggered = false;
+                    }
+                }
+            }
+        }
+        // Prune states for workers that are no longer active
+        for (const key of this.states.keys()) {
+            if (!activeKeys.has(key)) {
+                const state = this.states.get(key);
+                if (!state)
+                    continue;
+                if (state.triggered) {
+                    const parts = key.split(':');
+                    const ruleId = parts[0];
+                    const processName = parts.slice(1, -1).join(':');
+                    const workerId = Number(parts[parts.length - 1]);
+                    const rule = rules.find((r) => r.id === ruleId);
+                    if (rule) {
+                        this.buffer.push({
+                            type: 'alert:resolved',
+                            rule_id: ruleId,
+                            rule_name: rule.name,
+                            metric: rule.condition.metric,
+                            value: 0,
+                            threshold: rule.condition.threshold,
+                            process_name: processName,
+                            worker_id: workerId,
+                            hostname: this.host,
+                            timestamp: now,
+                        });
+                    }
+                }
+                this.states.delete(key);
+            }
+        }
+    }
+    drainAlerts() {
+        const alerts = this.buffer;
+        this.buffer = [];
+        return alerts;
+    }
+    restoreAlerts(alerts) {
+        this.buffer.unshift(...alerts);
+    }
+}
+function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=AlertEvaluator.js.map

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

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

package/dist/cli/commands/autostart.js

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+export const autostartCommand = new Command('autostart')
+    .alias('boot')
+    .description('Configure orkify to start on system boot')
+    .action(() => {
+    console.log(`${chalk.bold('Boot persistence')} requires a one-time systemd (Linux) or launchd (macOS) setup.\n` +
+        `\n` +
+        `See the guide: ${chalk.cyan('https://github.com/orkify/orkify#boot-persistence')}`);
+});
+//# sourceMappingURL=autostart.js.map

package/dist/cli/commands/crash-test.d.ts

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

package/dist/cli/commands/crash-test.js

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { IPCMessageType } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+export const crashTestCommand = new Command('_crash-test')
+    .description('Trigger a daemon crash for testing (internal)')
+    .action(async () => {
+    try {
+        await daemonClient.request(IPCMessageType.CRASH_TEST);
+    }
+    catch {
+        // Expected — daemon crashes after responding
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=crash-test.js.map

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

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

package/dist/cli/commands/daemon-reload.js

@@ -0,0 +1,72 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { IPCMessageType } from '../../constants.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+import { restoreDaemon } from '../../ipc/restoreDaemon.js';
+export const daemonReloadCommand = new Command('daemon-reload')
+    .description('Reload the daemon to pick up new code')
+    .action(async () => {
+    try {
+        // 1. Kill the daemon and capture its state (env vars + process configs + MCP)
+        console.log(chalk.blue('⟳ Stopping daemon...'));
+        let daemonEnv = {};
+        let processes = [];
+        let savedMcpOptions;
+        try {
+            const killResponse = await daemonClient.request(IPCMessageType.KILL_DAEMON);
+            const data = killResponse.data;
+            if (data?.env)
+                daemonEnv = data.env;
+            if (data?.processes)
+                processes = data.processes;
+            if (data?.mcpOptions)
+                savedMcpOptions = data.mcpOptions;
+        }
+        catch {
+            // Connection close is expected when daemon shuts down
+        }
+        daemonClient.disconnect();
+        // 2. Start new daemon and restore processes from in-memory configs
+        console.log(chalk.blue('⟳ Starting new daemon and restoring processes...'));
+        const resResponse = await restoreDaemon(daemonClient, processes, daemonEnv);
+        if (resResponse.success) {
+            const results = resResponse.data;
+            if (results.length === 0) {
+                console.log(chalk.green('✓ Daemon reloaded (no processes to restore)'));
+            }
+            else {
+                console.log(chalk.green(`✓ Daemon reloaded, restored ${results.length} process(es):`));
+                for (const info of results) {
+                    console.log(`  - ${info.name} (${info.workers.length} worker(s))`);
+                }
+            }
+        }
+        else {
+            console.error(chalk.red(`✗ Daemon restarted but failed to restore: ${resResponse.error}`));
+            process.exit(1);
+        }
+        // 3. Restore MCP HTTP server if it was running
+        if (savedMcpOptions) {
+            try {
+                const mcpResponse = await daemonClient.request(IPCMessageType.MCP_START, savedMcpOptions);
+                if (mcpResponse.success) {
+                    console.log(chalk.green(`✓ MCP HTTP server restored on http://${savedMcpOptions.bind}:${savedMcpOptions.port}/mcp`));
+                }
+                else {
+                    console.error(chalk.red(`✗ Failed to restore MCP server: ${mcpResponse.error}`));
+                }
+            }
+            catch (err) {
+                console.error(chalk.red(`✗ MCP restore error: ${err.message}`));
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+//# sourceMappingURL=daemon-reload.js.map

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

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

package/dist/cli/commands/delete.js

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

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

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+export declare const deployCommand: Command;
+export declare function parseErrorBody(resp: Response): Promise<string>;
+export declare function formatSize(bytes: number): string;
+export declare function computeSha256(filePath: string): Promise<string>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/cli/commands/deploy.js

@@ -0,0 +1,266 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { createReadStream, existsSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { IPC_DEPLOY_TIMEOUT, IPCMessageType, ORKIFY_CONFIG_FILE, TELEMETRY_DEFAULT_API_HOST, } from '../../constants.js';
+import { collectGitMetadata, getOrkifyConfig, interactiveConfig, readPackageJson, saveOrkifyConfig, } from '../../deploy/config.js';
+import { parseEnvFile } from '../../deploy/env.js';
+import { createTarball } from '../../deploy/tarball.js';
+import { daemonClient } from '../../ipc/DaemonClient.js';
+export const deployCommand = new Command('deploy').description('Deployment commands');
+deployCommand
+    .command('upload [dir]')
+    .description('Upload a build artifact for deployment (default: current directory)')
+    .option('--interactive', 'Force interactive config prompts')
+    .option('--api-key <key>', 'API key (or ORKIFY_API_KEY env)')
+    .option('--api-host <url>', 'API host (or ORKIFY_API_HOST env)')
+    .option('--npm-version-patch', 'Bump package.json patch version before upload (e.g. 1.0.0 → 1.0.1)')
+    .option('--no-sourcemaps', 'Exclude .map files from the artifact')
+    .action(async (dir, options) => {
+    try {
+        const projectDir = resolve(dir ?? process.cwd());
+        const apiKey = options.apiKey || process.env.ORKIFY_API_KEY;
+        const apiHost = options.apiHost || process.env.ORKIFY_API_HOST || TELEMETRY_DEFAULT_API_HOST;
+        if (!apiKey) {
+            console.error(chalk.red('✗ API key required. Set ORKIFY_API_KEY or use --api-key'));
+            process.exit(1);
+        }
+        if (!existsSync(resolve(projectDir, 'package.json'))) {
+            console.error(chalk.red('✗ No package.json found in ' + projectDir));
+            process.exit(1);
+        }
+        // 1. Get or create orkify.yml config
+        let config = getOrkifyConfig(projectDir);
+        if (!config || !config.processes?.length || options.interactive) {
+            config = await interactiveConfig(projectDir);
+            saveOrkifyConfig(projectDir, config);
+            console.log(chalk.green(`✓ Deploy config saved to ${ORKIFY_CONFIG_FILE}`));
+        }
+        if (!config.deploy) {
+            console.error(chalk.red(`✗ No deploy section found in ${ORKIFY_CONFIG_FILE}. Run with --interactive`));
+            process.exit(1);
+        }
+        if (!config.processes?.length) {
+            console.error(chalk.red(`✗ No processes defined in ${ORKIFY_CONFIG_FILE}. Run with --interactive`));
+            process.exit(1);
+        }
+        // 2. Bump patch version if requested
+        if (options.npmVersionPatch) {
+            const current = readPackageJson(projectDir).version || '0.0.0';
+            execSync('npm version patch --no-git-tag-version', { cwd: projectDir, stdio: 'pipe' });
+            const bumped = readPackageJson(projectDir).version || current;
+            console.log(chalk.dim(`  version: ${current} → ${bumped}`));
+        }
+        // 3. Collect git metadata
+        const gitMeta = collectGitMetadata(projectDir);
+        if (gitMeta.gitSha) {
+            console.log(chalk.dim(`  git: ${gitMeta.gitBranch ?? 'detached'} ${gitMeta.gitSha.slice(0, 7)}`));
+        }
+        // 4. Create tarball
+        const excludeSourceMaps = options.sourcemaps === false || config.deploy?.sourcemaps === false;
+        console.log('Creating artifact...');
+        const tarPath = await createTarball(projectDir, { excludeSourceMaps });
+        const tarStat = statSync(tarPath);
+        const sizeStr = formatSize(tarStat.size);
+        console.log(chalk.dim(`  ${sizeStr}`));
+        // 5. Compute SHA-256
+        const sha256 = await computeSha256(tarPath);
+        // 6. Request upload URL
+        console.log('Uploading...');
+        const pkg = readPackageJson(projectDir);
+        const uploadResp = await fetch(`${apiHost}/api/v1/deploy/upload`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                sha256,
+                sizeBytes: tarStat.size,
+                filename: `${pkg.name || 'artifact'}.tar.gz`,
+                gitSha: gitMeta.gitSha,
+                gitBranch: gitMeta.gitBranch,
+                gitAuthor: gitMeta.gitAuthor,
+                gitMessage: gitMeta.gitMessage,
+                deployConfig: config.deploy,
+            }),
+        });
+        if (!uploadResp.ok) {
+            const msg = await parseErrorBody(uploadResp);
+            console.error(chalk.red(`✗ Artifact upload failed: ${msg}`));
+            process.exit(1);
+        }
+        const { artifactId, uploadUrl, version } = (await uploadResp.json());
+        // 7. Upload tarball to pre-signed URL
+        const tarBuffer = readFileSync(tarPath);
+        const putResp = await fetch(uploadUrl, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/gzip',
+                'Content-Length': String(tarStat.size),
+            },
+            body: tarBuffer,
+        });
+        if (!putResp.ok) {
+            const msg = await parseErrorBody(putResp);
+            console.error(chalk.red(`✗ Artifact storage failed: ${msg}`));
+            process.exit(1);
+        }
+        // 8. Confirm upload
+        const confirmResp = await fetch(`${apiHost}/api/v1/deploy/upload/${artifactId}/confirm`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+        });
+        if (!confirmResp.ok) {
+            const msg = await parseErrorBody(confirmResp);
+            console.error(chalk.red(`✗ Artifact confirmation failed: ${msg}`));
+            process.exit(1);
+        }
+        // 9. Clean up tarball
+        unlinkSync(tarPath);
+        console.log(chalk.green(`✓ Artifact v${version} uploaded (${sizeStr}, ${sha256.slice(0, 12)}...)`));
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+});
+deployCommand
+    .command('pack [dir]')
+    .description('Create a deploy tarball without uploading')
+    .option('--output <path>', 'Output tarball path')
+    .option('--interactive', 'Force interactive config prompts')
+    .option('--no-sourcemaps', 'Exclude .map files from the artifact')
+    .action(async (dir, options) => {
+    try {
+        const projectDir = resolve(dir ?? process.cwd());
+        let config = getOrkifyConfig(projectDir);
+        if (!config || !config.processes?.length || options.interactive) {
+            config = await interactiveConfig(projectDir);
+            saveOrkifyConfig(projectDir, config);
+            console.log(chalk.green(`✓ Deploy config saved to ${ORKIFY_CONFIG_FILE}`));
+        }
+        if (!existsSync(join(projectDir, ORKIFY_CONFIG_FILE))) {
+            console.error(chalk.red(`✗ ${ORKIFY_CONFIG_FILE} not found. Run with --interactive to create one.`));
+            process.exit(1);
+        }
+        const excludeMaps = options.sourcemaps === false || config?.deploy?.sourcemaps === false;
+        console.log('Creating artifact...');
+        const tarPath = await createTarball(projectDir, { excludeSourceMaps: excludeMaps });
+        let finalPath = tarPath;
+        if (options.output) {
+            finalPath = resolve(options.output);
+            renameSync(tarPath, finalPath);
+        }
+        const tarStat = statSync(finalPath);
+        const sha256 = await computeSha256(finalPath);
+        console.log(chalk.green(`✓ Created: ${finalPath} (${formatSize(tarStat.size)}, sha256: ${sha256.slice(0, 12)}...)`));
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+});
+deployCommand
+    .command('local <tarball>')
+    .description('Deploy from a local tarball')
+    .option('--env-file <path>', 'Load env vars from file')
+    .action(async (tarball, options) => {
+    try {
+        const tarballPath = resolve(tarball);
+        if (!existsSync(tarballPath)) {
+            console.error(chalk.red(`✗ Tarball not found: ${tarballPath}`));
+            process.exit(1);
+        }
+        // Extract orkify.yml from tarball to read deploy config
+        const tmpDir = mkdtempSync(join(tmpdir(), 'orkify-local-'));
+        try {
+            execSync(`tar xzf "${tarballPath}" -C "${tmpDir}" ${ORKIFY_CONFIG_FILE}`, {
+                stdio: 'pipe',
+            });
+        }
+        catch {
+            rmSync(tmpDir, { recursive: true, force: true });
+            console.error(chalk.red(`✗ Tarball is not a valid orkify package: ${ORKIFY_CONFIG_FILE} not found`));
+            process.exit(1);
+        }
+        const config = getOrkifyConfig(tmpDir);
+        rmSync(tmpDir, { recursive: true, force: true });
+        if (!config?.deploy) {
+            console.error(chalk.red(`✗ No deploy section found in ${ORKIFY_CONFIG_FILE}`));
+            process.exit(1);
+        }
+        // Parse env file if provided
+        let env;
+        if (options.envFile) {
+            const envPath = resolve(options.envFile);
+            if (!existsSync(envPath)) {
+                console.error(chalk.red(`✗ Env file not found: ${envPath}`));
+                process.exit(1);
+            }
+            env = parseEnvFile(readFileSync(envPath, 'utf-8'));
+        }
+        console.log(`Deploying ${tarballPath}...`);
+        const payload = {
+            tarballPath,
+            deployConfig: config.deploy,
+            env,
+        };
+        const response = await daemonClient.requestWithProgress(IPCMessageType.DEPLOY_LOCAL, payload, (data) => {
+            const { phase, output } = data;
+            if (phase)
+                console.log(chalk.dim(`  → ${phase}`));
+            else if (output)
+                console.log(chalk.dim(`    ${output}`));
+        }, IPC_DEPLOY_TIMEOUT);
+        if (response.success) {
+            console.log(chalk.green('✓ Deploy complete'));
+        }
+        else {
+            console.error(chalk.red(`✗ Deploy failed: ${response.error}`));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Error: ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        daemonClient.disconnect();
+    }
+});
+export async function parseErrorBody(resp) {
+    try {
+        const json = (await resp.json());
+        if (json.error)
+            return json.error;
+    }
+    catch {
+        // Not JSON — fall through to text
+    }
+    return `${resp.status} ${resp.statusText}`;
+}
+export function formatSize(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(2))} ${sizes[i]}`;
+}
+export async function computeSha256(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash('sha256');
+        const stream = createReadStream(filePath);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('end', () => resolve(hash.digest('hex')));
+        stream.on('error', reject);
+    });
+}
+//# sourceMappingURL=deploy.js.map

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

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