axexec 1.0.0

package/dist/agents/opencode/adapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * OpenCode adapter implementation (server mode).
+ *
+ * Implements the {@link StreamableAdapter} interface for OpenCode using
+ * server mode with SSE for richer event streaming.
+ *
+ * Flow:
+ * 1. Spawn `opencode serve --port 0`
+ * 2. Wait for "listening on http://..." message
+ * 3. Connect to SSE endpoint `/event`
+ * 4. Create session via `POST /session`
+ * 5. Send prompt via `POST /session/:id/prompt_async`
+ * 6. Parse SSE events and yield AxexecEvents
+ * 7. Clean up server on completion
+ */
+export {};

package/dist/agents/opencode/adapter.js

@@ -0,0 +1,142 @@
+/**
+ * OpenCode adapter implementation (server mode).
+ *
+ * Implements the {@link StreamableAdapter} interface for OpenCode using
+ * server mode with SSE for richer event streaming.
+ *
+ * Flow:
+ * 1. Spawn `opencode serve --port 0`
+ * 2. Wait for "listening on http://..." message
+ * 3. Connect to SSE endpoint `/event`
+ * 4. Create session via `POST /session`
+ * 5. Send prompt via `POST /session/:id/prompt_async`
+ * 6. Parse SSE events and yield AxexecEvents
+ * 7. Clean up server on completion
+ */
+import { registerAdapter } from "../registry.js";
+import { cleanupSession } from "./cleanup-session.js";
+import { createSessionStartEvent } from "./create-session-start-event.js";
+import { determineSessionSuccess } from "../../determine-session-success.js";
+import { resolveBinary } from "../../resolve-binary.js";
+import { mapErrorToEvent } from "./map-error-to-event.js";
+import { processSSEEvents } from "./process-sse-events.js";
+import { createSession, sendPrompt } from "./session-api.js";
+import { spawnServer } from "./spawn-server.js";
+import { SSEConnectionError, streamSSE } from "./sse-client.js";
+const OPENCODE_INFO = {
+    id: "opencode",
+    name: "OpenCode",
+    package: "opencode-ai",
+};
+/**
+ * Streams events from OpenCode server mode.
+ */
+async function* streamSession(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const abortController = new AbortController();
+    const { signal } = abortController;
+    let serverProcess;
+    let serverUrl;
+    let sessionId;
+    let sessionComplete = false;
+    let sessionStartTime;
+    let sseReader;
+    // Forward termination signals
+    const forwardSignal = () => {
+        abortController.abort();
+    };
+    process.on("SIGINT", forwardSignal);
+    process.on("SIGTERM", forwardSignal);
+    try {
+        // 1. Spawn server
+        const server = await spawnServer({ cwd, signal, env: options.configEnv });
+        serverProcess = server.process;
+        serverUrl = server.url;
+        // 2. Connect to SSE and start streaming
+        const sseGenerator = streamSSE({
+            baseUrl: serverUrl,
+            directory: cwd,
+            signal,
+            onReader: (reader) => {
+                sseReader = reader;
+            },
+        });
+        // 3. Wait for server.connected event
+        const firstEvent = await sseGenerator.next();
+        if (firstEvent.done) {
+            throw new SSEConnectionError("SSE stream ended before server.connected");
+        }
+        if (firstEvent.value.type !== "server.connected") {
+            throw new SSEConnectionError(`Expected server.connected as first event, got: ${firstEvent.value.type}`);
+        }
+        // 4. Create session and send prompt
+        const session = await createSession(serverUrl, cwd);
+        sessionId = session.id;
+        sessionStartTime = Date.now();
+        await sendPrompt(serverUrl, sessionId, options.prompt, cwd, options.model);
+        // 5. Process SSE events
+        const eventProcessor = processSSEEvents(sseGenerator, {
+            serverUrl,
+            sessionId,
+            sessionStartTime,
+            requestedModel: options.model,
+            cwd,
+            signal,
+            onComplete: () => {
+                sessionComplete = true;
+            },
+            onAbort: () => {
+                sseReader?.cancel().catch(() => { });
+                abortController.abort();
+            },
+        });
+        for await (const event of eventProcessor) {
+            yield event;
+        }
+    }
+    catch (error) {
+        const errorEvent = mapErrorToEvent(error);
+        if (errorEvent) {
+            // Emit session.start if we have a session but haven't started streaming
+            if (sessionId) {
+                yield createSessionStartEvent({
+                    sessionId,
+                    timestamp: sessionStartTime ?? Date.now(),
+                    modelInfo: undefined,
+                    requestedModel: options.model,
+                });
+            }
+            yield errorEvent;
+        }
+        else {
+            throw error;
+        }
+    }
+    finally {
+        process.off("SIGINT", forwardSignal);
+        process.off("SIGTERM", forwardSignal);
+        abortController.abort();
+        await cleanupSession(serverProcess, serverUrl, sessionId, sessionComplete, sseReader, cwd);
+    }
+}
+/** Stub parser - not used in server mode */
+const noopParser = () => undefined;
+/** OpenCode adapter (server mode) */
+const openCodeAdapter = {
+    info: () => OPENCODE_INFO,
+    prepareCommand: () => ({
+        bin: resolveBinary({
+            name: "opencode",
+            command: "opencode",
+            environmentVariable: "AXEXEC_OPENCODE_PATH",
+            installHint: "npm install -g opencode-ai",
+        }),
+        args: ["serve", "--port", "0"],
+        env: {},
+    }),
+    createParser: () => noopParser,
+    isSuccess: determineSessionSuccess,
+    streamSession,
+};
+// Self-register on import
+registerAdapter(openCodeAdapter);

package/dist/agents/opencode/cleanup-session.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Session cleanup utilities for OpenCode adapter.
+ *
+ * Handles orderly shutdown of SSE connection, session abort, and server process.
+ */
+import type { ChildProcess } from "node:child_process";
+/**
+ * Cleans up session resources in the correct order.
+ *
+ * Order matters:
+ * 1. Cancel SSE reader (unblocks pending reads)
+ * 2. Abort session via API (needs server alive)
+ * 3. Dispose server instance via API (needs server alive)
+ * 4. Kill server process
+ */
+declare function cleanupSession(serverProcess: ChildProcess | undefined, serverUrl: string | undefined, sessionId: string | undefined, sessionComplete: boolean, sseReader: ReadableStreamDefaultReader<Uint8Array> | undefined, cwd: string): Promise<void>;
+export { cleanupSession };

package/dist/agents/opencode/cleanup-session.js

@@ -0,0 +1,41 @@
+/**
+ * Session cleanup utilities for OpenCode adapter.
+ *
+ * Handles orderly shutdown of SSE connection, session abort, and server process.
+ */
+import { abortSession, disposeInstance } from "./session-api.js";
+/**
+ * Cleans up session resources in the correct order.
+ *
+ * Order matters:
+ * 1. Cancel SSE reader (unblocks pending reads)
+ * 2. Abort session via API (needs server alive)
+ * 3. Dispose server instance via API (needs server alive)
+ * 4. Kill server process
+ */
+async function cleanupSession(serverProcess, serverUrl, sessionId, sessionComplete, sseReader, cwd) {
+    // Cancel SSE reader directly to unblock any pending reads
+    sseReader?.cancel().catch(() => { });
+    // Try to cleanly abort session and dispose instance BEFORE killing server
+    if (serverUrl && sessionId && !sessionComplete) {
+        await abortSession(serverUrl, sessionId, cwd);
+    }
+    if (serverUrl) {
+        await disposeInstance(serverUrl, cwd);
+    }
+    // Kill server gracefully with SIGTERM, then force with SIGKILL after timeout
+    if (!serverProcess || serverProcess.killed)
+        return;
+    serverProcess.kill("SIGTERM");
+    // Wait for process to exit (with timeout for SIGKILL escalation)
+    await new Promise((resolve) => {
+        const killTimeout = setTimeout(() => {
+            serverProcess.kill("SIGKILL");
+        }, 500);
+        serverProcess.once("exit", () => {
+            clearTimeout(killTimeout);
+            resolve();
+        });
+    });
+}
+export { cleanupSession };

package/dist/agents/opencode/create-session-start-event.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Creates a session.start event for OpenCode.
+ *
+ * Extracted to reduce complexity in the main adapter.
+ */
+import type { AxexecEvent } from "../../types/events.js";
+import type { MessageModelInfo } from "./session-api.js";
+interface SessionStartEventOptions {
+    sessionId: string;
+    timestamp: number;
+    modelInfo: MessageModelInfo | undefined;
+    requestedModel: string | undefined;
+}
+/**
+ * Creates a session.start event with model and provider info.
+ */
+declare function createSessionStartEvent(options: SessionStartEventOptions): AxexecEvent;
+export { createSessionStartEvent };

package/dist/agents/opencode/create-session-start-event.js

@@ -0,0 +1,24 @@
+/**
+ * Creates a session.start event for OpenCode.
+ *
+ * Extracted to reduce complexity in the main adapter.
+ */
+/**
+ * Creates a session.start event with model and provider info.
+ */
+function createSessionStartEvent(options) {
+    const { sessionId, timestamp, modelInfo, requestedModel } = options;
+    const model = modelInfo
+        ? `${modelInfo.providerID}/${modelInfo.modelID}`
+        : (requestedModel ?? "unknown");
+    const provider = modelInfo?.providerID;
+    return {
+        type: "session.start",
+        sessionId,
+        agent: "opencode",
+        model,
+        provider,
+        timestamp,
+    };
+}
+export { createSessionStartEvent };

package/dist/agents/opencode/detect-empty-session.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Empty session detection for OpenCode adapter.
+ *
+ * OpenCode server mode silently returns session.idle when models don't exist,
+ * credentials are missing, or other configuration issues prevent execution.
+ * This module detects these "empty sessions" and converts them to errors.
+ */
+import type { AxexecEvent } from "../../types/events.js";
+/** Tracks whether meaningful content was generated during a session */
+interface ContentTracker {
+    hasContent: boolean;
+}
+/** Creates a new content tracker */
+declare function createContentTracker(): ContentTracker;
+/** Updates tracker when content events are observed */
+declare function trackContentEvent(tracker: ContentTracker, event: AxexecEvent): void;
+/**
+ * Checks if a session.complete event should be converted to session.error.
+ *
+ * Returns an error event if the session completed without generating any
+ * content, indicating a silent failure (e.g., model not found, missing
+ * credentials, unsupported configuration).
+ */
+declare function checkEmptySession(event: AxexecEvent, tracker: ContentTracker): AxexecEvent | undefined;
+export { checkEmptySession, createContentTracker, trackContentEvent };

package/dist/agents/opencode/detect-empty-session.js

@@ -0,0 +1,42 @@
+/**
+ * Empty session detection for OpenCode adapter.
+ *
+ * OpenCode server mode silently returns session.idle when models don't exist,
+ * credentials are missing, or other configuration issues prevent execution.
+ * This module detects these "empty sessions" and converts them to errors.
+ */
+/** Creates a new content tracker */
+function createContentTracker() {
+    return { hasContent: false };
+}
+/** Updates tracker when content events are observed */
+function trackContentEvent(tracker, event) {
+    if (event.type === "agent.message" ||
+        event.type === "agent.reasoning" ||
+        event.type === "tool.call" ||
+        event.type === "tool.result") {
+        tracker.hasContent = true;
+    }
+}
+/**
+ * Checks if a session.complete event should be converted to session.error.
+ *
+ * Returns an error event if the session completed without generating any
+ * content, indicating a silent failure (e.g., model not found, missing
+ * credentials, unsupported configuration).
+ */
+function checkEmptySession(event, tracker) {
+    if (event.type !== "session.complete")
+        return undefined;
+    if (tracker.hasContent)
+        return undefined;
+    return {
+        type: "session.error",
+        code: "EMPTY_SESSION",
+        message: "Session completed without generating any output. " +
+            "This may indicate an invalid model, missing credentials, " +
+            "or an unsupported configuration.",
+        timestamp: event.timestamp,
+    };
+}
+export { checkEmptySession, createContentTracker, trackContentEvent };

package/dist/agents/opencode/map-error-to-event.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Maps OpenCode adapter errors to session.error events.
+ */
+import type { AxexecEvent } from "../../types/events.js";
+/**
+ * Maps a caught error to a session.error event, or returns undefined
+ * if the error should be rethrown.
+ */
+declare function mapErrorToEvent(error: unknown): AxexecEvent | undefined;
+export { mapErrorToEvent };

package/dist/agents/opencode/map-error-to-event.js

@@ -0,0 +1,55 @@
+/**
+ * Maps OpenCode adapter errors to session.error events.
+ */
+import { PromptSubmitError, SessionCreateError } from "./session-api.js";
+import { ServerStartError } from "./spawn-server.js";
+import { SSEConnectionError } from "./sse-client.js";
+/**
+ * Maps a caught error to a session.error event, or returns undefined
+ * if the error should be rethrown.
+ */
+function mapErrorToEvent(error) {
+    if (error instanceof ServerStartError) {
+        return {
+            type: "session.error",
+            code: "SERVER_START_ERROR",
+            message: error.message,
+            timestamp: Date.now(),
+        };
+    }
+    if (error instanceof SessionCreateError) {
+        return {
+            type: "session.error",
+            code: "SESSION_CREATE_ERROR",
+            message: error.message,
+            timestamp: Date.now(),
+        };
+    }
+    if (error instanceof PromptSubmitError) {
+        return {
+            type: "session.error",
+            code: "PROMPT_SUBMIT_ERROR",
+            message: error.message,
+            timestamp: Date.now(),
+        };
+    }
+    if (error instanceof SSEConnectionError) {
+        return {
+            type: "session.error",
+            code: "SSE_CONNECTION_ERROR",
+            message: error.message,
+            timestamp: Date.now(),
+        };
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+        return {
+            type: "session.error",
+            code: "ABORTED",
+            message: "Session aborted",
+            timestamp: Date.now(),
+        };
+    }
+    // Unknown error - should be rethrown
+    return undefined;
+}
+export { mapErrorToEvent };

package/dist/agents/opencode/parse-message-part.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Message part parsing for OpenCode SSE events.
+ *
+ * Handles parsing of message.part.updated events into AxexecEvents.
+ */
+import type { AxexecEvent } from "../../types/events.js";
+import type { MessagePartUpdatedEvent } from "./server-types.js";
+/** Aggregated session statistics */
+interface AggregatedStats {
+    costUsd: number;
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}
+/** Tool call tracking state */
+interface ToolCallState {
+    emittedToolCalls: Set<string>;
+}
+/** Parses a message.part.updated event */
+declare function parseMessagePartEvent(event: MessagePartUpdatedEvent, toolState: ToolCallState, stats: AggregatedStats): AxexecEvent[];
+export { parseMessagePartEvent };
+export type { AggregatedStats, ToolCallState };

package/dist/agents/opencode/parse-message-part.js

@@ -0,0 +1,112 @@
+/**
+ * Message part parsing for OpenCode SSE events.
+ *
+ * Handles parsing of message.part.updated events into AxexecEvents.
+ */
+/** Parses a message.part.updated event */
+function parseMessagePartEvent(event, toolState, stats) {
+    const part = event.properties.part;
+    switch (part.type) {
+        case "text": {
+            return parseTextPart(part);
+        }
+        case "reasoning": {
+            return parseReasoningPart(part);
+        }
+        case "tool": {
+            return parseToolPart(part, toolState);
+        }
+        case "step-finish": {
+            return parseStepFinishPart(part, stats);
+        }
+        case "step-start": {
+            // Ignore step-start events
+            return [];
+        }
+        default: {
+            return [];
+        }
+    }
+}
+/** Parses text part into agent.message */
+function parseTextPart(part) {
+    // Only emit when text has content and time.end is set (completed)
+    if (!part.text || !part.time?.end) {
+        return [];
+    }
+    return [
+        {
+            type: "agent.message",
+            content: part.text,
+            timestamp: Date.now(),
+        },
+    ];
+}
+/** Parses reasoning part into agent.reasoning */
+function parseReasoningPart(part) {
+    // Only emit when text has content and time.end is set (completed)
+    if (!part.text || !part.time?.end) {
+        return [];
+    }
+    return [
+        {
+            type: "agent.reasoning",
+            content: part.text,
+            timestamp: Date.now(),
+        },
+    ];
+}
+/** Parses tool part into tool.call and/or tool.result */
+function parseToolPart(part, toolState) {
+    const events = [];
+    const state = part.state;
+    // Emit tool.call when transitioning to running (or completed/error if we missed running)
+    if (!toolState.emittedToolCalls.has(part.callID) &&
+        (state.status === "running" ||
+            state.status === "completed" ||
+            state.status === "error")) {
+        toolState.emittedToolCalls.add(part.callID);
+        events.push({
+            type: "tool.call",
+            callId: part.callID,
+            tool: part.tool,
+            input: state.input,
+            timestamp: Date.now(),
+        });
+    }
+    // Emit tool.result when completed or error
+    if (state.status === "completed") {
+        events.push({
+            type: "tool.result",
+            callId: part.callID,
+            tool: part.tool,
+            output: state.output,
+            success: true,
+            timestamp: Date.now(),
+        });
+    }
+    else if (state.status === "error") {
+        events.push({
+            type: "tool.result",
+            callId: part.callID,
+            tool: part.tool,
+            output: state.error,
+            success: false,
+            timestamp: Date.now(),
+        });
+    }
+    return events;
+}
+/** Parses step-finish part to aggregate stats */
+function parseStepFinishPart(part, stats) {
+    // Aggregate stats
+    stats.costUsd += part.cost;
+    stats.inputTokens += part.tokens.input;
+    stats.outputTokens += part.tokens.output;
+    stats.reasoningTokens += part.tokens.reasoning;
+    stats.cacheReadTokens += part.tokens.cache.read;
+    stats.cacheWriteTokens += part.tokens.cache.write;
+    // step-finish doesn't produce any AxexecEvents directly
+    return [];
+}
+export { parseMessagePartEvent };

package/dist/agents/opencode/parse-sse-event.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SSE event parser for OpenCode server mode.
+ *
+ * Transforms OpenCode SSE events into normalized {@link AxexecEvent} types.
+ * This parser is stateful and tracks:
+ * - Cumulative cost/token stats from step-finish parts
+ * - Tool call state to emit tool.call/tool.result at appropriate times
+ * - Session start time for duration calculation
+ */
+import type { AxexecEvent } from "../../types/events.js";
+import type { OpenCodeSSEEvent } from "./server-types.js";
+/**
+ * Creates a parser function for SSE events.
+ *
+ * The parser maintains state across calls to:
+ * - Aggregate stats from step-finish events
+ * - Track which tool calls have been emitted
+ * - Calculate session duration
+ *
+ * @param startTimestamp - Optional timestamp when session started (for duration calculation)
+ */
+declare function createSSEEventParser(startTimestamp?: number): (event: OpenCodeSSEEvent) => AxexecEvent[];
+export { createSSEEventParser };

package/dist/agents/opencode/parse-sse-event.js

@@ -0,0 +1,125 @@
+/**
+ * SSE event parser for OpenCode server mode.
+ *
+ * Transforms OpenCode SSE events into normalized {@link AxexecEvent} types.
+ * This parser is stateful and tracks:
+ * - Cumulative cost/token stats from step-finish parts
+ * - Tool call state to emit tool.call/tool.result at appropriate times
+ * - Session start time for duration calculation
+ */
+import { isMessagePartUpdatedEvent, isPermissionUpdatedEvent, isSessionCreatedEvent, isSessionErrorEvent, isSessionIdleEvent, } from "./server-types.js";
+import { parseMessagePartEvent } from "./parse-message-part.js";
+/** Creates initial parser state */
+function createParserState() {
+    return {
+        sessionId: undefined,
+        model: "unknown",
+        startTimestamp: undefined,
+        stats: {
+            costUsd: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            reasoningTokens: 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+        },
+        toolState: {
+            emittedToolCalls: new Set(),
+        },
+    };
+}
+/**
+ * Creates a parser function for SSE events.
+ *
+ * The parser maintains state across calls to:
+ * - Aggregate stats from step-finish events
+ * - Track which tool calls have been emitted
+ * - Calculate session duration
+ *
+ * @param startTimestamp - Optional timestamp when session started (for duration calculation)
+ */
+function createSSEEventParser(startTimestamp) {
+    const state = createParserState();
+    // Use provided start timestamp if available
+    if (startTimestamp !== undefined) {
+        state.startTimestamp = startTimestamp;
+    }
+    return (event) => {
+        return parseSSEEvent(event, state);
+    };
+}
+/** Parses an SSE event into zero or more AxexecEvents */
+function parseSSEEvent(event, state) {
+    // Session lifecycle events
+    if (isSessionCreatedEvent(event)) {
+        // Skip if session.start was already emitted (startTimestamp was provided externally)
+        // This prevents duplicate session.start events when session is created via HTTP POST
+        if (state.startTimestamp !== undefined) {
+            // Just update sessionId without emitting
+            state.sessionId = event.properties.info.id;
+            return [];
+        }
+        state.sessionId = event.properties.info.id;
+        state.startTimestamp = Date.now();
+        return [
+            {
+                type: "session.start",
+                sessionId: event.properties.info.id,
+                agent: "opencode",
+                model: state.model,
+                // Provider unknown in fallback path (session.created doesn't include it)
+                timestamp: Date.now(),
+            },
+        ];
+    }
+    if (isSessionIdleEvent(event)) {
+        // Session completed - emit session.complete with aggregated stats
+        const durationMs = state.startTimestamp
+            ? Date.now() - state.startTimestamp
+            : 0;
+        return [
+            {
+                type: "session.complete",
+                stats: {
+                    durationMs,
+                    costUsd: state.stats.costUsd || undefined,
+                    inputTokens: state.stats.inputTokens || undefined,
+                    outputTokens: state.stats.outputTokens || undefined,
+                },
+                timestamp: Date.now(),
+            },
+        ];
+    }
+    if (isSessionErrorEvent(event)) {
+        const errorName = event.properties.error?.name ?? "UNKNOWN_ERROR";
+        const errorMessage = event.properties.error?.data?.message || "Unknown error occurred";
+        return [
+            {
+                type: "session.error",
+                code: errorName,
+                message: errorMessage,
+                timestamp: Date.now(),
+            },
+        ];
+    }
+    // Permission events - fail with error as per plan
+    if (isPermissionUpdatedEvent(event)) {
+        const tool = event.properties.tool ?? "unknown";
+        const { title } = event.properties;
+        return [
+            {
+                type: "session.error",
+                code: "PERMISSION_REQUIRED",
+                message: `OpenCode requires permission: ${tool}. ${title}. Pre-configure permissions in OpenCode settings.`,
+                timestamp: Date.now(),
+            },
+        ];
+    }
+    // Message part events
+    if (isMessagePartUpdatedEvent(event)) {
+        return parseMessagePartEvent(event, state.toolState, state.stats);
+    }
+    // Ignore server.connected, server.heartbeat, session.status, session.updated
+    return [];
+}
+export { createSSEEventParser };