openai-ws-opencode 0.1.4 → 0.1.5

package/README.md

@@ -101,7 +101,7 @@ Then point OpenCode at the packed tarball through the plugin array:
 
 ```jsonc
 {
-  "plugin": ["openai-ws-opencode@file:/absolute/path/openai-ws-opencode-0.1.4.tgz"]
+  "plugin": ["openai-ws-opencode@file:/absolute/path/openai-ws-opencode-0.1.5.tgz"]
 }
 ```
 

package/bin/setup.js

@@ -166,20 +166,28 @@ function applyJsonPatch(text, jsonPath, value) {
   }));
 }
 function pluginPackageName(specifier) {
-  if (specifier.startsWith("file://"))
-    return path.basename(new URL(specifier).pathname).replace(/\.[cm]?[jt]s$/, "");
+  if (specifier.startsWith("file:")) {
+    const filePath = specifier.startsWith("file://") ? new URL(specifier).pathname : specifier.slice("file:".length);
+    const base = path.basename(filePath);
+    if (base === PACKAGE_NAME || base.startsWith(`${PACKAGE_NAME}-`) || base.startsWith(`${PACKAGE_NAME}@`))
+      return PACKAGE_NAME;
+    return base.replace(/(?:\.tgz|\.[cm]?[jt]s)$/, "");
+  }
   const lastAt = specifier.lastIndexOf("@");
   return lastAt > 0 ? specifier.slice(0, lastAt) : specifier;
 }
-function patchConfigText(input, pluginSpec = DEFAULT_PLUGIN_SPEC) {
+function patchConfigText(input, pluginSpec = DEFAULT_PLUGIN_SPEC, replacePluginSpec = false) {
   let text = input.trim() ? input : "{}";
   const config = parse(text) ?? {};
   if (!config.$schema)
     text = applyJsonPatch(text, ["$schema"], SCHEMA);
   const current = (parse(text) ?? {}).plugin;
   const plugins = Array.isArray(current) ? [...current] : [];
-  if (!plugins.some((plugin) => typeof plugin === "string" && pluginPackageName(plugin) === PACKAGE_NAME)) {
+  const existingPluginIndex = plugins.findIndex((plugin) => typeof plugin === "string" && pluginPackageName(plugin) === PACKAGE_NAME);
+  if (existingPluginIndex === -1) {
     plugins.push(pluginSpec);
+  } else if (replacePluginSpec) {
+    plugins[existingPluginIndex] = pluginSpec;
   }
   text = applyJsonPatch(text, ["plugin"], plugins);
   const next = parse(text) ?? {};
@@ -192,6 +200,123 @@ function patchConfigText(input, pluginSpec = DEFAULT_PLUGIN_SPEC) {
 `
   }));
 }
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function cacheHomePath(cacheHome = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache")) {
+  return cacheHome;
+}
+function openCodeLatestCachePath(cacheHome) {
+  return path.join(cacheHomePath(cacheHome), "opencode", "packages", `${PACKAGE_NAME}@latest`);
+}
+async function pathExists(file) {
+  try {
+    await fs.access(file);
+    return true;
+  } catch (error) {
+    if (isNotFound(error))
+      return false;
+    throw error;
+  }
+}
+async function readPackageVersion(packageJsonPath) {
+  try {
+    const text = await fs.readFile(packageJsonPath, "utf8");
+    const parsed = JSON.parse(text);
+    return typeof parsed.version === "string" ? parsed.version : undefined;
+  } catch (error) {
+    if (isNotFound(error))
+      return;
+    throw error;
+  }
+}
+async function setupPackageVersion() {
+  const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+  const version = await readPackageVersion(packageJsonPath);
+  if (!version)
+    throw new Error(`Unable to read setup package version from ${packageJsonPath}`);
+  return version;
+}
+function semverParts(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  if (!match)
+    return;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareSemver(left, right) {
+  const leftParts = semverParts(left);
+  const rightParts = semverParts(right);
+  if (!leftParts || !rightParts)
+    return 0;
+  for (let index = 0;index < leftParts.length; index++) {
+    if (leftParts[index] !== rightParts[index])
+      return leftParts[index] < rightParts[index] ? -1 : 1;
+  }
+  return 0;
+}
+var SOURCE_EXTENSIONS = new Set([".cjs", ".js", ".mjs", ".ts"]);
+var BAD_OAUTH_PORT = /\bOAUTH_PORT\b\s*[:=]\s*1456\b/;
+var BAD_CODEX_ORIGINATOR = /\bCODEX_ORIGINATOR\b\s*[:=]\s*["']codex_cli_rs["']/;
+async function hasKnownBadConstants(packageRoot) {
+  const directories = [packageRoot];
+  let checkedFiles = 0;
+  while (directories.length > 0 && checkedFiles < 500) {
+    const current = directories.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch (error) {
+      if (isNotFound(error))
+        continue;
+      throw error;
+    }
+    for (const entry of entries) {
+      const entryPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules" && entry.name !== ".git")
+          directories.push(entryPath);
+        continue;
+      }
+      if (!entry.isFile() || !SOURCE_EXTENSIONS.has(path.extname(entry.name)))
+        continue;
+      checkedFiles += 1;
+      const source = await fs.readFile(entryPath, "utf8");
+      if (BAD_OAUTH_PORT.test(source) || BAD_CODEX_ORIGINATOR.test(source))
+        return true;
+      if (checkedFiles >= 500)
+        break;
+    }
+  }
+  return false;
+}
+function timestampForPath(date) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+async function staleDestination(cachePath, now) {
+  const base = `${cachePath}.stale-${timestampForPath(now)}`;
+  let candidate = base;
+  let suffix = 1;
+  while (await pathExists(candidate)) {
+    candidate = `${base}-${suffix}`;
+    suffix += 1;
+  }
+  return candidate;
+}
+async function repairStaleOpenCodeLatestCache(options = {}) {
+  const cachePath = openCodeLatestCachePath(options.cacheHome);
+  if (!await pathExists(cachePath))
+    return { cachePath, repaired: false };
+  const packageRoot = path.join(cachePath, "node_modules", PACKAGE_NAME);
+  const cachedVersion = await readPackageVersion(path.join(packageRoot, "package.json"));
+  const currentVersion = options.packageVersion ?? await setupPackageVersion();
+  const staleVersion = cachedVersion ? compareSemver(cachedVersion, currentVersion) < 0 : false;
+  const staleConstants = await hasKnownBadConstants(packageRoot);
+  if (!staleVersion && !staleConstants)
+    return { cachePath, repaired: false };
+  const movedTo = await staleDestination(cachePath, options.now?.() ?? new Date);
+  await fs.rename(cachePath, movedTo);
+  return { cachePath, movedTo, repaired: true };
+}
 async function setupOpenCodeConfig(options = {}) {
   const file = targetPath(options);
   let existing = "";
@@ -201,11 +326,19 @@ async function setupOpenCodeConfig(options = {}) {
     if (error?.code !== "ENOENT")
       throw error;
   }
-  const updated = patchConfigText(existing, options.pluginSpec ?? DEFAULT_PLUGIN_SPEC);
+  const updated = patchConfigText(existing, options.pluginSpec ?? DEFAULT_PLUGIN_SPEC, Boolean(options.pluginSpec));
   await fs.mkdir(path.dirname(file), { recursive: true });
   await fs.writeFile(file, updated.endsWith(`
 `) ? updated : `${updated}
 `, "utf8");
+  if (options.cacheRepair !== false) {
+    try {
+      await repairStaleOpenCodeLatestCache();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`Warning: could not repair OpenCode cache at ${openCodeLatestCachePath()}. Remove it manually if OpenCode keeps loading stale plugin code. ${message}`);
+    }
+  }
   return file;
 }
 function parseArgs(argv) {
@@ -220,8 +353,10 @@ function parseArgs(argv) {
       options.configPath = argv[++index];
     else if (arg === "--plugin")
       options.pluginSpec = argv[++index];
+    else if (arg === "--no-cache-repair")
+      options.cacheRepair = false;
     else if (arg === "--help" || arg === "-h") {
-      console.log("Usage: openai-ws-opencode setup [--global|--project] [--path <opencode.json>] [--plugin <specifier>]");
+      console.log("Usage: openai-ws-opencode setup [--global|--project] [--path <opencode.json>] [--plugin <specifier>] [--no-cache-repair]");
       process.exit(0);
     }
   }
@@ -247,6 +382,8 @@ if (isDirectExecution()) {
 }
 export {
   setupOpenCodeConfig,
+  repairStaleOpenCodeLatestCache,
   patchConfigText,
+  parseArgs,
   isDirectExecution
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openai-ws-opencode",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "OpenCode plugin for OpenAI Responses WebSocket transport.",
   "type": "module",
   "license": "MIT",