fix: restore plugin bundling needed for compiled binaries

shuv1337 · shuv1337 · commit ca4f9bd728c7 · 2025-12-21T11:52:25.000-08:00
Reverts c95f776 which broke the desktop/web app. The bundling logic is required for compiled binaries (//) to dynamically import plugins from the filesystem. Without it, the binary cannot resolve modules in ~/.cache/opencode/node_modules/. The test preload fix (OPENCODE_DISABLE_DEFAULT_PLUGINS=true) remains to prevent CI failures from plugins that fail to bundle.
diff --git a/packages/opencode/src/bun/index.ts b/packages/opencode/src/bun/index.ts
@@ -65,13 +65,20 @@ export namespace BunProc {
     using _ = await Lock.write("bun-install")
 
     const mod = path.join(Global.Path.cache, "node_modules", pkg)
+    const bundledDir = path.join(Global.Path.cache, "bundled")
+    const bundledFile = path.join(bundledDir, `${pkg.replace(/\//g, "-")}.js`)
     const pkgjson = Bun.file(path.join(Global.Path.cache, "package.json"))
     const parsed = await pkgjson.json().catch(async () => {
-      const result = { dependencies: {} }
+      const result = { dependencies: {}, bundled: {} }
       await Bun.write(pkgjson.name!, JSON.stringify(result, null, 2))
       return result
     })
-    if (parsed.dependencies[pkg] === version) return mod
+
+    // Check if already installed and bundled
+    const bundledExists = await Bun.file(bundledFile).exists()
+    if (parsed.dependencies[pkg] === version && bundledExists) {
+      return bundledFile
+    }
 
     // Build command arguments
     const args = ["add", "--force", "--exact", "--cwd", Global.Path.cache, pkg + "@" + version]
@@ -107,8 +114,95 @@ export namespace BunProc {
       }
     }
 
+    // Bundle the plugin with all dependencies for compiled binary compatibility
+    // This creates a single file that doesn't require subpath export resolution
+    await Bun.file(bundledDir)
+      .exists()
+      .then(async (exists) => {
+        if (!exists) await Bun.$`mkdir -p ${bundledDir}`
+      })
+
+    // Find the entry point from package.json
+    const installedPkgJson = Bun.file(path.join(mod, "package.json"))
+    const installedPkg = await installedPkgJson.json().catch(() => ({}))
+    const entryPoint = installedPkg.main || "index.js"
+    const entryPath = path.join(mod, entryPoint)
+
+    log.info("bundling plugin for compiled binary compatibility", {
+      pkg,
+      entryPath,
+      bundledFile,
+    })
+
+    try {
+      const result = await Bun.build({
+        entrypoints: [entryPath],
+        outdir: bundledDir,
+        naming: `${pkg.replace(/\//g, "-")}.js`,
+        target: "bun",
+        format: "esm",
+        // Bundle all dependencies to avoid subpath export resolution issues
+        packages: "bundle",
+      })
+
+      if (!result.success) {
+        log.error("failed to bundle plugin", {
+          pkg,
+          logs: result.logs,
+        })
+        // Fall back to unbundled module
+        return mod
+      }
+
+      // Copy non-JS assets (HTML, CSS, etc.) that plugins may need at runtime
+      // Some bundled code uses __dirname + ".." to find assets, so copy to both
+      // the bundled dir and the parent cache dir for compatibility
+      await copyPluginAssets(mod, bundledDir)
+      await copyPluginAssets(mod, Global.Path.cache)
+    } catch (e) {
+      log.error("failed to bundle plugin", {
+        pkg,
+        error: (e as Error).message,
+      })
+      // Fall back to unbundled module
+      return mod
+    }
+
     parsed.dependencies[pkg] = resolvedVersion
+    if (!parsed.bundled) parsed.bundled = {}
+    parsed.bundled[pkg] = bundledFile
     await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2))
-    return mod
+    return bundledFile
+  }
+
+  async function copyPluginAssets(pluginDir: string, targetDir: string) {
+    // Find and copy non-JS/TS assets that plugins might need at runtime
+    const assetExtensions = [".html", ".css", ".json", ".txt", ".svg", ".png", ".jpg", ".gif"]
+
+    async function copyAssetsRecursive(srcDir: string, destDir: string) {
+      const entries = await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: srcDir, dot: false }))
+
+      for (const entry of entries) {
+        const ext = path.extname(entry).toLowerCase()
+        if (assetExtensions.includes(ext)) {
+          const srcPath = path.join(srcDir, entry)
+          const destPath = path.join(destDir, path.basename(entry))
+
+          try {
+            const content = await Bun.file(srcPath).arrayBuffer()
+            await Bun.write(destPath, content)
+            log.info("copied plugin asset", { src: entry, dest: destPath })
+          } catch (e) {
+            log.error("failed to copy plugin asset", {
+              src: srcPath,
+              dest: destPath,
+              error: (e as Error).message,
+            })
+          }
+        }
+      }
+    }
+
+    await copyAssetsRecursive(pluginDir, targetDir)
   }
 }
diff --git a/packages/opencode/src/plugin/index.ts b/packages/opencode/src/plugin/index.ts
@@ -1,4 +1,5 @@
 import type { Hooks, PluginInput, Plugin as PluginInstance } from "@opencode-ai/plugin"
+import { pathToFileURL } from "node:url"
 import { Config } from "../config/config"
 import { Bus } from "../bus"
 import { Log } from "../util/log"
@@ -7,10 +8,74 @@ import { Server } from "../server/server"
 import { BunProc } from "../bun"
 import { Instance } from "../project/instance"
 import { Flag } from "../flag/flag"
+import { Global } from "../global"
+import * as path from "node:path"
+import * as crypto from "node:crypto"
 
 export namespace Plugin {
   const log = Log.create({ service: "plugin" })
 
+  /**
+   * Bundle a local plugin file with its dependencies.
+   * This ensures that local plugins can use npm dependencies that are installed
+   * in their parent directory's node_modules.
+   */
+  async function bundleLocalPlugin(filePath: string): Promise<string> {
+    const bundledDir = path.join(Global.Path.cache, "bundled-local")
+    await Bun.file(bundledDir)
+      .exists()
+      .then(async (exists) => {
+        if (!exists) await Bun.$`mkdir -p ${bundledDir}`
+      })
+
+    // Create a hash of the file path and its modification time for cache invalidation
+    const stat = await Bun.file(filePath)
+      .stat()
+      .catch(() => null)
+    const mtime = stat?.mtimeMs ?? 0
+    const hash = crypto.createHash("md5").update(`${filePath}:${mtime}`).digest("hex").slice(0, 12)
+    const baseName = path.basename(filePath, path.extname(filePath))
+    const bundledFile = path.join(bundledDir, `${baseName}-${hash}.js`)
+
+    // Check if already bundled
+    if (await Bun.file(bundledFile).exists()) {
+      log.info("using cached bundled local plugin", { path: filePath, bundled: bundledFile })
+      return bundledFile
+    }
+
+    log.info("bundling local plugin with dependencies", { path: filePath, bundled: bundledFile })
+
+    try {
+      const result = await Bun.build({
+        entrypoints: [filePath],
+        outdir: bundledDir,
+        naming: `${baseName}-${hash}.js`,
+        target: "bun",
+        format: "esm",
+        // Bundle all dependencies to resolve imports like 'jsonc-parser'
+        packages: "bundle",
+      })
+
+      if (!result.success) {
+        log.error("failed to bundle local plugin", {
+          path: filePath,
+          logs: result.logs,
+        })
+        // Fall back to direct import (will fail if deps are missing)
+        return filePath
+      }
+
+      return bundledFile
+    } catch (e) {
+      log.error("failed to bundle local plugin", {
+        path: filePath,
+        error: (e as Error).message,
+      })
+      // Fall back to direct import
+      return filePath
+    }
+  }
+
   const state = Instance.state(async () => {
     const client = createOpencodeClient({
       baseUrl: "http://localhost:4096",
@@ -33,16 +98,46 @@ export namespace Plugin {
     }
     for (let plugin of plugins) {
       log.info("loading plugin", { path: plugin })
+      let pluginUrl: string
       if (!plugin.startsWith("file://")) {
         const lastAtIndex = plugin.lastIndexOf("@")
         const pkg = lastAtIndex > 0 ? plugin.substring(0, lastAtIndex) : plugin
         const version = lastAtIndex > 0 ? plugin.substring(lastAtIndex + 1) : "latest"
-        plugin = await BunProc.install(pkg, version)
+        // BunProc.install now returns the bundled file path directly
+        const pluginPath = await BunProc.install(pkg, version)
+        pluginUrl = pathToFileURL(pluginPath).href
+      } else {
+        // Resolve relative file:// paths against the working directory
+        const filePath = plugin.substring("file://".length)
+        const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(Instance.directory, filePath)
+        // Bundle local plugins with their dependencies for compiled binary compatibility
+        const bundledPath = await bundleLocalPlugin(absolutePath)
+        pluginUrl = pathToFileURL(bundledPath).href
       }
-      const mod = await import(plugin)
-      for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
-        const init = await fn(input)
-        hooks.push(init)
+      try {
+        // Use dynamic import() with absolute file:// URLs for ES module compatibility
+        // pathToFileURL ensures proper URL encoding regardless of import.meta.url context
+        const mod = await import(pluginUrl)
+        for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
+          const init = await fn(input)
+          hooks.push(init)
+        }
+      } catch (e) {
+        const err = e as Error
+        // Check for module resolution issues
+        if (err.message?.includes("Cannot find module") || err.message?.includes("Cannot find package")) {
+          log.error("failed to load plugin", {
+            plugin,
+            error: err.message,
+            hint: "Make sure all plugin dependencies are installed. Run 'bun install' in the plugin directory.",
+          })
+        } else {
+          log.error("failed to load plugin", {
+            plugin,
+            error: err.message,
+          })
+        }
+        throw e
       }
     }
 
diff --git a/packages/opencode/test/plugin/plugin.test.ts b/packages/opencode/test/plugin/plugin.test.ts
@@ -0,0 +1,112 @@
+import { describe, test, expect, beforeAll } from "bun:test"
+import { tmpdir } from "../fixture/fixture"
+import * as fs from "fs/promises"
+import * as path from "path"
+import { Instance } from "@/project/instance"
+import { Config } from "@/config/config"
+import { Global } from "@/global"
+
+describe("Plugin", () => {
+  beforeAll(() => {
+    // Disable default plugins to isolate our test
+    process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = "true"
+  })
+
+  test("bundles local plugin with npm dependencies", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      init: async (dir) => {
+        // Create the .opencode/plugin directory structure
+        const pluginDir = path.join(dir, ".opencode", "plugin")
+        await fs.mkdir(pluginDir, { recursive: true })
+
+        // Create a package.json with jsonc-parser as a dependency
+        await Bun.write(
+          path.join(dir, ".opencode", "package.json"),
+          JSON.stringify(
+            {
+              name: "test-plugin",
+              version: "1.0.0",
+              type: "module",
+              dependencies: {
+                "jsonc-parser": "^3.2.0",
+                "@opencode-ai/plugin": "latest",
+              },
+            },
+            null,
+            2,
+          ),
+        )
+
+        // Install dependencies
+        await Bun.$`bun install`.cwd(path.join(dir, ".opencode")).quiet()
+
+        // Create a plugin that uses jsonc-parser
+        await Bun.write(
+          path.join(pluginDir, "test-plugin.ts"),
+          `
+import { parse } from "jsonc-parser"
+import type { Plugin } from "@opencode-ai/plugin"
+
+export const testPlugin: Plugin = async (input) => {
+  // Use jsonc-parser to prove it was bundled
+  const result = parse('{"test": true}')
+  console.log("Plugin loaded with jsonc-parser:", result)
+  return {}
+}
+`,
+        )
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const plugins = config.plugin ?? []
+
+        // Should have found our local plugin
+        const localPlugin = plugins.find((p) => p.includes("test-plugin.ts"))
+        expect(localPlugin).toBeDefined()
+
+        // Verify the bundled-local directory will be used
+        // The bundled plugins go to ~/.cache/opencode/bundled-local/
+        expect(Global.Path.cache).toBeDefined()
+        expect(plugins.length).toBeGreaterThan(0)
+        expect(localPlugin).toContain("file://")
+      },
+    })
+  })
+
+  test("caches bundled local plugins based on file modification time", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      init: async (dir) => {
+        const pluginDir = path.join(dir, ".opencode", "plugin")
+        await fs.mkdir(pluginDir, { recursive: true })
+
+        await Bun.write(
+          path.join(dir, ".opencode", "package.json"),
+          JSON.stringify({ name: "test-cache", version: "1.0.0", type: "module" }, null, 2),
+        )
+
+        await Bun.write(
+          path.join(pluginDir, "cache-test.ts"),
+          `
+import type { Plugin } from "@opencode-ai/plugin"
+export const cacheTestPlugin: Plugin = async () => ({})
+`,
+        )
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const config = await Config.get()
+        const plugins = config.plugin ?? []
+        expect(plugins.some((p) => p.includes("cache-test.ts"))).toBe(true)
+      },
+    })
+  })
+})
diff --git a/packages/opencode/test/preload.ts b/packages/opencode/test/preload.ts
@@ -16,6 +16,10 @@ process.env["XDG_CACHE_HOME"] = path.join(dir, "cache")
 process.env["XDG_CONFIG_HOME"] = path.join(dir, "config")
 process.env["XDG_STATE_HOME"] = path.join(dir, "state")
 
+// Disable default plugins (opencode-anthropic-auth, opencode-copilot-auth) during tests
+// These plugins have dependencies that can fail to bundle in CI environments
+process.env["OPENCODE_DISABLE_DEFAULT_PLUGINS"] = "true"
+
 // Pre-fetch models.json so tests don't need the macro fallback
 // Also write the cache version file to prevent global/index.ts from clearing the cache
 const cacheDir = path.join(dir, "cache", "opencode")
