opencode-gateway 0.1.1 → 0.2.1

package/dist/memory/prompt.js

@@ -0,0 +1,122 @@
+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/runtime/executor.d.ts

@@ -29,6 +29,7 @@ export declare class GatewayExecutor {
     private waitUntilIdle;
     private appendPrompt;
     private cleanupResidualBusySession;
+    private waitForSessionToSettle;
     private abortSessionAndWaitForSettle;
     private createInternalPromptIdentity;
     private executeDriver;

package/dist/runtime/executor.js

@@ -2,6 +2,7 @@ import { ConversationCoordinator } from "./conversation-coordinator";
 import { runOpencodeDriver } from "./opencode-runner";
 const SESSION_ABORT_SETTLE_TIMEOUT_MS = 5_000;
 const SESSION_ABORT_POLL_MS = 250;
+const SESSION_RESIDUAL_BUSY_GRACE_POLLS = 3;
 export class GatewayExecutor {
     module;
     store;
@@ -250,10 +251,10 @@ export class GatewayExecutor {
         expectCommandResult(result, "appendPrompt");
     }
     async cleanupResidualBusySession(sessionId) {
-        if (!(await this.opencode.isSessionBusy(sessionId))) {
+        if (await this.waitForSessionToSettle(sessionId, SESSION_RESIDUAL_BUSY_GRACE_POLLS)) {
             return;
         }
-        this.logger.log("warn", `aborting residual busy gateway session after prompt completion: ${sessionId}`);
+        this.logger.log("debug", `aborting residual busy gateway session after prompt completion: ${sessionId}`);
         try {
             await this.abortSessionAndWaitForSettle(sessionId);
         }
@@ -261,6 +262,17 @@ export class GatewayExecutor {
             this.logger.log("warn", `residual busy gateway session did not settle after abort: ${sessionId}: ${extractErrorMessage(error)}`);
         }
     }
+    async waitForSessionToSettle(sessionId, extraPolls) {
+        for (let attempt = 0; attempt <= extraPolls; attempt += 1) {
+            if (!(await this.opencode.isSessionBusy(sessionId))) {
+                return true;
+            }
+            if (attempt < extraPolls) {
+                await Bun.sleep(SESSION_ABORT_POLL_MS);
+            }
+        }
+        return false;
+    }
     async abortSessionAndWaitForSettle(sessionId) {
         await this.opencode.abortSession(sessionId);
         const deadline = Date.now() + SESSION_ABORT_SETTLE_TIMEOUT_MS;

package/dist/session/context.d.ts

@@ -6,5 +6,5 @@ export declare class GatewaySessionContext {
     replaceReplyTargets(sessionId: string, conversationKey: string, targets: BindingDeliveryTarget[], recordedAtMs: number): void;
     listReplyTargets(sessionId: string): BindingDeliveryTarget[];
     getDefaultReplyTarget(sessionId: string): BindingDeliveryTarget | null;
-    buildSystemPrompt(sessionId: string): string | null;
+    isGatewaySession(sessionId: string): boolean;
 }

package/dist/session/context.js

@@ -17,34 +17,7 @@ export class GatewaySessionContext {
     getDefaultReplyTarget(sessionId) {
         return this.store.getDefaultSessionReplyTarget(sessionId);
     }
-    buildSystemPrompt(sessionId) {
-        const targets = this.listReplyTargets(sessionId);
-        if (targets.length === 0) {
-            return null;
-        }
-        if (targets.length === 1) {
-            const target = targets[0];
-            return [
-                "Gateway context:",
-                `- Current message source channel: ${target.channel}`,
-                `- Current reply target id: ${target.target}`,
-                `- Current reply topic: ${target.topic ?? "none"}`,
-                "- Unless the user explicitly asks otherwise, channel-aware actions should default to this target.",
-                "- If the user asks to start a fresh channel session, use channel_new_session.",
-                "- If the user asks for a one-shot reminder or relative-time follow-up, prefer schedule_once.",
-                "- If the user asks for a recurring schedule, prefer cron_upsert.",
-                "- Use schedule_list and schedule_status to inspect existing scheduled jobs and recent run results.",
-                "- Scheduled results delivered to this channel are automatically appended to this session as context.",
-            ].join("\n");
-        }
-        return [
-            "Gateway context:",
-            `- This session currently fans out to ${targets.length} reply targets.`,
-            ...targets.map((target, index) => `- Target ${index + 1}: channel=${target.channel}, id=${target.target}, topic=${target.topic ?? "none"}`),
-            "- If a tool needs a single explicit target, do not guess; ask the user or use explicit tool arguments.",
-            "- If the user asks to start a fresh channel session for this route, use channel_new_session.",
-            "- Prefer schedule_once for one-shot reminders and cron_upsert for recurring schedules.",
-            "- Use schedule_list and schedule_status to inspect scheduled jobs and recent run results.",
-        ].join("\n");
+    isGatewaySession(sessionId) {
+        return this.store.hasGatewaySession(sessionId);
     }
 }

package/dist/session/system-prompt.d.ts

@@ -0,0 +1,8 @@
+import type { GatewayMemoryPromptProvider } from "../memory/prompt";
+import type { GatewaySessionContext } from "./context";
+export declare class GatewaySystemPromptBuilder {
+    private readonly sessions;
+    private readonly memory;
+    constructor(sessions: GatewaySessionContext, memory: GatewayMemoryPromptProvider);
+    buildPrompts(sessionId: string): Promise<string[]>;
+}

package/dist/session/system-prompt.js

@@ -0,0 +1,52 @@
+export class GatewaySystemPromptBuilder {
+    sessions;
+    memory;
+    constructor(sessions, memory) {
+        this.sessions = sessions;
+        this.memory = memory;
+    }
+    async buildPrompts(sessionId) {
+        if (!this.sessions.isGatewaySession(sessionId)) {
+            return [];
+        }
+        const prompts = [];
+        const gatewayPrompt = buildGatewayContextPrompt(this.sessions.listReplyTargets(sessionId));
+        if (gatewayPrompt !== null) {
+            prompts.push(gatewayPrompt);
+        }
+        const memoryPrompt = await this.memory.buildPrompt();
+        if (memoryPrompt !== null) {
+            prompts.push(memoryPrompt);
+        }
+        return prompts;
+    }
+}
+function buildGatewayContextPrompt(targets) {
+    if (targets.length === 0) {
+        return null;
+    }
+    if (targets.length === 1) {
+        const target = targets[0];
+        return [
+            "Gateway context:",
+            `- Current message source channel: ${target.channel}`,
+            `- Current reply target id: ${target.target}`,
+            `- Current reply topic: ${target.topic ?? "none"}`,
+            "- Unless the user explicitly asks otherwise, channel-aware actions should default to this target.",
+            "- If the user asks to start a fresh channel session, use channel_new_session.",
+            "- If the user asks for a one-shot reminder or relative-time follow-up, prefer schedule_once.",
+            "- If the user asks for a recurring schedule, prefer cron_upsert.",
+            "- Use schedule_list and schedule_status to inspect existing scheduled jobs and recent run results.",
+            "- Scheduled results delivered to this channel are automatically appended to this session as context.",
+        ].join("\n");
+    }
+    return [
+        "Gateway context:",
+        `- This session currently fans out to ${targets.length} reply targets.`,
+        ...targets.map((target, index) => `- Target ${index + 1}: channel=${target.channel}, id=${target.target}, topic=${target.topic ?? "none"}`),
+        "- If a tool needs a single explicit target, do not guess; ask the user or use explicit tool arguments.",
+        "- If the user asks to start a fresh channel session for this route, use channel_new_session.",
+        "- Prefer schedule_once for one-shot reminders and cron_upsert for recurring schedules.",
+        "- Use schedule_list and schedule_status to inspect scheduled jobs and recent run results.",
+    ].join("\n");
+}

package/dist/store/sqlite.d.ts

@@ -112,6 +112,7 @@ export declare class SqliteStore {
     replaceSessionReplyTargets(input: PersistSessionReplyTargetsInput): void;
     listSessionReplyTargets(sessionId: string): BindingDeliveryTarget[];
     getDefaultSessionReplyTarget(sessionId: string): BindingDeliveryTarget | null;
+    hasGatewaySession(sessionId: string): boolean;
     appendJournal(entry: RuntimeJournalEntry): void;
     replacePendingQuestion(input: PersistPendingQuestionInput): void;
     deletePendingQuestion(requestId: string): void;

package/dist/store/sqlite.js

@@ -109,6 +109,28 @@ export class SqliteStore {
             .get(sessionId);
         return row ? mapSessionReplyTargetRow(row) : null;
     }
+    hasGatewaySession(sessionId) {
+        const binding = this.db
+            .query(`
+                    SELECT 1 AS present
+                    FROM session_bindings
+                    WHERE session_id = ?1
+                    LIMIT 1;
+                `)
+            .get(sessionId);
+        if (binding?.present === 1) {
+            return true;
+        }
+        const replyTarget = this.db
+            .query(`
+                    SELECT 1 AS present
+                    FROM session_reply_targets
+                    WHERE session_id = ?1
+                    LIMIT 1;
+                `)
+            .get(sessionId);
+        return replyTarget?.present === 1;
+    }
     appendJournal(entry) {
         this.db
             .query(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gateway",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Gateway plugin for OpenCode",
   "license": "MIT",
   "type": "module",

package/dist/host/noop.d.ts

@@ -1,4 +0,0 @@
-import type { BindingLoggerHost } from "../binding";
-export declare class ConsoleLoggerHost implements BindingLoggerHost {
-    log(level: string, message: string): void;
-}

package/dist/host/noop.js

@@ -1,14 +0,0 @@
-export class ConsoleLoggerHost {
-    log(level, message) {
-        const line = `[gateway:${level}] ${message}`;
-        if (level === "error") {
-            console.error(line);
-            return;
-        }
-        if (level === "warn") {
-            console.warn(line);
-            return;
-        }
-        console.info(line);
-    }
-}