opencode-gateway 0.2.3 → 0.2.4

package/dist/memory/prompt.js

@@ -1,122 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { extname, relative } from "node:path";
-const MARKDOWN_GLOBS = ["**/*.md", "**/*.markdown"];
-const UTF8_TEXT_DECODER = new TextDecoder("utf-8", { fatal: true });
-export class GatewayMemoryPromptProvider {
-    config;
-    logger;
-    constructor(config, logger) {
-        this.config = config;
-        this.logger = logger;
-    }
-    async buildPrompt() {
-        if (this.config.entries.length === 0) {
-            return null;
-        }
-        const sections = await Promise.all(this.config.entries.map((entry) => this.buildEntrySection(entry)));
-        return ["Gateway memory:", ...sections].join("\n\n");
-    }
-    async buildEntrySection(entry) {
-        const lines = [`Configured path: ${entry.displayPath}`, `Description: ${entry.description}`];
-        const injectedFiles = await collectInjectedFiles(entry, this.logger);
-        for (const file of injectedFiles) {
-            lines.push("");
-            lines.push(`File: ${file.displayPath}`);
-            lines.push(codeFence(file.infoString, file.text));
-        }
-        return lines.join("\n");
-    }
-}
-async function collectInjectedFiles(entry, logger) {
-    if (entry.kind === "file") {
-        if (!entry.injectContent) {
-            return [];
-        }
-        const text = await readTextFile(entry.path, logger);
-        if (text === null) {
-            return [];
-        }
-        return [
-            {
-                displayPath: entry.displayPath,
-                infoString: inferFenceInfoString(entry.path),
-                text,
-            },
-        ];
-    }
-    const filePaths = new Set();
-    if (entry.injectMarkdownContents) {
-        for (const pattern of MARKDOWN_GLOBS) {
-            addMatchingFiles(filePaths, entry.path, pattern);
-        }
-    }
-    for (const pattern of entry.globs) {
-        addMatchingFiles(filePaths, entry.path, pattern);
-    }
-    const injectedFiles = [];
-    for (const filePath of [...filePaths].sort((left, right) => left.localeCompare(right))) {
-        const text = await readTextFile(filePath, logger);
-        if (text === null) {
-            continue;
-        }
-        injectedFiles.push({
-            displayPath: relativeDisplayPath(entry.path, entry.displayPath, filePath),
-            infoString: inferFenceInfoString(filePath),
-            text,
-        });
-    }
-    return injectedFiles;
-}
-function addMatchingFiles(result, cwd, pattern) {
-    const glob = new Bun.Glob(pattern);
-    for (const match of glob.scanSync({ cwd, absolute: true, onlyFiles: true })) {
-        result.add(match);
-    }
-}
-async function readTextFile(path, logger) {
-    let bytes;
-    try {
-        bytes = await readFile(path);
-    }
-    catch (error) {
-        logger.log("warn", `memory file could not be read and will be skipped: ${path}: ${formatError(error)}`);
-        return null;
-    }
-    let text;
-    try {
-        text = UTF8_TEXT_DECODER.decode(bytes);
-    }
-    catch {
-        logger.log("warn", `memory file is not valid UTF-8 and will be skipped: ${path}`);
-        return null;
-    }
-    if (text.includes("\u0000")) {
-        logger.log("warn", `memory file looks binary and will be skipped: ${path}`);
-        return null;
-    }
-    return text;
-}
-function relativeDisplayPath(rootPath, rootDisplayPath, filePath) {
-    const suffix = relative(rootPath, filePath);
-    if (suffix.length === 0) {
-        return rootDisplayPath;
-    }
-    return `${rootDisplayPath}/${suffix.replaceAll("\\", "/")}`;
-}
-function inferFenceInfoString(path) {
-    const extension = extname(path).slice(1).toLowerCase();
-    if (!/^[a-z0-9_+-]+$/.test(extension)) {
-        return "";
-    }
-    return extension;
-}
-function codeFence(infoString, text) {
-    const language = infoString.length === 0 ? "" : infoString;
-    return [`\`\`\`${language}`, text, "```"].join("\n");
-}
-function formatError(error) {
-    if (error instanceof Error && error.message.trim().length > 0) {
-        return error.message;
-    }
-    return String(error);
-}

package/dist/opencode/adapter.js

@@ -1,340 +0,0 @@
-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 isSessionBusy(sessionId) {
-        const statuses = await this.client.session.status({
-            query: { directory: this.directory },
-            responseStyle: "data",
-            throwOnError: true,
-        });
-        const current = unwrapData(statuses)[sessionId];
-        return current?.type === "busy";
-    }
-    async abortSession(sessionId) {
-        try {
-            await this.client.session.abort({
-                path: { id: sessionId },
-                query: { directory: this.directory },
-                responseStyle: "data",
-                throwOnError: true,
-            });
-        }
-        catch (error) {
-            if (isMissingSessionError(error)) {
-                return;
-            }
-            throw error;
-        }
-    }
-    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;
-        let stableCandidateKey = null;
-        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) {
-                const candidateKey = createAssistantCandidateKey(response);
-                if (stableCandidateKey === candidateKey) {
-                    return {
-                        kind: "awaitPromptResponse",
-                        sessionId: command.sessionId,
-                        messageId: response.info.id,
-                        parts: response.parts.flatMap(toBindingMessagePart),
-                    };
-                }
-                stableCandidateKey = candidateKey;
-            }
-            else {
-                stableCandidateKey = null;
-            }
-            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 createAssistantCandidateKey(message) {
-    return JSON.stringify({
-        messageId: message.info.id,
-        finish: message.info.finish ?? null,
-        hasError: message.info.error !== undefined,
-        parts: message.parts.map((part) => ({
-            id: part.id ?? null,
-            type: part.type,
-            text: typeof part.text === "string" ? part.text : null,
-            ignored: part.ignored === true,
-        })),
-    });
-}
-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.trim().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.js

@@ -1,82 +0,0 @@
-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.js

@@ -1,48 +0,0 @@
-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.js

@@ -1,65 +0,0 @@
-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.js

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

package/dist/questions/client.js

@@ -1,36 +0,0 @@
-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 {};
-}