beehaven 0.8.16

package/dist/commands/user.js

@@ -0,0 +1,240 @@
+/**
+ * beehaven user — per-user admin sugar (auto-discovers folders)
+ *
+ * Wraps the worker's /admin/do/<type>/<id>/<action> surface so dev doesn't
+ * type `beehaven admin sql User/<id> "..."` for each folder. The DO type
+ * comes from --workspace, or `userWorkspace` in beehaven.json (project root
+ * or worker subdir), or errors with a helpful message.
+ *
+ * Subcommands:
+ *   inspect           Storage breakdown + per-table row counts
+ *   dump [folder]     Dump one folder (or all) for this user as JSON
+ *   sql "<query>"     Sugar over admin:sql for this user's DO
+ *   export [--out]    Dump every folder to one JSON file
+ *   wipe --yes        Call the project's configured wipe action (or DELETE per-folder)
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { color, spinner, table } from '../spinner.js';
+import { getAdminClient, doActionPath } from '../lib/admin-client.js';
+function findProjectConfig(start = process.cwd()) {
+    let dir = resolve(start);
+    while (true) {
+        const p = join(dir, 'beehaven.json');
+        if (existsSync(p)) {
+            try {
+                return { ...JSON.parse(readFileSync(p, 'utf-8')), _path: p };
+            }
+            catch {
+                return {};
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return {};
+        dir = parent;
+    }
+}
+function resolveWorkspaceType(opts) {
+    if (opts.workspace)
+        return opts.workspace;
+    const cfg = findProjectConfig();
+    const fromConfig = cfg.user?.workspace ?? cfg.userWorkspace;
+    if (fromConfig)
+        return fromConfig;
+    return {
+        error: 'Unknown user workspace type. Pass --workspace <ClassName> (e.g. --workspace User),\n' +
+            '  or add to beehaven.json:  { "userWorkspace": "User" }',
+    };
+}
+export async function user(opts) {
+    if (!opts.userId) {
+        console.error('Usage: beehaven user <userId> <inspect|dump|sql|export|wipe> [args]');
+        process.exit(1);
+    }
+    const wsType = resolveWorkspaceType(opts);
+    if (typeof wsType !== 'string') {
+        console.error(color.red(wsType.error));
+        process.exit(1);
+    }
+    const client = getAdminClient({ url: opts.url, secret: opts.secret });
+    if ('error' in client) {
+        console.error(color.red(client.error));
+        process.exit(1);
+    }
+    const sub = opts.subcommand ?? 'inspect';
+    switch (sub) {
+        case 'inspect': {
+            const s = spinner(`Inspecting ${wsType}/${opts.userId}…`).start();
+            const { ok, status, body } = await client.call(doActionPath(wsType, opts.userId, 'admin:storage'), { method: 'POST', body: {} });
+            if (!ok) {
+                s.fail(`HTTP ${status}: ${body?.error ?? 'unknown'}`);
+                process.exit(1);
+            }
+            const totalMb = body?.sqlite?.mb ?? '?';
+            s.succeed(`${wsType}/${opts.userId} — ${totalMb} MB`);
+            const sizes = body?.tableSizes ?? {};
+            const rows = Object.entries(sizes).map(([t, info]) => [
+                color.cyan(t),
+                String(info.rowCount ?? '—'),
+                info.bytes ? `${(info.bytes / 1024).toFixed(1)} KB` : '—',
+            ]);
+            console.log('');
+            console.log(table(['Table', 'Rows', 'Size'], rows));
+            console.log('');
+            console.log(color.dim(`  beehaven user ${opts.userId} dump <table>`));
+            console.log(color.dim(`  beehaven user ${opts.userId} export`));
+            return;
+        }
+        case 'sql': {
+            const query = opts.positionals[0];
+            if (!query) {
+                console.error('Usage: beehaven user <userId> sql "<query>"');
+                process.exit(1);
+            }
+            const s = spinner('Running SQL…').start();
+            const { ok, status, body } = await client.call(doActionPath(wsType, opts.userId, 'admin:sql'), { method: 'POST', body: { query } });
+            if (!ok) {
+                s.fail(`HTTP ${status}: ${body?.error ?? 'unknown'}`);
+                process.exit(1);
+            }
+            const results = body?.rows ?? [];
+            s.succeed(`${results.length} rows`);
+            if (results.length === 0) {
+                console.log(color.dim('(no rows)'));
+                return;
+            }
+            if (opts.json) {
+                console.log(JSON.stringify(results, null, 2));
+                return;
+            }
+            const cols = Object.keys(results[0]);
+            console.log(table(cols, results.map((r) => cols.map((c) => String(r[c] ?? '')))));
+            return;
+        }
+        case 'dump': {
+            const folder = opts.positionals[0];
+            if (!folder) {
+                console.error('Usage: beehaven user <userId> dump <folder> [--out file]');
+                process.exit(1);
+            }
+            const s = spinner(`Dumping ${folder}…`).start();
+            const { ok, status, body } = await client.call(doActionPath(wsType, opts.userId, 'admin:sql'), { method: 'POST', body: { query: `SELECT * FROM ${folder}` } });
+            if (!ok) {
+                s.fail(`HTTP ${status}: ${body?.error ?? 'unknown'}`);
+                process.exit(1);
+            }
+            const rows = body?.rows ?? [];
+            s.succeed(`${rows.length} rows from ${folder}`);
+            const payload = JSON.stringify(rows, null, 2);
+            if (opts.out) {
+                writeFileSync(opts.out, payload);
+                console.log(color.green(`✓ Wrote ${opts.out}`));
+            }
+            else {
+                console.log(payload);
+            }
+            return;
+        }
+        case 'export': {
+            const cfg = findProjectConfig();
+            const exportAction = cfg.user?.exportAction;
+            if (exportAction) {
+                const s = spinner(`Calling ${exportAction}…`).start();
+                const { ok, status, body } = await client.call(doActionPath(wsType, opts.userId, exportAction), { method: 'POST', body: {} });
+                if (!ok) {
+                    s.fail(`HTTP ${status}: ${body?.error ?? 'unknown'}`);
+                    process.exit(1);
+                }
+                s.succeed(`Exported ${opts.userId}`);
+                const payload = JSON.stringify(body, null, 2);
+                if (opts.out) {
+                    writeFileSync(opts.out, payload);
+                    console.log(color.green(`✓ Wrote ${opts.out}`));
+                }
+                else
+                    console.log(payload);
+                return;
+            }
+            // Fallback: enumerate folders, dump each
+            const sList = spinner('Enumerating tables…').start();
+            const tablesRes = await client.call(doActionPath(wsType, opts.userId, 'admin:sql'), {
+                method: 'POST',
+                body: {
+                    query: "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_cf_%'",
+                },
+            });
+            if (!tablesRes.ok) {
+                sList.fail(`HTTP ${tablesRes.status}`);
+                process.exit(1);
+            }
+            const tableNames = (tablesRes.body?.rows ?? []).map((r) => r.name);
+            sList.succeed(`${tableNames.length} tables`);
+            const out = {};
+            for (const t of tableNames) {
+                const r = await client.call(doActionPath(wsType, opts.userId, 'admin:sql'), {
+                    method: 'POST',
+                    body: { query: `SELECT * FROM ${t}` },
+                });
+                out[t] = r.body?.rows ?? [];
+                console.log(color.dim(`  ${t}: ${out[t].length} rows`));
+            }
+            const payload = JSON.stringify(out, null, 2);
+            if (opts.out) {
+                writeFileSync(opts.out, payload);
+                console.log(color.green(`✓ Wrote ${opts.out}`));
+            }
+            else
+                console.log(payload);
+            return;
+        }
+        case 'wipe': {
+            if (!opts.yes) {
+                console.error(color.yellow(`This will DELETE all data on ${wsType}/${opts.userId}.`));
+                console.error(color.dim('Re-run with --yes to confirm.'));
+                process.exit(1);
+            }
+            const cfg = findProjectConfig();
+            const wipeAction = cfg.user?.wipeAction;
+            if (wipeAction) {
+                const s = spinner(`Calling ${wipeAction}…`).start();
+                const { ok, status, body } = await client.call(doActionPath(wsType, opts.userId, wipeAction), { method: 'POST', body: {} });
+                if (!ok) {
+                    s.fail(`HTTP ${status}: ${body?.error ?? 'unknown'}`);
+                    process.exit(1);
+                }
+                s.succeed(`Wiped ${opts.userId}`);
+                return;
+            }
+            // Fallback: DELETE FROM each user table
+            const tablesRes = await client.call(doActionPath(wsType, opts.userId, 'admin:sql'), {
+                method: 'POST',
+                body: {
+                    query: "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_cf_%'",
+                },
+            });
+            if (!tablesRes.ok) {
+                console.error(color.red('Could not enumerate tables.'));
+                process.exit(1);
+            }
+            const tableNames = (tablesRes.body?.rows ?? []).map((r) => r.name);
+            for (const t of tableNames) {
+                const s = spinner(`DELETE FROM ${t}…`).start();
+                const { ok, status } = await client.call(doActionPath(wsType, opts.userId, 'admin:sql'), {
+                    method: 'POST',
+                    body: { query: `DELETE FROM ${t}` },
+                });
+                if (!ok)
+                    s.fail(`${t}: HTTP ${status}`);
+                else
+                    s.succeed(t);
+            }
+            console.log(color.dim('  (configure beehaven.json "user.wipeAction" to call a single project-defined wipe RPC instead)'));
+            return;
+        }
+        default:
+            console.error(`Unknown user subcommand: ${sub}`);
+            console.error('Use: inspect | dump | sql | export | wipe');
+            process.exit(1);
+    }
+}

package/dist/commands/voice-tts.js

@@ -0,0 +1,319 @@
+/**
+ * voice-tts.ts — `beehaven voice <subcommand>`: choose how `beehaven speak`
+ * makes sound, and manage locally cloned voices.
+ *
+ * Bare `beehaven voice` is still the push-to-talk REPL (`voice.ts`); this file
+ * owns the noun-y subcommands underneath it:
+ *
+ *   beehaven voice status              what's active + what's installed
+ *   beehaven voice provider [<name>]   read / set the TTS provider flag
+ *   beehaven voice setup               install the local Qwen3-TTS runtime
+ *   beehaven voice clone <name> <file> clone a voice from a recording
+ *   beehaven voice list                cloned voices
+ *   beehaven voice use <name>          which cloned voice speak uses
+ *   beehaven voice remove <name>       forget a cloned voice
+ *   beehaven voice test ["text"]       synthesize + play a sample
+ *
+ * The provider + voice are PERSISTED (in `~/.beehaven/config.json`) rather than
+ * env-only because `speak` is one process per utterance — an env var exported
+ * in one shell tells the next invocation nothing.
+ */
+import { color, spinner } from '../spinner.js';
+import { TTS_PROVIDERS, isTtsProvider, patchCliConfig, readCliConfig, resolveTtsProvider, resolveTtsVoice, } from '../feature-flags.js';
+import * as qwen3 from '../tts-qwen3.js';
+/** Subcommands this module claims. Anything else falls through to the REPL. */
+export const VOICE_SUBCOMMANDS = [
+    'status',
+    'provider',
+    'setup',
+    'clone',
+    'list',
+    'use',
+    'remove',
+    'test',
+];
+export function isVoiceSubcommand(s) {
+    return !!s && VOICE_SUBCOMMANDS.includes(s);
+}
+/**
+ * ⚠ `Record<TtsProvider, …>` IS LOAD-BEARING, NOT DECORATION. It is the only thing
+ * that made removing `avatar` and `system` from `TTS_PROVIDERS` a COMPILE error
+ * rather than a menu that offers engines nothing can run. Keep the exact type.
+ */
+const PROVIDER_BLURB = {
+    auto: 'the default — resolves to qwen3-mlx',
+    'qwen3-mlx': 'local Qwen3-TTS under Apple MLX — on-device, cloned voice',
+    none: 'silent — synthesize nothing',
+};
+function usage() {
+    console.log('');
+    console.log(`  ${color.bold('beehaven voice')} — TTS provider + cloned voices`);
+    console.log('');
+    for (const [cmd, desc] of [
+        ['status', 'active provider, voice, and runtime state'],
+        ['provider [<name>]', `show or set the provider (${TTS_PROVIDERS.join(' | ')})`],
+        ['setup', 'install the local Qwen3-TTS (MLX) runtime'],
+        ['clone <name> <audio>', 'clone a voice from a recording (3-30s is plenty)'],
+        ['list', 'list cloned voices'],
+        ['use <name>', 'set the cloned voice speak uses'],
+        ['remove <name>', 'forget a cloned voice'],
+        ['test ["text"]', 'synthesize + play a sample with current settings'],
+    ]) {
+        console.log(`    ${cmd.padEnd(24)} ${color.dim(desc)}`);
+    }
+    console.log('');
+    console.log(`  ${color.dim('Bare `beehaven voice` starts the push-to-talk REPL.')}`);
+    console.log('');
+}
+export async function cmdVoiceTts(sub, args, values) {
+    switch (sub) {
+        case 'status':
+            return status();
+        case 'provider':
+            return provider(args[0]);
+        case 'setup':
+            return setup();
+        case 'clone':
+            return clone(args[0], args[1], values);
+        case 'list':
+            return list();
+        case 'use':
+            return use(args[0]);
+        case 'remove':
+            return remove(args[0]);
+        case 'test':
+            return test(args.join(' '), values);
+        default:
+            usage();
+    }
+}
+// ── status ──────────────────────────────────────────────────────────────────
+async function status() {
+    const active = resolveTtsProvider();
+    const voice = resolveTtsVoice();
+    const fromEnv = !!(process.env.BEEHAVEN_TTS_PROVIDER ?? '').trim();
+    console.log('');
+    console.log(`  ${color.bold('TTS')}`);
+    console.log(`    Provider:  ${color.cyan(active)}  ${color.dim(PROVIDER_BLURB[active])}` +
+        (fromEnv ? color.dim('  [from $BEEHAVEN_TTS_PROVIDER]') : ''));
+    console.log(`    Voice:     ${voice ? color.cyan(voice) : color.dim('(none — base voice)')}`);
+    console.log('');
+    console.log(`  ${color.bold('qwen3-mlx runtime')}`);
+    if (!qwen3.isSupported()) {
+        console.log(`    ${color.yellow('unavailable')} — ${qwen3.unsupportedReason()}`);
+    }
+    else if (!qwen3.isInstalled()) {
+        console.log(`    ${color.yellow('not installed')} — run ${color.cyan('beehaven voice setup')}`);
+    }
+    else {
+        try {
+            const p = await qwen3.probe();
+            console.log(`    ${color.green('ready')}  mlx-audio ${p.mlxAudio} · mlx ${p.mlx} · py ${p.python}`);
+            console.log(`    Device:    ${p.device}`);
+            console.log(`    Model:     ${color.dim(qwen3.QWEN3_DEFAULT_MODEL)}`);
+        }
+        catch (e) {
+            console.log(`    ${color.red('broken')} — ${e?.message ?? e}`);
+            console.log(`    ${color.dim('Reinstall with `beehaven voice setup`.')}`);
+        }
+    }
+    const voices = qwen3.listVoices();
+    console.log('');
+    console.log(`  ${color.bold('Cloned voices')}  ${voices.length ? voices.map((v) => v.name).join(', ') : color.dim('(none)')}`);
+    console.log('');
+}
+// ── provider ────────────────────────────────────────────────────────────────
+function provider(next) {
+    if (!next) {
+        const active = resolveTtsProvider();
+        console.log('');
+        for (const p of TTS_PROVIDERS) {
+            const mark = p === active ? color.green('●') : color.dim('○');
+            console.log(`  ${mark} ${p.padEnd(11)} ${color.dim(PROVIDER_BLURB[p])}`);
+        }
+        console.log('');
+        console.log(`  ${color.dim('Set with: beehaven voice provider <name>')}`);
+        console.log('');
+        return;
+    }
+    if (!isTtsProvider(next)) {
+        console.error(`  ${color.red('✗')} unknown provider "${next}" — expected: ${TTS_PROVIDERS.join(' | ')}`);
+        process.exit(1);
+    }
+    // `auto` is the default, so store nothing rather than pinning the literal —
+    // that way a future change to the default ladder reaches users who never
+    // opted out of it.
+    patchCliConfig({ ttsProvider: next === 'auto' ? undefined : next });
+    console.log(`  ${color.green('✓')} TTS provider → ${color.cyan(next)}  ${color.dim(PROVIDER_BLURB[next])}`);
+    if (next === 'qwen3-mlx') {
+        if (!qwen3.isSupported()) {
+            console.log(`  ${color.yellow('!')} ${qwen3.unsupportedReason()} — speak will fall back.`);
+        }
+        else if (!qwen3.isInstalled()) {
+            console.log(`  ${color.dim('↳')} not installed yet: ${color.cyan('beehaven voice setup')}`);
+        }
+        else if (!resolveTtsVoice()) {
+            const have = qwen3.listVoices();
+            console.log(have.length
+                ? `  ${color.dim('↳')} no voice selected: ${color.cyan(`beehaven voice use ${have[0].name}`)}`
+                : `  ${color.dim('↳')} clone a voice: ${color.cyan('beehaven voice clone <name> <audio>')}`);
+        }
+    }
+}
+// ── setup ───────────────────────────────────────────────────────────────────
+async function setup() {
+    if (!qwen3.isSupported()) {
+        console.error(`  ${color.red('✗')} ${qwen3.unsupportedReason()}`);
+        process.exit(1);
+    }
+    if (qwen3.isInstalled()) {
+        console.log(`  ${color.green('✓')} already installed at ${color.dim(qwen3.QWEN3_ROOT)}`);
+    }
+    else {
+        const sp = spinner('installing Qwen3-TTS runtime (mlx-audio + mlx)…').start();
+        try {
+            await qwen3.install((line) => sp.update(`installing… ${line.slice(0, 60)}`));
+            sp.succeed(`installed ${qwen3.MLX_AUDIO_SPEC} at ${qwen3.QWEN3_ROOT}`);
+        }
+        catch (e) {
+            sp.fail(`install failed: ${e?.message ?? e}`);
+            process.exit(1);
+        }
+    }
+    const sp2 = spinner('verifying MLX…').start();
+    try {
+        const p = await qwen3.probe();
+        sp2.succeed(`mlx-audio ${p.mlxAudio} · mlx ${p.mlx} · ${p.device}`);
+    }
+    catch (e) {
+        sp2.fail(`verification failed: ${e?.message ?? e}`);
+        process.exit(1);
+    }
+    console.log('');
+    console.log(`  ${color.dim('Next:')} beehaven voice clone <name> <audio-file>`);
+    console.log(`  ${color.dim('Then:')} beehaven voice provider qwen3-mlx`);
+    console.log('');
+}
+// ── clone ───────────────────────────────────────────────────────────────────
+async function clone(name, audio, values) {
+    if (!name || !audio) {
+        console.error('  Usage: beehaven voice clone <name> <audio-file> [--ref-text "…"] [--force]');
+        process.exit(1);
+    }
+    if (!qwen3.isSupported()) {
+        console.error(`  ${color.red('✗')} ${qwen3.unsupportedReason()}`);
+        process.exit(1);
+    }
+    if (!qwen3.isInstalled()) {
+        console.error(`  ${color.red('✗')} qwen3-mlx not installed — run \`beehaven voice setup\` first`);
+        process.exit(1);
+    }
+    const refText = values['ref-text'];
+    const sp = spinner(refText ? `cloning "${name}"…` : `cloning "${name}" — transcribing reference with whisper…`).start();
+    try {
+        const v = await qwen3.cloneVoice(name, audio, {
+            refText,
+            force: !!values.force,
+            onLine: (l) => sp.update(`cloning "${name}"… ${l.slice(0, 50)}`),
+        });
+        sp.succeed(`cloned voice ${color.cyan(name)}`);
+        console.log(`    ${color.dim('reference:')} ${v.refAudio}`);
+        console.log(`    ${color.dim('transcript:')} ${JSON.stringify(v.refText.slice(0, 120))}${v.refText.length > 120 ? '…' : ''}`);
+        if (v.transcribedBy)
+            console.log(`    ${color.dim('transcribed by:')} ${v.transcribedBy}`);
+        console.log('');
+        console.log(`  ${color.dim('Use it:')} beehaven voice use ${name}`);
+        console.log(`  ${color.dim('Then:')}   beehaven voice provider qwen3-mlx`);
+        console.log('');
+    }
+    catch (e) {
+        sp.fail(`clone failed: ${e?.message ?? e}`);
+        process.exit(1);
+    }
+}
+// ── list / use / remove ─────────────────────────────────────────────────────
+function list() {
+    const voices = qwen3.listVoices();
+    const active = resolveTtsVoice();
+    if (!voices.length) {
+        console.log('');
+        console.log(`  ${color.dim('No cloned voices.')}`);
+        console.log(`  ${color.dim('Clone one:')} beehaven voice clone <name> <audio-file>`);
+        console.log('');
+        return;
+    }
+    console.log('');
+    for (const v of voices) {
+        const mark = v.name === active ? color.green('●') : color.dim('○');
+        const when = new Date(v.createdAt).toISOString().slice(0, 10);
+        console.log(`  ${mark} ${color.bold(v.name.padEnd(16))} ${color.dim(when)}  ${color.dim(v.source ?? v.refAudio)}`);
+        console.log(`    ${color.dim(JSON.stringify(v.refText.slice(0, 90)) + (v.refText.length > 90 ? '…' : ''))}`);
+    }
+    console.log('');
+}
+function use(name) {
+    if (!name) {
+        console.error('  Usage: beehaven voice use <name>   (or `none` to clear)');
+        process.exit(1);
+    }
+    if (name === 'none' || name === '-') {
+        patchCliConfig({ ttsVoice: undefined });
+        console.log(`  ${color.green('✓')} cloned voice cleared — Qwen3 will use its base voice`);
+        return;
+    }
+    if (!qwen3.getVoice(name)) {
+        const have = qwen3.listVoices().map((v) => v.name);
+        console.error(`  ${color.red('✗')} no cloned voice "${name}"` +
+            (have.length ? ` — have: ${have.join(', ')}` : ' — clone one first'));
+        process.exit(1);
+    }
+    patchCliConfig({ ttsVoice: name });
+    console.log(`  ${color.green('✓')} speak voice → ${color.cyan(name)}`);
+    if (resolveTtsProvider() !== 'qwen3-mlx') {
+        console.log(`  ${color.dim('↳')} only ${color.cyan('qwen3-mlx')} speaks cloned voices: ` +
+            color.cyan('beehaven voice provider qwen3-mlx'));
+    }
+}
+function remove(name) {
+    if (!name) {
+        console.error('  Usage: beehaven voice remove <name>');
+        process.exit(1);
+    }
+    if (!qwen3.removeVoice(name)) {
+        console.error(`  ${color.red('✗')} no cloned voice "${name}"`);
+        process.exit(1);
+    }
+    if (readCliConfig().ttsVoice === name)
+        patchCliConfig({ ttsVoice: undefined });
+    console.log(`  ${color.green('✓')} removed cloned voice ${name}`);
+}
+// ── test ────────────────────────────────────────────────────────────────────
+async function test(text, values) {
+    const sample = text.trim() ||
+        'This is the beehaven command line, speaking through Qwen3 text to speech, running locally on this machine.';
+    const voice = values['tts-voice'] ?? resolveTtsVoice();
+    if (!qwen3.isInstalled()) {
+        console.error(`  ${color.red('✗')} qwen3-mlx not installed — run \`beehaven voice setup\``);
+        process.exit(1);
+    }
+    const sp = spinner(`synthesizing${voice ? ` as "${voice}"` : ''}…`).start();
+    try {
+        const res = await qwen3.synthesize(sample, {
+            voice,
+            onLine: (l) => sp.update(`synthesizing… ${l.slice(0, 50)}`),
+        });
+        sp.succeed(`${res.durationSec ?? '?'}s of audio in ${res.elapsedSec}s` +
+            (res.realTimeFactor ? ` (${res.realTimeFactor}x real-time)` : '') +
+            (res.voice ? ` · voice ${color.cyan(res.voice)}` : ' · base voice'));
+        const { playAudioFile } = await import('../audio-play.js');
+        const played = await playAudioFile(res.path);
+        if (!played.ok) {
+            console.error(`  ${color.yellow('!')} could not play it: ${played.error}`);
+            console.log(`    ${color.dim('audio is at')} ${res.path}`);
+        }
+    }
+    catch (e) {
+        sp.fail(`synthesis failed: ${e?.message ?? e}`);
+        process.exit(1);
+    }
+}