openworkgraph 0.2.12

package/dist/blob-store.d.ts

@@ -0,0 +1,40 @@
+import type { FileHandle } from 'node:fs/promises';
+export interface PreparedBlob {
+    readonly sha256: string;
+    readonly bytes: number;
+    readonly mime: string;
+    readonly path: string;
+    readonly text: string | null;
+}
+export declare const supportsText: (mime: string) => boolean;
+export declare const validMime: (mime: string) => boolean;
+export declare const opaqueFileMime: (mime: string) => boolean;
+export declare const mimeMatchesBytes: (declared: string, sniffed: string, allowGenericOctet?: boolean) => boolean;
+export declare const hashBytes: (bytes: Uint8Array) => string;
+/** The source can grow after stat: never let readFile allocate without a bound. */
+export declare function readBounded(file: FileHandle, max: number): Promise<Buffer>;
+import { sniffResourceMime as sniffMime } from "./vendor/protocol/index.js";
+export { sniffMime };
+/** Files are generation-addressed, not overwritten by hash. A committed GC queue
+ * can never unlink a later upload of the same bytes. Paths are private service data. */
+export declare class BlobStore {
+    readonly root: string;
+    readonly maxBytes: number;
+    private readonly prepared;
+    constructor(root: string, options?: {
+        maxBytes?: number;
+    });
+    private directory;
+    private write;
+    prepare(bytes: Uint8Array, declaredMime?: string, expectedHash?: string): Promise<PreparedBlob>;
+    assertPrepared(blob: PreparedBlob): void;
+    writeChunk(bytes: Uint8Array): Promise<string>;
+    private validatePath;
+    read(path: string): Promise<Buffer>;
+    /** Verify immutable media without allocating a full-video Buffer. */
+    withVerifiedFile<T>(path: string, expected: {
+        bytes: number;
+        sha256: string;
+    }, use: (path: string) => Promise<T>): Promise<T>;
+    remove(path: string): Promise<void>;
+}

package/dist/blob-store.js

@@ -0,0 +1,218 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { WORKGRAPH_UPLOAD_MAX_BYTES } from "./vendor/protocol/index.js";
+import { mkdir, open, realpath, unlink } from 'node:fs/promises';
+import { constants, lstatSync, realpathSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { ServiceError } from './errors.js';
+export const supportsText = (mime) => ['text/plain', 'text/markdown', 'text/csv', 'application/json', 'application/xml', 'text/xml', 'text/yaml', 'text/x-yaml', 'application/yaml', 'application/x-yaml'].includes(mime);
+const SNIFFED_MEDIA = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp', 'application/pdf', 'video/mp4', 'video/webm']);
+export const validMime = (mime) => /^[a-zA-Z0-9.+-]+[/][a-zA-Z0-9.+-]+$/.test(mime);
+export const opaqueFileMime = (mime) => validMime(mime) && mime !== 'application/octet-stream' && !supportsText(mime) && !SNIFFED_MEDIA.has(mime);
+export const mimeMatchesBytes = (declared, sniffed, allowGenericOctet = false) => declared === sniffed ||
+    (allowGenericOctet && declared === 'application/octet-stream') ||
+    (sniffed === 'text/plain' && (supportsText(declared) || declared === 'application/octet-stream' || opaqueFileMime(declared))) ||
+    (sniffed === 'application/octet-stream' && opaqueFileMime(declared));
+export const hashBytes = (bytes) => createHash('sha256').update(bytes).digest('hex');
+function blobRoot(input) {
+    const root = resolve(input);
+    if (process.platform !== 'win32')
+        return root;
+    // Windows may supply 8.3 paths. Reject actual links before canonicalizing spelling.
+    let canonical;
+    for (let path = root;; path = dirname(path)) {
+        try {
+            if (lstatSync(path).isSymbolicLink())
+                throw new ServiceError('INVALID_REQUEST', 'Blob directories cannot be symlinks');
+            canonical ??= join(realpathSync.native(path), relative(path, root));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (dirname(path) === path)
+            break;
+    }
+    return canonical ?? root;
+}
+async function syncDirectory(path) {
+    // Node cannot open directory handles for fsync on Windows. File data is synced above.
+    if (process.platform === 'win32')
+        return;
+    const directory = await open(path, constants.O_RDONLY);
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}
+/** The source can grow after stat: never let readFile allocate without a bound. */
+export async function readBounded(file, max) {
+    const parts = [];
+    let total = 0;
+    while (true) {
+        const buffer = Buffer.alloc(Math.min(64 * 1024, max - total + 1));
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, null);
+        if (!bytesRead)
+            break;
+        total += bytesRead;
+        if (total > max)
+            throw new ServiceError('PAYLOAD_TOO_LARGE', 'File exceeds maximum');
+        parts.push(buffer.subarray(0, bytesRead));
+    }
+    return Buffer.concat(parts, total);
+}
+import { sniffResourceMime as sniffMime } from "./vendor/protocol/index.js";
+export { sniffMime };
+/** Files are generation-addressed, not overwritten by hash. A committed GC queue
+ * can never unlink a later upload of the same bytes. Paths are private service data. */
+export class BlobStore {
+    root;
+    maxBytes;
+    prepared = new WeakSet();
+    constructor(root, options = {}) {
+        this.root = blobRoot(root);
+        this.maxBytes = options.maxBytes ?? WORKGRAPH_UPLOAD_MAX_BYTES;
+        if (!Number.isSafeInteger(this.maxBytes) || this.maxBytes < 1)
+            throw new Error('Invalid maximum upload size');
+    }
+    async directory(kind) {
+        const directory = join(this.root, kind);
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        if (await realpath(this.root) !== this.root || await realpath(directory) !== directory)
+            throw new ServiceError('INVALID_REQUEST', 'Blob directories cannot be symlinks');
+        return directory;
+    }
+    async write(bytes, kind) {
+        const directory = await this.directory(kind);
+        const path = join(directory, randomUUID());
+        const file = await open(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
+        try {
+            await file.writeFile(bytes);
+            await file.sync();
+            await file.chmod(0o400);
+        }
+        catch (error) {
+            await file.close();
+            await unlink(path).catch(() => { });
+            throw error;
+        }
+        try {
+            await file.close();
+            await syncDirectory(directory);
+        }
+        catch (error) {
+            await unlink(path).catch(() => { });
+            throw error;
+        }
+        return path;
+    }
+    async prepare(bytes, declaredMime = 'application/octet-stream', expectedHash) {
+        if (bytes.byteLength > this.maxBytes)
+            throw new ServiceError('PAYLOAD_TOO_LARGE', 'Resource exceeds configured maximum');
+        const stable = Buffer.from(bytes);
+        const sha256 = hashBytes(stable), mime = sniffMime(stable);
+        if (expectedHash !== undefined && (!/^[a-f0-9]{64}$/.test(expectedHash) || sha256 !== expectedHash))
+            throw new ServiceError('INVALID_REQUEST', 'SHA-256 mismatch');
+        const declared = declaredMime.toLowerCase().split(';')[0].trim();
+        if (!validMime(declared) || !mimeMatchesBytes(declared, mime, true))
+            throw new ServiceError('UNSUPPORTED_MEDIA_TYPE', 'Declared MIME does not match content');
+        if (declared === 'application/json') {
+            try {
+                JSON.parse(stable.toString('utf8'));
+            }
+            catch {
+                throw new ServiceError('UNSUPPORTED_MEDIA_TYPE', 'Invalid JSON content');
+            }
+        }
+        const effectiveMime = supportsText(declared) || opaqueFileMime(declared) ? declared : mime;
+        const result = Object.freeze({ sha256, bytes: stable.byteLength, mime: effectiveMime, path: await this.write(stable, 'objects'), text: supportsText(effectiveMime) ? new TextDecoder('utf-8', { fatal: true }).decode(stable) : null });
+        this.prepared.add(result);
+        return result;
+    }
+    assertPrepared(blob) { if (!this.prepared.has(blob))
+        throw new ServiceError('INVALID_REQUEST', 'Expected an immutable blob prepared by this store'); }
+    async writeChunk(bytes) { if (bytes.byteLength < 1 || bytes.byteLength > Math.min(this.maxBytes, 4 * 1024 * 1024))
+        throw new ServiceError('PAYLOAD_TOO_LARGE', 'Chunk exceeds maximum'); return this.write(Buffer.from(bytes), 'chunks'); }
+    validatePath(path) {
+        if (!['objects', 'chunks'].some(kind => dirname(path) === join(this.root, kind)) || !/^[0-9a-f-]{36}$/.test(path.slice(path.lastIndexOf(sep) + 1)))
+            throw new ServiceError('INVALID_REQUEST', 'Unmanaged blob path');
+        if (resolve(path) !== path)
+            throw new ServiceError('INVALID_REQUEST', 'Unmanaged blob path');
+    }
+    async read(path) {
+        this.validatePath(path);
+        if (await realpath(path) !== path)
+            throw new ServiceError('INVALID_REQUEST', 'Blob symlinks are forbidden');
+        const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const stat = await file.stat();
+            if (!stat.isFile())
+                throw new ServiceError('INVALID_REQUEST', 'Expected regular blob file');
+            if (stat.size > this.maxBytes)
+                throw new ServiceError('PAYLOAD_TOO_LARGE', 'Blob exceeds maximum');
+            return await readBounded(file, this.maxBytes);
+        }
+        finally {
+            await file.close();
+        }
+    }
+    /** Verify immutable media without allocating a full-video Buffer. */
+    async withVerifiedFile(path, expected, use) {
+        this.validatePath(path);
+        if (await realpath(path) !== path)
+            throw new ServiceError('INVALID_REQUEST', 'Blob symlinks are forbidden');
+        const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const before = await file.stat({ bigint: true });
+            if (!before.isFile() || before.size !== BigInt(expected.bytes) || before.size > BigInt(this.maxBytes))
+                throw new ServiceError('INTERNAL_ERROR', 'Stored blob integrity check failed');
+            const hash = createHash('sha256');
+            const buffer = Buffer.alloc(64 * 1024);
+            let total = 0;
+            while (true) {
+                const { bytesRead } = await file.read(buffer, 0, buffer.length, null);
+                if (!bytesRead)
+                    break;
+                total += bytesRead;
+                if (total > expected.bytes)
+                    throw new ServiceError('INTERNAL_ERROR', 'Stored blob integrity check failed');
+                hash.update(buffer.subarray(0, bytesRead));
+            }
+            if (total !== expected.bytes || hash.digest('hex') !== expected.sha256)
+                throw new ServiceError('INTERNAL_ERROR', 'Stored blob integrity check failed');
+            const result = await use(path);
+            if (await realpath(path) !== path)
+                throw new ServiceError('INVALID_REQUEST', 'Blob symlinks are forbidden');
+            const current = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+            try {
+                const after = await current.stat({ bigint: true });
+                if (after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size || after.mtimeNs !== before.mtimeNs || after.ctimeNs !== before.ctimeNs)
+                    throw new ServiceError('INTERNAL_ERROR', 'Stored blob changed during preview');
+            }
+            finally {
+                await current.close();
+            }
+            return result;
+        }
+        finally {
+            await file.close();
+        }
+    }
+    async remove(path) {
+        this.validatePath(path);
+        // Never traverse a replaced parent symlink, even when a deletion was queued.
+        if (await realpath(join(path, '..')) !== join(path, '..'))
+            throw new ServiceError('INVALID_REQUEST', 'Blob parent symlinks are forbidden');
+        try {
+            await unlink(path);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        // Marking the durable deletion queue completed must follow a durable unlink.
+        await syncDirectory(dirname(path));
+    }
+}
+//# sourceMappingURL=blob-store.js.map

package/dist/cli-help.d.ts

@@ -0,0 +1 @@
+export declare function formatHelp(): string;

package/dist/cli-help.js

@@ -0,0 +1,63 @@
+import { SERVICE_VERSION } from "./vendor/protocol/index.js";
+export function formatHelp() {
+    const row = (syntax, description) => '  ' + syntax.padEnd(32) + description;
+    return [
+        '',
+        'OpenWorkgraph  ' + SERVICE_VERSION,
+        'Local workflow service',
+        '',
+        'Usage',
+        '  openworkgraph <command> [options]',
+        '',
+        'Service management',
+        row('start', 'Start in the background'),
+        row('restart', 'Restart the service; acts as start when it is not running'),
+        row('update', 'Stop the service, install the latest package, and restart it if it was running'),
+        row('serve', 'Run in the foreground'),
+        row('status', 'Show service status'),
+        row('logs', 'Show service logs'),
+        row('stop', 'Wait for active tasks, then stop; keep queued tasks'),
+        row('capacity [COUNT]', 'Show or set concurrency (a positive integer)'),
+        '',
+        'Client pairing',
+        row('pair --client-code <CLIENT_CODE>', 'Verify origin and fingerprint, then approve the client'),
+        row('sessions', 'List client sessions'),
+        row('revoke-session <SESSION_ID>', 'Revoke a session'),
+        '',
+        'Backup and restore',
+        row('backup create', 'Create a backup'),
+        row('backup list', 'List backups'),
+        row('backup download <BACKUP_ID>', 'Download a backup; requires --output <NEW_FILE>'),
+        row('restore preview <PATH>', 'Preview a restore and its SHA-256'),
+        row('restore apply <PATH>', 'Restore locally; requires --sha256 <HASH>'),
+        '',
+        'Plugins',
+        row('plugin register <MANIFEST>', 'Register a trusted plugin JSON manifest'),
+        '',
+        'Startup options · start / serve only',
+        row('--data-dir <PATH>', 'Set and remember the service data directory'),
+        row('--host <ADDRESS>', 'Listen address (default: 0.0.0.0)'),
+        row('--port <PORT>', 'Listen port (default: 14317)'),
+        '  restart accepts --host / --port overrides; if stopping takes over 10 seconds, check status.',
+        '',
+        'Other options',
+        row('version', 'Show version'),
+        row('--yes', 'pair: explicitly approve in non-interactive scripts'),
+        row('--output-json', 'Output JSON for scripts and automation'),
+        row('--interrupt-and-stop', 'stop / restart / update: legacy alias; stopping cancels active and queued tasks'),
+        row('--idempotency-key <KEY>', 'backup create: set an idempotency key'),
+        row('--help', 'Show help'),
+        row('--version', 'Show version'),
+        '',
+        'Examples',
+        '  openworkgraph start --host 127.0.0.1',
+        '  openworkgraph pair --client-code 12345678',
+        '  openworkgraph status',
+        '  openworkgraph restart',
+        '  openworkgraph update',
+        '  openworkgraph backup create',
+        '  openworkgraph stop',
+        '',
+    ].join('\n');
+}
+//# sourceMappingURL=cli-help.js.map

package/dist/cli-output.d.ts

@@ -0,0 +1,4 @@
+export declare function formatHumanOutput(command: string, value: unknown): string;
+export declare function printOutput(command: string, value: unknown, outputJson?: boolean): void;
+export declare function formatPairingResult(value: unknown, outputJson?: boolean): string;
+export declare function formatCliError(error: unknown, outputJson?: boolean): string;

package/dist/cli-output.js

@@ -0,0 +1,130 @@
+import { ServiceError } from './errors.js';
+const fields = {
+    acceptedTasksUnaffected: 'Accepted tasks unaffected', activeRuns: 'Active runs', available: 'Available', backupId: 'Backup ID', browserName: 'Client name', bytes: 'Size', capacity: 'Capacity', code: 'Pairing code', createdAt: 'Created at', current: 'Current session', currentVersion: 'Current version', endpoints: 'Runtime endpoints', event: 'Event', expiresAt: 'Expires at', fingerprint: 'Public key fingerprint SHA-256', id: 'ID', instanceId: 'Instance ID', integrity: 'Integrity', invalidatesAllSessions: 'Invalidates all sessions', lastUsedAt: 'Last used at', latestVersion: 'Latest version', listenHost: 'Listen address', localEndpoint: 'Local endpoint', location: 'Storage location', mode: 'Mode', occupied: 'Occupied', origin: 'Web origin', output: 'Output file', packageName: 'Package', pairedAt: 'Paired at', pairingCommand: 'Pairing command', pausesQueuedRuns: 'Pauses queued runs', pluginId: 'Plugin ID', registered: 'Registered', requiresMaintenance: 'Requires maintenance', restarted: 'Runtime restarted', restored: 'Restored', revoked: 'Revoked session', schemaVersion: 'Schema version', serviceId: 'Runtime ID', sha256: 'SHA-256', state: 'State', time: 'Time', typeId: 'Type ID', updateAvailable: 'Update available', updated: 'Package updated', version: 'Version',
+};
+const titles = {
+    'backup create': 'Backup created', 'backup download': 'Backup downloaded', 'backup list': 'Backups', capacity: 'Runtime capacity', logs: 'Runtime logs', 'plugin register': 'Plugin registered', restart: 'Runtime restarted', 'restore apply': 'Backup restored', 'restore preview': 'Restore preview', 'revoke-session': 'Session revoked', sessions: 'Client sessions', start: 'Runtime started', status: 'Runtime status', stop: 'Runtime stopping', update: 'Runtime update',
+};
+const states = { active: 'Active', creating: 'Creating', draining: 'Draining', expired: 'Expired', failed: 'Failed', interrupting: 'Interrupting', ready: 'Ready', running: 'Running' };
+const events = { backup_failed: 'Backup failed', backup_ready: 'Backup ready', draining: 'Draining started', interrupting: 'Interrupting', restored: 'Restored', shutdown_failed: 'Shutdown failed', started: 'Started', startup_failed: 'Startup failed', stopped: 'Stopped' };
+const values = { pairing: 'Waiting for client pairing', verified: 'Verified' };
+const translatedErrors = new Map([
+    ['Unknown command; use --help', 'Unknown command. Use --help to see available commands.'],
+    ['Port must be an integer from 0 to 65535', 'Port must be an integer from 0 to 65535.'],
+    ['Unexpected arguments', 'Unexpected arguments. Use --help for command syntax.'],
+    ['Service not running or management unavailable', 'The service is not running or local management is unavailable.'],
+    ['Startup acknowledgment timed out; inspect status before retrying', 'Startup confirmation timed out. Run status before retrying.'],
+    ['Service is still draining; interactions/cancel remain available', 'The service is still draining; interactions and cancellation remain available.'],
+]);
+const fallbackErrors = {
+    INVALID_REQUEST: 'The command request is invalid.',
+    ORIGIN_DENIED: 'The client origin is not allowed.',
+    PAIRING_CODE_EXPIRED: 'The pairing code has expired. Generate a new code in the browser.',
+    PAIRING_CODE_INVALID: 'The pairing code is invalid. Generate a new code in the browser.',
+    PAIRING_CODE_USED: 'The pairing code has already been used. Generate a new code in the browser.',
+    SERVICE_MISMATCH: 'The client code belongs to a different runtime.',
+    SERVICE_NOT_RUNNING: 'The runtime is not running or local management is unavailable.',
+};
+function displayWidth(value) { return [...value].reduce((width, char) => width + (/[^\x00-\xff]/.test(char) ? 2 : 1), 0); }
+function padLabel(value, width) { return value + ' '.repeat(Math.max(0, width - displayWidth(value))); }
+function formatDate(value) {
+    if (!/^\d{4}-\d{2}-\d{2}T/.test(value))
+        return value;
+    const date = new Date(value);
+    return Number.isNaN(date.valueOf()) ? value : date.toLocaleString('en-US', { hour12: false });
+}
+function formatBytes(value) {
+    if (value < 1024)
+        return value + ' B';
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let size = value / 1024;
+    let unit = units[0];
+    for (let index = 1; index < units.length && size >= 1024; index++) {
+        size /= 1024;
+        unit = units[index];
+    }
+    return size.toFixed(size >= 10 ? 1 : 2).replace(/\.0+$|(?<=\.[0-9])0$/, '') + ' ' + unit;
+}
+function scalar(key, value) {
+    if (value === null)
+        return '—';
+    if (typeof value === 'boolean')
+        return value ? 'Yes' : 'No';
+    if (typeof value === 'number')
+        return key === 'bytes' ? formatBytes(value) : String(value);
+    if (typeof value === 'string') {
+        if (key === 'state' && states[value])
+            return states[value];
+        if (key === 'event' && events[value])
+            return events[value];
+        if (key.endsWith('At') || key === 'time')
+            return formatDate(value);
+        return values[value] || value || '—';
+    }
+    return String(value);
+}
+function recordLines(value, indent = '  ') {
+    const entries = Object.entries(value).filter(([, item]) => item !== undefined);
+    const scalarEntries = entries.filter(([, item]) => item === null || ['string', 'number', 'boolean'].includes(typeof item));
+    const labelWidth = Math.max(0, ...scalarEntries.map(([key]) => displayWidth(fields[key] ?? key)));
+    const lines = scalarEntries.map(([key, item]) => indent + padLabel(fields[key] ?? key, labelWidth) + '  ' + scalar(key, item));
+    for (const [key, item] of entries) {
+        if (item === null || ['string', 'number', 'boolean'].includes(typeof item))
+            continue;
+        const label = fields[key] ?? key;
+        if (Array.isArray(item)) {
+            if (item.every(entry => entry === null || ['string', 'number', 'boolean'].includes(typeof entry)))
+                lines.push(indent + label + '  ' + (item.length ? item.map(entry => scalar(key, entry)).join(', ') : '—'));
+            else {
+                lines.push(indent + label);
+                lines.push(...listLines(item, indent + '  '));
+            }
+        }
+        else if (typeof item === 'object') {
+            lines.push(indent + label);
+            lines.push(...recordLines(item, indent + '  '));
+        }
+    }
+    return lines;
+}
+function listLines(items, indent = '  ') {
+    if (items.length === 0)
+        return [indent + 'No records.'];
+    const lines = [];
+    items.forEach((item, index) => {
+        if (item && typeof item === 'object' && !Array.isArray(item)) {
+            lines.push(indent + (index + 1) + '.');
+            lines.push(...recordLines(item, indent + '   '));
+        }
+        else
+            lines.push(indent + (index + 1) + '. ' + scalar('', item));
+        if (index < items.length - 1)
+            lines.push('');
+    });
+    return lines;
+}
+export function formatHumanOutput(command, value) {
+    const title = titles[command] ?? 'Command result';
+    const lines = Array.isArray(value) ? listLines(value) : value && typeof value === 'object' ? recordLines(value) : ['  ' + scalar('', value)];
+    return ['', title, '', ...lines, ''].join('\n');
+}
+export function printOutput(command, value, outputJson = false) { console.log(outputJson ? JSON.stringify(value) : formatHumanOutput(command, value)); }
+export function formatPairingResult(value, outputJson = false) {
+    if (outputJson)
+        return JSON.stringify(value);
+    const result = value;
+    if (result.code)
+        return ['', 'Legacy client authorization completed', '', '  One-time pairing code  ' + result.code, '', '  Valid for              5 minutes, one use only', '  Expires at             ' + formatDate(result.expiresAt), '  Web origin             ' + result.origin, '  Runtime ID             ' + result.serviceId, ...(result.endpoints?.length ? ['  Runtime endpoints      ' + result.endpoints.join(', ')] : []), '', 'Return to the original browser page and enter the pairing code above.', ''].join('\n');
+    return ['', 'Client pairing approved', '', '  Web origin             ' + result.origin, '  Runtime ID             ' + result.serviceId, '  Request expires at     ' + formatDate(result.expiresAt), ...(result.endpoints?.length ? ['  Runtime endpoints      ' + result.endpoints.join(', ')] : []), '', 'The browser will detect approval and connect automatically. Keep the pairing page open.', ''].join('\n');
+}
+export function formatCliError(error, outputJson = false) {
+    const code = error instanceof ServiceError ? error.code : 'STARTUP_FAILED';
+    const raw = error instanceof Error ? error.message : 'Command failed.';
+    const source = raw.startsWith('Background startup refused: ') ? raw.slice('Background startup refused: '.length) : raw;
+    const message = translatedErrors.get(source) ?? (/\p{Script=Han}/u.test(source) ? fallbackErrors[code] ?? 'The command failed. See the error code for details.' : source);
+    if (outputJson)
+        return JSON.stringify({ code, message });
+    const width = Math.max(displayWidth('Code'), displayWidth('Reason'));
+    return ['', 'Command failed', '', '  ' + padLabel('Code', width) + '  ' + code, '  ' + padLabel('Reason', width) + '  ' + message, ''].join('\n');
+}
+//# sourceMappingURL=cli-output.js.map

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};