infinicode 1.0.0 → 2.0.0

package/dist/commands/run.js

@@ -1,83 +1,373 @@
+/**
+ * infinicode run — launch the infinicode TUI with the full kernel provider
+ * pool injected.
+ *
+ * The TUI is infinicode's SolidJS terminal UI (themes, markdown rendering,
+ * diff view, plugin slots, the infinicode gold theme + animated logo).
+ * infinicode builds the provider config from the saved kernel config
+ * (Ollama master + all cloud providers: Groq, OpenRouter, GitHub, NVIDIA,
+ * HF, Gemini) and injects it via OPENCODE_CONFIG_CONTENT so the TUI can
+ * use every provider — not just a single Ollama master.
+ *
+ * The kernel's router/recovery/verification do not run inside the TUI;
+ * the TUI is the Harness (prompts, workflows, personas). The kernel owns
+ * execution. For headless mission execution with full kernel routing,
+ * use `infinicode mission run`.
+ */
 import chalk from 'chalk';
 import ora from 'ora';
-export async function runAgent(masterUrl, model, useTui, config) {
-    // Check connection first
-    const spinner = ora('Connecting to Ollama...').start();
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ASCII_VIDEO_FPS, ASCII_VIDEO_FRAMES } from '../ascii-video-animation.js';
+import { getProviderPreset } from '../kernel/free-providers.js';
+import { buildKernelFromConfig } from '../kernel/setup.js';
+import { SilentLogger } from '../kernel/index.js';
+import { openAICompatBaseURL } from '../kernel/provider-url.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROMPT_ANIMATION_MAX_FRAMES = Math.min(ASCII_VIDEO_FRAMES.length, ASCII_VIDEO_FPS * 3);
+function resolveInfinicodeCommand() {
+    const rootDir = resolve(__dirname, '..', '..');
+    const bundled = join(rootDir, 'bin', 'infinicode-tui.exe');
+    return existsSync(bundled) ? bundled : 'infinicode';
+}
+function fitPromptFrameToTerminal(frame) {
+    const columns = Math.max(1, (process.stdout.columns ?? 120) - 1);
+    const rows = Math.max(1, Math.min((process.stdout.rows ?? 40) - 8, 24));
+    const lines = frame.split('\n');
+    const maxWidth = Math.max(...lines.map(line => line.length), 0);
+    const startColumn = Math.max(0, Math.floor((maxWidth - columns) / 2));
+    const startRow = Math.max(0, Math.floor((lines.length - rows) / 2));
+    return lines
+        .slice(startRow, startRow + rows)
+        .map(line => line.slice(startColumn, startColumn + columns).padEnd(columns, ' '))
+        .join('\n');
+}
+function colorPromptFrame(frame) {
+    return chalk.hex('#fbbf24')(fitPromptFrameToTerminal(frame));
+}
+async function renderPromptAnimation() {
+    const firstFrame = ASCII_VIDEO_FRAMES[0] ?? '';
+    if (!firstFrame)
+        return;
+    if (!process.stdout.isTTY || process.env.CI) {
+        console.log(colorPromptFrame(firstFrame));
+        return;
+    }
+    const frameDelayMs = Math.round(1000 / ASCII_VIDEO_FPS);
+    let renderedRows = 0;
+    process.stdout.write('\x1b[?25l\x1b[?7l');
+    try {
+        for (let index = 0; index < PROMPT_ANIMATION_MAX_FRAMES; index++) {
+            const output = colorPromptFrame(ASCII_VIDEO_FRAMES[index] ?? firstFrame);
+            const rows = output.split('\n').length;
+            if (renderedRows > 0) {
+                process.stdout.write(`\x1b[${renderedRows}F`);
+            }
+            process.stdout.write(`${output}\n`);
+            renderedRows = rows;
+            await new Promise(resolve => setTimeout(resolve, frameDelayMs));
+        }
+    }
+    finally {
+        if (renderedRows > 0) {
+            process.stdout.write(`\x1b[${renderedRows}F\x1b[J`);
+        }
+        process.stdout.write('\x1b[0m\x1b[?7h\x1b[?25h');
+    }
+}
+/**
+ * Check if Ollama is reachable at the given URL.
+ */
+async function isOllamaReachable(url) {
     try {
-        const response = await fetch(`${masterUrl}/api/tags`, {
-            signal: AbortSignal.timeout(5000)
+        const response = await fetch(`${url}/api/tags`, {
+            signal: AbortSignal.timeout(5000),
         });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the best reachable Ollama master URL (LAN → Tailscale fallback).
+ */
+async function resolveConfiguredMasterUrl(config) {
+    const masterUrl = config.get('masterUrl');
+    const tailscaleMasterUrl = config.get('tailscaleMasterUrl');
+    const candidates = [
+        masterUrl,
+        ...(tailscaleMasterUrl && tailscaleMasterUrl !== masterUrl ? [tailscaleMasterUrl] : []),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const response = await fetch(`${candidate}/api/tags`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            if (response.ok) {
+                if (candidate !== masterUrl) {
+                    console.log(chalk.yellow(`LAN unavailable; using Tailscale master ${candidate}`));
+                }
+                return candidate;
+            }
+        }
+        catch {
+            // try next
+        }
+    }
+    return masterUrl;
+}
+/** Build one opencode model entry, carrying the real context window so the TUI
+ * knows each model's limits (helps compaction). */
+function modelEntry(m) {
+    const entry = { name: m.name ?? m.id };
+    // Only set a limit when we have a real context value (> the 8192 default) —
+    // a wrong-small limit would make opencode compact large models too early.
+    if (m.contextLength && m.contextLength > 8192) {
+        entry.limit = { context: m.contextLength, output: Math.min(16384, Math.max(2048, Math.floor(m.contextLength / 16))) };
+    }
+    return entry;
+}
+function modelMap(models) {
+    return Object.fromEntries(models.map(m => [m.id, modelEntry(m)]));
+}
+function buildProviderConfig(masterUrl, defaultModel, cloudProviders, masterReachable, modelsByProvider = {}) {
+    const providers = {};
+    // Prefer the provider's full fetched catalog; fall back to the curated preset.
+    const catalog = (id, fallback) => {
+        const fetched = modelsByProvider[id];
+        return fetched && fetched.length ? fetched : fallback;
+    };
+    // Only inject Ollama if the master is reachable
+    if (masterReachable) {
+        providers['ollama'] = {
+            npm: '@ai-sdk/openai-compatible',
+            name: 'Ollama',
+            options: {
+                baseURL: `${masterUrl}/v1`,
+            },
+            models: modelMap(catalog('ollama', [{ id: defaultModel, name: defaultModel, contextLength: 8192 }])),
+        };
+    }
+    for (const cfg of cloudProviders) {
+        if (!cfg.enabled || !cfg.apiKey)
+            continue;
+        const preset = getProviderPreset(cfg.id);
+        const fallback = (preset?.knownModels ?? []).map(m => ({ id: m.id, name: m.name, contextLength: m.contextLength }));
+        const models = modelMap(catalog(cfg.id, fallback));
+        if (cfg.id === 'gemini') {
+            providers[cfg.id] = {
+                npm: '@ai-sdk/google',
+                name: cfg.name,
+                options: {
+                    apiKey: cfg.apiKey,
+                },
+                models,
+            };
+        }
+        else {
+            providers[cfg.id] = {
+                npm: '@ai-sdk/openai-compatible',
+                name: cfg.name,
+                options: {
+                    // Normalize so the AI SDK's `<base>/chat/completions` resolves
+                    // correctly for every provider (e.g. Groq needs the /v1 segment).
+                    baseURL: openAICompatBaseURL(cfg.baseURL),
+                    apiKey: cfg.apiKey,
+                    headers: cfg.headerName && cfg.headerName !== 'Authorization'
+                        ? { [cfg.headerName]: cfg.apiKey }
+                        : undefined,
+                },
+                models,
+            };
         }
-        const data = await response.json();
-        const models = data.models || [];
-        const hasModel = models.some(m => m.name === model || m.name.startsWith(model.split(':')[0]));
-        if (!hasModel) {
-            spinner.warn(`Model '${model}' not found`);
-            if (models.length > 0) {
-                console.log(chalk.dim(`\nAvailable: ${models.slice(0, 5).map(m => m.name).join(', ')}`));
+    }
+    return providers;
+}
+/**
+ * Pick the best default model: the pinned coding-worker model if set
+ * and its provider is healthy, otherwise the first cloud provider's
+ * recommended coding model, otherwise the Ollama default.
+ */
+async function pickDefaultModel(config, masterReachable) {
+    const workerModels = config.get('workerModels') ?? {};
+    const codingPin = workerModels['coding'];
+    // 1. Honor the coding-worker pin if its provider is available
+    if (codingPin) {
+        const cloudProviders = config.get('cloudProviders') ?? [];
+        const isCloud = cloudProviders.some(p => p.id === codingPin.providerId && p.enabled);
+        if (codingPin.providerId === 'ollama' && masterReachable) {
+            return { provider: codingPin.providerId, model: codingPin.modelId };
+        }
+        if (isCloud) {
+            return { provider: codingPin.providerId, model: codingPin.modelId };
+        }
+    }
+    // 2. If Ollama is reachable, use the Ollama default model
+    if (masterReachable) {
+        return { provider: 'ollama', model: config.get('defaultModel') };
+    }
+    // 3. Ollama down — pick the first enabled cloud provider's recommended coding model
+    const cloudProviders = config.get('cloudProviders') ?? [];
+    for (const cp of cloudProviders) {
+        if (!cp.enabled || !cp.apiKey)
+            continue;
+        const preset = getProviderPreset(cp.id);
+        const recs = preset?.recommended?.['coding'] ?? [];
+        if (recs.length > 0) {
+            return { provider: cp.id, model: recs[0] };
+        }
+        // fallback to first known model
+        const first = preset?.knownModels?.[0];
+        if (first) {
+            return { provider: cp.id, model: first.id };
+        }
+    }
+    // 4. Nothing reachable — return Ollama default anyway (TUI will show error)
+    return { provider: 'ollama', model: config.get('defaultModel') };
+}
+/**
+ * One kernel pass for the TUI launch: fetch each provider's FULL model catalog
+ * in parallel (so all models are exposed, incl. large ones like GLM-5.2 on HF
+ * and Nemotron-Ultra on NVIDIA), then route the default model under the policy.
+ */
+async function prepareRouting(config, policyName) {
+    const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
+    const modelsByProvider = {};
+    try {
+        // Let background token-verified health checks run first.
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        // Fetch every provider's full catalog concurrently.
+        await Promise.all(kernel.providerManager.list().map(async (provider) => {
+            try {
+                const caps = await provider.capabilities();
+                modelsByProvider[provider.info.id] = caps.models;
             }
-            console.log(chalk.yellow(`\nPull the model first:`));
-            console.log(chalk.cyan(`  ollama pull ${model}\n`));
-            process.exit(1);
+            catch {
+                modelsByProvider[provider.info.id] = [];
+            }
+        }));
+        const providers = (await kernel.providerManager.getHealthyProviders()).map(p => p.info);
+        const models = await kernel.providerManager.getAvailableModels();
+        let routed = null;
+        if (providers.length > 0 && models.length > 0) {
+            const ranked = kernel.router.rank({
+                capabilities: ['coding', 'reasoning'],
+                preferences: { reasoning: 95, speed: 80, contextLength: 32_000 },
+                policy: kernel.policies.get(policyName),
+                availableProviders: providers,
+                availableModels: models,
+                // Interactive sessions grow large; prefer a model that can accept a
+                // sizeable request so we don't default to a low-TPM free tier (e.g. Groq
+                // free ≈ 12k) that rejects big prompts mid-session.
+                estimatedRequestTokens: 16_000,
+            });
+            if (ranked[0])
+                routed = { providerId: ranked[0].providerId, modelId: ranked[0].modelId };
         }
-        spinner.succeed('Ollama connected');
+        return { routed, modelsByProvider };
+    }
+    catch {
+        return { routed: null, modelsByProvider };
+    }
+    finally {
+        kernel.destroy();
+    }
+}
+/** Ensure the routed model exists in the TUI's injected provider config. */
+function ensureModelInjected(providers, providerId, modelId) {
+    const p = providers[providerId];
+    if (!p)
+        return;
+    p.models = p.models ?? {};
+    if (!p.models[modelId])
+        p.models[modelId] = { name: modelId };
+}
+export async function runAgent(_masterUrl, _model, _useTui, config) {
+    const masterUrl = await resolveConfiguredMasterUrl(config);
+    const masterReachable = await isOllamaReachable(masterUrl);
+    const defaultModel = config.get('defaultModel');
+    const cloudProviders = config.get('cloudProviders') ?? [];
+    const enabledCloud = cloudProviders.filter(p => p.enabled);
+    const policyName = config.get('policy') ?? 'balanced';
+    // One kernel pass: load every provider's full model catalog (in parallel) and
+    // route the default model under the policy.
+    const routeSpinner = ora('loading model catalog & routing...').start();
+    const { routed, modelsByProvider } = await prepareRouting(config, policyName);
+    routeSpinner.stop();
+    const providers = buildProviderConfig(masterUrl, defaultModel, cloudProviders, masterReachable, modelsByProvider);
+    let defaultProvider;
+    let pickedModel;
+    if (routed && providers[routed.providerId]) {
+        defaultProvider = routed.providerId;
+        pickedModel = routed.modelId;
+        ensureModelInjected(providers, routed.providerId, routed.modelId);
     }
-    catch (error) {
-        spinner.fail('Connection failed');
-        console.log(chalk.red(`\n✗ Could not connect to ${masterUrl}`));
-        console.log(chalk.dim('\nRun: infinicode connect <master-ip>\n'));
-        process.exit(1);
+    else {
+        const fb = await pickDefaultModel(config, masterReachable);
+        defaultProvider = fb.provider;
+        pickedModel = fb.model;
     }
-    // Set environment for opencode
-    process.env.LOCAL_ENDPOINT = `${masterUrl}/v1`;
+    const modelRef = `${defaultProvider}/${pickedModel}`;
+    const providerCount = Object.keys(providers).length;
+    const modelCount = Object.values(providers).reduce((n, p) => n + Object.keys(p.models ?? {}).length, 0);
+    const policy = config.get('policy') ?? 'local-first';
+    const pinnedCount = Object.keys(config.get('workerModels') ?? {}).length;
+    const routingInfo = `AUTO ${policy} ${providerCount}P ${pinnedCount}pins`;
     process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
-        providers: {
-            anthropic: { disabled: true },
-            openai: { disabled: true },
-            gemini: { disabled: true },
-            groq: { disabled: true },
-            openrouter: { disabled: true },
-            xai: { disabled: true },
-            azure: { disabled: true },
-            bedrock: { disabled: true },
-            vertexai: { disabled: true },
-            copilot: { disabled: true },
-            local: { apiKey: 'not-needed' }
+        $schema: 'https://opencode.ai/config.json',
+        provider: providers,
+        model: modelRef,
+        small_model: modelRef,
+        enabled_providers: Object.keys(providers),
+        agent: {
+            build: {
+                model: modelRef,
+                description: `◆ ${routingInfo}`,
+                color: 'primary',
+            },
+            plan: {
+                model: modelRef,
+                description: `◆ ${routingInfo}`,
+                color: 'secondary',
+            },
         },
-        agents: {
-            coder: { model: `local.${model}` }
-        },
-        tui: {
-            theme: config.get('theme') || 'infini'
-        }
     });
-    console.log(chalk.dim(`\nStarting with ${chalk.cyan(model)}...`));
-    console.log(chalk.dim('─'.repeat(40)));
-    // Try to run opencode
+    console.log(chalk.dim(`\ninfinicode — launching TUI with ${chalk.cyan(String(providerCount))} provider(s), ${chalk.cyan(String(modelCount))} model(s)`));
+    console.log(chalk.dim(`  default model: ${chalk.cyan(modelRef)}`));
+    console.log(chalk.dim(`  policy: ${chalk.cyan(config.get('policy') ?? 'local-first')}`));
+    if (enabledCloud.length > 0) {
+        console.log(chalk.dim(`  cloud: ${enabledCloud.map(p => p.id).join(', ')}`));
+    }
+    if (!masterReachable) {
+        console.log(chalk.yellow(`  ⚠ Ollama not reachable — using cloud providers only`));
+    }
+    console.log(chalk.dim('-'.repeat(40)));
+    await renderPromptAnimation();
     const { execa } = await import('execa');
+    const infinicodeCommand = resolveInfinicodeCommand();
     try {
-        // Check if opencode is installed
-        await execa('which', ['opencode']).catch(() => execa('where', ['opencode']));
-        // Run opencode
-        await execa('opencode', [], {
+        if (infinicodeCommand === 'infinicode') {
+            await execa('which', ['infinicode']).catch(() => execa('where', ['infinicode']));
+        }
+        await execa(infinicodeCommand, [], {
             stdio: 'inherit',
-            env: process.env
+            env: process.env,
         });
     }
     catch (e) {
-        if (e.code === 'ENOENT' || e.exitCode === 1) {
-            console.log(chalk.yellow('\n⚠️  OpenCode not found.'));
-            console.log(chalk.dim('\nInstall it with:'));
-            console.log(chalk.cyan('  npm install -g opencode'));
-            console.log(chalk.dim('\nOr use infinicode with the Go binary:'));
-            console.log(chalk.cyan('  cd /path/to/opencode-infini && go build -o infini && ./infini'));
+        const err = e;
+        if (err.code === 'ENOENT') {
+            console.log(chalk.yellow('\ninfinicode TUI binary not found.'));
+            console.log(chalk.dim('\nThe TUI requires the infinicode binary in bin/ or on PATH.'));
+            console.log(chalk.dim('Build from source:'));
+            console.log(chalk.cyan('  pnpm build'));
             console.log();
             process.exit(1);
         }
-        if (e.exitCode) {
-            process.exit(e.exitCode);
+        if (err.exitCode) {
+            process.exit(err.exitCode);
         }
         throw e;
     }

package/dist/commands/serve.d.ts

@@ -0,0 +1,18 @@
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/setup.js';
+export interface ServeOptions {
+    role?: string;
+    name?: string;
+    port?: string;
+    host?: string;
+    token?: string;
+    seed?: string[];
+    autoUpdate?: boolean;
+    hub?: boolean;
+    tailscale?: boolean;
+    tag?: string;
+    gateway?: string;
+    gatewayToken?: string;
+    gatewayPassword?: string;
+}
+export declare function serve(config: Conf<InfinicodeConfig>, opts: ServeOptions): Promise<void>;

package/dist/commands/serve.js

@@ -0,0 +1,127 @@
+/**
+ * infinicode serve — run this device as a federation mesh node.
+ *
+ *   infinicode serve                       start the mesh (uses config.federation)
+ *   infinicode serve --role satellite --seed http://100.x.y.z:47913
+ *   infinicode serve --hub --port 47913 --name workstation
+ *
+ * The node exposes an HTTP+SSE mesh endpoint, streams its activity + hardware
+ * telemetry to connected peers/harnesses, dispatches tasks across the mesh, and
+ * (as a satellite) inherits shared API/provider config from its hub.
+ */
+import chalk from 'chalk';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { buildKernelFromConfig } from '../kernel/setup.js';
+import { Federation, MoltfedConnector, loadOrCreateIdentity } from '../kernel/index.js';
+function pkgVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        return JSON.parse(readFileSync(join(here, '..', '..', 'package.json'), 'utf8')).version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export async function serve(config, opts) {
+    const fed = config.get('federation') ?? {};
+    const role = (opts.hub ? 'hub' : opts.role ?? fed.role ?? 'peer');
+    const port = opts.port ? parseInt(opts.port, 10) : fed.port ?? 47913;
+    const seeds = [...(fed.seeds ?? []), ...(opts.seed ?? [])];
+    const token = opts.token ?? fed.token;
+    const kernel = buildKernelFromConfig(config);
+    const identity = loadOrCreateIdentity({ role, displayName: opts.name ?? fed.displayName });
+    // Manifest inputs are read live from the kernel so the map shows real caps.
+    const describe = () => {
+        const defs = kernel.workerRuntime.listRegisteredDefinitions();
+        const caps = [...new Set(defs.flatMap(d => d.capabilities))];
+        return {
+            version: pkgVersion(),
+            capabilities: caps,
+            workers: defs.map(d => d.type),
+            commands: kernel.commands.list().map(c => c.name),
+            providers: kernel.providerManager.listInfos().map(p => p.id),
+        };
+    };
+    // Satellite: persist shared config locally so providers/keys survive a restart.
+    const applyConfig = (cfg) => {
+        if (cfg.cloudProviders)
+            config.set('cloudProviders', cfg.cloudProviders);
+        if (cfg.policy)
+            config.set('policy', cfg.policy);
+        if (cfg.defaultModel)
+            config.set('defaultModel', cfg.defaultModel);
+        console.log(chalk.green(`  ✓ applied shared config (rev ${cfg.revision}) — restart to load new providers`));
+    };
+    const federation = new Federation({
+        kernel,
+        identity,
+        describe,
+        logger: kernel.logger,
+        options: {
+            version: pkgVersion(),
+            port,
+            host: opts.host ?? fed.host,
+            token,
+            heartbeatMs: (fed.heartbeatSec ?? 30) * 1000,
+            autoUpdate: opts.autoUpdate ?? fed.autoUpdate,
+            applyConfig,
+        },
+    });
+    console.log(chalk.bold(`\n  infinicode mesh node`));
+    console.log(chalk.dim('  ' + '-'.repeat(46)));
+    console.log(`  node:   ${chalk.cyan(identity.displayName)} ${chalk.dim('(' + identity.nodeId + ')')}`);
+    console.log(`  role:   ${chalk.yellow(role)}`);
+    console.log(`  listen: ${chalk.cyan((opts.host ?? fed.host ?? '0.0.0.0') + ':' + port)}`);
+    if (token)
+        console.log(`  auth:   ${chalk.green('token required')}`);
+    console.log();
+    await federation.start();
+    // Connect to seeds and, as a satellite, pull shared config from the first hub.
+    for (const url of seeds) {
+        const peer = await federation.connect(url);
+        if (peer) {
+            console.log(chalk.green(`  ✓ connected to ${peer.displayName} @ ${url}`));
+            if (role === 'satellite') {
+                const applied = await federation.pullConfig(peer.nodeId).catch(() => false);
+                if (applied)
+                    console.log(chalk.green(`  ✓ pulled shared config from ${peer.displayName}`));
+            }
+        }
+    }
+    // Optional: auto-discover peers over Tailscale (no --seed needed).
+    if (opts.tailscale) {
+        const n = await federation.discoverAndConnect(opts.tag).catch(() => 0);
+        console.log(chalk.green(`  ✓ tailscale discovery connected ${n} peer(s)`));
+    }
+    // Optional: log this node into an InfiniBot gateway so it renders live on the
+    // neural-mesh map + hardware panels (no InfiniBot changes needed).
+    let connector;
+    if (opts.gateway) {
+        connector = new MoltfedConnector({
+            gatewayUrl: opts.gateway,
+            token: opts.gatewayToken,
+            password: opts.gatewayPassword,
+            client: { id: identity.displayName, version: pkgVersion(), platform: 'node', mode: 'backend' },
+            logger: kernel.logger,
+            getNodeStatuses: () => federation.nodeStatuses(),
+            getHardware: () => federation.latestHardware(),
+            subscribeFrames: (cb) => federation.onFrames(cb),
+        });
+        connector.start();
+        console.log(chalk.green(`  ✓ linking to InfiniBot gateway ${opts.gateway}`));
+    }
+    console.log(chalk.dim(`\n  mesh online — Ctrl-C to stop. Peers: ${federation.peers().length}\n`));
+    const shutdown = async () => {
+        console.log(chalk.dim('\n  stopping mesh…'));
+        connector?.stop();
+        await federation.stop();
+        kernel.destroy();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+    // Keep the process alive.
+    await new Promise(() => { });
+}

package/dist/commands/setup.d.ts

@@ -1,2 +1,2 @@
 import type Conf from 'conf';
-export declare function setupMaster(masterIp: string, port: string, model: string, config: Conf<any>): Promise<void>;
+export declare function setupMaster(masterIp: string, port: string, model: string, config: Conf<any>, tailscaleMasterIp?: string, tailscalePort?: string): Promise<void>;