opencode-gateway 0.2.0 → 0.2.2

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:
@@ -92,5 +93,6 @@ Memory rules:
 - `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`
+- relative paths are resolved from `opencode-gateway-workspace`
+- absolute paths are still allowed
 - memory is injected only into gateway-managed sessions

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

@@ -21,7 +21,7 @@ export function buildGatewayConfigTemplate(stateDbPath) {
         "allowed_users = []",
         "",
         "# Optional long-lived memory sources injected into gateway-managed sessions.",
-        "# Relative paths are resolved from this config file.",
+        "# Relative paths are resolved from opencode-gateway-workspace.",
         "#",
         "# [[memory.entries]]",
         '# path = "memory/project.md"',

package/dist/cli.js

@@ -58,13 +58,15 @@ function formatCliHelp() {
 
 // src/cli/doctor.ts
 import { readFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 
 // src/config/paths.ts
 import { homedir } from "node:os";
 import { dirname, join, resolve as resolve2 } from "node:path";
 var GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
 var OPENCODE_CONFIG_FILE = "opencode.json";
+var OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
+var OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
 var GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
 function resolveOpencodeConfigDir(env) {
   const explicit = env.OPENCODE_CONFIG_DIR;
@@ -95,10 +97,11 @@ function defaultOpencodeConfigDir(env) {
 // src/cli/opencode-config.ts
 var OPENCODE_SCHEMA_URL = "https://opencode.ai/config.json";
 var PACKAGE_NAME = "opencode-gateway";
+var PACKAGE_SPEC = "opencode-gateway@latest";
 function createDefaultOpencodeConfig(managed) {
   const document = {
     $schema: OPENCODE_SCHEMA_URL,
-    plugin: [PACKAGE_NAME]
+    plugin: [PACKAGE_SPEC]
   };
   if (managed) {
     document.server = {
@@ -109,20 +112,17 @@ function createDefaultOpencodeConfig(managed) {
   return document;
 }
 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
@@ -132,14 +132,14 @@ function ensureGatewayPlugin(document) {
     changed: true,
     document: {
       ...document,
-      plugin: [...plugins, PACKAGE_NAME]
+      plugin: [...plugins, PACKAGE_SPEC]
     }
   };
 }
 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)}`);
   }
@@ -152,9 +152,143 @@ function stringifyOpencodeConfig(document) {
   return `${JSON.stringify(document, null, 2)}
 `;
 }
+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;
+  }
+  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 === `
+`) {
+        inLineComment = false;
+        result += current;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (current === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+      } else if (current === `
+`) {
+        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}@`);
+}
+
+// src/cli/opencode-config-file.ts
+import { join as join2 } from "node:path";
 
 // src/cli/paths.ts
 import { constants } from "node:fs";
@@ -178,17 +312,34 @@ async function pathExists(path) {
   }
 }
 
+// src/cli/opencode-config-file.ts
+async function resolveOpencodeConfigFile(configDir) {
+  for (const fileName of OPENCODE_CONFIG_FILE_CANDIDATES) {
+    const path = join2(configDir, fileName);
+    if (await pathExists(path)) {
+      return {
+        path,
+        exists: true
+      };
+    }
+  }
+  return {
+    path: join2(configDir, OPENCODE_CONFIG_FILE_JSONC),
+    exists: false
+  };
+}
+
 // src/cli/doctor.ts
 async function runDoctor(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const opencodeConfigPath = join2(configDir, OPENCODE_CONFIG_FILE);
-  const gatewayConfigPath = join2(configDir, GATEWAY_CONFIG_FILE);
+  const gatewayConfigPath = join3(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"}`);
@@ -210,21 +361,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
     };
   } catch (error) {
@@ -237,7 +375,7 @@ async function inspectOpencodeConfig(path) {
 
 // src/cli/init.ts
 import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname2, join as join4 } from "node:path";
 
 // src/cli/templates.ts
 function buildGatewayConfigTemplate(stateDbPath) {
@@ -263,7 +401,7 @@ function buildGatewayConfigTemplate(stateDbPath) {
     "allowed_users = []",
     "",
     "# Optional long-lived memory sources injected into gateway-managed sessions.",
-    "# Relative paths are resolved from this config file.",
+    "# Relative paths are resolved from opencode-gateway-workspace.",
     "#",
     "# [[memory.entries]]",
     '# path = "memory/project.md"',
@@ -286,13 +424,14 @@ function escapeTomlString(value) {
 // src/cli/init.ts
 async function runInit(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const opencodeConfigPath = join3(configDir, OPENCODE_CONFIG_FILE);
-  const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
+  const gatewayConfigPath = join4(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";
   } else {

package/dist/config/gateway.js

@@ -7,6 +7,7 @@ import { defaultGatewayStateDbPath, resolveGatewayConfigPath, resolveGatewayWork
 import { parseTelegramConfig } from "./telegram";
 export async function loadGatewayConfig(env = process.env) {
     const configPath = resolveGatewayConfigPath(env);
+    const workspaceDirPath = resolveGatewayWorkspacePath(configPath);
     const rawConfig = await readGatewayConfigFile(configPath);
     const stateDbValue = rawConfig?.gateway?.state_db;
     if (stateDbValue !== undefined && typeof stateDbValue !== "string") {
@@ -17,12 +18,12 @@ export async function loadGatewayConfig(env = process.env) {
         configPath,
         stateDbPath,
         mediaRootPath: resolveMediaRootPath(stateDbPath),
-        workspaceDirPath: resolveGatewayWorkspacePath(configPath),
+        workspaceDirPath,
         logLevel: parseGatewayLogLevel(rawConfig?.gateway?.log_level, "gateway.log_level"),
         hasLegacyGatewayTimezone: rawConfig?.gateway?.timezone !== undefined,
         legacyGatewayTimezone: readLegacyGatewayTimezone(rawConfig?.gateway?.timezone),
         mailbox: parseMailboxConfig(rawConfig?.gateway?.mailbox),
-        memory: await parseMemoryConfig(rawConfig?.memory, configPath),
+        memory: await parseMemoryConfig(rawConfig?.memory, workspaceDirPath),
         cron: parseCronConfig(rawConfig?.cron),
         telegram: parseTelegramConfig(rawConfig?.channels?.telegram, env),
     };

package/dist/config/memory.d.ts

@@ -15,4 +15,4 @@ export type GatewayMemoryEntryConfig = {
     injectMarkdownContents: boolean;
     globs: string[];
 };
-export declare function parseMemoryConfig(value: unknown, configPath: string): Promise<GatewayMemoryConfig>;
+export declare function parseMemoryConfig(value: unknown, workspaceDirPath: string): Promise<GatewayMemoryConfig>;

package/dist/config/memory.js

@@ -1,8 +1,8 @@
 import { stat } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-export async function parseMemoryConfig(value, configPath) {
+import { resolve } from "node:path";
+export async function parseMemoryConfig(value, workspaceDirPath) {
     const table = readMemoryTable(value);
-    const entries = await readMemoryEntries(table.entries, configPath);
+    const entries = await readMemoryEntries(table.entries, workspaceDirPath);
     return { entries };
 }
 function readMemoryTable(value) {
@@ -14,16 +14,16 @@ function readMemoryTable(value) {
     }
     return value;
 }
-async function readMemoryEntries(value, configPath) {
+async function readMemoryEntries(value, workspaceDirPath) {
     if (value === undefined) {
         return [];
     }
     if (!Array.isArray(value)) {
         throw new Error("memory.entries must be an array when present");
     }
-    return await Promise.all(value.map((entry, index) => readMemoryEntry(entry, index, configPath)));
+    return await Promise.all(value.map((entry, index) => readMemoryEntry(entry, index, workspaceDirPath)));
 }
-async function readMemoryEntry(value, index, configPath) {
+async function readMemoryEntry(value, index, workspaceDirPath) {
     const field = `memory.entries[${index}]`;
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         throw new Error(`${field} must be a table`);
@@ -31,7 +31,7 @@ async function readMemoryEntry(value, index, configPath) {
     const entry = value;
     const displayPath = readRequiredString(entry.path, `${field}.path`);
     const description = readRequiredString(entry.description, `${field}.description`);
-    const resolvedPath = resolve(dirname(configPath), displayPath);
+    const resolvedPath = resolve(workspaceDirPath, displayPath);
     const metadata = await statPath(resolvedPath, `${field}.path`);
     if (metadata.isFile()) {
         ensureDirectoryOnlyFieldIsAbsent(entry.inject_markdown_contents, `${field}.inject_markdown_contents`);

package/dist/config/paths.d.ts

@@ -1,5 +1,7 @@
 export declare const GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
 export declare const OPENCODE_CONFIG_FILE = "opencode.json";
+export declare const OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
+export declare const OPENCODE_CONFIG_FILE_CANDIDATES: readonly ["opencode.jsonc", "opencode.json"];
 export declare const GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
 type EnvSource = Record<string, string | undefined>;
 export declare function resolveGatewayConfigPath(env: EnvSource): string;

package/dist/config/paths.js

@@ -2,6 +2,8 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 export const GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
 export const OPENCODE_CONFIG_FILE = "opencode.json";
+export const OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
+export const OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
 export const GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
 export function resolveGatewayConfigPath(env) {
     const explicit = env.OPENCODE_GATEWAY_CONFIG;

package/package.json

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