opencode-gateway 0.1.0

package/dist/opencode/adapter.js

@@ -0,0 +1,291 @@
+import { basename } from "node:path";
+import { pathToFileURL } from "node:url";
+const SESSION_IDLE_POLL_MS = 250;
+const PROMPT_RESPONSE_TIMEOUT_MS = 90_000;
+export class OpencodeSdkAdapter {
+    client;
+    directory;
+    constructor(client, directory) {
+        this.client = client;
+        this.directory = directory;
+    }
+    async createFreshSession(title) {
+        const session = await this.client.session.create({
+            body: { title },
+            query: { directory: this.directory },
+            responseStyle: "data",
+            throwOnError: true,
+        });
+        return unwrapData(session).id;
+    }
+    async execute(command) {
+        try {
+            switch (command.kind) {
+                case "lookupSession":
+                    return await this.lookupSession(command.sessionId);
+                case "createSession":
+                    return await this.createSession(command.title);
+                case "waitUntilIdle":
+                    return await this.waitUntilIdle(command.sessionId);
+                case "appendPrompt":
+                    return await this.appendPrompt(command);
+                case "sendPromptAsync":
+                    return await this.sendPromptAsync(command);
+                case "awaitPromptResponse":
+                    return await this.awaitPromptResponse(command);
+                case "readMessage":
+                    return await this.readMessage(command);
+                case "listMessages":
+                    return await this.listMessages(command);
+            }
+        }
+        catch (error) {
+            return toErrorResult(command, error);
+        }
+    }
+    async lookupSession(sessionId) {
+        try {
+            await this.client.session.get({
+                path: { id: sessionId },
+                query: { directory: this.directory },
+                responseStyle: "data",
+                throwOnError: true,
+            });
+            return {
+                kind: "lookupSession",
+                sessionId,
+                found: true,
+            };
+        }
+        catch (error) {
+            if (isMissingSessionError(error)) {
+                return {
+                    kind: "lookupSession",
+                    sessionId,
+                    found: false,
+                };
+            }
+            throw error;
+        }
+    }
+    async createSession(title) {
+        return {
+            kind: "createSession",
+            sessionId: await this.createFreshSession(title),
+        };
+    }
+    async waitUntilIdle(sessionId) {
+        for (;;) {
+            const statuses = await this.client.session.status({
+                query: { directory: this.directory },
+                responseStyle: "data",
+                throwOnError: true,
+            });
+            const current = unwrapData(statuses)[sessionId];
+            if (!current || current.type === "idle") {
+                return {
+                    kind: "waitUntilIdle",
+                    sessionId,
+                };
+            }
+            await Bun.sleep(SESSION_IDLE_POLL_MS);
+        }
+    }
+    async appendPrompt(command) {
+        await this.client.session.prompt({
+            path: { id: command.sessionId },
+            query: { directory: this.directory },
+            body: {
+                messageID: command.messageId,
+                noReply: true,
+                parts: command.parts.map(toSessionPromptPart),
+            },
+            responseStyle: "data",
+            throwOnError: true,
+        });
+        return {
+            kind: "appendPrompt",
+            sessionId: command.sessionId,
+        };
+    }
+    async sendPromptAsync(command) {
+        await this.client.session.promptAsync({
+            path: { id: command.sessionId },
+            query: { directory: this.directory },
+            body: {
+                messageID: command.messageId,
+                parts: command.parts.map(toSessionPromptPart),
+            },
+            throwOnError: true,
+        });
+        return {
+            kind: "sendPromptAsync",
+            sessionId: command.sessionId,
+        };
+    }
+    async awaitPromptResponse(command) {
+        const deadline = Date.now() + PROMPT_RESPONSE_TIMEOUT_MS;
+        for (;;) {
+            const messages = await this.client.session.messages({
+                path: { id: command.sessionId },
+                query: {
+                    directory: this.directory,
+                    limit: 64,
+                },
+                responseStyle: "data",
+                throwOnError: true,
+            });
+            const response = selectAssistantResponse(unwrapData(messages), command.messageId);
+            if (response !== null) {
+                return {
+                    kind: "awaitPromptResponse",
+                    sessionId: command.sessionId,
+                    messageId: response.info.id,
+                    parts: response.parts.flatMap(toBindingMessagePart),
+                };
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`assistant message for prompt ${command.messageId} is unavailable after prompt completion`);
+            }
+            await Bun.sleep(SESSION_IDLE_POLL_MS);
+        }
+    }
+    async readMessage(command) {
+        const message = await this.client.session.message({
+            path: {
+                id: command.sessionId,
+                messageID: command.messageId,
+            },
+            query: { directory: this.directory },
+            responseStyle: "data",
+            throwOnError: true,
+        });
+        return {
+            kind: "readMessage",
+            sessionId: command.sessionId,
+            messageId: command.messageId,
+            parts: unwrapData(message).parts.flatMap(toBindingMessagePart),
+        };
+    }
+    async listMessages(command) {
+        const messages = await this.client.session.messages({
+            path: { id: command.sessionId },
+            query: {
+                directory: this.directory,
+                limit: 32,
+            },
+            responseStyle: "data",
+            throwOnError: true,
+        });
+        return {
+            kind: "listMessages",
+            sessionId: command.sessionId,
+            messages: unwrapData(messages).flatMap(toBindingMessage),
+        };
+    }
+}
+function unwrapData(value) {
+    return typeof value === "object" && value !== null && "data" in value ? value.data : value;
+}
+function toSessionPromptPart(part) {
+    switch (part.kind) {
+        case "text":
+            return {
+                id: part.partId,
+                type: "text",
+                text: part.text,
+            };
+        case "file":
+            return {
+                id: part.partId,
+                type: "file",
+                mime: part.mimeType,
+                url: pathToFileURL(part.localPath).href,
+                filename: part.fileName ?? basename(part.localPath),
+            };
+    }
+}
+function selectAssistantResponse(messages, userMessageId) {
+    const assistantChildren = messages.filter(isAssistantChildMessage(userMessageId));
+    for (let index = assistantChildren.length - 1; index >= 0; index -= 1) {
+        const candidate = assistantChildren[index];
+        if (hasVisibleText(candidate)) {
+            return candidate;
+        }
+    }
+    for (let index = assistantChildren.length - 1; index >= 0; index -= 1) {
+        const candidate = assistantChildren[index];
+        if (candidate.info?.finish === "stop" || candidate.info?.error !== undefined) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function isAssistantChildMessage(userMessageId) {
+    return (message) => message.info?.role === "assistant" && message.info.parentID === userMessageId;
+}
+function toBindingMessagePart(part) {
+    if (typeof part.id !== "string" || typeof part.messageID !== "string" || part.type.length === 0) {
+        return [];
+    }
+    return [
+        {
+            messageId: part.messageID,
+            partId: part.id,
+            type: part.type,
+            text: typeof part.text === "string" ? part.text : null,
+            ignored: part.ignored === true,
+        },
+    ];
+}
+function hasVisibleText(message) {
+    return message.parts.some((part) => part.type === "text" && part.ignored !== true && typeof part.text === "string" && part.text.length > 0);
+}
+function toBindingMessage(message) {
+    if (typeof message.info?.id !== "string" ||
+        typeof message.info.role !== "string" ||
+        message.info.role.length === 0) {
+        return [];
+    }
+    return [
+        {
+            messageId: message.info.id,
+            role: message.info.role,
+            parentId: typeof message.info.parentID === "string" ? message.info.parentID : null,
+            parts: message.parts.flatMap(toBindingMessagePart),
+        },
+    ];
+}
+function toErrorResult(command, error) {
+    return {
+        kind: "error",
+        commandKind: command.kind,
+        sessionId: "sessionId" in command ? command.sessionId : null,
+        code: isMissingSessionError(error) ? "missingSession" : "unknown",
+        message: extractErrorMessage(error),
+    };
+}
+function isMissingSessionError(error) {
+    if (typeof error !== "object" || error === null) {
+        return false;
+    }
+    const name = "name" in error ? error.name : undefined;
+    const message = "data" in error ? extractDataMessage(error.data) : null;
+    return name === "NotFoundError" && message?.includes("Session not found:") === true;
+}
+function extractDataMessage(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const message = value.message;
+    return typeof message === "string" ? message : null;
+}
+function extractErrorMessage(error) {
+    if (error instanceof Error && error.message.length > 0) {
+        return error.message;
+    }
+    if (typeof error === "string" && error.length > 0) {
+        return error;
+    }
+    return "OpenCode command failed";
+}

package/dist/opencode/driver-hub.d.ts

@@ -0,0 +1,15 @@
+import type { OpencodeExecutionDriver } from "../binding";
+import { type OpencodeRuntimeEvent } from "./event-normalize";
+type TextSnapshotHandler = (text: string) => Promise<void> | void;
+export declare class OpencodeEventHub {
+    private readonly activeDrivers;
+    private nextDriverId;
+    registerDriver(sessionId: string, driver: OpencodeExecutionDriver, onPreview: TextSnapshotHandler): {
+        dispose(): void;
+        updateSession(sessionId: string): void;
+    };
+    handleEvent(event: OpencodeRuntimeEvent): void;
+    private dispatchToSession;
+    private publishDirective;
+}
+export {};

package/dist/opencode/driver-hub.js

@@ -0,0 +1,82 @@
+import { normalizeExecutionObservation } from "./event-normalize";
+export class OpencodeEventHub {
+    activeDrivers = new Map();
+    nextDriverId = 0;
+    registerDriver(sessionId, driver, onPreview) {
+        const driverId = this.nextDriverId++;
+        attachDriver(this.activeDrivers, sessionId, driverId, {
+            driver,
+            onPreview,
+        });
+        return {
+            dispose: () => {
+                detachDriver(this.activeDrivers, sessionId, driverId);
+            },
+            updateSession: (nextSessionId) => {
+                if (nextSessionId === sessionId) {
+                    return;
+                }
+                const current = this.activeDrivers.get(sessionId)?.get(driverId);
+                if (!current) {
+                    return;
+                }
+                detachDriver(this.activeDrivers, sessionId, driverId);
+                attachDriver(this.activeDrivers, nextSessionId, driverId, current);
+                sessionId = nextSessionId;
+            },
+        };
+    }
+    handleEvent(event) {
+        const observation = normalizeExecutionObservation(event);
+        if (observation === null) {
+            return;
+        }
+        if ("sessionId" in observation) {
+            this.dispatchToSession(observation.sessionId, observation);
+            return;
+        }
+        for (const drivers of this.activeDrivers.values()) {
+            for (const driver of drivers.values()) {
+                this.publishDirective(driver, driver.driver.observeEvent(observation, monotonicNowMs()));
+            }
+        }
+    }
+    dispatchToSession(sessionId, observation) {
+        const drivers = this.activeDrivers.get(sessionId);
+        if (!drivers) {
+            return;
+        }
+        for (const driver of drivers.values()) {
+            this.publishDirective(driver, driver.driver.observeEvent(observation, monotonicNowMs()));
+        }
+    }
+    publishDirective(driver, directive) {
+        if (directive.kind !== "preview" || directive.text === null) {
+            return;
+        }
+        void Promise.resolve(driver.onPreview(directive.text)).catch(() => {
+            // Preview delivery must not break the final response path.
+        });
+    }
+}
+function monotonicNowMs() {
+    return Math.trunc(performance.now());
+}
+function attachDriver(activeDrivers, sessionId, driverId, driver) {
+    let drivers = activeDrivers.get(sessionId);
+    if (!drivers) {
+        drivers = new Map();
+        activeDrivers.set(sessionId, drivers);
+    }
+    drivers.set(driverId, driver);
+}
+function detachDriver(activeDrivers, sessionId, driverId) {
+    const drivers = activeDrivers.get(sessionId);
+    if (!drivers) {
+        return;
+    }
+    drivers.delete(driverId);
+    if (drivers.size === 0) {
+        activeDrivers.delete(sessionId);
+    }
+}

package/dist/opencode/event-normalize.d.ts

@@ -0,0 +1,48 @@
+import type { BindingExecutionObservation } from "../binding";
+type MessageInfo = {
+    sessionID: string;
+    id: string;
+    role: string;
+    parentID?: string;
+} | {
+    sessionID: string;
+    id: string;
+    role: "assistant";
+    parentID: string;
+};
+type MessageUpdatedEvent = {
+    type: "message.updated";
+    properties: {
+        info: MessageInfo;
+    };
+};
+type MessagePart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: string;
+    text?: string | null;
+    ignored?: boolean;
+};
+type MessagePartUpdatedEvent = {
+    type: "message.part.updated";
+    properties: {
+        part: MessagePart;
+        delta?: string;
+    };
+};
+type MessagePartDeltaEvent = {
+    type: "message.part.delta";
+    properties: {
+        messageID: string;
+        partID: string;
+        field: string;
+        delta: string;
+    };
+};
+export type OpencodeRuntimeEvent = MessageUpdatedEvent | MessagePartUpdatedEvent | MessagePartDeltaEvent | {
+    type: string;
+    properties?: unknown;
+};
+export declare function normalizeExecutionObservation(event: OpencodeRuntimeEvent): BindingExecutionObservation | null;
+export {};

package/dist/opencode/event-normalize.js

@@ -0,0 +1,48 @@
+export function normalizeExecutionObservation(event) {
+    if (isMessageUpdatedEvent(event)) {
+        const info = event.properties.info;
+        return {
+            kind: "messageUpdated",
+            sessionId: info.sessionID,
+            messageId: info.id,
+            role: info.role,
+            parentId: typeof info.parentID === "string" ? info.parentID : null,
+        };
+    }
+    if (isMessagePartUpdatedEvent(event)) {
+        const part = event.properties.part;
+        if (part.type !== "text") {
+            return null;
+        }
+        return {
+            kind: "textPartUpdated",
+            sessionId: part.sessionID,
+            messageId: part.messageID,
+            partId: part.id,
+            text: typeof part.text === "string" ? part.text : null,
+            delta: typeof event.properties.delta === "string" ? event.properties.delta : null,
+            ignored: part.ignored === true,
+        };
+    }
+    if (isMessagePartDeltaEvent(event)) {
+        if (event.properties.field !== "text" || event.properties.delta.length === 0) {
+            return null;
+        }
+        return {
+            kind: "textPartDelta",
+            messageId: event.properties.messageID,
+            partId: event.properties.partID,
+            delta: event.properties.delta,
+        };
+    }
+    return null;
+}
+function isMessageUpdatedEvent(event) {
+    return event.type === "message.updated" && typeof event.properties === "object" && event.properties !== null;
+}
+function isMessagePartUpdatedEvent(event) {
+    return event.type === "message.part.updated" && typeof event.properties === "object" && event.properties !== null;
+}
+function isMessagePartDeltaEvent(event) {
+    return event.type === "message.part.delta" && typeof event.properties === "object" && event.properties !== null;
+}

package/dist/opencode/event-stream.d.ts

@@ -0,0 +1,23 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { BindingLoggerHost } from "../binding";
+import type { OpencodeEventHub, OpencodeRuntimeEvent } from "./events";
+export declare class OpencodeEventStream {
+    private readonly client;
+    private readonly directory;
+    private readonly hub;
+    private readonly consumers;
+    private readonly logger;
+    private running;
+    private connected;
+    private lastError;
+    constructor(client: OpencodeClient, directory: string, hub: OpencodeEventHub, consumers: OpencodeEventConsumerLike[], logger: BindingLoggerHost);
+    isConnected(): boolean;
+    lastStreamError(): string | null;
+    start(): void;
+    stop(): void;
+    private runLoop;
+}
+type OpencodeEventConsumerLike = {
+    handleEvent(event: OpencodeRuntimeEvent): void;
+};
+export {};

package/dist/opencode/event-stream.js

@@ -0,0 +1,65 @@
+import { formatError } from "../utils/error";
+const RECONNECT_DELAY_MS = 1_000;
+export class OpencodeEventStream {
+    client;
+    directory;
+    hub;
+    consumers;
+    logger;
+    running = false;
+    connected = false;
+    lastError = null;
+    constructor(client, directory, hub, consumers, logger) {
+        this.client = client;
+        this.directory = directory;
+        this.hub = hub;
+        this.consumers = consumers;
+        this.logger = logger;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    lastStreamError() {
+        return this.lastError;
+    }
+    start() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        void this.runLoop();
+    }
+    stop() {
+        this.running = false;
+    }
+    async runLoop() {
+        while (this.running) {
+            try {
+                const events = await this.client.event.subscribe({
+                    query: { directory: this.directory },
+                    onSseError: (error) => {
+                        this.connected = false;
+                        this.lastError = formatError(error);
+                    },
+                });
+                this.connected = true;
+                this.lastError = null;
+                for await (const event of events.stream) {
+                    const runtimeEvent = event;
+                    this.hub.handleEvent(runtimeEvent);
+                    for (const consumer of this.consumers) {
+                        consumer.handleEvent(runtimeEvent);
+                    }
+                }
+            }
+            catch (error) {
+                this.lastError = formatError(error);
+                this.logger.log("warn", `opencode event stream failed: ${this.lastError}`);
+            }
+            finally {
+                this.connected = false;
+            }
+            await Bun.sleep(RECONNECT_DELAY_MS);
+        }
+    }
+}

package/dist/opencode/events.d.ts

@@ -0,0 +1,2 @@
+export { OpencodeEventHub } from "./driver-hub";
+export type { OpencodeRuntimeEvent } from "./event-normalize";

package/dist/opencode/events.js

@@ -0,0 +1 @@
+export { OpencodeEventHub } from "./driver-hub";

package/dist/questions/client.d.ts

@@ -0,0 +1,5 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
+type GatewayPluginClient = PluginInput["client"];
+export declare function createQuestionClient(client: GatewayPluginClient, serverUrl: URL, directory: string): ReturnType<typeof createOpencodeClient>;
+export {};

package/dist/questions/client.js

@@ -0,0 +1,36 @@
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
+export function createQuestionClient(client, serverUrl, directory) {
+    const snapshot = readClientConfig(client);
+    return createOpencodeClient({
+        baseUrl: snapshot.baseUrl ?? serverUrl.toString(),
+        directory,
+        headers: stripManagedHeaders(snapshot.headers),
+    });
+}
+function readClientConfig(client) {
+    const configReader = client._client?.getConfig;
+    if (typeof configReader !== "function") {
+        return {};
+    }
+    return configReader() ?? {};
+}
+function stripManagedHeaders(headers) {
+    if (headers === undefined) {
+        return undefined;
+    }
+    const normalized = new Headers(toHeadersInit(headers));
+    normalized.delete("x-opencode-directory");
+    const result = Object.fromEntries(normalized.entries());
+    return Object.keys(result).length === 0 ? undefined : result;
+}
+function toHeadersInit(headers) {
+    if (headers instanceof Headers || Array.isArray(headers)) {
+        return headers;
+    }
+    if (typeof headers === "object" && headers !== null) {
+        return Object.fromEntries(Object.entries(headers)
+            .filter((entry) => typeof entry[1] === "string")
+            .map(([key, value]) => [key, value]));
+    }
+    return {};
+}

package/dist/questions/format.d.ts

@@ -0,0 +1,3 @@
+import type { GatewayQuestionRequest } from "./types";
+export declare function formatPlainTextQuestion(request: GatewayQuestionRequest): string;
+export declare function formatQuestionReplyError(request: GatewayQuestionRequest, message: string): string;

package/dist/questions/format.js

@@ -0,0 +1,36 @@
+export function formatPlainTextQuestion(request) {
+    return [
+        "OpenCode needs additional input before it can continue.",
+        "",
+        ...request.questions.flatMap((question, index) => formatQuestionBlock(question, index)),
+        formatReplyInstructions(request.questions),
+    ].join("\n");
+}
+export function formatQuestionReplyError(request, message) {
+    return [message, "", formatReplyInstructions(request.questions)].join("\n");
+}
+function formatQuestionBlock(question, index) {
+    const label = `Question ${index + 1}: ${question.header}`;
+    const options = question.options.length === 0
+        ? []
+        : [
+            "Options:",
+            ...question.options.map((option, optionIndex) => `${optionIndex + 1}. ${option.label} - ${option.description}`),
+        ];
+    return [label, question.question, ...options, ""];
+}
+function formatReplyInstructions(questions) {
+    if (questions.length === 1) {
+        const question = questions[0];
+        const selectionHint = question.multiple
+            ? "Reply with one line. You may send option numbers or labels separated by commas."
+            : "Reply with one line. You may send an option number, an option label, or custom text.";
+        return ["How to reply:", `- ${selectionHint}`, "- Reply /cancel to reject this question."].join("\n");
+    }
+    return [
+        "How to reply:",
+        "- Reply with one non-empty line per question, in order.",
+        "- Each line may use option numbers, option labels, or custom text when allowed.",
+        "- Reply /cancel to reject this question.",
+    ].join("\n");
+}

package/dist/questions/normalize.d.ts

@@ -0,0 +1,10 @@
+import type { OpencodeRuntimeEvent } from "../opencode/events";
+import type { GatewayQuestionRequest } from "./types";
+export type GatewayQuestionEvent = {
+    kind: "asked";
+    request: GatewayQuestionRequest;
+} | {
+    kind: "resolved";
+    requestId: string;
+};
+export declare function normalizeQuestionEvent(event: OpencodeRuntimeEvent): GatewayQuestionEvent | null;