@myagentroam/node 0.1.4 → 0.1.6

package/dist/main.js

@@ -4,6 +4,7 @@ import { NodeConnector } from './connector.js';
 import { loadNodeConfig, nodeConfigPath, nodeDatabasePath } from './config.js';
 import { getNodeHealth } from './health.js';
 import { removeServiceDefinition, writeServiceDefinition } from './service.js';
+import { superviseNode } from './supervisor.js';
 const [command = 'status', ...args] = process.argv.slice(2);
 const config = readOption(args, '--config') ?? nodeConfigPath();
 const output = readOption(args, '--output') ?? defaultServicePath();
@@ -14,6 +15,11 @@ if (command === 'run') {
         process.once(signal, () => connector.stop());
     }
 }
+else if (command === 'supervise') {
+    if (process.argv[1] === undefined)
+        throw new Error('NODE_ENTRYPOINT_UNAVAILABLE');
+    await superviseNode(config, process.argv[1]);
+}
 else if (command === 'install') {
     await writeCurrentServiceDefinition(output, config);
     process.stdout.write(`${output}\n`);
@@ -44,4 +50,3 @@ async function writeCurrentServiceDefinition(output, configPath) {
     const nodeConfig = await loadNodeConfig(configPath);
     await writeServiceDefinition(output, process.execPath, configPath, process.platform, process.argv[1], [dirname(nodeDatabasePath(nodeConfig, configPath)), ...nodeConfig.allowedRoots]);
 }
-//# sourceMappingURL=main.js.map

package/dist/migrations/v001.js

@@ -246,4 +246,3 @@ export function assertNodeSchema(database) {
         throw new Error('NODE_DATABASE_BASELINE_MISMATCH:approvals');
     }
 }
-//# sourceMappingURL=v001.js.map

package/dist/migrations/v002.js

@@ -141,4 +141,3 @@ function integer(row, key) {
 function nullableInteger(row, key) {
     return row[key] === null || row[key] === undefined ? null : integer(row, key);
 }
-//# sourceMappingURL=v002.js.map

package/dist/migrations/v003.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseSync } from 'node:sqlite';
+export declare const NODE_SCHEMA_VERSION_V3 = 3;
+export declare function migrateNodeSchemaV3(database: DatabaseSync): void;
+export declare function assertNodeSchemaV3(database: DatabaseSync): void;

package/dist/migrations/v003.js

@@ -0,0 +1,44 @@
+export const NODE_SCHEMA_VERSION_V3 = 3;
+export function migrateNodeSchemaV3(database) {
+    database.exec('PRAGMA foreign_keys = OFF');
+    database.exec('BEGIN IMMEDIATE');
+    try {
+        database.exec(`ALTER TABLE agent_sessions RENAME TO agent_sessions_v2;
+      CREATE TABLE agent_sessions (
+        id TEXT PRIMARY KEY,
+        workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+        runner TEXT NOT NULL CHECK (runner IN ('codex', 'claude-code', 'opencode')),
+        pin_order INTEGER CHECK (pin_order IS NULL OR pin_order >= 0),
+        metadata TEXT NOT NULL CHECK (json_valid(metadata))
+      ) STRICT;
+      INSERT INTO agent_sessions SELECT * FROM agent_sessions_v2;
+      DROP TABLE agent_sessions_v2;
+      ALTER TABLE runner_defaults RENAME TO runner_defaults_v2;
+      CREATE TABLE runner_defaults (
+        runner TEXT PRIMARY KEY CHECK (runner IN ('codex', 'claude-code', 'opencode')),
+        model TEXT NOT NULL, effort TEXT NOT NULL, access TEXT NOT NULL
+      ) STRICT;
+      INSERT INTO runner_defaults SELECT * FROM runner_defaults_v2;
+      DROP TABLE runner_defaults_v2;`);
+        database
+            .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
+            .run(NODE_SCHEMA_VERSION_V3, Date.now());
+        database.exec('COMMIT');
+    }
+    catch (error) {
+        database.exec('ROLLBACK');
+        throw error;
+    }
+    finally {
+        database.exec('PRAGMA foreign_keys = ON');
+    }
+}
+export function assertNodeSchemaV3(database) {
+    for (const table of ['agent_sessions', 'runner_defaults']) {
+        const row = database
+            .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?")
+            .get(table);
+        if (typeof row?.sql !== 'string' || !row.sql.includes("'opencode'"))
+            throw new Error(`NODE_DATABASE_SCHEMA_INVALID:${table}:runner`);
+    }
+}

package/dist/native-jsonl-reader.js

@@ -95,4 +95,3 @@ async function readAt(handle, size, position) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=native-jsonl-reader.js.map

package/dist/native-session-history.d.ts

@@ -4,6 +4,7 @@ export interface NativeTranscriptMessage {
     readonly role: 'USER' | 'ASSISTANT';
     readonly text: string;
     readonly createdAt: number | null;
+    readonly nativeId?: string;
 }
 export interface NativeTranscriptToolCall {
     readonly kind: 'tool_call';
@@ -18,6 +19,23 @@ export interface NativeTranscriptToolCall {
     readonly imageAttachments?: readonly NativeTranscriptImageAttachment[];
     readonly failed: boolean;
     readonly createdAt: number | null;
+    readonly nativeId?: string;
+}
+export interface NativeTranscriptUnknown {
+    readonly kind: 'unknown';
+    readonly sourceEventType: string;
+    readonly label: string;
+    readonly createdAt: number | null;
+    readonly nativeId?: string;
+}
+export interface NativeTranscriptReasoningSummary {
+    readonly kind: 'reasoning_summary';
+    readonly sections: readonly {
+        readonly index: number;
+        readonly text: string;
+    }[];
+    readonly createdAt: number | null;
+    readonly nativeId?: string;
 }
 export interface NativeTranscriptImageAttachment {
     readonly name: string;
@@ -25,7 +43,7 @@ export interface NativeTranscriptImageAttachment {
     /** Codex-owned local artifact path; never sent to Web. */
     readonly localPath?: string;
 }
-export type NativeTranscriptItem = NativeTranscriptMessage | NativeTranscriptToolCall;
+export type NativeTranscriptItem = NativeTranscriptMessage | NativeTranscriptToolCall | NativeTranscriptReasoningSummary | NativeTranscriptUnknown;
 export interface NativeSessionHistory {
     readonly runner: RunnerName;
     readonly externalSessionId: string;

package/dist/native-session-history.js

@@ -261,7 +261,8 @@ async function readTranscript(path, runner, byteLimit) {
         const generatedImage = codexGeneratedImageEvent(value);
         if (generatedImage !== undefined)
             items.push(generatedImage);
-        for (const item of transcriptItems(value)) {
+        for (const parsedItem of transcriptItems(value)) {
+            const item = recordId === undefined ? parsedItem : { ...parsedItem, nativeId: recordId };
             if (item.kind === 'tool_result') {
                 const toolIndex = toolIndexes.get(item.toolUseId);
                 if (toolIndex === undefined)
@@ -395,7 +396,10 @@ function transcriptItems(record) {
         return results;
     const values = [
         ...toolUsesOf(record, createdAt),
-        ...codexToolUsesOf(record, createdAt)
+        ...codexToolUsesOf(record, createdAt),
+        ...codexReasoningSummariesOf(record, createdAt),
+        ...unsupportedCodexResponseItems(record, createdAt),
+        ...unsupportedTranscriptItems(record, createdAt)
     ];
     const role = roleOf(record);
     if (role === undefined)
@@ -411,6 +415,65 @@ function transcriptItems(record) {
     values.unshift({ kind: 'message', role, text, createdAt });
     return values;
 }
+function unsupportedCodexResponseItems(record, createdAt) {
+    const payload = codexToolPayload(record);
+    const type = typeof payload?.type === 'string' ? payload.type : undefined;
+    if (type === undefined ||
+        typeof payload?.role === 'string' ||
+        type === 'reasoning' ||
+        type === 'custom_tool_call' ||
+        type === 'custom_tool_call_output' ||
+        type === 'function_call' ||
+        type === 'function_call_output')
+        return [];
+    return [
+        {
+            kind: 'unknown',
+            sourceEventType: `codex:${type}`,
+            label: `Codex ${compact(type).slice(0, 128)}`,
+            createdAt
+        }
+    ];
+}
+function codexReasoningSummariesOf(record, createdAt) {
+    const payload = codexToolPayload(record);
+    if (payload?.type !== 'reasoning')
+        return [];
+    const sections = Array.isArray(payload.summary)
+        ? payload.summary.flatMap((value, index) => {
+            if (typeof value !== 'string')
+                return [];
+            const text = compact(value).slice(0, 10_000);
+            return text.length === 0 ? [] : [{ index, text }];
+        })
+        : [];
+    return [{ kind: 'reasoning_summary', sections, createdAt }];
+}
+function unsupportedTranscriptItems(record, createdAt) {
+    return contentBlocks(record).flatMap((block) => {
+        const type = typeof block.type === 'string' ? block.type : undefined;
+        if (type === undefined ||
+            type === 'text' ||
+            type === 'input_text' ||
+            type === 'output_text' ||
+            type === 'image' ||
+            type === 'input_image' ||
+            type === 'thinking' ||
+            type === 'redacted_thinking' ||
+            type === 'encrypted_thinking' ||
+            type === 'tool_use' ||
+            type === 'tool_result')
+            return [];
+        return [
+            {
+                kind: 'unknown',
+                sourceEventType: `transcript:${type}`,
+                label: `Agent ${compact(type).slice(0, 128)}`,
+                createdAt
+            }
+        ];
+    });
+}
 function toolUsesOf(record, createdAt) {
     return contentBlocks(record).flatMap((block) => {
         if (block['type'] !== 'tool_use' ||
@@ -768,4 +831,3 @@ function indexKey(runner, cwd, externalSessionId) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=native-session-history.js.map

package/dist/opencode-runtime.d.ts

@@ -0,0 +1,33 @@
+export interface OpenCodeProbe {
+    readonly available: boolean;
+    readonly compatible: boolean;
+    readonly version?: string;
+}
+export interface OpenCodeProviderCatalog {
+    readonly connected?: readonly string[];
+    readonly default?: Readonly<Record<string, string>>;
+    readonly all?: readonly {
+        readonly id?: string;
+        readonly name?: string;
+        readonly source?: 'env' | 'config' | 'custom' | 'api';
+        readonly models?: Readonly<Record<string, {
+            readonly id?: string;
+            readonly name?: string;
+            readonly variants?: Readonly<Record<string, {
+                readonly disabled?: boolean;
+            }>>;
+            readonly limit?: {
+                readonly context?: number;
+            };
+        }>>;
+    }[];
+}
+export interface OpenCodeProfileModel {
+    readonly id: string;
+    readonly label: string;
+    readonly supportedEfforts: string[];
+}
+export declare function probeOpenCode(command?: string): OpenCodeProbe;
+export declare function probeOpenCodeAsync(command?: string): Promise<OpenCodeProbe>;
+export declare function openCodeProfileModels(catalog: OpenCodeProviderCatalog): OpenCodeProfileModel[];
+export declare function openCodeContextLimits(catalog: OpenCodeProviderCatalog): ReadonlyMap<string, number>;

package/dist/opencode-runtime.js

@@ -0,0 +1,80 @@
+import { spawnSync } from 'node:child_process';
+import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from './operational.js';
+const PROBE_TIMEOUT_MS = 3_000;
+export function probeOpenCode(command = 'opencode') {
+    const invocation = platformCliInvocation(command, ['--version']);
+    const result = spawnSync(invocation.command, invocation.args, {
+        windowsHide: true,
+        env: minimalRunnerEnvironment(),
+        timeout: PROBE_TIMEOUT_MS,
+        encoding: 'utf8'
+    });
+    if (result.status !== 0 || result.error !== undefined)
+        return { available: false, compatible: false };
+    return openCodeProbeResult(`${result.stdout}${result.stderr}`);
+}
+export async function probeOpenCodeAsync(command = 'opencode') {
+    const invocation = platformCliInvocation(command, ['--version']);
+    const result = await runRunnerProbe(invocation.command, invocation.args, {
+        env: minimalRunnerEnvironment(),
+        timeoutMs: PROBE_TIMEOUT_MS
+    });
+    return result.status === 0
+        ? openCodeProbeResult(`${result.stdout}${result.stderr}`)
+        : { available: false, compatible: false };
+}
+function openCodeProbeResult(output) {
+    const version = output.trim().replace(/^v/i, '').slice(0, 128);
+    return {
+        available: version.length > 0,
+        compatible: /^1\.18\./.test(version),
+        ...(version.length === 0 ? {} : { version })
+    };
+}
+export function openCodeProfileModels(catalog) {
+    const connected = new Set(catalog.connected ?? []);
+    return (catalog.all ?? [])
+        .filter((provider) => typeof provider.id === 'string' &&
+        connected.has(provider.id) &&
+        provider.source === 'config')
+        .flatMap((provider) => {
+        const providerId = provider.id;
+        return Object.entries(provider.models ?? {}).flatMap(([key, model]) => {
+            const modelId = boundedString(model.id) ?? boundedString(key);
+            if (modelId === undefined)
+                return [];
+            const variants = Object.entries(model.variants ?? {})
+                .filter(([, value]) => value.disabled !== true)
+                .map(([id]) => id)
+                .filter((id) => id.length > 0 && id.length <= 64)
+                .slice(0, 32);
+            return [
+                {
+                    id: `${providerId}/${modelId}`.slice(0, 128),
+                    label: (boundedString(model.name) ?? modelId).slice(0, 128),
+                    supportedEfforts: variants
+                }
+            ];
+        });
+    });
+}
+export function openCodeContextLimits(catalog) {
+    const connected = new Set(catalog.connected ?? []);
+    return new Map((catalog.all ?? [])
+        .filter((provider) => typeof provider.id === 'string' &&
+        connected.has(provider.id) &&
+        provider.source === 'config')
+        .flatMap((provider) => Object.entries(provider.models ?? {}).flatMap(([key, model]) => {
+        const modelId = boundedString(model.id) ?? boundedString(key);
+        const context = model.limit?.context;
+        return modelId !== undefined && Number.isSafeInteger(context) && (context ?? 0) > 0
+            ? [[`${provider.id}/${modelId}`, context]]
+            : [];
+    })));
+}
+function boundedString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 && trimmed.length <= 4096 ? trimmed : undefined;
+}

package/dist/opencode-server.d.ts

@@ -0,0 +1,47 @@
+import { spawn } from 'node:child_process';
+import type { OpenCodeProviderCatalog } from './opencode-runtime.js';
+export interface OpenCodeServerOptions {
+    readonly command?: string;
+    readonly startTimeoutMs?: number;
+    readonly spawnProcess?: typeof spawn;
+}
+export declare class OpenCodeServerClient {
+    private readonly options;
+    private child;
+    private client;
+    private starting;
+    private environment;
+    constructor(options?: OpenCodeServerOptions);
+    configureEnvironment(environment: Readonly<Record<string, string>>): void;
+    start(): Promise<void>;
+    private startServer;
+    providers(directory: string): Promise<OpenCodeProviderCatalog>;
+    sessions(directory: string, limit?: number): Promise<readonly unknown[]>;
+    sessionStatus(directory: string): Promise<Readonly<Record<string, unknown>>>;
+    createSession(directory: string, title?: string): Promise<unknown>;
+    forkSession(directory: string, sessionID: string, messageID: string): Promise<unknown>;
+    messages(directory: string, sessionID: string, limit?: number): Promise<readonly unknown[]>;
+    updateSession(directory: string, sessionID: string, title: string): Promise<unknown>;
+    deleteSession(directory: string, sessionID: string): Promise<unknown>;
+    abort(directory: string, sessionID: string): Promise<unknown>;
+    summarize(directory: string, sessionID: string, model: string): Promise<unknown>;
+    replyPermission(directory: string, requestID: string, decision: 'APPROVED' | 'REJECTED'): Promise<unknown>;
+    replyQuestion(directory: string, requestID: string, answers: readonly (readonly string[])[]): Promise<unknown>;
+    rejectQuestion(directory: string, requestID: string): Promise<unknown>;
+    prompt(input: {
+        readonly directory: string;
+        readonly sessionID: string;
+        readonly text: string;
+        readonly model: string;
+        readonly variant?: string;
+        readonly agent?: 'plan' | 'build';
+        readonly attachments?: readonly {
+            readonly name: string;
+            readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
+            readonly dataBase64: string;
+        }[];
+    }): Promise<unknown>;
+    subscribe(directory: string, signal: AbortSignal, onEvent: (event: unknown) => void, onReady?: () => void): Promise<void>;
+    stop(): Promise<void>;
+    private requireClient;
+}

package/dist/opencode-server.js

@@ -0,0 +1,250 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { createServer } from 'node:net';
+import { createOpencodeClient } from '@opencode-ai/sdk/v2/client';
+import { minimalRunnerEnvironment, platformCliInvocation } from './operational.js';
+import { terminateProcessTree } from './process-tree.js';
+const START_TIMEOUT_MS = 10_000;
+export class OpenCodeServerClient {
+    options;
+    child;
+    client;
+    starting;
+    environment = {};
+    constructor(options = {}) {
+        this.options = options;
+    }
+    configureEnvironment(environment) {
+        if (this.child !== undefined)
+            throw new Error('OPENCODE_SERVER_ALREADY_STARTED');
+        this.environment = { ...environment };
+    }
+    async start() {
+        if (this.client !== undefined)
+            return;
+        if (this.starting !== undefined)
+            return this.starting;
+        const starting = this.startServer();
+        this.starting = starting;
+        try {
+            await starting;
+        }
+        finally {
+            if (this.starting === starting)
+                this.starting = undefined;
+        }
+    }
+    async startServer() {
+        const port = await availablePort();
+        const password = randomBytes(24).toString('base64url');
+        const invocation = platformCliInvocation(this.options.command ?? 'opencode', [
+            'serve',
+            '--hostname',
+            '127.0.0.1',
+            '--port',
+            String(port)
+        ]);
+        const spawnProcess = this.options.spawnProcess ?? spawn;
+        const child = spawnProcess(invocation.command, invocation.args, {
+            windowsHide: true,
+            detached: process.platform !== 'win32',
+            env: {
+                ...minimalRunnerEnvironment(),
+                ...this.environment,
+                OPENCODE_SERVER_USERNAME: 'opencode',
+                OPENCODE_SERVER_PASSWORD: password,
+                OPENCODE_DISABLE_AUTOUPDATE: 'true'
+            },
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        this.child = child;
+        const authorization = `Basic ${Buffer.from(`opencode:${password}`).toString('base64')}`;
+        const client = createOpencodeClient({
+            baseUrl: `http://127.0.0.1:${port}`,
+            headers: { authorization },
+            throwOnError: true
+        });
+        try {
+            await waitUntilHealthy(`http://127.0.0.1:${port}/global/health`, authorization, child, this.options.startTimeoutMs ?? START_TIMEOUT_MS);
+            this.client = client;
+        }
+        catch (error) {
+            await this.stop();
+            throw error;
+        }
+    }
+    async providers(directory) {
+        const client = await this.requireClient();
+        return unwrap(await client.provider.list({ directory }));
+    }
+    async sessions(directory, limit = 100) {
+        const client = await this.requireClient();
+        return unwrap(await client.session.list({ directory, limit }));
+    }
+    async sessionStatus(directory) {
+        const client = await this.requireClient();
+        return unwrap(await client.session.status({ directory }));
+    }
+    async createSession(directory, title) {
+        const client = await this.requireClient();
+        return unwrap(await client.session.create({ directory, ...(title === undefined ? {} : { title }) }));
+    }
+    async forkSession(directory, sessionID, messageID) {
+        const client = await this.requireClient();
+        return unwrap(await client.session.fork({ directory, sessionID, messageID }));
+    }
+    async messages(directory, sessionID, limit = 100) {
+        const client = await this.requireClient();
+        return unwrap(await client.session.messages({ directory, sessionID, limit }));
+    }
+    async updateSession(directory, sessionID, title) {
+        const client = await this.requireClient();
+        return unwrap(await client.session.update({ directory, sessionID, title }));
+    }
+    async deleteSession(directory, sessionID) {
+        const client = await this.requireClient();
+        return unwrap(await client.session.delete({ directory, sessionID }));
+    }
+    async abort(directory, sessionID) {
+        const client = await this.requireClient();
+        return unwrap(await client.session.abort({ directory, sessionID }));
+    }
+    async summarize(directory, sessionID, model) {
+        const client = await this.requireClient();
+        const separator = model.indexOf('/');
+        if (separator <= 0 || separator === model.length - 1)
+            throw new Error('OPENCODE_MODEL_INVALID');
+        return unwrap(await client.session.summarize({
+            directory,
+            sessionID,
+            providerID: model.slice(0, separator),
+            modelID: model.slice(separator + 1)
+        }));
+    }
+    async replyPermission(directory, requestID, decision) {
+        const client = await this.requireClient();
+        return unwrap(await client.permission.reply({
+            directory,
+            requestID,
+            reply: decision === 'APPROVED' ? 'once' : 'reject'
+        }));
+    }
+    async replyQuestion(directory, requestID, answers) {
+        const client = await this.requireClient();
+        return unwrap(await client.question.reply({
+            directory,
+            requestID,
+            answers: answers.map((answer) => [...answer])
+        }));
+    }
+    async rejectQuestion(directory, requestID) {
+        const client = await this.requireClient();
+        return unwrap(await client.question.reject({ directory, requestID }));
+    }
+    async prompt(input) {
+        const client = await this.requireClient();
+        const separator = input.model.indexOf('/');
+        if (separator <= 0 || separator === input.model.length - 1)
+            throw new Error('OPENCODE_MODEL_INVALID');
+        return unwrap(await client.session.promptAsync({
+            directory: input.directory,
+            sessionID: input.sessionID,
+            model: {
+                providerID: input.model.slice(0, separator),
+                modelID: input.model.slice(separator + 1)
+            },
+            ...(input.variant === undefined || input.variant.length === 0
+                ? {}
+                : { variant: input.variant }),
+            ...(input.agent === undefined ? {} : { agent: input.agent }),
+            parts: [
+                { type: 'text', text: input.text },
+                ...(input.attachments ?? []).map((attachment) => ({
+                    type: 'file',
+                    mime: attachment.mime,
+                    filename: attachment.name,
+                    url: `data:${attachment.mime};base64,${attachment.dataBase64}`
+                }))
+            ]
+        }));
+    }
+    async subscribe(directory, signal, onEvent, onReady) {
+        const client = await this.requireClient();
+        const stream = await client.event.subscribe({ directory }, { signal });
+        onReady?.();
+        for await (const event of stream.stream)
+            onEvent(event);
+    }
+    async stop() {
+        this.client = undefined;
+        const child = this.child;
+        this.child = undefined;
+        if (child === undefined)
+            return;
+        if (child.pid === undefined) {
+            child.kill('SIGTERM');
+            return;
+        }
+        try {
+            await terminateProcessTree({
+                pid: child.pid,
+                kill: (signal) => child.kill(signal)
+            });
+        }
+        catch {
+            child.kill('SIGTERM');
+        }
+    }
+    async requireClient() {
+        await this.start();
+        return this.client;
+    }
+}
+async function availablePort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address !== null ? address.port : undefined;
+            server.close((error) => {
+                if (error !== undefined)
+                    reject(error);
+                else if (port === undefined)
+                    reject(new Error('OPENCODE_PORT_UNAVAILABLE'));
+                else
+                    resolve(port);
+            });
+        });
+    });
+}
+async function waitUntilHealthy(url, authorization, child, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null)
+            throw new Error('OPENCODE_SERVER_EXITED');
+        try {
+            const response = await fetch(url, {
+                headers: { authorization },
+                signal: AbortSignal.timeout(Math.min(1_000, Math.max(1, deadline - Date.now())))
+            });
+            if (response.ok)
+                return;
+        }
+        catch {
+            // The child may still be binding its loopback socket.
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    throw new Error('OPENCODE_SERVER_START_TIMEOUT');
+}
+function unwrap(result) {
+    if (typeof result !== 'object' || result === null || !('data' in result))
+        return result;
+    const wrapped = result;
+    if (wrapped.error !== undefined)
+        throw new Error('OPENCODE_REQUEST_FAILED');
+    if (wrapped.data === undefined)
+        throw new Error('OPENCODE_RESPONSE_INVALID');
+    return wrapped.data;
+}

package/dist/operational.js

@@ -101,12 +101,19 @@ export function platformCliInvocation(command, args, platform = process.platform
     const cliCommand = platformCliCommand(command, platform);
     if (platform !== 'win32' || !/\.(?:cmd|bat)$/i.test(cliCommand))
         return { command: cliCommand, args };
-    if (![cliCommand, ...args].every((value) => /^[A-Za-z0-9_./:\\-]+$/.test(value)))
+    if (![cliCommand, ...args].every((value) => /^[A-Za-z0-9_@./:\\ -]+$/.test(value)))
         throw new Error('NODE_CLI_COMMAND_INVALID');
-    return { command: comspec, args: ['/d', '/s', '/c', [cliCommand, ...args].join(' ')] };
+    return {
+        command: comspec,
+        args: [
+            '/d',
+            '/s',
+            '/c',
+            [cliCommand, ...args].map((value) => (value.includes(' ') ? `"${value}"` : value)).join(' ')
+        ]
+    };
 }
 export function nodeLog(event, fields = {}) {
     const safeFields = redactLogValue(fields);
     process.stdout.write(`${JSON.stringify({ timestamp: new Date().toISOString(), level: 'info', component: 'mar-node', event, ...safeFields })}\n`);
 }
-//# sourceMappingURL=operational.js.map

package/dist/process-tree.js

@@ -16,4 +16,3 @@ export async function terminateProcessTree(child, platform = process.platform, r
         child.kill('SIGTERM');
     }
 }
-//# sourceMappingURL=process-tree.js.map