@opencode/plugin 0.0.0-dev-20713 → 0.0.0-dev-20716

package/README.md

@@ -0,0 +1,18 @@
+# `@opencode/plugin`
+
+Authoring interfaces and runtime loader support for OpenCode V2 plugins:
+
+- `@opencode/plugin` — [Promise plugin API](./src/README.md)
+- `@opencode/plugin/effect` — [Effect plugin API](./src/effect/README.md)
+- `@opencode/plugin/rpc` — portable RPC contract definitions
+- `@opencode/plugin/tui` — terminal UI plugin API
+
+## Packaging And Runtime `effect`
+
+When the OpenCode CLI loads server or TUI plugins, it resolves imports of `effect`, exported `effect/*` subpaths, and `@opencode/plugin` entrypoints (including imports from dependencies inside a plugin's `node_modules`) to the host's runtime module instances so fibers, loggers, and `Schema` parsers share one copy.
+
+- Declare `effect` as a `peerDependency` (and `devDependency` for local type-checking and testing) rather than a bundled runtime dependency.
+- Do not bundle `effect` into published plugin files; if you build with a bundler, keep `effect` and `effect/*` external. Two copies of `effect` do not share fiber, logger, or `Schema` internals.
+- Plugins and their `node_modules` dependencies always receive OpenCode's host `effect` instance. Use `effect` APIs and module paths compatible with the OpenCode release you target; dependencies built on another `effect` major (such as Effect 3) are not supported.
+- Only public `effect` subpaths are provided. A plugin that imports one of Effect's private `internal` modules fails to load with an error naming the path.
+- The compiled OpenCode binary does not include the Scalar and Swagger UI assets used by Effect's HTTP API docs pages; serving those pages from a plugin shows a notice instead.

package/dist/runtime-modules.d.ts

@@ -0,0 +1,6 @@
+export type RuntimeModuleLoader = () => Record<string, unknown> | Promise<Record<string, unknown>>;
+export declare function resolveHostPackageRoots(from?: string, packages?: readonly string[]): string[];
+export declare function loadRuntimeModules(): Readonly<Record<string, RuntimeModuleLoader>>;
+export declare function discoverPluginRuntimeSpecifiers(from?: string, packages?: readonly string[]): ReadonlyMap<string, string>;
+export declare function pluginRuntimeLoaderCode(specifier: string, entries: ReadonlyMap<string, string>): string;
+export declare function createLoader(resolved: string): RuntimeModuleLoader;

package/dist/runtime-modules.js

@@ -0,0 +1,101 @@
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const runtimePackages = ["effect", "@opencode/plugin"];
+export function resolveHostPackageRoots(from = import.meta.dir, packages = runtimePackages) {
+    return packages.flatMap((pkgName) => {
+        const dir = path.dirname(Bun.resolveSync(`${pkgName}/package.json`, from));
+        return [dir, findNodeModulesDir(pkgName, from, dir)];
+    });
+}
+export function loadRuntimeModules() {
+    const entries = discoverPluginRuntimeSpecifiers();
+    const effectEntry = entries.get("effect");
+    if (effectEntry)
+        require(effectEntry);
+    return Object.fromEntries([...entries.entries()].map(([specifier, resolved]) => [specifier, createLoader(resolved)]));
+}
+export function discoverPluginRuntimeSpecifiers(from = import.meta.dir, packages = runtimePackages) {
+    const entries = new Map();
+    for (const pkgName of packages) {
+        const realDir = path.dirname(Bun.resolveSync(`${pkgName}/package.json`, from));
+        // Resolve workspace @opencode/plugin paths via node_modules so OpenTUI does not wrap host files in async rewrite loaders.
+        const loadDir = findNodeModulesDir(pkgName, from, realDir);
+        const toLoadPath = (resolved) => loadDir === realDir ? resolved : path.join(loadDir, path.relative(realDir, resolved));
+        const rootEntry = Bun.resolveSync(pkgName, from);
+        const relParts = path.relative(realDir, rootEntry).replaceAll("\\", "/").split("/");
+        const scanDir = relParts.length > 1 ? path.join(realDir, relParts[0]) : realDir;
+        const ext = path.extname(rootEntry) || ".js";
+        entries.set(pkgName, toLoadPath(rootEntry));
+        for (const file of new Bun.Glob(`**/*${ext}`).scanSync({ cwd: scanDir })) {
+            const normalized = file.replaceAll("\\", "/");
+            if (normalized.startsWith("internal/") ||
+                normalized.includes("/internal/") ||
+                normalized.startsWith("source.") ||
+                normalized.startsWith("runtime")) {
+                continue;
+            }
+            const base = normalized.slice(0, -ext.length);
+            if (base === "index")
+                continue;
+            const candidates = base.endsWith("/index")
+                ? [`${pkgName}/${base.slice(0, -"/index".length)}`, `${pkgName}/${base}`]
+                : [`${pkgName}/${base}`];
+            for (const specifier of candidates) {
+                if (entries.has(specifier))
+                    continue;
+                try {
+                    entries.set(specifier, toLoadPath(Bun.resolveSync(specifier, from)));
+                }
+                catch { }
+            }
+        }
+    }
+    return entries;
+}
+export function pluginRuntimeLoaderCode(specifier, entries) {
+    if (specifier.startsWith("effect/")) {
+        const slash = specifier.lastIndexOf("/");
+        const parent = specifier.slice(0, slash);
+        const member = specifier.slice(slash + 1);
+        const parentResolved = entries.get(parent);
+        const resolved = entries.get(specifier);
+        if (member !== "index" &&
+            parentResolved &&
+            resolved &&
+            require(parentResolved)[member] === require(resolved)) {
+            return `() => require(${JSON.stringify(parent)})[${JSON.stringify(member)}]`;
+        }
+    }
+    return `() => require(${JSON.stringify(specifier)})`;
+}
+export function createLoader(resolved) {
+    let cached;
+    let pending;
+    return () => {
+        if (cached)
+            return cached;
+        if (pending)
+            return pending;
+        try {
+            return (cached = require(resolved));
+        }
+        catch {
+            return (pending = import(pathToFileURL(resolved).href).then((mod) => (cached = mod), (error) => {
+                pending = undefined;
+                throw error;
+            }));
+        }
+    };
+}
+function findNodeModulesDir(pkgName, from, realDir) {
+    if (/[/\\]node_modules[/\\]/.test(realDir))
+        return realDir;
+    for (let dir = path.resolve(from);; dir = path.dirname(dir)) {
+        const candidate = path.join(dir, "node_modules", pkgName);
+        if (existsSync(candidate) && realpathSync(candidate) === realDir)
+            return candidate;
+        if (path.dirname(dir) === dir)
+            return realDir;
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,4 @@
+import { type RuntimeModuleLoader } from "./runtime-modules.js";
+export declare function provides(specifier: string): boolean;
+export declare function ensurePluginRuntime(): Readonly<Record<string, RuntimeModuleLoader>>;
+export declare function createForeignPackageFilter(rootsInput?: Iterable<string>): RegExp;

package/dist/runtime.js

@@ -0,0 +1,46 @@
+import { loadRuntimeModules, resolveHostPackageRoots } from "./runtime-modules.js";
+const foreignPkgSuffix = String.raw `(?:node_modules[/\\](@opencode[/\\]plugin|effect)|(@opencode[/\\]plugin|effect)@[^/\\]+@@@\d+)`;
+const foreignPkgPattern = new RegExp(String.raw `^(.*[/\\]${foreignPkgSuffix})[/\\](.+)$`);
+let installed;
+export function provides(specifier) {
+    return installed !== undefined && Object.hasOwn(installed, specifier);
+}
+export function ensurePluginRuntime() {
+    if (typeof Bun === "undefined")
+        return {};
+    if (installed)
+        return installed;
+    const modules = loadRuntimeModules();
+    installed = modules;
+    Bun.plugin({
+        name: "opencode-plugin-runtime",
+        setup(build) {
+            for (const [specifier, load] of Object.entries(modules)) {
+                build.module(specifier, () => {
+                    const exports = load();
+                    return exports instanceof Promise
+                        ? exports.then((value) => ({ exports: value, loader: "object" }))
+                        : { exports, loader: "object" };
+                });
+            }
+            build.onLoad({ filter: createForeignPackageFilter() }, (args) => {
+                const match = args.path.match(foreignPkgPattern);
+                const target = match ? `${match[2] ?? match[3]}/${match[4]}`.replaceAll("\\", "/") : args.path;
+                throw new Error(`Cannot load "${target}" from plugin node_modules: "${target}" is not provided by OpenCode; plugins must use the host's "effect" and "@opencode/plugin" modules.`);
+            });
+        },
+    });
+    return modules;
+}
+export function createForeignPackageFilter(rootsInput = resolveHostPackageRoots()) {
+    const suffix = String.raw `[/\\]${foreignPkgSuffix}[/\\].*\.[cm]?[jt]sx?(?:[?#].*)?$`;
+    const roots = [...new Set(rootsInput)];
+    if (roots.length === 0)
+        return new RegExp(suffix);
+    const escaped = roots
+        .map((value) => value
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/(?:\\\/|\\\\|\/)+/g, "[/\\\\]"))
+        .join("|");
+    return new RegExp(`^(?!(?:${escaped})[/\\\\]).*${suffix}`);
+}

package/dist/source.bun.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { Host } from "./host.js";
+import { provides } from "./runtime.js";
 import { localSource } from "./source.js";
 import { missingPackageTarget } from "./source.package.js";
 let generation = Date.now();
@@ -41,6 +42,8 @@ export async function prepareSource(entrypoint, track) {
                 ? new URL(item.path, pathToFileURL(file))
                 : localSource(item.path, path.dirname(file));
             if (!local) {
+                if (provides(item.path))
+                    continue;
                 try {
                     Bun.resolveSync(item.path, path.dirname(file));
                 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/plugin",
-  "version": "0.0.0-dev-20713",
+  "version": "0.0.0-dev-20716",
   "type": "module",
   "license": "MIT",
   "scripts": {
@@ -22,6 +22,10 @@
       "import": "./dist/host.js",
       "types": "./dist/host.d.ts"
     },
+    "./runtime": {
+      "import": "./dist/runtime.js",
+      "types": "./dist/runtime.d.ts"
+    },
     "./tui": {
       "import": "./dist/tui/index.js",
       "types": "./dist/tui/index.d.ts"
@@ -43,15 +47,15 @@
   ],
   "dependencies": {
     "@ai-sdk/provider": "3.0.8",
-    "@opencode/ai": "0.0.0-dev-20713",
-    "@opencode/client": "0.0.0-dev-20713",
-    "@opencode/protocol": "0.0.0-dev-20713",
-    "@opencode/schema": "0.0.0-dev-20713",
-    "@opencode/util": "0.0.0-dev-20713",
+    "@opencode/ai": "0.0.0-dev-20716",
+    "@opencode/client": "0.0.0-dev-20716",
+    "@opencode/protocol": "0.0.0-dev-20716",
+    "@opencode/schema": "0.0.0-dev-20716",
+    "@opencode/util": "0.0.0-dev-20716",
     "effect": "4.0.0-rc.112"
   },
   "peerDependencies": {
-    "@opencode/theme": "0.0.0-dev-20713",
+    "@opencode/theme": "0.0.0-dev-20716",
     "@opentui/core": ">=0.5.16",
     "@opentui/solid": ">=0.5.16",
     "solid-js": ">=1.9.0"
@@ -71,7 +75,7 @@
     }
   },
   "devDependencies": {
-    "@opencode/theme": "0.0.0-dev-20713",
+    "@opencode/theme": "0.0.0-dev-20716",
     "@opentui/core": "0.5.16",
     "@opentui/solid": "0.5.16",
     "@tsconfig/bun": "1.0.9",