fix(core): plugins are always reinstalled

packages/opencode/src/bun/index.ts

@@ -7,6 +7,7 @@ import { NamedError } from "@opencode-ai/util/error"
 import { readableStreamToText } from "bun"
 import { createRequire } from "module"
 import { Lock } from "../util/lock"
+import { Npm } from "../npm"
 
 export namespace BunProc {
   const log = Log.create({ service: "bun" })
@@ -75,7 +76,22 @@ export namespace BunProc {
     const dependencies = parsed.dependencies ?? {}
     if (!parsed.dependencies) parsed.dependencies = dependencies
     const modExists = await Filesystem.exists(mod)
-    if (dependencies[pkg] === version && modExists) return mod
+    const cachedVersion = dependencies[pkg]
+
+    if (modExists && cachedVersion) {
+      if (version !== "latest") {
+        if (cachedVersion === version) return mod
+      }
+
+      if (version === "latest") {
+        const isOutdated = await Npm.isOutdated(pkg, cachedVersion)
+        if (!isOutdated) return mod
+        log.info("Cached version is outdated, proceeding with install", {
+          pkg,
+          cachedVersion,
+        })
+      }
+    }
 
     const proxied = !!(
       process.env.HTTP_PROXY ||

packages/opencode/src/config/config.ts

@@ -28,6 +28,7 @@ import { existsSync } from "fs"
 import { Bus } from "@/bus"
 import { GlobalBus } from "@/bus/global"
 import { Event } from "../server/event"
+import { Npm } from "../npm"
 
 export namespace Config {
   const log = Log.create({ service: "config" })
@@ -132,9 +133,10 @@ export namespace Config {
         }
       }
 
-      const exists = existsSync(path.join(dir, "node_modules"))
-      const installing = installDependencies(dir)
-      if (!exists) await installing
+      const shouldInstall = await needsInstall(dir)
+      if (shouldInstall) {
+        await installDependencies(dir)
+      }
 
       result.command = mergeDeep(result.command ?? {}, await loadCommand(dir))
       result.agent = mergeDeep(result.agent, await loadAgent(dir))
@@ -197,6 +199,7 @@ export namespace Config {
 
   export async function installDependencies(dir: string) {
     const pkg = path.join(dir, "package.json")
+    const targetVersion = Installation.isLocal() ? "latest" : Installation.VERSION
 
     if (!(await Bun.file(pkg).exists())) {
       await Bun.write(pkg, "{}")
@@ -206,18 +209,43 @@ export namespace Config {
     const hasGitIgnore = await Bun.file(gitignore).exists()
     if (!hasGitIgnore) await Bun.write(gitignore, ["node_modules", "package.json", "bun.lock", ".gitignore"].join("\n"))
 
-    await BunProc.run(
-      ["add", "@opencode-ai/plugin@" + (Installation.isLocal() ? "latest" : Installation.VERSION), "--exact"],
-      {
-        cwd: dir,
-      },
-    ).catch(() => {})
+    await BunProc.run(["add", `@opencode-ai/plugin@${targetVersion}`, "--exact"], {
+      cwd: dir,
+    }).catch(() => {})
 
     // Install any additional dependencies defined in the package.json
     // This allows local plugins and custom tools to use external packages
     await BunProc.run(["install"], { cwd: dir }).catch(() => {})
   }
 
+  async function needsInstall(dir: string) {
+    const nodeModules = path.join(dir, "node_modules")
+    if (!existsSync(nodeModules)) return true
+
+    const pkg = path.join(dir, "package.json")
+    const pkgFile = Bun.file(pkg)
+    const pkgExists = await pkgFile.exists()
+    if (!pkgExists) return true
+
+    const parsed = await pkgFile.json().catch(() => null)
+    const dependencies = parsed?.dependencies ?? {}
+    const depVersion = dependencies["@opencode-ai/plugin"]
+    if (!depVersion) return true
+
+    const targetVersion = Installation.isLocal() ? "latest" : Installation.VERSION
+    if (targetVersion === "latest") {
+      const isOutdated = await Npm.isOutdated("@opencode-ai/plugin", depVersion)
+      if (!isOutdated) return false
+      log.info("Cached version is outdated, proceeding with install", {
+        pkg: "@opencode-ai/plugin",
+        cachedVersion: depVersion,
+      })
+      return true
+    }
+    if (depVersion === targetVersion) return false
+    return true
+  }
+
   function rel(item: string, patterns: string[]) {
     for (const pattern of patterns) {
       const index = item.indexOf(pattern)

packages/opencode/src/npm/index.ts

@@ -0,0 +1,53 @@
+import { Log } from "../util/log"
+
+export namespace Npm {
+  const log = Log.create({ service: "npm" })
+
+  export async function getLatestVersion(pkg: string): Promise<string | null> {
+    const encoded = pkg.replace("/", "%2F")
+    const url = `https://registry.npmjs.org/${encoded}/latest`
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/json",
+      },
+    }).catch(() => null)
+
+    if (!response) {
+      log.warn("Failed to fetch latest version from registry", { pkg })
+      return null
+    }
+
+    if (!response.ok) {
+      log.warn("Failed to fetch latest version from registry", { pkg, status: response.status })
+      return null
+    }
+
+    const data = (await response.json().catch(() => null)) as { version?: string } | null
+    if (!data?.version) return null
+    return data.version
+  }
+
+  export function compareVersions(left: string, right: string): number {
+    const leftParts = left.split(".").map((part) => parseInt(part, 10) || 0)
+    const rightParts = right.split(".").map((part) => parseInt(part, 10) || 0)
+    const length = Math.max(leftParts.length, rightParts.length)
+
+    for (let i = 0; i < length; i++) {
+      const leftValue = leftParts[i] ?? 0
+      const rightValue = rightParts[i] ?? 0
+      if (leftValue < rightValue) return -1
+      if (leftValue > rightValue) return 1
+    }
+
+    return 0
+  }
+
+  export async function isOutdated(pkg: string, cachedVersion: string): Promise<boolean> {
+    const latestVersion = await getLatestVersion(pkg)
+    if (!latestVersion) {
+      log.warn("Failed to resolve latest version, using cached", { pkg, cachedVersion })
+      return false
+    }
+    return compareVersions(cachedVersion, latestVersion) < 0
+  }
+}