@loom-framework/core 0.1.0-alpha.19 → 0.1.0-alpha.190

package/dist/cli/commands/process.js

@@ -0,0 +1,630 @@
+/**
+ * Process CLI Commands
+ *
+ * loom process add/list/status/run/pause/resume/remove/update/logs/generate/export
+ */
+import chalk from 'chalk';
+import { resolveToken, resolveServer, requireToken, CliAuthError } from '../helpers/auth-client.js';
+/** Commander.js collect parser: accumulate repeated --source values into an array */
+function collectSource(value, previous) {
+    return previous.concat([value]);
+}
+/** Convert repeated --source CLI values into ProcessSource[].
+ *  Single command: unnamed source (lifecycle name = {process}-feeder)
+ *  Multiple commands: auto-numbered 1, 2, 3... (lifecycle name = {process}-feeder-1, etc.)
+ */
+function buildSourcesFromCommands(commands) {
+    if (commands.length === 1) {
+        return [{ command: commands[0] }];
+    }
+    return commands.map((cmd, i) => ({
+        name: String(i + 1),
+        command: cmd,
+    }));
+}
+/** Handle CliAuthError in catch blocks */
+function handleAuthError(err) {
+    if (err instanceof CliAuthError) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+}
+async function fetchApi(path, options = {}) {
+    const baseUrl = resolveServer(options.server).replace(/\/$/, '');
+    const headers = {};
+    if (options.body) {
+        headers['Content-Type'] = 'application/json';
+    }
+    if (options.token) {
+        headers['Authorization'] = `Bearer ${options.token}`;
+    }
+    const response = await fetch(`${baseUrl}${path}`, {
+        method: options.method ?? 'GET',
+        headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+    });
+    if (response.status === 401)
+        throw new Error('Authentication failed. Token may be expired.');
+    if (response.status === 403) {
+        const data = await response.json();
+        throw new Error(`Permission denied: ${data.error || 'Insufficient permissions'}${data.required ? ` (required: ${data.required}, actual: ${data.actual})` : ''}`);
+    }
+    const data = await response.json();
+    if (!response.ok) {
+        throw new Error(data.error ?? `HTTP ${response.status}`);
+    }
+    return data;
+}
+export function registerProcessCommand(program) {
+    const processCmd = program.command('process').description('Process automation management');
+    // loom process add
+    processCmd.command('add')
+        .requiredOption('--name <name>', 'Process name (^[a-zA-Z][a-zA-Z0-9_-]*$)')
+        .option('--cron <expression>', 'Cron schedule expression')
+        .option('--cron-timezone <tz>', 'Cron timezone (default: system)')
+        .option('--subscribe <pattern>', 'EventBus pattern to subscribe (e.g. "data:create:tasks") — creates an event subscription')
+        .option('--event-filter <json>', 'Event payload filter as JSON (used with --subscribe)')
+        .option('--event-debounce <ms>', 'Debounce window for event triggers in ms (default: 0, no debounce)', '0')
+        .option('--prompt <text>', 'Inline prompt for lightweight process')
+        .option('--process <name>', 'Full process name (expects .loom/processes/{name}/PROCESS.md)')
+        .option('--source <command>', 'Feeder script command, repeatable (e.g. --source "bash examples/feeders/ingest.sh"). Requires --subscribe.', collectSource, [])
+        .option('--description <text>', 'Process description')
+        .option('--owner <username>', 'Owner username (default: from processes config)')
+        .option('--owner-token <jwt>', 'Owner service token (used directly)')
+        .option('--metrics-config <path>', 'Path to metrics DashboardWidget config JSON')
+        .option('--model <name>', 'AI model name to use for this process (from model management)')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (opts) => {
+        // Validate: exactly one of --prompt or --process must be set
+        if (!opts.prompt && !opts.process) {
+            console.error(chalk.red('Error: Either --prompt or --process must be specified'));
+            process.exit(1);
+        }
+        if (opts.prompt && opts.process) {
+            console.error(chalk.red('Error: Cannot specify both --prompt and --process'));
+            process.exit(1);
+        }
+        // Validate: --source requires --subscribe
+        if (opts.source.length > 0 && !opts.subscribe) {
+            console.error(chalk.red('Error: --source requires --subscribe (feeder must have an event pattern)'));
+            process.exit(1);
+        }
+        try {
+            const token = requireToken(opts.token);
+            const body = {
+                name: opts.name,
+                owner: opts.owner ?? 'admin',
+            };
+            if (opts.description)
+                body.description = opts.description;
+            if (opts.cron)
+                body.cron = opts.cron;
+            if (opts.cronTimezone)
+                body.cronTimezone = opts.cronTimezone;
+            if (opts.prompt)
+                body.prompt = opts.prompt;
+            if (opts.process)
+                body.hasProcessFile = true;
+            if (opts.ownerToken)
+                body.ownerToken = opts.ownerToken;
+            if (opts.source.length > 0) {
+                body.sources = buildSourcesFromCommands(opts.source);
+            }
+            if (opts.model)
+                body.model = opts.model;
+            if (opts.metricsConfig) {
+                try {
+                    const fs = await import('fs/promises');
+                    const content = await fs.readFile(opts.metricsConfig, 'utf-8');
+                    body.metricsConfig = JSON.parse(content);
+                }
+                catch (err) {
+                    console.error(chalk.red(`Error reading metrics config: ${err instanceof Error ? err.message : String(err)}`));
+                    process.exit(1);
+                }
+            }
+            // If --subscribe is provided, create a subscription alongside the process
+            if (opts.subscribe) {
+                const subscription = {
+                    pattern: opts.subscribe,
+                };
+                if (opts.eventFilter) {
+                    try {
+                        subscription.filter = JSON.parse(opts.eventFilter);
+                    }
+                    catch {
+                        console.error(chalk.red('Error: --event-filter must be valid JSON'));
+                        process.exit(1);
+                    }
+                }
+                if (opts.eventDebounce)
+                    subscription.debounceMs = parseInt(opts.eventDebounce, 10);
+                body.subscription = subscription;
+            }
+            const result = await fetchApi('/api/v1/processes', {
+                method: 'POST',
+                body,
+                token,
+                server: opts.server,
+            });
+            console.log(chalk.green(`Process "${result.data.name}" created successfully`));
+            if (result.data.cron)
+                console.log(`  Cron: ${result.data.cron}`);
+            if (opts.subscribe)
+                console.log(`  Event subscription: ${opts.subscribe}`);
+            if (result.data.sources?.length) {
+                for (const s of result.data.sources) {
+                    const label = s.name ? `Source (${s.name})` : `Source`;
+                    console.log(`  ${label}: ${s.command}`);
+                }
+            }
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process list
+    processCmd.command('list')
+        .option('--status <status>', 'Filter by status (active|paused)')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (opts) => {
+        try {
+            const token = resolveToken(opts.token);
+            const result = await fetchApi(`/api/v1/processes${opts.status ? `?status=${opts.status}` : ''}`, {
+                token: token ?? undefined,
+                server: opts.server,
+            });
+            if (result.data.length === 0) {
+                console.log('No processes found.');
+                return;
+            }
+            console.log(chalk.bold('Processes:'));
+            for (const proc of result.data) {
+                const triggers = [];
+                if (proc.cron)
+                    triggers.push(`cron: ${proc.cron}`);
+                const eventSubs = proc.eventSubscriptions;
+                if (eventSubs && eventSubs.length > 0) {
+                    for (const sub of eventSubs)
+                        triggers.push(`event: ${sub.pattern}`);
+                }
+                const mode = proc.hasProcessFile ? 'full' : 'lightweight';
+                const status = proc.paused ? chalk.yellow('paused') : chalk.green('active');
+                console.log(`  ${chalk.bold(proc.name)} (${mode}) ${status}`);
+                if (triggers.length > 0)
+                    console.log(`    Triggers: ${triggers.join(', ')}`);
+                if (proc.sources?.length) {
+                    for (const s of proc.sources) {
+                        const label = s.name ? `Source (${s.name})` : 'Source';
+                        console.log(`    ${label}: ${s.command}`);
+                    }
+                }
+                console.log(`    Owner: ${proc.owner}`);
+            }
+            console.log(`\nQueue: ${result.queue.running} running / ${result.queue.queued} queued (max: ${result.queue.maxConcurrent})`);
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process status <name>
+    processCmd.command('status <name>')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, opts) => {
+        try {
+            const token = requireToken(opts.token);
+            const result = await fetchApi(`/api/v1/processes/${name}`, {
+                token,
+                server: opts.server,
+            });
+            const proc = result.data;
+            console.log(chalk.bold(`Process: ${proc.name}`));
+            console.log(`  Status: ${proc.status}`);
+            console.log(`  Mode: ${proc.hasProcessFile ? 'full (PROCESS.md)' : 'lightweight (prompt)'}`);
+            console.log(`  Owner: ${proc.owner}`);
+            if (proc.cron)
+                console.log(`  Cron: ${proc.cron}${proc.cronTimezone ? ` (${proc.cronTimezone})` : ''}`);
+            const eventSubs = proc.eventSubscriptions;
+            if (eventSubs && eventSubs.length > 0) {
+                for (const sub of eventSubs) {
+                    const cfg = sub.config;
+                    const debounce = typeof cfg?.debounceMs === 'number' ? cfg.debounceMs : undefined;
+                    let line = `  Event: ${sub.pattern}`;
+                    if (debounce)
+                        line += ` (debounce: ${debounce}ms)`;
+                    if (sub.active === false)
+                        line += ' [inactive]';
+                    console.log(line);
+                }
+            }
+            if (proc.sources?.length) {
+                for (const s of proc.sources) {
+                    const label = s.name ? `Source (${s.name})` : 'Source';
+                    console.log(`  ${label}: ${s.command}`);
+                }
+            }
+            if (proc.description)
+                console.log(`  Description: ${proc.description}`);
+            if (proc.prompt)
+                console.log(`  Prompt: ${proc.prompt.substring(0, 100)}${proc.prompt.length > 100 ? '...' : ''}`);
+            console.log(`  Created: ${proc.createdAt}`);
+            console.log(`  Updated: ${proc.updatedAt}`);
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process run <name>
+    processCmd.command('run <name>')
+        .option('--payload <json>', 'Event payload as JSON')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, opts) => {
+        const body = {};
+        if (opts.payload) {
+            try {
+                body.eventPayload = JSON.parse(opts.payload);
+            }
+            catch {
+                console.error(chalk.red('Error: --payload must be valid JSON'));
+                process.exit(1);
+            }
+        }
+        try {
+            const token = requireToken(opts.token);
+            const result = await fetchApi(`/api/v1/processes/${name}/run`, {
+                method: 'POST',
+                body,
+                token,
+                server: opts.server,
+            });
+            console.log(chalk.green(`Process "${name}" triggered. Run ID: ${result.runId}`));
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process pause <name>
+    processCmd.command('pause <name>')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, opts) => {
+        try {
+            const token = requireToken(opts.token);
+            await fetchApi(`/api/v1/processes/${name}/pause`, { method: 'POST', token, server: opts.server });
+            console.log(chalk.yellow(`Process "${name}" paused`));
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process resume <name>
+    processCmd.command('resume <name>')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, opts) => {
+        try {
+            const token = requireToken(opts.token);
+            await fetchApi(`/api/v1/processes/${name}/resume`, { method: 'POST', token, server: opts.server });
+            console.log(chalk.green(`Process "${name}" resumed`));
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process remove <name>
+    processCmd.command('remove <name>')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, opts) => {
+        try {
+            const token = requireToken(opts.token);
+            await fetchApi(`/api/v1/processes/${name}`, { method: 'DELETE', token, server: opts.server });
+            console.log(chalk.green(`Process "${name}" removed`));
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process update <name>
+    processCmd.command('update <name>')
+        .option('--cron <expression>', 'Update cron schedule expression')
+        .option('--cron-timezone <tz>', 'Update cron timezone')
+        .option('--prompt <text>', 'Update inline prompt')
+        .option('--description <text>', 'Update description')
+        .option('--source <command>', 'Feeder script command, repeatable (e.g. --source "bash examples/feeders/ingest.sh"). Replaces all existing sources.', collectSource, [])
+        .option('--model <name>', 'Update AI model name (empty string to remove binding)')
+        .option('--subscribe-add <pattern>', 'Add an event subscription for this process')
+        .option('--subscribe-filter <json>', 'Event payload filter as JSON (used with --subscribe-add)')
+        .option('--subscribe-debounce <ms>', 'Debounce window for event triggers in ms (used with --subscribe-add)', '0')
+        .option('--subscribe-remove <id>', 'Remove an event subscription by ID')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, opts) => {
+        const body = {};
+        if (opts.cron !== undefined)
+            body.cron = opts.cron;
+        if (opts.cronTimezone !== undefined)
+            body.cronTimezone = opts.cronTimezone;
+        if (opts.prompt !== undefined)
+            body.prompt = opts.prompt;
+        if (opts.description !== undefined)
+            body.description = opts.description;
+        if (opts.source.length > 0) {
+            body.sources = buildSourcesFromCommands(opts.source);
+        }
+        if (opts.model !== undefined)
+            body.model = opts.model;
+        // Handle --subscribe-add
+        if (opts.subscribeAdd) {
+            const subscription = {
+                pattern: opts.subscribeAdd,
+                filter: undefined,
+                debounceMs: opts.subscribeDebounce ? parseInt(opts.subscribeDebounce, 10) : undefined,
+            };
+            if (opts.subscribeFilter) {
+                try {
+                    subscription.filter = JSON.parse(opts.subscribeFilter);
+                }
+                catch {
+                    console.error(chalk.red('Error: --subscribe-filter must be valid JSON'));
+                    process.exit(1);
+                }
+            }
+            // Remove undefined entries
+            if (!subscription.filter)
+                delete subscription.filter;
+            if (!subscription.debounceMs)
+                delete subscription.debounceMs;
+            body.subscriptionAdd = subscription;
+        }
+        // Handle --subscribe-remove
+        if (opts.subscribeRemove) {
+            body.subscriptionRemoveId = opts.subscribeRemove;
+        }
+        if (Object.keys(body).length === 0) {
+            console.error(chalk.red('Error: At least one update field is required (--cron, --prompt, --subscribe-add, etc.)'));
+            process.exit(1);
+        }
+        try {
+            const token = requireToken(opts.token);
+            const result = await fetchApi(`/api/v1/processes/${name}`, {
+                method: 'PUT',
+                body,
+                token,
+                server: opts.server,
+            });
+            console.log(chalk.green(`Process "${result.data.name}" updated`));
+            if (opts.subscribeAdd)
+                console.log(`  Event subscription added: ${opts.subscribeAdd}`);
+            if (opts.subscribeRemove)
+                console.log(`  Event subscription removed: ${opts.subscribeRemove}`);
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process logs <name> [runId]
+    processCmd.command('logs <name> [runId]')
+        .option('--last <number>', 'Number of recent log entries (alias for --limit)', '20')
+        .option('--limit <number>', 'Max log entries')
+        .option('--offset <number>', 'Offset for pagination', '0')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, runId, opts) => {
+        try {
+            const token = requireToken(opts.token);
+            if (runId) {
+                const result = await fetchApi(`/api/v1/processes/${name}/logs/${runId}`, {
+                    token,
+                    server: opts.server,
+                });
+                console.log(JSON.stringify(result.data, null, 2));
+            }
+            else {
+                const limit = opts.limit ?? opts.last;
+                const result = await fetchApi(`/api/v1/processes/${name}/logs?limit=${limit}&offset=${opts.offset ?? 0}`, {
+                    token,
+                    server: opts.server,
+                });
+                if (result.data.length === 0) {
+                    console.log(`No logs found for process "${name}".`);
+                    return;
+                }
+                for (const log of result.data) {
+                    const status = log.status;
+                    const statusColor = status === 'completed' ? chalk.green : status === 'failed' ? chalk.red : status === 'timeout' ? chalk.yellow : chalk.blue;
+                    const duration = log.durationMs ? `${(log.durationMs / 1000).toFixed(1)}s` : '-';
+                    console.log(`  ${statusColor(status.padEnd(10))} ${log.runId}  ${log.triggerType}  ${duration.padStart(8)}  ${log.startedAt}`);
+                    if (log.error)
+                        console.log(`    Error: ${chalk.red(log.error)}`);
+                }
+            }
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process generate <name>
+    processCmd.command('generate <name>')
+        .option('--description <text>', 'Process description')
+        .action(async (name, opts) => {
+        const fs = await import('fs/promises');
+        const processDir = `.loom/users/admin/processes/${name}`;
+        const processFile = `${processDir}/PROCESS.md`;
+        try {
+            await fs.mkdir(processDir, { recursive: true });
+            const template = `# Process: ${name}
+
+${opts.description ? `## Description\n${opts.description}\n` : ''}## Trigger
+
+_Specify trigger conditions (cron schedule or EventBus pattern)_
+
+## Flow
+
+_Define the steps this process should follow_
+
+1. Step 1: ...
+2. Step 2: ...
+
+## Decision Points
+
+_List key decisions the AI should make during execution_
+
+## Metrics
+
+_Define what success looks like and how to measure it_
+
+## Evolution
+
+_How should this process improve over time?_
+
+## References
+
+_List files in the references/ directory that support this process:_
+- _Skill references (e.g., CLI command usage, API docs)_
+- _Domain knowledge (e.g., data schemas, business rules)_
+- _Scripts or tools (e.g., data transforms, query templates)_
+_Only create the references/ directory and add files when needed._
+`;
+            await fs.writeFile(processFile, template, 'utf-8');
+            console.log(chalk.green(`Process scaffold created at ${processDir}/`));
+            console.log(`  Edit the PROCESS.md file to define your process.`);
+            console.log(`  Then run: ${chalk.cyan(`loom process add --process ${name} --owner <username>`)}`);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process export <name>
+    processCmd.command('export <name>')
+        .option('--format <format>', 'Export format (json)', 'json')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, opts) => {
+        try {
+            const token = requireToken(opts.token);
+            const result = await fetchApi(`/api/v1/processes/${name}`, {
+                token,
+                server: opts.server,
+            });
+            console.log(JSON.stringify(result.data, null, 2));
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process metrics-report <name>
+    processCmd.command('metrics-report <name>')
+        .requiredOption('--metric-name <name>', 'Metric name')
+        .requiredOption('--value <number>', 'Metric value', parseFloat)
+        .option('--run-id <id>', 'Run ID (from LOOM_RUN_ID env)')
+        .option('--timestamp <iso>', 'ISO timestamp (defaults to now)')
+        .option('--dimensions <json>', 'Dimension labels as JSON')
+        .option('--target <number>', 'Target value', parseFloat)
+        .option('--unit <unit>', 'Unit label (e.g. "%", "条")')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, opts) => {
+        try {
+            const token = resolveToken(opts.token) ?? process.env.LOOM_TOKEN;
+            if (!token) {
+                console.error(chalk.red('Error: Auth token required (--token or LOOM_TOKEN env)'));
+                process.exit(1);
+            }
+            const body = {
+                metricName: opts.metricName,
+                value: opts.value,
+                runId: opts.runId ?? process.env.LOOM_RUN_ID ?? '',
+            };
+            if (opts.timestamp)
+                body.timestamp = opts.timestamp;
+            if (opts.target !== undefined)
+                body.target = opts.target;
+            if (opts.unit)
+                body.unit = opts.unit;
+            if (opts.dimensions) {
+                try {
+                    body.dimensions = JSON.parse(opts.dimensions);
+                }
+                catch {
+                    console.error(chalk.red('Error: --dimensions must be valid JSON'));
+                    process.exit(1);
+                }
+            }
+            const server = opts.server ?? (process.env.LOOM_SERVER ? `${process.env.LOOM_SERVER}` : undefined);
+            await fetchApi(`/api/v1/processes/${name}/metrics-report`, {
+                method: 'POST',
+                body,
+                token,
+                server,
+            });
+            console.log(chalk.green(`Metric "${opts.metricName}" reported (value: ${opts.value}${opts.unit ? ` ${opts.unit}` : ''})`));
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // loom process metrics-set-view-config <name>
+    processCmd.command('metrics-set-view-config <name>')
+        .requiredOption('--config <json>', 'View config JSON (or @file to read from file)')
+        .option('--token <token>', 'Auth token')
+        .option('--server <url>', 'Server URL')
+        .action(async (name, opts) => {
+        try {
+            const token = requireToken(opts.token);
+            let configJson = opts.config;
+            if (configJson.startsWith('@')) {
+                const fs = await import('fs/promises');
+                configJson = await fs.readFile(configJson.substring(1), 'utf-8');
+            }
+            let config;
+            try {
+                config = JSON.parse(configJson);
+            }
+            catch {
+                console.error(chalk.red('Error: --config must be valid JSON'));
+                process.exit(1);
+            }
+            await fetchApi(`/api/v1/processes/${name}/metrics-view-config`, {
+                method: 'PUT',
+                body: config,
+                token,
+                server: opts.server,
+            });
+            console.log(chalk.green(`View config set for process "${name}"`));
+        }
+        catch (err) {
+            handleAuthError(err);
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=process.js.map