opencode-aicodewith-auth 0.1.3 → 0.1.4

package/dist/index.js

@@ -60,8 +60,8 @@ var aicodewith = createAicodewith();
 
 // index.ts
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path from "path";
-import os from "os";
+import path4 from "path";
+import os3 from "os";
 
 // lib/constants.ts
 var PLUGIN_NAME = "opencode-aicodewith-auth";
@@ -993,9 +993,440 @@ async function handleSuccessResponse(response, isStreaming) {
   });
 }
 
+// lib/hooks/auto-update/index.ts
+import { spawn } from "child_process";
+
+// lib/hooks/auto-update/checker.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// lib/hooks/auto-update/constants.ts
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs";
+var PACKAGE_NAME = "opencode-aicodewith-auth";
+var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+var NPM_FETCH_TIMEOUT = 5000;
+function getCacheDir() {
+  if (process.platform === "win32") {
+    return path.join(process.env.LOCALAPPDATA ?? os.homedir(), "opencode");
+  }
+  return path.join(os.homedir(), ".cache", "opencode");
+}
+var CACHE_DIR3 = getCacheDir();
+var INSTALLED_PACKAGE_JSON = path.join(CACHE_DIR3, "node_modules", PACKAGE_NAME, "package.json");
+function getUserConfigDir() {
+  if (process.platform === "win32") {
+    const crossPlatformDir = path.join(os.homedir(), ".config");
+    const appdataDir = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    const crossPlatformConfig = path.join(crossPlatformDir, "opencode", "opencode.json");
+    const crossPlatformConfigJsonc = path.join(crossPlatformDir, "opencode", "opencode.jsonc");
+    if (fs.existsSync(crossPlatformConfig) || fs.existsSync(crossPlatformConfigJsonc)) {
+      return crossPlatformDir;
+    }
+    return appdataDir;
+  }
+  return process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+}
+function getWindowsAppdataDir() {
+  if (process.platform !== "win32")
+    return null;
+  return process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+}
+var USER_CONFIG_DIR = getUserConfigDir();
+var USER_OPENCODE_CONFIG = path.join(USER_CONFIG_DIR, "opencode", "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = path.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc");
+
+// lib/hooks/auto-update/checker.ts
+import * as os2 from "os";
+var LOG_PREFIX = `[${PACKAGE_NAME}:auto-update]`;
+function log(...args) {
+  if (process.env.DEBUG?.includes(PACKAGE_NAME) || process.env.DEBUG?.includes("auto-update")) {
+    console.log(LOG_PREFIX, ...args);
+  }
+}
+function stripJsonComments(json) {
+  return json.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m).replace(/,(\s*[}\]])/g, "$1");
+}
+function getConfigPaths(directory) {
+  const paths = [
+    path2.join(directory, ".opencode", "opencode.json"),
+    path2.join(directory, ".opencode", "opencode.jsonc"),
+    USER_OPENCODE_CONFIG,
+    USER_OPENCODE_CONFIG_JSONC
+  ];
+  if (process.platform === "win32") {
+    const crossPlatformDir = path2.join(os2.homedir(), ".config");
+    const appdataDir = getWindowsAppdataDir();
+    if (appdataDir) {
+      const alternateDir = USER_CONFIG_DIR === crossPlatformDir ? appdataDir : crossPlatformDir;
+      const alternateConfig = path2.join(alternateDir, "opencode", "opencode.json");
+      const alternateConfigJsonc = path2.join(alternateDir, "opencode", "opencode.jsonc");
+      if (!paths.includes(alternateConfig)) {
+        paths.push(alternateConfig);
+      }
+      if (!paths.includes(alternateConfigJsonc)) {
+        paths.push(alternateConfigJsonc);
+      }
+    }
+  }
+  return paths;
+}
+function getLocalDevPath(directory) {
+  for (const configPath of getConfigPaths(directory)) {
+    try {
+      if (!fs2.existsSync(configPath))
+        continue;
+      const content = fs2.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(stripJsonComments(content));
+      const plugins = config.plugin ?? [];
+      for (const entry of plugins) {
+        if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
+          try {
+            return fileURLToPath2(entry);
+          } catch {
+            return entry.replace("file://", "");
+          }
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function findPackageJsonUp(startPath) {
+  try {
+    const stat = fs2.statSync(startPath);
+    let dir = stat.isDirectory() ? startPath : path2.dirname(startPath);
+    for (let i = 0;i < 10; i++) {
+      const pkgPath = path2.join(dir, "package.json");
+      if (fs2.existsSync(pkgPath)) {
+        try {
+          const content = fs2.readFileSync(pkgPath, "utf-8");
+          const pkg = JSON.parse(content);
+          if (pkg.name === PACKAGE_NAME)
+            return pkgPath;
+        } catch {}
+      }
+      const parent = path2.dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
+  return null;
+}
+function getLocalDevVersion(directory) {
+  const localPath = getLocalDevPath(directory);
+  if (!localPath)
+    return null;
+  try {
+    const pkgPath = findPackageJsonUp(localPath);
+    if (!pkgPath)
+      return null;
+    const content = fs2.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function findPluginEntry(directory) {
+  for (const configPath of getConfigPaths(directory)) {
+    try {
+      if (!fs2.existsSync(configPath))
+        continue;
+      const content = fs2.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(stripJsonComments(content));
+      const plugins = config.plugin ?? [];
+      for (const entry of plugins) {
+        if (entry === PACKAGE_NAME) {
+          return { entry, isPinned: false, pinnedVersion: null, configPath };
+        }
+        if (entry.startsWith(`${PACKAGE_NAME}@`)) {
+          const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1);
+          const isPinned = pinnedVersion !== "latest";
+          return { entry, isPinned, pinnedVersion: isPinned ? pinnedVersion : null, configPath };
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function getCachedVersion() {
+  try {
+    if (fs2.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs2.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.version)
+        return pkg.version;
+    }
+  } catch {}
+  try {
+    const currentDir = path2.dirname(fileURLToPath2(import.meta.url));
+    const pkgPath = findPackageJsonUp(currentDir);
+    if (pkgPath) {
+      const content = fs2.readFileSync(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.version)
+        return pkg.version;
+    }
+  } catch (err) {
+    log("Failed to resolve version from current directory:", err);
+  }
+  return null;
+}
+function updatePinnedVersion(configPath, oldEntry, newVersion) {
+  try {
+    const content = fs2.readFileSync(configPath, "utf-8");
+    const newEntry = `${PACKAGE_NAME}@${newVersion}`;
+    const pluginMatch = content.match(/"plugin"\s*:\s*\[/);
+    if (!pluginMatch || pluginMatch.index === undefined) {
+      log(`No "plugin" array found in ${configPath}`);
+      return false;
+    }
+    const startIdx = pluginMatch.index + pluginMatch[0].length;
+    let bracketCount = 1;
+    let endIdx = startIdx;
+    for (let i = startIdx;i < content.length && bracketCount > 0; i++) {
+      if (content[i] === "[")
+        bracketCount++;
+      else if (content[i] === "]")
+        bracketCount--;
+      endIdx = i;
+    }
+    const before = content.slice(0, startIdx);
+    const pluginArrayContent = content.slice(startIdx, endIdx);
+    const after = content.slice(endIdx);
+    const escapedOldEntry = oldEntry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`["']${escapedOldEntry}["']`);
+    if (!regex.test(pluginArrayContent)) {
+      log(`Entry "${oldEntry}" not found in plugin array of ${configPath}`);
+      return false;
+    }
+    const updatedPluginArray = pluginArrayContent.replace(regex, `"${newEntry}"`);
+    const updatedContent = before + updatedPluginArray + after;
+    if (updatedContent === content) {
+      log(`No changes made to ${configPath}`);
+      return false;
+    }
+    fs2.writeFileSync(configPath, updatedContent, "utf-8");
+    log(`Updated ${configPath}: ${oldEntry} \u2192 ${newEntry}`);
+    return true;
+  } catch (err) {
+    log(`Failed to update config file ${configPath}:`, err);
+    return false;
+  }
+}
+async function getLatestVersion() {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
+  try {
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return data.latest ?? null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+// lib/hooks/auto-update/cache.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+function stripTrailingCommas(json) {
+  return json.replace(/,(\s*[}\]])/g, "$1");
+}
+function removeFromBunLock(packageName) {
+  const lockPath = path3.join(CACHE_DIR3, "bun.lock");
+  if (!fs3.existsSync(lockPath))
+    return false;
+  try {
+    const content = fs3.readFileSync(lockPath, "utf-8");
+    const lock = JSON.parse(stripTrailingCommas(content));
+    let modified = false;
+    if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
+      delete lock.workspaces[""].dependencies[packageName];
+      modified = true;
+    }
+    if (lock.packages?.[packageName]) {
+      delete lock.packages[packageName];
+      modified = true;
+    }
+    if (modified) {
+      fs3.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+      log(`Removed from bun.lock: ${packageName}`);
+    }
+    return modified;
+  } catch {
+    return false;
+  }
+}
+function invalidatePackage(packageName = PACKAGE_NAME) {
+  try {
+    const pkgDir = path3.join(CACHE_DIR3, "node_modules", packageName);
+    const pkgJsonPath = path3.join(CACHE_DIR3, "package.json");
+    let packageRemoved = false;
+    let dependencyRemoved = false;
+    let lockRemoved = false;
+    if (fs3.existsSync(pkgDir)) {
+      fs3.rmSync(pkgDir, { recursive: true, force: true });
+      log(`Package removed: ${pkgDir}`);
+      packageRemoved = true;
+    }
+    if (fs3.existsSync(pkgJsonPath)) {
+      const content = fs3.readFileSync(pkgJsonPath, "utf-8");
+      const pkgJson = JSON.parse(content);
+      if (pkgJson.dependencies?.[packageName]) {
+        delete pkgJson.dependencies[packageName];
+        fs3.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        log(`Dependency removed from package.json: ${packageName}`);
+        dependencyRemoved = true;
+      }
+    }
+    lockRemoved = removeFromBunLock(packageName);
+    if (!packageRemoved && !dependencyRemoved && !lockRemoved) {
+      log(`Package not found, nothing to invalidate: ${packageName}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    log("Failed to invalidate package:", err);
+    return false;
+  }
+}
+
+// lib/hooks/auto-update/index.ts
+function createAutoUpdateHook(ctx, options = {}) {
+  const { autoUpdate = true } = options;
+  let hasChecked = false;
+  return {
+    event: async ({ event }) => {
+      if (event.type !== "session.created")
+        return;
+      if (hasChecked)
+        return;
+      const props = event.properties;
+      if (props?.info?.parentID)
+        return;
+      hasChecked = true;
+      const localDevVersion = getLocalDevVersion(ctx.directory);
+      if (localDevVersion) {
+        log("Local development mode, skipping update check");
+        return;
+      }
+      runBackgroundUpdateCheck(ctx, autoUpdate).catch((err) => {
+        log("Background update check failed:", err);
+      });
+    }
+  };
+}
+async function runBackgroundUpdateCheck(ctx, autoUpdate) {
+  const pluginInfo = findPluginEntry(ctx.directory);
+  if (!pluginInfo) {
+    log("Plugin not found in config");
+    return;
+  }
+  const cachedVersion = getCachedVersion();
+  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
+  if (!currentVersion) {
+    log("No version found (cached or pinned)");
+    return;
+  }
+  const latestVersion = await getLatestVersion();
+  if (!latestVersion) {
+    log("Failed to fetch latest version");
+    return;
+  }
+  if (currentVersion === latestVersion) {
+    log("Already on latest version");
+    return;
+  }
+  log(`Update available: ${currentVersion} \u2192 ${latestVersion}`);
+  if (!autoUpdate) {
+    await showUpdateAvailableToast(ctx, currentVersion, latestVersion);
+    log("Auto-update disabled, notification only");
+    return;
+  }
+  if (pluginInfo.isPinned) {
+    const updated = updatePinnedVersion(pluginInfo.configPath, pluginInfo.entry, latestVersion);
+    if (!updated) {
+      await showUpdateAvailableToast(ctx, currentVersion, latestVersion);
+      log("Failed to update pinned version in config");
+      return;
+    }
+    log(`Config updated: ${pluginInfo.entry} \u2192 ${PACKAGE_NAME}@${latestVersion}`);
+  }
+  invalidatePackage(PACKAGE_NAME);
+  const installSuccess = await runBunInstallSafe();
+  if (installSuccess) {
+    await showAutoUpdatedToast(ctx, currentVersion, latestVersion);
+    log(`Update installed: ${currentVersion} \u2192 ${latestVersion}`);
+  } else {
+    await showUpdateAvailableToast(ctx, currentVersion, latestVersion);
+    log("bun install failed; update not installed (falling back to notification-only)");
+  }
+}
+async function runBunInstallSafe() {
+  return new Promise((resolve) => {
+    try {
+      const child = spawn("bun", ["install"], {
+        cwd: CACHE_DIR3,
+        stdio: "ignore",
+        detached: true
+      });
+      child.unref();
+      child.on("close", (code) => {
+        resolve(code === 0);
+      });
+      child.on("error", () => {
+        resolve(false);
+      });
+      setTimeout(() => resolve(false), 30000);
+    } catch (err) {
+      log("bun install error:", err);
+      resolve(false);
+    }
+  });
+}
+async function showUpdateAvailableToast(ctx, currentVersion, latestVersion) {
+  await ctx.client.tui.showToast({
+    body: {
+      title: `${PACKAGE_NAME} Update Available`,
+      message: `v${currentVersion} \u2192 v${latestVersion}
+Restart OpenCode to apply.`,
+      variant: "info",
+      duration: 8000
+    }
+  }).catch(() => {});
+  log(`Update available toast shown: v${latestVersion}`);
+}
+async function showAutoUpdatedToast(ctx, oldVersion, newVersion) {
+  await ctx.client.tui.showToast({
+    body: {
+      title: `${PACKAGE_NAME} Updated!`,
+      message: `v${oldVersion} \u2192 v${newVersion}
+Restart OpenCode to apply.`,
+      variant: "success",
+      duration: 8000
+    }
+  }).catch(() => {});
+  log(`Auto-updated toast shown: v${oldVersion} \u2192 v${newVersion}`);
+}
+
 // index.ts
 var CODEX_MODEL_PREFIXES = ["gpt-", "codex"];
-var PACKAGE_NAME = "opencode-aicodewith-auth";
+var PACKAGE_NAME2 = "opencode-aicodewith-auth";
 var PROVIDER_NAME = "AICodewith";
 var PLUGIN_ENTRY = import.meta.url;
 var PROVIDER_EXT = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
@@ -1013,10 +1444,10 @@ var MODEL_CONFIGS = {
 };
 var ALLOWED_MODEL_IDS = Object.keys(MODEL_CONFIGS);
 var ALLOWED_MODEL_SET = new Set(ALLOWED_MODEL_IDS);
-var homeDir = process.env.OPENCODE_TEST_HOME || os.homedir();
-var configRoot = process.env.XDG_CONFIG_HOME || path.join(homeDir, ".config");
-var configDir = path.join(configRoot, "opencode");
-var configPath = path.join(configDir, "opencode.json");
+var homeDir = process.env.OPENCODE_TEST_HOME || os3.homedir();
+var configRoot = process.env.XDG_CONFIG_HOME || path4.join(homeDir, ".config");
+var configDir = path4.join(configRoot, "opencode");
+var configPath = path4.join(configDir, "opencode.json");
 var ensureConfigPromise;
 var toModelMap = (ids, existing = {}) => ids.reduce((acc, id) => {
   const existingConfig = Object.prototype.hasOwnProperty.call(existing, id) ? existing[id] : {};
@@ -1032,7 +1463,7 @@ var readJson = async (filePath) => {
     return;
   }
 };
-var isPackageEntry = (value) => value === PACKAGE_NAME || value.startsWith(`${PACKAGE_NAME}@`);
+var isPackageEntry = (value) => value === PACKAGE_NAME2 || value.startsWith(`${PACKAGE_NAME2}@`);
 var ensurePluginEntry = (list) => {
   if (!Array.isArray(list))
     return [PLUGIN_ENTRY];
@@ -1146,14 +1577,14 @@ var ensureGeminiSseParam = (url) => {
 };
 var buildGeminiUrl = (originalUrl, streaming) => {
   const original = new URL(originalUrl);
-  let path2 = original.pathname;
-  if (!path2.includes("/v1beta/") && !path2.includes("/v1/")) {
-    path2 = `/v1beta${path2.startsWith("/") ? "" : "/"}${path2}`;
+  let path5 = original.pathname;
+  if (!path5.includes("/v1beta/") && !path5.includes("/v1/")) {
+    path5 = `/v1beta${path5.startsWith("/") ? "" : "/"}${path5}`;
   }
   const base = new URL(AICODEWITH_GEMINI_BASE_URL);
   const basePath = base.pathname.replace(/\/$/, "");
   const target = new URL(base.origin);
-  target.pathname = `${basePath}${path2}`;
+  target.pathname = `${basePath}${path5}`;
   target.search = original.search;
   const url = target.toString();
   return streaming ? ensureGeminiSseParam(url) : url;
@@ -1188,10 +1619,11 @@ var getOutputTokenLimit = (input, output) => {
   }
   return DEFAULT_OUTPUT_TOKEN_MAX;
 };
-var AicodewithCodexAuthPlugin = async (_ctx) => {
+var AicodewithCodexAuthPlugin = async (ctx) => {
   await ensureConfigFile().catch((error) => {
-    console.warn(`[${PACKAGE_NAME}] Failed to update opencode config: ${error instanceof Error ? error.message : error}`);
+    console.warn(`[${PACKAGE_NAME2}] Failed to update opencode config: ${error instanceof Error ? error.message : error}`);
   });
+  const autoUpdateHook = createAutoUpdateHook(ctx, { autoUpdate: true });
   const authHook = {
     provider: PROVIDER_ID,
     loader: async (getAuth, _provider) => {
@@ -1267,6 +1699,7 @@ var AicodewithCodexAuthPlugin = async (_ctx) => {
     config: async (config) => {
       applyProviderConfig(config);
     },
+    event: autoUpdateHook.event,
     "chat.params": async (input, output) => {
       if (input.model.providerID !== PROVIDER_ID)
         return;

package/dist/lib/hooks/auto-update/cache.d.ts

@@ -0,0 +1 @@
+export declare function invalidatePackage(packageName?: string): boolean;

package/dist/lib/hooks/auto-update/checker.d.ts

@@ -0,0 +1,10 @@
+import type { PluginEntryInfo } from "./types";
+declare function log(...args: unknown[]): void;
+export declare function isLocalDevMode(directory: string): boolean;
+export declare function getLocalDevPath(directory: string): string | null;
+export declare function getLocalDevVersion(directory: string): string | null;
+export declare function findPluginEntry(directory: string): PluginEntryInfo | null;
+export declare function getCachedVersion(): string | null;
+export declare function updatePinnedVersion(configPath: string, oldEntry: string, newVersion: string): boolean;
+export declare function getLatestVersion(): Promise<string | null>;
+export { log };

package/dist/lib/hooks/auto-update/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file constants.ts
+ * @input  None
+ * @output Auto-update configuration constants
+ * @pos    Constants for package paths, npm registry, cache directories
+ */
+export declare const PACKAGE_NAME = "opencode-aicodewith-auth";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/opencode-aicodewith-auth/dist-tags";
+export declare const NPM_FETCH_TIMEOUT = 5000;
+export declare const CACHE_DIR: string;
+export declare const INSTALLED_PACKAGE_JSON: string;
+export declare function getWindowsAppdataDir(): string | null;
+export declare const USER_CONFIG_DIR: string;
+export declare const USER_OPENCODE_CONFIG: string;
+export declare const USER_OPENCODE_CONFIG_JSONC: string;

package/dist/lib/hooks/auto-update/index.d.ts

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { AutoUpdateOptions } from "./types";
+export declare function createAutoUpdateHook(ctx: PluginInput, options?: AutoUpdateOptions): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export type { AutoUpdateOptions } from "./types";
+export { invalidatePackage } from "./cache";

package/dist/lib/hooks/auto-update/types.d.ts

@@ -0,0 +1,29 @@
+export interface NpmDistTags {
+    latest: string;
+    [key: string]: string;
+}
+export interface OpencodeConfig {
+    plugin?: string[];
+    [key: string]: unknown;
+}
+export interface PackageJson {
+    version: string;
+    name?: string;
+    [key: string]: unknown;
+}
+export interface UpdateCheckResult {
+    needsUpdate: boolean;
+    currentVersion: string | null;
+    latestVersion: string | null;
+    isLocalDev: boolean;
+    isPinned: boolean;
+}
+export interface AutoUpdateOptions {
+    autoUpdate?: boolean;
+}
+export interface PluginEntryInfo {
+    entry: string;
+    isPinned: boolean;
+    pinnedVersion: string | null;
+    configPath: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-aicodewith-auth",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "OpenCode plugin for AICodewith authentication - Access GPT-5.2, Claude, and Gemini models through AICodewith API",
   "type": "module",
   "main": "dist/index.js",