feat(core): manage configurable plugin generations

packages/core/src/config/plugin/agent.ts

@@ -1,6 +1,6 @@
 export * as ConfigAgentPlugin from "./agent"
 
-import { define } from "../../plugin/internal"
+import { define } from "@opencode-ai/plugin/v2/effect/plugin"
 import path from "path"
 import { Effect, Option, Schema, Stream } from "effect"
 import { AgentV2 } from "../../agent"
@@ -34,7 +34,7 @@ const agentKeys = new Set([
 ])
 
 export const Plugin = define({
-  id: "config-agent",
+  id: "opencode.config.agent",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const fs = yield* FSUtil.Service

packages/core/src/config/plugin/command.ts

@@ -1,6 +1,6 @@
 export * as ConfigCommandPlugin from "./command"
 
-import { define } from "../../plugin/internal"
+import { define } from "@opencode-ai/plugin/v2/effect/plugin"
 import path from "path"
 import { Effect, Option, Schema, Stream } from "effect"
 import { CommandV2 } from "../../command"
@@ -13,7 +13,7 @@ import { ConfigMarkdown } from "../markdown"
 const decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info)
 
 export const Plugin = define({
-  id: "config-command",
+  id: "opencode.config.command",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const fs = yield* FSUtil.Service

packages/core/src/config/plugin/external.ts

@@ -1,136 +0,0 @@
-export * as ConfigExternalPlugin from "./external"
-
-import type { Plugin as EffectPlugin } from "@opencode-ai/plugin/v2/effect"
-import type { Plugin as PromisePlugin } from "@opencode-ai/plugin/v2/promise"
-import { Effect, Schema } from "effect"
-import path from "path"
-import { fileURLToPath, pathToFileURL } from "url"
-import { Config } from "../../config"
-import { FSUtil } from "../../fs-util"
-import { Location } from "../../location"
-import { Npm } from "../../npm"
-import { define } from "../../plugin/internal"
-import { PluginPromise } from "../../plugin/promise"
-
-const PluginModule = Schema.Struct({
-  default: Schema.Union([
-    Schema.Struct({
-      id: Schema.String,
-      effect: Schema.declare<EffectPlugin["effect"]>(
-        (input): input is EffectPlugin["effect"] => typeof input === "function",
-      ),
-    }),
-    Schema.Struct({
-      id: Schema.String,
-      setup: Schema.declare<PromisePlugin["setup"]>(
-        (input): input is PromisePlugin["setup"] => typeof input === "function",
-      ),
-    }),
-  ]),
-})
-
-const PluginPackage = Schema.Struct({
-  exports: Schema.optional(Schema.Unknown),
-  main: Schema.optional(Schema.String),
-  module: Schema.optional(Schema.String),
-})
-
-export const Plugin = define({
-  id: "config-plugin",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const fs = yield* FSUtil.Service
-    const location = yield* Location.Service
-    const npm = yield* Npm.Service
-    const load = Effect.fn("ConfigExternalPlugin.load")(function* () {
-      const configured: { package: string; options?: Record<string, unknown> }[] = []
-
-      for (const entry of yield* config.entries()) {
-        if (entry.type === "document") {
-          const directory = entry.path ? path.dirname(entry.path) : location.directory
-          for (const item of entry.info.plugins ?? []) {
-            const ref = typeof item === "string" ? { package: item } : item
-            const packageName = (() => {
-              if (ref.package.startsWith("file://")) return fileURLToPath(ref.package)
-              if (ref.package.startsWith("./") || ref.package.startsWith("../")) {
-                return path.resolve(directory, ref.package)
-              }
-              return ref.package
-            })()
-            configured.push({ package: packageName, options: ref.options })
-          }
-        }
-
-        if (entry.type === "directory") {
-          const files = yield* fs
-            .glob("{plugin,plugins}/*.{ts,js}", {
-              cwd: entry.path,
-              absolute: true,
-              include: "file",
-              dot: true,
-              symlink: true,
-            })
-            .pipe(Effect.orElseSucceed(() => []))
-          const directories = yield* fs
-            .glob("{plugin,plugins}/*", {
-              cwd: entry.path,
-              absolute: true,
-              include: "all",
-              dot: true,
-              symlink: true,
-            })
-            .pipe(
-              Effect.flatMap((items) =>
-                Effect.filter(items, (item) => fs.isDir(item), {
-                  concurrency: "unbounded",
-                }),
-              ),
-              Effect.orElseSucceed(() => []),
-            )
-          const packages = yield* Effect.forEach(
-            directories.sort(),
-            (directory) => resolvePackageEntrypoint(fs, directory),
-            { concurrency: "unbounded" },
-          ).pipe(Effect.map((items) => items.filter((item): item is string => item !== undefined)))
-          files.sort()
-          for (const file of files) configured.push({ package: file })
-          for (const file of packages) configured.push({ package: file })
-        }
-      }
-
-      return yield* Effect.forEach(configured, (ref) =>
-        Effect.gen(function* () {
-          const entrypoint = path.isAbsolute(ref.package)
-            ? pathToFileURL(ref.package).href
-            : (yield* npm.add(ref.package)).entrypoint
-          if (!entrypoint) return
-          yield* Effect.log({ msg: "loading plugin", id: ref.package, entrypoint })
-          const mod = yield* Effect.promise(() => import(entrypoint))
-          const value = (yield* Schema.decodeUnknownEffect(PluginModule)(mod)).default
-          const plugin = "effect" in value ? value : PluginPromise.fromPromise(value)
-          return {
-            id: plugin.id,
-            effect: (host: Parameters<typeof plugin.effect>[0]) =>
-              plugin.effect({ ...host, options: ref.options ?? {} }),
-          }
-        }).pipe(Effect.catchCause(() => Effect.succeed(undefined))),
-      ).pipe(Effect.map((plugins) => plugins.filter((plugin) => plugin !== undefined)))
-    })
-    for (const plugin of yield* load()) yield* ctx.plugin.add(plugin)
-  }),
-})
-
-const resolvePackageEntrypoint = Effect.fnUntraced(function* (fs: FSUtil.Interface, directory: string) {
-  const pkg = yield* fs.readJson(path.join(directory, "package.json")).pipe(
-    Effect.flatMap(Schema.decodeUnknownEffect(PluginPackage)),
-    Effect.catch(() => Effect.succeed(undefined)),
-  )
-  const exported = typeof pkg?.exports === "string" ? pkg.exports : undefined
-  const entries = [exported, pkg?.module, pkg?.main, "index.ts", "index.js"]
-
-  return yield* Effect.forEach(entries, (entry) => {
-    if (!entry) return Effect.succeed(undefined)
-    const file = path.resolve(directory, entry)
-    return fs.isFile(file).pipe(Effect.map((exists) => (exists ? file : undefined)))
-  }).pipe(Effect.map((items) => items.find((item): item is string => item !== undefined)))
-})

packages/core/src/config/plugin/provider.ts

@@ -1,12 +1,12 @@
 export * as ConfigProviderPlugin from "./provider"
 
-import { define } from "../../plugin/internal"
+import { define } from "@opencode-ai/plugin/v2/effect/plugin"
 import { Effect, Stream } from "effect"
 import { Config } from "../../config"
 import { ModelV2 } from "../../model"
 
 export const Plugin = define({
-  id: "config-provider",
+  id: "opencode.config.provider",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const loaded = { entries: yield* config.entries() }

packages/core/src/config/plugin/reference.ts

@@ -1,6 +1,6 @@
 export * as ConfigReferencePlugin from "./reference"
 
-import { define } from "../../plugin/internal"
+import { define } from "@opencode-ai/plugin/v2/effect/plugin"
 import path from "path"
 import { Effect, Stream } from "effect"
 import { Config } from "../../config"
@@ -11,7 +11,7 @@ import { Global } from "../../global"
 import { Location } from "../../location"
 
 export const Plugin = define({
-  id: "core/config-reference",
+  id: "opencode.config.reference",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const location = yield* Location.Service

packages/core/src/config/plugin/skill.ts

@@ -1,6 +1,6 @@
 export * as ConfigSkillPlugin from "./skill"
 
-import { define } from "../../plugin/internal"
+import { define } from "@opencode-ai/plugin/v2/effect/plugin"
 import path from "path"
 import { Effect, Stream } from "effect"
 import { Config } from "../../config"
@@ -10,7 +10,7 @@ import { Global } from "../../global"
 import { Location } from "../../location"
 
 export const Plugin = define({
-  id: "config-skill",
+  id: "opencode.config.skill",
   effect: Effect.fn(function* (ctx) {
     const config = yield* Config.Service
     const global = yield* Global.Service