@wpro-eng/opencode-config 1.3.0 → 1.4.0

package/dist/index.js

@@ -9649,7 +9649,7 @@ function createDisableMatcher(disable) {
 }
 
 // src/index.ts
-import * as path8 from "path";
+import * as path9 from "path";
 
 // src/mcp-schema.ts
 import * as fs6 from "fs";
@@ -9880,8 +9880,191 @@ function updatePluginStatus(data) {
   writePluginStatus(status);
 }
 
+// src/auto-update.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
+var PACKAGE_NAME = "@wpro-eng/opencode-config";
+var NPM_DIST_TAGS_URL = `https://registry.npmjs.org/-/package/${encodeURIComponent(PACKAGE_NAME)}/dist-tags`;
+var REGISTRY_FETCH_TIMEOUT = 5000;
+var BUN_INSTALL_TIMEOUT = 60000;
+function getOpenCodeCacheDir() {
+  const xdgCache = process.env.XDG_CACHE_HOME || path8.join(process.env.HOME || "~", ".cache");
+  return path8.join(xdgCache, "opencode");
+}
+function getOpenCodeConfigDir() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME || path8.join(process.env.HOME || "~", ".config");
+  return path8.join(xdgConfig, "opencode");
+}
+function getCachedVersion() {
+  const pkgJsonPath = path8.join(getOpenCodeCacheDir(), "node_modules", PACKAGE_NAME, "package.json");
+  try {
+    if (!fs8.existsSync(pkgJsonPath))
+      return null;
+    const content = fs8.readFileSync(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function getLatestVersion() {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), REGISTRY_FETCH_TIMEOUT);
+  try {
+    const response = await fetch(NPM_DIST_TAGS_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);
+  }
+}
+function stripTrailingCommas(json) {
+  return json.replace(/,(\s*[}\]])/g, "$1");
+}
+function removeFromBunLock(cacheDir) {
+  const textLockPath = path8.join(cacheDir, "bun.lock");
+  const binaryLockPath = path8.join(cacheDir, "bun.lockb");
+  if (fs8.existsSync(textLockPath)) {
+    try {
+      const content = fs8.readFileSync(textLockPath, "utf-8");
+      const lock = JSON.parse(stripTrailingCommas(content));
+      if (lock.packages?.[PACKAGE_NAME]) {
+        delete lock.packages[PACKAGE_NAME];
+        fs8.writeFileSync(textLockPath, JSON.stringify(lock, null, 2));
+        logDebug(`Removed ${PACKAGE_NAME} from bun.lock`);
+        return true;
+      }
+      return false;
+    } catch {
+      try {
+        fs8.unlinkSync(textLockPath);
+        logDebug("Deleted unparseable bun.lock to force re-resolution");
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+  if (fs8.existsSync(binaryLockPath)) {
+    try {
+      fs8.unlinkSync(binaryLockPath);
+      logDebug("Deleted bun.lockb to force re-resolution");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function invalidatePackage() {
+  const cacheDir = getOpenCodeCacheDir();
+  const configDir = getOpenCodeConfigDir();
+  const pkgDirs = [
+    path8.join(cacheDir, "node_modules", PACKAGE_NAME),
+    path8.join(configDir, "node_modules", PACKAGE_NAME)
+  ];
+  let packageRemoved = false;
+  let lockRemoved = false;
+  for (const pkgDir of pkgDirs) {
+    if (fs8.existsSync(pkgDir)) {
+      fs8.rmSync(pkgDir, { recursive: true, force: true });
+      logDebug(`Removed cached package: ${pkgDir}`);
+      packageRemoved = true;
+    }
+  }
+  lockRemoved = removeFromBunLock(cacheDir);
+  return packageRemoved || lockRemoved;
+}
+async function runBunInstall() {
+  const cacheDir = getOpenCodeCacheDir();
+  const packageJsonPath = path8.join(cacheDir, "package.json");
+  if (!fs8.existsSync(packageJsonPath)) {
+    logDebug("No package.json in OpenCode cache, skipping bun install");
+    return false;
+  }
+  try {
+    const proc = Bun.spawn(["bun", "install"], {
+      cwd: cacheDir,
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve5) => {
+      timeoutId = setTimeout(() => resolve5("timeout"), BUN_INSTALL_TIMEOUT);
+    });
+    const exitPromise = proc.exited.then(() => "completed");
+    const result = await Promise.race([exitPromise, timeoutPromise]);
+    clearTimeout(timeoutId);
+    if (result === "timeout") {
+      try {
+        proc.kill();
+      } catch {}
+      logError("bun install timed out after 60s");
+      return false;
+    }
+    if (proc.exitCode !== 0) {
+      logError(`bun install failed with exit code ${proc.exitCode}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logError(`bun install failed: ${message}`);
+    return false;
+  }
+}
+async function checkAndUpdate() {
+  const cachedVersion = getCachedVersion();
+  const latestVersion = await getLatestVersion();
+  if (!latestVersion) {
+    logDebug("Could not fetch latest version from npm registry, skipping update check");
+    return {
+      updateAvailable: false,
+      previousVersion: cachedVersion,
+      latestVersion: null,
+      installed: false
+    };
+  }
+  if (cachedVersion === latestVersion) {
+    logDebug(`Already on latest version: ${cachedVersion}`);
+    return {
+      updateAvailable: false,
+      previousVersion: cachedVersion,
+      latestVersion,
+      installed: false
+    };
+  }
+  log(`Update available: ${cachedVersion ?? "unknown"} \u2192 ${latestVersion}`);
+  invalidatePackage();
+  const installSuccess = await runBunInstall();
+  if (installSuccess) {
+    log(`Updated to ${latestVersion}. Restart OpenCode to apply.`);
+    return {
+      updateAvailable: true,
+      previousVersion: cachedVersion,
+      latestVersion,
+      installed: true
+    };
+  }
+  logError(`Failed to install update to ${latestVersion}`);
+  return {
+    updateAvailable: true,
+    previousVersion: cachedVersion,
+    latestVersion,
+    installed: false,
+    error: "bun install failed"
+  };
+}
+
 // src/index.ts
-var PACKAGE_ROOT = path8.resolve(import.meta.dir, "..");
+var PACKAGE_ROOT = path9.resolve(import.meta.dir, "..");
 var initialized = false;
 var REQUIRED_RUNTIME_PLUGINS = ["@tarquinen/opencode-dcp@latest"];
 var DEFAULT_OPENCODE_AGENTS_TO_DISABLE = ["build", "plan"];
@@ -10358,7 +10541,16 @@ var WpromoteConfigPlugin = async (ctx) => {
         }
       }
     },
-    event: async ({ event }) => {}
+    event: async ({ event }) => {
+      if (event.type !== "session.created")
+        return;
+      const props = event.properties;
+      if (props?.info?.parentID)
+        return;
+      checkAndUpdate().catch((err) => {
+        logError(`Auto-update check failed: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    }
   };
 };
 var RemoteSkillsPlugin = WpromoteConfigPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpro-eng/opencode-config",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Wpromote OpenCode plugin to sync team config assets on startup",
   "repository": {
     "type": "git",