opencode-gateway 0.1.1 → 0.2.1

package/README.md

@@ -12,13 +12,14 @@ npx opencode-gateway init
 
 This ensures:
 
-- `plugin: ["opencode-gateway"]` exists in `opencode.json`
-- `opencode-gateway.toml` exists next to `opencode.json`
+- `plugin` contains `opencode-gateway@latest`
+- `opencode-gateway.toml` exists next to the preferred OpenCode config file
 
 By default the CLI uses `OPENCODE_CONFIG_DIR` when it is set, otherwise it
 writes to:
 
-- `~/.config/opencode/opencode.json`
+- an existing `~/.config/opencode/opencode.jsonc` or `~/.config/opencode/opencode.json`
+- otherwise a new `~/.config/opencode/opencode.jsonc`
 - `~/.config/opencode/opencode-gateway.toml`
 
 Check what it resolved:
@@ -48,6 +49,7 @@ opencode serve
 ```toml
 [gateway]
 state_db = "/home/you/.local/share/opencode-gateway/state.db"
+# log_level = "warn"
 
 [cron]
 enabled = true
@@ -60,6 +62,17 @@ bot_token_env = "TELEGRAM_BOT_TOKEN"
 poll_timeout_seconds = 25
 allowed_chats = []
 allowed_users = []
+
+[[memory.entries]]
+path = "memory/project.md"
+description = "Project conventions and long-lived context"
+inject_content = true
+
+[[memory.entries]]
+path = "memory/notes"
+description = "Domain notes and operating docs"
+inject_markdown_contents = true
+globs = ["**/*.rs", "notes/**/*.txt"]
 ```
 
 When Telegram is enabled, export the bot token through the configured
@@ -68,3 +81,17 @@ environment variable, for example:
 ```bash
 export TELEGRAM_BOT_TOKEN="..."
 ```
+
+Gateway plugin logs are off by default. Set `gateway.log_level` to `error`,
+`warn`, `info`, or `debug` to emit that level and anything above it.
+
+Memory rules:
+
+- all entries inject their configured path and description
+- file contents are injected only when `inject_content = true`
+- directory entries default to description-only
+- `inject_markdown_contents = true` recursively injects `*.md` and `*.markdown`
+- `globs` are relative to the configured directory and may match other UTF-8
+  text files
+- relative paths are resolved from `opencode-gateway.toml`
+- memory is injected only into gateway-managed sessions

package/dist/binding/gateway.d.ts

@@ -60,8 +60,9 @@ export type BindingOutboundMessage = {
 export type BindingTransportHost = {
     sendMessage(message: BindingOutboundMessage): Promise<BindingHostAck>;
 };
+export type BindingLogLevel = "debug" | "info" | "warn" | "error";
 export type BindingLoggerHost = {
-    log(level: string, message: string): void;
+    log(level: BindingLogLevel, message: string): void;
 };
 export type GatewayContract = {
     gatewayStatus(): GatewayStatusSnapshot;

package/dist/binding/index.d.ts

@@ -1,7 +1,7 @@
 import type { BindingCronJobSpec, BindingInboundMessage, BindingPreparedExecution, GatewayContract } from "./gateway";
 import type { BindingOpencodeExecutionInput, OpencodeExecutionDriver } from "./opencode";
 export type { BindingExecutionObservation, BindingProgressiveDirective } from "./execution";
-export type { BindingCronJobSpec, BindingDeliveryTarget, BindingHostAck, BindingInboundAttachment, BindingInboundMessage, BindingLoggerHost, BindingOutboundMessage, BindingPreparedExecution, BindingPromptPart, BindingRuntimeReport, BindingTransportHost, GatewayContract, GatewayStatusSnapshot, } from "./gateway";
+export type { BindingCronJobSpec, BindingDeliveryTarget, BindingHostAck, BindingInboundAttachment, BindingInboundMessage, BindingLoggerHost, BindingLogLevel, BindingOutboundMessage, BindingPreparedExecution, BindingPromptPart, BindingRuntimeReport, BindingTransportHost, GatewayContract, GatewayStatusSnapshot, } from "./gateway";
 export type { BindingOpencodeCommand, BindingOpencodeCommandPart, BindingOpencodeCommandResult, BindingOpencodeDriverStep, BindingOpencodeExecutionInput, BindingOpencodeMessage, BindingOpencodeMessagePart, BindingOpencodePrompt, OpencodeExecutionDriver, } from "./opencode";
 export type GatewayBindingModule = GatewayContract & {
     prepareInboundExecution: (message: BindingInboundMessage) => BindingPreparedExecution;

package/dist/cli/doctor.js

@@ -1,18 +1,19 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { GATEWAY_CONFIG_FILE, OPENCODE_CONFIG_FILE, resolveGatewayWorkspacePath } from "../config/paths";
-import { parseOpencodeConfig } from "./opencode-config";
+import { GATEWAY_CONFIG_FILE, resolveGatewayWorkspacePath } from "../config/paths";
+import { inspectGatewayPlugin, parseOpencodeConfig } from "./opencode-config";
+import { resolveOpencodeConfigFile } from "./opencode-config-file";
 import { pathExists, resolveCliConfigDir } from "./paths";
 export async function runDoctor(options, env) {
     const configDir = resolveCliConfigDir(options, env);
-    const opencodeConfigPath = join(configDir, OPENCODE_CONFIG_FILE);
     const gatewayConfigPath = join(configDir, GATEWAY_CONFIG_FILE);
     const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
-    const opencodeStatus = await inspectOpencodeConfig(opencodeConfigPath);
+    const opencodeConfig = await resolveOpencodeConfigFile(configDir);
+    const opencodeStatus = await inspectOpencodeConfig(opencodeConfig.path);
     const gatewayOverride = env.OPENCODE_GATEWAY_CONFIG?.trim() || null;
     console.log("doctor report");
     console.log(`  config dir: ${configDir}`);
-    console.log(`  opencode config: ${await describePath(opencodeConfigPath)}`);
+    console.log(`  opencode config: ${await describePath(opencodeConfig.path)}`);
     console.log(`  gateway config: ${await describePath(gatewayConfigPath)}`);
     console.log(`  gateway workspace: ${await describePath(workspaceDirPath)}`);
     console.log(`  gateway config override: ${gatewayOverride ?? "not set"}`);
@@ -34,21 +35,8 @@ async function inspectOpencodeConfig(path) {
     }
     try {
         const parsed = parseOpencodeConfig(await readFile(path, "utf8"), path);
-        const plugins = parsed.plugin;
-        if (plugins === undefined) {
-            return {
-                pluginConfigured: "no",
-                error: null,
-            };
-        }
-        if (!Array.isArray(plugins)) {
-            return {
-                pluginConfigured: "invalid",
-                error: "`plugin` is not an array",
-            };
-        }
         return {
-            pluginConfigured: plugins.some((entry) => entry === "opencode-gateway") ? "yes" : "no",
+            pluginConfigured: inspectGatewayPlugin(parsed),
             error: null,
         };
     }

package/dist/cli/init.js

@@ -1,18 +1,20 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { defaultGatewayStateDbPath, GATEWAY_CONFIG_FILE, OPENCODE_CONFIG_FILE, resolveGatewayWorkspacePath, } from "../config/paths";
+import { defaultGatewayStateDbPath, GATEWAY_CONFIG_FILE, resolveGatewayWorkspacePath } from "../config/paths";
 import { createDefaultOpencodeConfig, ensureGatewayPlugin, parseOpencodeConfig, stringifyOpencodeConfig, } from "./opencode-config";
+import { resolveOpencodeConfigFile } from "./opencode-config-file";
 import { pathExists, resolveCliConfigDir } from "./paths";
 import { buildGatewayConfigTemplate } from "./templates";
 export async function runInit(options, env) {
     const configDir = resolveCliConfigDir(options, env);
-    const opencodeConfigPath = join(configDir, OPENCODE_CONFIG_FILE);
     const gatewayConfigPath = join(configDir, GATEWAY_CONFIG_FILE);
     const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
+    const opencodeConfig = await resolveOpencodeConfigFile(configDir);
+    const opencodeConfigPath = opencodeConfig.path;
     await mkdir(configDir, { recursive: true });
     await mkdir(workspaceDirPath, { recursive: true });
     let opencodeStatus = "already present";
-    if (!(await pathExists(opencodeConfigPath))) {
+    if (!opencodeConfig.exists) {
         await writeFile(opencodeConfigPath, stringifyOpencodeConfig(createDefaultOpencodeConfig(options.managed)));
         opencodeStatus = "created";
     }

package/dist/cli/opencode-config-file.d.ts

@@ -0,0 +1,5 @@
+export type ResolvedOpencodeConfigFile = {
+    path: string;
+    exists: boolean;
+};
+export declare function resolveOpencodeConfigFile(configDir: string): Promise<ResolvedOpencodeConfigFile>;

package/dist/cli/opencode-config-file.js

@@ -0,0 +1,18 @@
+import { join } from "node:path";
+import { OPENCODE_CONFIG_FILE_CANDIDATES, OPENCODE_CONFIG_FILE_JSONC } from "../config/paths";
+import { pathExists } from "./paths";
+export async function resolveOpencodeConfigFile(configDir) {
+    for (const fileName of OPENCODE_CONFIG_FILE_CANDIDATES) {
+        const path = join(configDir, fileName);
+        if (await pathExists(path)) {
+            return {
+                path,
+                exists: true,
+            };
+        }
+    }
+    return {
+        path: join(configDir, OPENCODE_CONFIG_FILE_JSONC),
+        exists: false,
+    };
+}

package/dist/cli/opencode-config.d.ts

@@ -3,8 +3,10 @@ export type EnsurePluginResult = {
     changed: boolean;
     document: OpencodeConfigDocument;
 };
+export type GatewayPluginStatus = "yes" | "no" | "needs_update";
 export declare function createDefaultOpencodeConfig(managed: boolean): OpencodeConfigDocument;
 export declare function ensureGatewayPlugin(document: OpencodeConfigDocument): EnsurePluginResult;
 export declare function parseOpencodeConfig(source: string, path: string): OpencodeConfigDocument;
 export declare function stringifyOpencodeConfig(document: OpencodeConfigDocument): string;
+export declare function inspectGatewayPlugin(document: OpencodeConfigDocument): GatewayPluginStatus;
 export {};

package/dist/cli/opencode-config.js

@@ -1,9 +1,10 @@
 const OPENCODE_SCHEMA_URL = "https://opencode.ai/config.json";
 const PACKAGE_NAME = "opencode-gateway";
+const PACKAGE_SPEC = "opencode-gateway@latest";
 export function createDefaultOpencodeConfig(managed) {
     const document = {
         $schema: OPENCODE_SCHEMA_URL,
-        plugin: [PACKAGE_NAME],
+        plugin: [PACKAGE_SPEC],
     };
     if (managed) {
         document.server = {
@@ -14,20 +15,17 @@ export function createDefaultOpencodeConfig(managed) {
     return document;
 }
 export function ensureGatewayPlugin(document) {
-    const plugins = document.plugin;
+    const plugins = readPluginArray(document);
     if (plugins === undefined) {
         return {
             changed: true,
             document: {
                 ...document,
-                plugin: [PACKAGE_NAME],
+                plugin: [PACKAGE_SPEC],
             },
         };
     }
-    if (!Array.isArray(plugins)) {
-        throw new Error("opencode.json field `plugin` must be an array when present");
-    }
-    if (plugins.some((entry) => entry === PACKAGE_NAME)) {
+    if (plugins.includes(PACKAGE_SPEC)) {
         return {
             changed: false,
             document,
@@ -37,14 +35,14 @@ export function ensureGatewayPlugin(document) {
         changed: true,
         document: {
             ...document,
-            plugin: [...plugins, PACKAGE_NAME],
+            plugin: [...plugins, PACKAGE_SPEC],
         },
     };
 }
 export function parseOpencodeConfig(source, path) {
     let parsed;
     try {
-        parsed = JSON.parse(source);
+        parsed = JSON.parse(toStrictJson(source));
     }
     catch (error) {
         throw new Error(`failed to parse opencode config ${path}: ${formatError(error)}`);
@@ -57,6 +55,140 @@ export function parseOpencodeConfig(source, path) {
 export function stringifyOpencodeConfig(document) {
     return `${JSON.stringify(document, null, 2)}\n`;
 }
+export function inspectGatewayPlugin(document) {
+    const plugins = readPluginArray(document);
+    if (plugins === undefined) {
+        return "no";
+    }
+    if (plugins.includes(PACKAGE_SPEC)) {
+        return "yes";
+    }
+    return plugins.some((entry) => isGatewayPluginReference(entry)) ? "needs_update" : "no";
+}
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function readPluginArray(document) {
+    const plugins = document.plugin;
+    if (plugins === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(plugins)) {
+        throw new Error("opencode config field `plugin` must be an array when present");
+    }
+    const normalized = [];
+    for (const [index, entry] of plugins.entries()) {
+        if (typeof entry !== "string") {
+            throw new Error(`opencode config field \`plugin[${index}]\` must be a string`);
+        }
+        normalized.push(entry);
+    }
+    return normalized;
+}
+function toStrictJson(source) {
+    return stripTrailingCommas(stripJsonComments(source));
+}
+function stripJsonComments(source) {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const current = source[index];
+        const next = source[index + 1];
+        if (inLineComment) {
+            if (current === "\n") {
+                inLineComment = false;
+                result += current;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (current === "*" && next === "/") {
+                inBlockComment = false;
+                index += 1;
+            }
+            else if (current === "\n") {
+                result += current;
+            }
+            continue;
+        }
+        if (inString) {
+            result += current;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (current === "\\") {
+                escaped = true;
+            }
+            else if (current === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (current === '"') {
+            inString = true;
+            result += current;
+            continue;
+        }
+        if (current === "/" && next === "/") {
+            inLineComment = true;
+            index += 1;
+            continue;
+        }
+        if (current === "/" && next === "*") {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+        result += current;
+    }
+    return result;
+}
+function stripTrailingCommas(source) {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const current = source[index];
+        if (inString) {
+            result += current;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (current === "\\") {
+                escaped = true;
+            }
+            else if (current === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (current === '"') {
+            inString = true;
+            result += current;
+            continue;
+        }
+        if (current === ",") {
+            const nextSignificant = findNextSignificantCharacter(source, index + 1);
+            if (nextSignificant === "]" || nextSignificant === "}") {
+                continue;
+            }
+        }
+        result += current;
+    }
+    return result;
+}
+function findNextSignificantCharacter(source, startIndex) {
+    for (let index = startIndex; index < source.length; index += 1) {
+        const current = source[index];
+        if (!/\s/.test(current)) {
+            return current;
+        }
+    }
+    return null;
+}
+function isGatewayPluginReference(entry) {
+    return entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`);
+}

package/dist/cli/templates.js

@@ -5,6 +5,7 @@ export function buildGatewayConfigTemplate(stateDbPath) {
         "",
         "[gateway]",
         `state_db = "${escapeTomlString(stateDbPath)}"`,
+        '# log_level = "warn"',
         "",
         "[cron]",
         "enabled = true",
@@ -19,6 +20,20 @@ export function buildGatewayConfigTemplate(stateDbPath) {
         "allowed_chats = []",
         "allowed_users = []",
         "",
+        "# Optional long-lived memory sources injected into gateway-managed sessions.",
+        "# Relative paths are resolved from this config file.",
+        "#",
+        "# [[memory.entries]]",
+        '# path = "memory/project.md"',
+        '# description = "Project conventions and long-lived context"',
+        "# inject_content = true",
+        "#",
+        "# [[memory.entries]]",
+        '# path = "memory/notes"',
+        '# description = "Domain notes and operating docs"',
+        "# inject_markdown_contents = true",
+        '# globs = ["**/*.rs", "notes/**/*.txt"]',
+        "",
     ].join("\n");
 }
 function escapeTomlString(value) {