tokenmaw 0.3.0

package/dist/backend.js

@@ -0,0 +1,595 @@
+/**
+ * backend.ts — LLM backend abstraction.
+ *
+ * Supports:
+ *  • OpenAI-compatible chat completions over SSE
+ *  • Anthropic Messages API over SSE
+ *  • Local NDJSON chat endpoints used by some OpenAI-style runtimes
+ *
+ * The backend is selected via the LLM_BACKEND env var or .agentrc config.
+ */
+import { resilientFetch, FetchError } from './fetch.js';
+import { responsesStream } from './responses.js';
+import { CODER_VERSION } from './version.js';
+const USER_AGENT = `tokenmaw/${CODER_VERSION}`;
+export function transportHeaders(config) {
+    const headers = { 'user-agent': USER_AGENT };
+    if (config.sessionId)
+        headers['x-opencode-session'] = config.sessionId;
+    return headers;
+}
+const ANTHROPIC_VERSION = '2023-06-01';
+const DEFAULT_ANTHROPIC_MAX_TOKENS = 8192;
+export function normalizeOpenAIBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+}
+export function openAIChatCompletionsUrl(baseUrl) {
+    return `${normalizeOpenAIBaseUrl(baseUrl)}/v1/chat/completions`;
+}
+function parseNdjsonLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeToolArguments(args) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(args ?? {})) {
+        normalized[key] = typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    return normalized;
+}
+function toolCallId(prefix = 'call') {
+    return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
+}
+// ── Local NDJSON backend ────────────────────────────────────────────────────
+async function* ollamaStream(config, systemPrompt, messages, tools, signal) {
+    const body = {
+        model: config.model,
+        stream: true,
+        messages: [{ role: 'system', content: String(systemPrompt) }, ...messages],
+    };
+    if (tools?.length)
+        body.tools = tools;
+    const response = await resilientFetch(`${config.baseUrl.replace(/\/$/, '')}/api/chat`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', ...transportHeaders(config) },
+        body: JSON.stringify(body),
+        retries: 2,
+        timeout: 120_000,
+        signal,
+    });
+    if (!response.ok)
+        throw new FetchError(`NDJSON backend HTTP ${response.status}`, response.status, false);
+    if (!response.body)
+        throw new Error('No response body from NDJSON backend');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = done ? '' : lines.pop() ?? '';
+        for (const line of lines) {
+            const obj = parseNdjsonLine(line);
+            if (!obj)
+                continue;
+            if (obj.message?.thinking)
+                yield { content: null, thinking: obj.message.thinking, done: false };
+            if (obj.message?.content) {
+                yield { content: obj.message.content, done: false };
+            }
+            if (obj.message?.tool_calls?.length) {
+                yield { content: null, toolCalls: obj.message.tool_calls, done: false };
+            }
+            if (obj.done) {
+                yield { content: null, done: true };
+                return;
+            }
+        }
+        if (done)
+            break;
+    }
+}
+async function ollamaNonStream(config, systemPrompt, messages, tools) {
+    const body = {
+        model: config.model,
+        stream: false,
+        messages: [{ role: 'system', content: String(systemPrompt) }, ...messages],
+    };
+    if (tools?.length)
+        body.tools = tools;
+    const response = await resilientFetch(`${config.baseUrl.replace(/\/$/, '')}/api/chat`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', ...transportHeaders(config) },
+        body: JSON.stringify(body),
+        retries: 2,
+        timeout: 120_000,
+    });
+    if (!response.ok) {
+        throw new FetchError(`NDJSON backend HTTP ${response.status}: ${await response.text()}`, response.status, false);
+    }
+    const data = await response.json();
+    return {
+        content: data.message?.content ?? null,
+        toolCalls: data.message?.tool_calls,
+        done: true,
+    };
+}
+function convertToOpenAIMessages(systemPrompt, messages) {
+    const result = [{ role: 'system', content: systemPrompt }];
+    for (const message of messages) {
+        if (message.role === 'tool') {
+            result.push({
+                role: 'tool',
+                content: message.content,
+                ...(message.tool_use_id ? { tool_call_id: message.tool_use_id } : {}),
+            });
+            continue;
+        }
+        if (message.tool_calls?.length) {
+            result.push({
+                role: 'assistant',
+                content: message.content,
+                tool_calls: message.tool_calls.map((toolCall) => ({
+                    id: toolCall.id ?? toolCallId(),
+                    type: 'function',
+                    function: {
+                        name: toolCall.function.name,
+                        arguments: JSON.stringify(toolCall.function.arguments),
+                    },
+                })),
+            });
+            continue;
+        }
+        result.push({ role: message.role, content: message.content });
+    }
+    return result;
+}
+function convertToOllamaToolCalls(openaiCalls) {
+    return openaiCalls.map((toolCall) => {
+        let args = {};
+        try {
+            args = JSON.parse(toolCall.function.arguments);
+        }
+        catch {
+            // Keep empty args if malformed.
+        }
+        return {
+            id: toolCall.id,
+            function: { name: toolCall.function.name, arguments: args },
+        };
+    });
+}
+function convertToolsToOpenAI(tools) {
+    if (!tools?.length)
+        return undefined;
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.function.name,
+            description: tool.function.description,
+            parameters: tool.function.parameters,
+        },
+    }));
+}
+function applyOpenAIRequestOptions(body, config) {
+    const options = config.requestOptions;
+    if (!options)
+        return;
+    if (typeof options.temperature === 'number')
+        body.temperature = options.temperature;
+    if (typeof options.topP === 'number')
+        body.top_p = options.topP;
+    if (typeof options.maxTokens === 'number')
+        body.max_tokens = options.maxTokens;
+    if (options.extraBody)
+        Object.assign(body, options.extraBody);
+}
+async function* openaiStream(config, systemPrompt, messages, tools, signal) {
+    const headers = { 'content-type': 'application/json', ...transportHeaders(config) };
+    if (config.apiKey)
+        headers['authorization'] = `Bearer ${config.apiKey}`;
+    const body = {
+        model: config.model,
+        stream: true,
+        messages: convertToOpenAIMessages(systemPrompt, messages),
+    };
+    applyOpenAIRequestOptions(body, config);
+    const openaiTools = convertToolsToOpenAI(tools);
+    if (openaiTools)
+        body.tools = openaiTools;
+    const response = await resilientFetch(openAIChatCompletionsUrl(config.baseUrl), {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        retries: 2,
+        timeout: 120_000,
+        signal,
+    });
+    if (!response.ok)
+        throw new FetchError(`OpenAI-compatible HTTP ${response.status}: ${await response.text()}`, response.status, false);
+    if (!response.body)
+        throw new Error('No response body from OpenAI-compatible backend');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const pendingToolCalls = new Map();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed === 'data: [DONE]') {
+                if (trimmed === 'data: [DONE]' && pendingToolCalls.size > 0) {
+                    yield { content: null, toolCalls: convertToOllamaToolCalls([...pendingToolCalls.values()]), done: false };
+                    pendingToolCalls.clear();
+                }
+                if (trimmed === 'data: [DONE]') {
+                    yield { content: null, done: true };
+                    return;
+                }
+                continue;
+            }
+            if (!trimmed.startsWith('data: '))
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed.slice(6));
+                const choice = parsed.choices?.[0];
+                if (!choice)
+                    continue;
+                const thinking = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
+                if (thinking)
+                    yield { content: null, thinking, done: false };
+                if (choice.delta?.content) {
+                    yield { content: choice.delta.content, done: false };
+                }
+                if (choice.delta?.tool_calls) {
+                    for (const toolCall of choice.delta.tool_calls) {
+                        if (toolCall.id) {
+                            pendingToolCalls.set(toolCall.index, {
+                                id: toolCall.id,
+                                type: 'function',
+                                function: {
+                                    name: toolCall.function?.name ?? '',
+                                    arguments: toolCall.function?.arguments ?? '',
+                                },
+                            });
+                        }
+                        else if (pendingToolCalls.has(toolCall.index)) {
+                            const existing = pendingToolCalls.get(toolCall.index);
+                            if (toolCall.function?.name)
+                                existing.function.name += toolCall.function.name;
+                            if (toolCall.function?.arguments)
+                                existing.function.arguments += toolCall.function.arguments;
+                        }
+                    }
+                }
+                if (choice.finish_reason === 'tool_calls' && pendingToolCalls.size > 0) {
+                    yield { content: null, toolCalls: convertToOllamaToolCalls([...pendingToolCalls.values()]), done: false };
+                    pendingToolCalls.clear();
+                }
+                if (choice.finish_reason === 'stop') {
+                    yield { content: null, done: true };
+                    return;
+                }
+            }
+            catch {
+                // Skip malformed SSE chunks.
+            }
+        }
+    }
+}
+async function openaiNonStream(config, systemPrompt, messages, tools) {
+    const headers = { 'content-type': 'application/json', ...transportHeaders(config) };
+    if (config.apiKey)
+        headers['authorization'] = `Bearer ${config.apiKey}`;
+    const body = {
+        model: config.model,
+        stream: false,
+        messages: convertToOpenAIMessages(systemPrompt, messages),
+    };
+    applyOpenAIRequestOptions(body, config);
+    const openaiTools = convertToolsToOpenAI(tools);
+    if (openaiTools)
+        body.tools = openaiTools;
+    const response = await resilientFetch(openAIChatCompletionsUrl(config.baseUrl), {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        retries: 2,
+        timeout: 120_000,
+    });
+    if (!response.ok)
+        throw new FetchError(`OpenAI-compatible HTTP ${response.status}: ${await response.text()}`, response.status, false);
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    return {
+        content: choice?.message?.content ?? null,
+        toolCalls: choice?.message?.tool_calls ? convertToOllamaToolCalls(choice.message.tool_calls) : undefined,
+        done: true,
+    };
+}
+function convertToolsToAnthropic(tools) {
+    if (!tools?.length)
+        return undefined;
+    return tools.map((tool) => ({
+        name: tool.function.name,
+        description: tool.function.description,
+        input_schema: tool.function.parameters,
+    }));
+}
+function convertToAnthropicMessages(messages) {
+    const result = [];
+    for (const message of messages) {
+        if (message.role === 'tool') {
+            if (message.tool_use_id) {
+                result.push({
+                    role: 'user',
+                    content: [{
+                            type: 'tool_result',
+                            tool_use_id: message.tool_use_id,
+                            content: message.content ?? '',
+                        }],
+                });
+            }
+            else {
+                result.push({ role: 'user', content: message.content ?? '' });
+            }
+            continue;
+        }
+        if (message.tool_calls?.length) {
+            const content = [];
+            if (message.content)
+                content.push({ type: 'text', text: message.content });
+            for (const toolCall of message.tool_calls) {
+                content.push({
+                    type: 'tool_use',
+                    id: toolCall.id ?? toolCallId('toolu'),
+                    name: toolCall.function.name,
+                    input: toolCall.function.arguments,
+                });
+            }
+            result.push({ role: 'assistant', content });
+            continue;
+        }
+        result.push({
+            role: message.role === 'assistant' ? 'assistant' : 'user',
+            content: message.content ?? '',
+        });
+    }
+    return result;
+}
+function buildAnthropicHeaders(config) {
+    const headers = {
+        'content-type': 'application/json',
+        'anthropic-version': ANTHROPIC_VERSION,
+        ...transportHeaders(config),
+    };
+    if (config.apiKey)
+        headers['x-api-key'] = config.apiKey;
+    return headers;
+}
+function anthropicToolStateToCall(state) {
+    let input = {};
+    if (state.inputText.trim()) {
+        try {
+            input = normalizeToolArguments(JSON.parse(state.inputText));
+        }
+        catch {
+            input = normalizeToolArguments(state.initialInput);
+        }
+    }
+    else {
+        input = normalizeToolArguments(state.initialInput);
+    }
+    return {
+        id: state.id,
+        function: {
+            name: state.name,
+            arguments: input,
+        },
+    };
+}
+function parseSseFrame(frame) {
+    const lines = frame.split('\n');
+    let event;
+    const dataLines = [];
+    for (const line of lines) {
+        if (line.startsWith('event:')) {
+            event = line.slice(6).trim();
+        }
+        else if (line.startsWith('data:')) {
+            dataLines.push(line.slice(5).trimStart());
+        }
+    }
+    return { event, data: dataLines.join('\n') };
+}
+async function* anthropicStream(config, systemPrompt, messages, tools, signal) {
+    const body = {
+        model: config.model,
+        max_tokens: DEFAULT_ANTHROPIC_MAX_TOKENS,
+        stream: true,
+        system: systemPrompt,
+        messages: convertToAnthropicMessages(messages),
+    };
+    const anthropicTools = convertToolsToAnthropic(tools);
+    if (anthropicTools)
+        body.tools = anthropicTools;
+    const response = await resilientFetch(`${config.baseUrl.replace(/\/$/, '')}/v1/messages`, {
+        method: 'POST',
+        headers: buildAnthropicHeaders(config),
+        body: JSON.stringify(body),
+        retries: 2,
+        timeout: 120_000,
+        signal,
+    });
+    if (!response.ok)
+        throw new FetchError(`Anthropic HTTP ${response.status}: ${await response.text()}`, response.status, false);
+    if (!response.body)
+        throw new Error('No response body from Anthropic backend');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const pendingToolCalls = new Map();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const frames = buffer.split('\n\n');
+        buffer = frames.pop() ?? '';
+        for (const frame of frames) {
+            const { event, data } = parseSseFrame(frame);
+            if (!data || data === '[DONE]') {
+                if (data === '[DONE]') {
+                    yield { content: null, done: true };
+                    return;
+                }
+                continue;
+            }
+            if (event === 'ping')
+                continue;
+            try {
+                const parsed = JSON.parse(data);
+                if (event === 'error') {
+                    throw new Error(parsed.error?.message ?? 'Anthropic streaming error');
+                }
+                if (event === 'content_block_start' && parsed.content_block?.type === 'tool_use') {
+                    pendingToolCalls.set(parsed.index ?? pendingToolCalls.size, {
+                        id: parsed.content_block.id ?? toolCallId('toolu'),
+                        name: parsed.content_block.name ?? '',
+                        inputText: '',
+                        initialInput: parsed.content_block.input,
+                    });
+                    continue;
+                }
+                if (event === 'content_block_delta') {
+                    if (parsed.delta?.type === 'thinking_delta' && parsed.delta.thinking) {
+                        yield { content: null, thinking: parsed.delta.thinking, done: false };
+                    }
+                    if (parsed.delta?.type === 'text_delta' && parsed.delta.text) {
+                        yield { content: parsed.delta.text, done: false };
+                    }
+                    if (parsed.delta?.type === 'input_json_delta' && typeof parsed.index === 'number') {
+                        const existing = pendingToolCalls.get(parsed.index);
+                        if (existing && parsed.delta.partial_json) {
+                            existing.inputText += parsed.delta.partial_json;
+                        }
+                    }
+                    continue;
+                }
+                if (event === 'content_block_stop' && typeof parsed.index === 'number' && pendingToolCalls.has(parsed.index)) {
+                    const toolCall = anthropicToolStateToCall(pendingToolCalls.get(parsed.index));
+                    pendingToolCalls.delete(parsed.index);
+                    yield { content: null, toolCalls: [toolCall], done: false };
+                    continue;
+                }
+                if (event === 'message_stop') {
+                    yield { content: null, done: true };
+                    return;
+                }
+            }
+            catch {
+                // Ignore malformed frames and keep streaming.
+            }
+        }
+    }
+}
+async function anthropicNonStream(config, systemPrompt, messages, tools) {
+    const body = {
+        model: config.model,
+        max_tokens: DEFAULT_ANTHROPIC_MAX_TOKENS,
+        stream: false,
+        system: systemPrompt,
+        messages: convertToAnthropicMessages(messages),
+    };
+    const anthropicTools = convertToolsToAnthropic(tools);
+    if (anthropicTools)
+        body.tools = anthropicTools;
+    const response = await resilientFetch(`${config.baseUrl.replace(/\/$/, '')}/v1/messages`, {
+        method: 'POST',
+        headers: buildAnthropicHeaders(config),
+        body: JSON.stringify(body),
+        retries: 2,
+        timeout: 120_000,
+    });
+    if (!response.ok)
+        throw new FetchError(`Anthropic HTTP ${response.status}: ${await response.text()}`, response.status, false);
+    const data = await response.json();
+    const textParts = [];
+    const toolCalls = [];
+    for (const block of data.content ?? []) {
+        if (block.type === 'text' && block.text) {
+            textParts.push(block.text);
+            continue;
+        }
+        if (block.type === 'tool_use') {
+            toolCalls.push({
+                id: block.id ?? toolCallId('toolu'),
+                function: {
+                    name: block.name ?? '',
+                    arguments: normalizeToolArguments(block.input),
+                },
+            });
+        }
+    }
+    return {
+        content: textParts.join('') || null,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        done: true,
+    };
+}
+// ── Public API ──────────────────────────────────────────────────────────────
+export function chatStream(config, systemPrompt, messages, tools, signal) {
+    if (config.type === 'openai' && config.wireApi === 'responses')
+        return responsesStream(config, systemPrompt, messages, tools, signal);
+    if (config.type === 'anthropic')
+        return anthropicStream(config, systemPrompt, messages, tools, signal);
+    if (config.type === 'openai')
+        return openaiStream(config, systemPrompt, messages, tools, signal);
+    return ollamaStream(config, systemPrompt, messages, tools, signal);
+}
+export async function chatNonStream(config, systemPrompt, messages, tools) {
+    if (config.type === 'openai' && config.wireApi === 'responses') {
+        const result = { content: '', thinking: '', toolCalls: [], done: true };
+        for await (const chunk of responsesStream(config, systemPrompt, messages, tools)) {
+            result.content += chunk.content ?? '';
+            result.thinking += chunk.thinking ?? '';
+            result.toolCalls.push(...chunk.toolCalls ?? []);
+        }
+        return result;
+    }
+    if (config.type === 'anthropic')
+        return anthropicNonStream(config, systemPrompt, messages, tools);
+    if (config.type === 'openai')
+        return openaiNonStream(config, systemPrompt, messages, tools);
+    return ollamaNonStream(config, systemPrompt, messages, tools);
+}
+/**
+ * Detect backend type from a URL heuristically.
+ * - Anthropic hosts or `/v1/messages` → anthropic
+ * - `/v1` or known OpenAI hosts → openai
+ * - localhost:11434 → ollama transport
+ * - Otherwise → openai
+ */
+export function detectBackend(url) {
+    const lower = url.toLowerCase();
+    if (lower.includes('api.anthropic.com') || lower.includes('/v1/messages'))
+        return 'anthropic';
+    if (lower.includes('/v1') || lower.includes('api.openai.com'))
+        return 'openai';
+    if (lower.includes('localhost:11434') || lower.includes('127.0.0.1:11434'))
+        return 'ollama';
+    return 'openai';
+}

package/dist/cli.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { loadConfig, saveConfig, saveSelectedModel } from './config.js';
+import { setToolPolicy } from './infra/tools.js';
+import { resolveModelConfig } from './model-config.js';
+import { defaultPolicy } from './policy.js';
+import { AgentRegistry } from './runtime/agent-registry.js';
+import { AgentRuntime } from './runtime/agent-runtime.js';
+import { runFullscreenTui } from './ui/fullscreen-tui.js';
+import { CODER_VERSION } from './version.js';
+async function main() {
+    const program = new Command();
+    program.name('maw').description('Document-driven coding agent runtime').version(CODER_VERSION);
+    program.allowExcessArguments(false).showSuggestionAfterError();
+    program.option('--model <name>', 'default model name or .agentrc alias');
+    let config = await loadConfig();
+    const selectedFromCli = () => program.opts().model;
+    setToolPolicy(defaultPolicy(config.policyLevel ?? 'moderate', process.cwd()));
+    const registry = new AgentRegistry({ workspaceRoot: process.cwd() });
+    const runtime = new AgentRuntime({
+        registry,
+        workspaceRoot: process.cwd(),
+        defaultModel: selectedFromCli() ?? config.model,
+        resolveModel: (alias) => resolveModelConfig(config, alias).config,
+    });
+    const configManager = {
+        getConfig: () => config,
+        saveConfig: async (next) => {
+            await saveConfig(next);
+            config = next;
+            setToolPolicy(defaultPolicy(config.policyLevel ?? 'moderate', process.cwd()));
+        },
+    };
+    program
+        .command('run')
+        .description('Run one non-interactive main-agent session')
+        .requiredOption('--prompt <text>', 'message for the main agent')
+        .option('--session <id>', 'session id')
+        .action(async (options) => {
+        runtime.setDefaultModel(selectedFromCli() ?? config.model);
+        try {
+            await runtime.whenReady();
+            const sessionId = options.session ?? `run-${Date.now()}`;
+            await runtime.openSession(sessionId);
+            if (selectedFromCli())
+                await runtime.setSessionDefaultModel(sessionId, selectedFromCli());
+            const turnId = await runtime.submitMessage(sessionId, options.prompt);
+            await runtime.waitForIdle(sessionId);
+            const session = runtime.getSession(sessionId);
+            const failed = runtime.listInstances(sessionId).find((instance) => instance.status === 'failed');
+            if (failed)
+                throw new Error(failed.lastError ?? 'Agent failed');
+            const submitted = session.messages.findIndex((message) => message.role === 'user' && message.turnId === turnId);
+            const response = session.messages.slice(submitted + 1).reverse().find((message) => message.role === 'assistant');
+            if (response)
+                process.stdout.write(`${response.content}\n`);
+        }
+        finally {
+            await runtime.shutdown();
+        }
+    });
+    program
+        .command('agents')
+        .description('List effective Agent Specs')
+        .action(async () => {
+        await runtime.whenReady();
+        for (const spec of runtime.listAgentSpecs()) {
+            process.stdout.write(`${spec.id}\t${spec.scope}\t${spec.model ?? 'inherit'}\t${spec.description}\n`);
+        }
+        await runtime.shutdown();
+    });
+    program.action(async () => {
+        if (!process.stdin.isTTY || !process.stdout.isTTY)
+            throw new Error('Interactive mode requires a terminal. Use maw run --prompt "..." for non-interactive execution.');
+        await runtime.whenReady();
+        const requested = selectedFromCli();
+        const selected = resolveModelConfig(config, requested);
+        runtime.setDefaultModel(requested ?? config.model);
+        await runFullscreenTui(runtime, {
+            modelName: selected.name,
+            modelAliases: Object.keys(config.models ?? {}),
+            resolveModel: (alias) => resolveModelConfig(config, alias),
+            persistModelSelection: async (alias) => {
+                await saveSelectedModel(alias);
+                config = { ...config, model: alias };
+            },
+            configManager,
+        });
+        await runtime.shutdown();
+    });
+    const shutdown = async () => {
+        await runtime.shutdown().catch(() => undefined);
+        process.exit(0);
+    };
+    process.once('SIGTERM', () => { void shutdown(); });
+    await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});