opencode-gateway 0.2.0 → 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:

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.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) {
@@ -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/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.1",
   "description": "Gateway plugin for OpenCode",
   "license": "MIT",
   "type": "module",