@intent-systems/nexus 2026.1.5-3

package/dist/logging.js

@@ -0,0 +1,506 @@
+import fs from "node:fs";
+import path from "node:path";
+import util from "node:util";
+import { Chalk } from "chalk";
+import { Logger as TsLogger } from "tslog";
+import { loadConfig } from "./config/config.js";
+import { resolveStateDir } from "./config/paths.js";
+import { isVerbose } from "./globals.js";
+import { defaultRuntime } from "./runtime.js";
+// Default log directory: ~/nexus/state/logs (was /tmp/nexus, but that didn't persist across sessions)
+// Legacy: If /tmp/nexus exists and ~/nexus/state/logs doesn't, use /tmp/nexus for migration
+function resolveDefaultLogDir() {
+    const stateDir = resolveStateDir();
+    const newLogDir = path.join(stateDir, "logs");
+    const legacyLogDir = "/tmp/nexus";
+    // If new path doesn't exist but legacy does, use legacy for migration
+    try {
+        if (!fs.existsSync(newLogDir) && fs.existsSync(legacyLogDir)) {
+            return legacyLogDir;
+        }
+    }
+    catch {
+        // If fs check fails, just use new path
+    }
+    return newLogDir;
+}
+export const DEFAULT_LOG_DIR = resolveDefaultLogDir();
+export const DEFAULT_LOG_FILE = path.join(DEFAULT_LOG_DIR, "nexus.log"); // legacy single-file path
+const LOG_PREFIX = "nexus";
+const LOG_SUFFIX = ".log";
+const MAX_LOG_AGE_MS = 24 * 60 * 60 * 1000; // 24h
+const ALLOWED_LEVELS = [
+    "silent",
+    "fatal",
+    "error",
+    "warn",
+    "info",
+    "debug",
+    "trace",
+];
+let cachedLogger = null;
+let cachedSettings = null;
+let cachedConsoleSettings = null;
+let overrideSettings = null;
+let consolePatched = false;
+let forceConsoleToStderr = false;
+let rawConsole = null;
+function normalizeLevel(level) {
+    const candidate = level ?? "info";
+    return ALLOWED_LEVELS.includes(candidate)
+        ? candidate
+        : "info";
+}
+function resolveSettings() {
+    const cfg = overrideSettings ?? loadConfig().logging;
+    const level = normalizeLevel(cfg?.level);
+    const file = cfg?.file ?? defaultRollingPathForToday();
+    return { level, file };
+}
+function resolveConsoleSettings() {
+    const cfg = overrideSettings ?? loadConfig().logging;
+    const level = normalizeConsoleLevel(cfg?.consoleLevel);
+    const style = normalizeConsoleStyle(cfg?.consoleStyle);
+    return { level, style };
+}
+function settingsChanged(a, b) {
+    if (!a)
+        return true;
+    return a.level !== b.level || a.file !== b.file;
+}
+function consoleSettingsChanged(a, b) {
+    if (!a)
+        return true;
+    return a.level !== b.level || a.style !== b.style;
+}
+function levelToMinLevel(level) {
+    // tslog level ordering: fatal=0, error=1, warn=2, info=3, debug=4, trace=5
+    const map = {
+        fatal: 0,
+        error: 1,
+        warn: 2,
+        info: 3,
+        debug: 4,
+        trace: 5,
+        silent: Number.POSITIVE_INFINITY,
+    };
+    return map[level];
+}
+export function isFileLogLevelEnabled(level) {
+    const settings = cachedSettings ?? resolveSettings();
+    if (!cachedSettings)
+        cachedSettings = settings;
+    return levelToMinLevel(level) <= levelToMinLevel(settings.level);
+}
+function normalizeConsoleLevel(level) {
+    if (isVerbose())
+        return "debug";
+    const candidate = level ?? "info";
+    return ALLOWED_LEVELS.includes(candidate)
+        ? candidate
+        : "info";
+}
+function normalizeConsoleStyle(style) {
+    if (style === "compact" || style === "json" || style === "pretty") {
+        return style;
+    }
+    if (!process.stdout.isTTY)
+        return "compact";
+    return "pretty";
+}
+function buildLogger(settings) {
+    fs.mkdirSync(path.dirname(settings.file), { recursive: true });
+    // Clean up stale rolling logs when using a dated log filename.
+    if (isRollingPath(settings.file)) {
+        pruneOldRollingLogs(path.dirname(settings.file));
+    }
+    const logger = new TsLogger({
+        name: "nexus",
+        minLevel: levelToMinLevel(settings.level),
+        type: "hidden", // no ansi formatting
+    });
+    logger.attachTransport((logObj) => {
+        try {
+            const time = logObj.date?.toISOString?.() ?? new Date().toISOString();
+            const line = JSON.stringify({ ...logObj, time });
+            fs.appendFileSync(settings.file, `${line}\n`, { encoding: "utf8" });
+        }
+        catch {
+            // never block on logging failures
+        }
+    });
+    return logger;
+}
+export function getLogger() {
+    const settings = resolveSettings();
+    if (!cachedLogger || settingsChanged(cachedSettings, settings)) {
+        cachedLogger = buildLogger(settings);
+        cachedSettings = settings;
+    }
+    return cachedLogger;
+}
+export function getConsoleSettings() {
+    const settings = resolveConsoleSettings();
+    if (!cachedConsoleSettings ||
+        consoleSettingsChanged(cachedConsoleSettings, settings)) {
+        cachedConsoleSettings = settings;
+    }
+    return cachedConsoleSettings;
+}
+export function getChildLogger(bindings, opts) {
+    const base = getLogger();
+    const minLevel = opts?.level ? levelToMinLevel(opts.level) : undefined;
+    const name = bindings ? JSON.stringify(bindings) : undefined;
+    return base.getSubLogger({
+        name,
+        minLevel,
+        prefix: bindings ? [name ?? ""] : [],
+    });
+}
+// Baileys expects a pino-like logger shape. Provide a lightweight adapter.
+export function toPinoLikeLogger(logger, level) {
+    const buildChild = (bindings) => toPinoLikeLogger(logger.getSubLogger({
+        name: bindings ? JSON.stringify(bindings) : undefined,
+    }), level);
+    return {
+        level,
+        child: buildChild,
+        trace: (...args) => logger.trace(...args),
+        debug: (...args) => logger.debug(...args),
+        info: (...args) => logger.info(...args),
+        warn: (...args) => logger.warn(...args),
+        error: (...args) => logger.error(...args),
+        fatal: (...args) => logger.fatal(...args),
+    };
+}
+export function getResolvedLoggerSettings() {
+    return resolveSettings();
+}
+export function getResolvedConsoleSettings() {
+    return getConsoleSettings();
+}
+// Test helpers
+export function setLoggerOverride(settings) {
+    overrideSettings = settings;
+    cachedLogger = null;
+    cachedSettings = null;
+}
+export function resetLogger() {
+    cachedLogger = null;
+    cachedSettings = null;
+    cachedConsoleSettings = null;
+    overrideSettings = null;
+}
+// Route all console output (including tslog console writes) to stderr.
+// This keeps stdout clean for RPC/JSON modes.
+export function routeLogsToStderr() {
+    forceConsoleToStderr = true;
+}
+const SUPPRESSED_CONSOLE_PREFIXES = [
+    "Closing session:",
+    "Opening session:",
+    "Removing old closed session:",
+    "Session already closed",
+    "Session already open",
+];
+function shouldSuppressConsoleMessage(message) {
+    if (isVerbose())
+        return false;
+    return SUPPRESSED_CONSOLE_PREFIXES.some((prefix) => message.startsWith(prefix));
+}
+function isEpipeError(err) {
+    return Boolean(err?.code === "EPIPE");
+}
+/**
+ * Route console.* calls through pino while still emitting to stdout/stderr.
+ * This keeps user-facing output unchanged but guarantees every console call is captured in log files.
+ */
+export function enableConsoleCapture() {
+    if (consolePatched)
+        return;
+    consolePatched = true;
+    const logger = getLogger();
+    const original = {
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error,
+        debug: console.debug,
+        trace: console.trace,
+    };
+    rawConsole = {
+        log: original.log,
+        info: original.info,
+        warn: original.warn,
+        error: original.error,
+    };
+    const forward = (level, orig) => (...args) => {
+        const formatted = util.format(...args);
+        if (shouldSuppressConsoleMessage(formatted))
+            return;
+        try {
+            // Map console levels to pino
+            if (level === "trace") {
+                logger.trace(formatted);
+            }
+            else if (level === "debug") {
+                logger.debug(formatted);
+            }
+            else if (level === "info") {
+                logger.info(formatted);
+            }
+            else if (level === "warn") {
+                logger.warn(formatted);
+            }
+            else if (level === "error" || level === "fatal") {
+                logger.error(formatted);
+            }
+            else {
+                logger.info(formatted);
+            }
+        }
+        catch {
+            // never block console output on logging failures
+        }
+        if (forceConsoleToStderr) {
+            const target = level === "error" || level === "fatal" || level === "warn"
+                ? process.stderr
+                : process.stderr; // in RPC/JSON mode, keep stdout clean
+            try {
+                target.write(`${formatted}\n`);
+            }
+            catch (err) {
+                if (isEpipeError(err))
+                    return;
+                throw err;
+            }
+        }
+        else {
+            try {
+                orig.apply(console, args);
+            }
+            catch (err) {
+                if (isEpipeError(err))
+                    return;
+                throw err;
+            }
+        }
+    };
+    console.log = forward("info", original.log);
+    console.info = forward("info", original.info);
+    console.warn = forward("warn", original.warn);
+    console.error = forward("error", original.error);
+    console.debug = forward("debug", original.debug);
+    console.trace = forward("trace", original.trace);
+}
+function shouldLogToConsole(level, settings) {
+    const current = levelToMinLevel(level);
+    const min = levelToMinLevel(settings.level);
+    return current <= min;
+}
+function isRichConsoleEnv() {
+    const term = (process.env.TERM ?? "").toLowerCase();
+    if (process.env.COLORTERM || process.env.TERM_PROGRAM)
+        return true;
+    return term.length > 0 && term !== "dumb";
+}
+function getColorForConsole() {
+    if (process.env.NO_COLOR)
+        return new Chalk({ level: 0 });
+    const hasTty = Boolean(process.stdout.isTTY || process.stderr.isTTY);
+    return hasTty || isRichConsoleEnv()
+        ? new Chalk({ level: 1 })
+        : new Chalk({ level: 0 });
+}
+const SUBSYSTEM_COLORS = [
+    "cyan",
+    "green",
+    "yellow",
+    "blue",
+    "magenta",
+    "red",
+];
+const SUBSYSTEM_COLOR_OVERRIDES = {
+    "gmail-watcher": "blue",
+};
+const SUBSYSTEM_PREFIXES_TO_DROP = ["gateway", "providers"];
+const SUBSYSTEM_MAX_SEGMENTS = 2;
+function pickSubsystemColor(color, subsystem) {
+    const override = SUBSYSTEM_COLOR_OVERRIDES[subsystem];
+    if (override)
+        return color[override];
+    let hash = 0;
+    for (let i = 0; i < subsystem.length; i += 1) {
+        hash = (hash * 31 + subsystem.charCodeAt(i)) | 0;
+    }
+    const idx = Math.abs(hash) % SUBSYSTEM_COLORS.length;
+    const name = SUBSYSTEM_COLORS[idx];
+    return color[name];
+}
+function formatSubsystemForConsole(subsystem) {
+    const parts = subsystem.split("/").filter(Boolean);
+    const original = parts.join("/") || subsystem;
+    while (parts.length > 0 &&
+        SUBSYSTEM_PREFIXES_TO_DROP.includes(parts[0])) {
+        parts.shift();
+    }
+    if (parts.length === 0)
+        return original;
+    if (parts[0] === "whatsapp" || parts[0] === "telegram") {
+        return parts[0];
+    }
+    if (parts.length > SUBSYSTEM_MAX_SEGMENTS) {
+        return parts.slice(-SUBSYSTEM_MAX_SEGMENTS).join("/");
+    }
+    return parts.join("/");
+}
+function formatConsoleLine(opts) {
+    const displaySubsystem = opts.style === "json"
+        ? opts.subsystem
+        : formatSubsystemForConsole(opts.subsystem);
+    if (opts.style === "json") {
+        return JSON.stringify({
+            time: new Date().toISOString(),
+            level: opts.level,
+            subsystem: displaySubsystem,
+            message: opts.message,
+            ...opts.meta,
+        });
+    }
+    const color = getColorForConsole();
+    const prefix = `[${displaySubsystem}]`;
+    const prefixColor = pickSubsystemColor(color, displaySubsystem);
+    const levelColor = opts.level === "error" || opts.level === "fatal"
+        ? color.red
+        : opts.level === "warn"
+            ? color.yellow
+            : opts.level === "debug" || opts.level === "trace"
+                ? color.gray
+                : color.cyan;
+    const time = opts.style === "pretty"
+        ? color.gray(new Date().toISOString().slice(11, 19))
+        : "";
+    const prefixToken = prefixColor(prefix);
+    const head = [time, prefixToken].filter(Boolean).join(" ");
+    return `${head} ${levelColor(opts.message)}`;
+}
+function writeConsoleLine(level, line) {
+    const sink = rawConsole ?? console;
+    if (forceConsoleToStderr || level === "error" || level === "fatal") {
+        (sink.error ?? console.error)(line);
+    }
+    else if (level === "warn") {
+        (sink.warn ?? console.warn)(line);
+    }
+    else {
+        (sink.log ?? console.log)(line);
+    }
+}
+function logToFile(fileLogger, level, message, meta) {
+    if (level === "silent")
+        return;
+    const safeLevel = level;
+    const method = fileLogger[safeLevel];
+    if (typeof method !== "function")
+        return;
+    if (meta && Object.keys(meta).length > 0) {
+        method.call(fileLogger, meta, message);
+    }
+    else {
+        method.call(fileLogger, message);
+    }
+}
+export function createSubsystemLogger(subsystem) {
+    let fileLogger = null;
+    const getFileLogger = () => {
+        if (!fileLogger)
+            fileLogger = getChildLogger({ subsystem });
+        return fileLogger;
+    };
+    const emit = (level, message, meta) => {
+        const consoleSettings = getConsoleSettings();
+        let consoleMessageOverride;
+        let fileMeta = meta;
+        if (meta && Object.keys(meta).length > 0) {
+            const { consoleMessage, ...rest } = meta;
+            if (typeof consoleMessage === "string") {
+                consoleMessageOverride = consoleMessage;
+            }
+            fileMeta = Object.keys(rest).length > 0 ? rest : undefined;
+        }
+        logToFile(getFileLogger(), level, message, fileMeta);
+        if (!shouldLogToConsole(level, consoleSettings))
+            return;
+        const line = formatConsoleLine({
+            level,
+            subsystem,
+            message: consoleSettings.style === "json"
+                ? message
+                : (consoleMessageOverride ?? message),
+            style: consoleSettings.style,
+            meta: fileMeta,
+        });
+        writeConsoleLine(level, line);
+    };
+    const logger = {
+        subsystem,
+        trace: (message, meta) => emit("trace", message, meta),
+        debug: (message, meta) => emit("debug", message, meta),
+        info: (message, meta) => emit("info", message, meta),
+        warn: (message, meta) => emit("warn", message, meta),
+        error: (message, meta) => emit("error", message, meta),
+        fatal: (message, meta) => emit("fatal", message, meta),
+        raw: (message) => {
+            logToFile(getFileLogger(), "info", message, { raw: true });
+            writeConsoleLine("info", message);
+        },
+        child: (name) => createSubsystemLogger(`${subsystem}/${name}`),
+    };
+    return logger;
+}
+export function runtimeForLogger(logger, exit = defaultRuntime.exit) {
+    return {
+        log: (message) => logger.info(message),
+        error: (message) => logger.error(message),
+        exit,
+    };
+}
+export function createSubsystemRuntime(subsystem, exit = defaultRuntime.exit) {
+    return runtimeForLogger(createSubsystemLogger(subsystem), exit);
+}
+function defaultRollingPathForToday() {
+    const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+    return path.join(DEFAULT_LOG_DIR, `${LOG_PREFIX}-${today}${LOG_SUFFIX}`);
+}
+function isRollingPath(file) {
+    const base = path.basename(file);
+    return (base.startsWith(`${LOG_PREFIX}-`) &&
+        base.endsWith(LOG_SUFFIX) &&
+        base.length === `${LOG_PREFIX}-YYYY-MM-DD${LOG_SUFFIX}`.length);
+}
+function pruneOldRollingLogs(dir) {
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        const cutoff = Date.now() - MAX_LOG_AGE_MS;
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (!entry.name.startsWith(`${LOG_PREFIX}-`) ||
+                !entry.name.endsWith(LOG_SUFFIX))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            try {
+                const stat = fs.statSync(fullPath);
+                if (stat.mtimeMs < cutoff) {
+                    fs.rmSync(fullPath, { force: true });
+                }
+            }
+            catch {
+                // ignore errors during pruning
+            }
+        }
+    }
+    catch {
+        // ignore missing dir or read errors
+    }
+}

package/dist/macos/gateway-daemon.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import process from "node:process";
+const BUNDLED_VERSION = typeof __NEXUS_VERSION__ === "string" ? __NEXUS_VERSION__ : "0.0.0";
+function argValue(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx < 0)
+        return undefined;
+    const value = args[idx + 1];
+    return value && !value.startsWith("-") ? value : undefined;
+}
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+const args = process.argv.slice(2);
+async function main() {
+    if (hasFlag(args, "--version") || hasFlag(args, "-v")) {
+        // Match `nexus --version` behavior for Swift env/version checks.
+        // Keep output a single line.
+        console.log(BUNDLED_VERSION);
+        process.exit(0);
+    }
+    // Bun runtime ships a global `Long` that protobufjs detects, but it does not
+    // implement the long.js API that Baileys/WAProto expects (fromBits, ...).
+    // Ensure we use long.js so the embedded gateway doesn't crash at startup.
+    if (typeof process.versions.bun === "string") {
+        const mod = await import("long");
+        const Long = mod.default ?? mod;
+        globalThis.Long = Long;
+    }
+    const [{ loadConfig }, { startGatewayServer }, { setGatewayWsLogStyle }, { setVerbose }, { defaultRuntime },] = await Promise.all([
+        import("../config/config.js"),
+        import("../gateway/server.js"),
+        import("../gateway/ws-logging.js"),
+        import("../globals.js"),
+        import("../runtime.js"),
+    ]);
+    setVerbose(hasFlag(args, "--verbose"));
+    const wsLogRaw = (hasFlag(args, "--compact") ? "compact" : argValue(args, "--ws-log"));
+    const wsLogStyle = wsLogRaw === "compact" ? "compact" : wsLogRaw === "full" ? "full" : "auto";
+    setGatewayWsLogStyle(wsLogStyle);
+    const cfg = loadConfig();
+    const portRaw = argValue(args, "--port") ??
+        process.env.NEXUS_GATEWAY_PORT ??
+        process.env.NEXUS_GATEWAY_PORT ??
+        (typeof cfg.gateway?.port === "number" ? String(cfg.gateway.port) : "") ??
+        "18789";
+    const port = Number.parseInt(portRaw, 10);
+    if (Number.isNaN(port) || port <= 0) {
+        defaultRuntime.error(`Invalid --port (${portRaw})`);
+        process.exit(1);
+    }
+    const bindRaw = argValue(args, "--bind") ??
+        process.env.NEXUS_GATEWAY_BIND ??
+        process.env.NEXUS_GATEWAY_BIND ??
+        cfg.gateway?.bind ??
+        "loopback";
+    const bind = bindRaw === "loopback" ||
+        bindRaw === "tailnet" ||
+        bindRaw === "lan" ||
+        bindRaw === "auto"
+        ? bindRaw
+        : null;
+    if (!bind) {
+        defaultRuntime.error('Invalid --bind (use "loopback", "tailnet", "lan", or "auto")');
+        process.exit(1);
+    }
+    const token = argValue(args, "--token");
+    if (token) {
+        process.env.NEXUS_GATEWAY_TOKEN = token;
+        process.env.NEXUS_GATEWAY_TOKEN = token; // backward compat
+    }
+    let server = null;
+    let shuttingDown = false;
+    let forceExitTimer = null;
+    let restartResolver = null;
+    const cleanupSignals = () => {
+        process.removeListener("SIGTERM", onSigterm);
+        process.removeListener("SIGINT", onSigint);
+        process.removeListener("SIGUSR1", onSigusr1);
+    };
+    const request = (action, signal) => {
+        if (shuttingDown) {
+            defaultRuntime.log(`gateway: received ${signal} during shutdown; ignoring`);
+            return;
+        }
+        shuttingDown = true;
+        const isRestart = action === "restart";
+        defaultRuntime.log(`gateway: received ${signal}; ${isRestart ? "restarting" : "shutting down"}`);
+        forceExitTimer = setTimeout(() => {
+            defaultRuntime.error("gateway: shutdown timed out; exiting without full cleanup");
+            cleanupSignals();
+            process.exit(0);
+        }, 5000);
+        void (async () => {
+            try {
+                await server?.close({
+                    reason: isRestart ? "gateway restarting" : "gateway stopping",
+                    restartExpectedMs: isRestart ? 1500 : null,
+                });
+            }
+            catch (err) {
+                defaultRuntime.error(`gateway: shutdown error: ${String(err)}`);
+            }
+            finally {
+                if (forceExitTimer)
+                    clearTimeout(forceExitTimer);
+                server = null;
+                if (isRestart) {
+                    shuttingDown = false;
+                    restartResolver?.();
+                }
+                else {
+                    cleanupSignals();
+                    process.exit(0);
+                }
+            }
+        })();
+    };
+    const onSigterm = () => request("stop", "SIGTERM");
+    const onSigint = () => request("stop", "SIGINT");
+    const onSigusr1 = () => request("restart", "SIGUSR1");
+    process.on("SIGTERM", onSigterm);
+    process.on("SIGINT", onSigint);
+    process.on("SIGUSR1", onSigusr1);
+    try {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            try {
+                server = await startGatewayServer(port, { bind });
+            }
+            catch (err) {
+                cleanupSignals();
+                defaultRuntime.error(`Gateway failed to start: ${String(err)}`);
+                process.exit(1);
+            }
+            await new Promise((resolve) => {
+                restartResolver = resolve;
+            });
+        }
+    }
+    finally {
+        cleanupSignals();
+    }
+}
+void main();

package/dist/macos/relay.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import process from "node:process";
+const BUNDLED_VERSION = typeof __NEXUS_VERSION__ === "string" ? __NEXUS_VERSION__ : "0.0.0";
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+async function patchBunLongForProtobuf() {
+    // Bun ships a global `Long` that protobufjs detects, but it is not long.js and
+    // misses critical APIs (fromBits, ...). Baileys WAProto expects long.js.
+    if (typeof process.versions.bun !== "string")
+        return;
+    const mod = await import("long");
+    const Long = mod.default ?? mod;
+    globalThis.Long = Long;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    // Swift side expects `--version` to return a plain semver string.
+    if (hasFlag(args, "--version") ||
+        hasFlag(args, "-V") ||
+        hasFlag(args, "-v")) {
+        console.log(BUNDLED_VERSION);
+        process.exit(0);
+    }
+    await patchBunLongForProtobuf();
+    const { loadDotEnv } = await import("../infra/dotenv.js");
+    loadDotEnv({ quiet: true });
+    const { ensureNexusCliOnPath } = await import("../infra/path-env.js");
+    ensureNexusCliOnPath();
+    const { enableConsoleCapture } = await import("../logging.js");
+    enableConsoleCapture();
+    const { assertSupportedRuntime } = await import("../infra/runtime-guard.js");
+    assertSupportedRuntime();
+    const { isUnhandledRejectionHandled } = await import("../infra/unhandled-rejections.js");
+    const { buildProgram } = await import("../cli/program.js");
+    const program = buildProgram();
+    process.on("unhandledRejection", (reason, _promise) => {
+        if (isUnhandledRejectionHandled(reason))
+            return;
+        console.error("[nexus] Unhandled promise rejection:", reason instanceof Error ? (reason.stack ?? reason.message) : reason);
+        process.exit(1);
+    });
+    process.on("uncaughtException", (error) => {
+        console.error("[nexus] Uncaught exception:", error.stack ?? error.message);
+        process.exit(1);
+    });
+    await program.parseAsync(process.argv);
+}
+void main();