136 lines
4.8 KiB
TypeScript
136 lines
4.8 KiB
TypeScript
export * as PluginV2 from "./plugin"
|
|
|
|
import type { Plugin } from "@opencode-ai/plugin/v2/effect"
|
|
import { Event, ID, type Info } from "@opencode-ai/schema/plugin"
|
|
import { makeLocationNode } from "./effect/app-node"
|
|
import { Context, Effect, Exit, Layer, Scope, Semaphore } from "effect"
|
|
import { AgentV2 } from "./agent"
|
|
import { AISDK } from "./aisdk"
|
|
import { Catalog } from "./catalog"
|
|
import { CommandV2 } from "./command"
|
|
import { EventV2 } from "./event"
|
|
import { Integration } from "./integration"
|
|
import { Location } from "./location"
|
|
import { PluginHost } from "./plugin/host"
|
|
import { PluginRuntime } from "./plugin/runtime"
|
|
import { Reference } from "./reference"
|
|
import { SkillV2 } from "./skill"
|
|
import { State } from "./state"
|
|
import { ToolRegistry } from "./tool/registry"
|
|
import { ToolHooks } from "./tool/hooks"
|
|
|
|
export interface Interface {
|
|
readonly activate: (plugins: readonly { readonly plugin: Plugin; readonly version?: string }[]) => Effect.Effect<void>
|
|
readonly list: () => Effect.Effect<Info[]>
|
|
}
|
|
|
|
export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Plugin") {}
|
|
|
|
const layer = Layer.effect(
|
|
Service,
|
|
Effect.gen(function* () {
|
|
const events = yield* EventV2.Service
|
|
const scope = yield* Scope.make()
|
|
const active = new Map<typeof ID.Type, Scope.Closeable>()
|
|
const lock = Semaphore.makeUnsafe(1)
|
|
let generation: readonly { readonly id: typeof ID.Type; readonly version?: string }[] | undefined = []
|
|
let host: Parameters<Plugin["effect"]>[0]
|
|
|
|
const activate = Effect.fn("Plugin.activate")(function* (
|
|
plugins: readonly { readonly plugin: Plugin; readonly version?: string }[],
|
|
) {
|
|
const definitions = plugins.map((entry) => ({
|
|
...entry.plugin,
|
|
id: ID.make(entry.plugin.id),
|
|
...(entry.version === undefined ? {} : { version: entry.version }),
|
|
}))
|
|
const ids = new Set<typeof ID.Type>()
|
|
for (const definition of definitions) {
|
|
if (ids.has(definition.id)) return yield* Effect.die(new Error(`Duplicate plugin ID: ${definition.id}`))
|
|
ids.add(definition.id)
|
|
}
|
|
|
|
yield* lock.withPermit(
|
|
Effect.gen(function* () {
|
|
if (
|
|
generation !== undefined &&
|
|
generation.length === definitions.length &&
|
|
generation.every(
|
|
(plugin, index) => plugin.id === definitions[index]?.id && plugin.version === definitions[index]?.version,
|
|
)
|
|
) {
|
|
return
|
|
}
|
|
generation = undefined
|
|
const exit = yield* State.batch(
|
|
Effect.gen(function* () {
|
|
const scopes = Array.from(active.values()).toReversed()
|
|
active.clear()
|
|
const inherit = yield* State.inherit()
|
|
yield* Effect.forEach(scopes, (scope) => Scope.close(scope, Exit.void).pipe(Effect.ignore), {
|
|
discard: true,
|
|
})
|
|
|
|
for (const definition of definitions) {
|
|
const child = yield* Scope.fork(scope)
|
|
const loaded = yield* Effect.suspend(() => definition.effect(host)).pipe(
|
|
inherit,
|
|
Effect.updateContext((_context: Context.Context<never>) => Context.make(Scope.Scope, child)),
|
|
Effect.withSpan("Plugin.load", { attributes: { "plugin.id": definition.id } }),
|
|
Effect.andThen(events.publish(Event.Added, { id: definition.id })),
|
|
Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(child, exit) : Effect.void)),
|
|
Effect.exit,
|
|
)
|
|
if (Exit.isFailure(loaded)) return loaded
|
|
active.set(definition.id, child)
|
|
}
|
|
return Exit.void
|
|
}),
|
|
)
|
|
if (Exit.isFailure(exit)) return yield* exit
|
|
generation = definitions.map((definition) => ({
|
|
id: definition.id,
|
|
...(definition.version === undefined ? {} : { version: definition.version }),
|
|
}))
|
|
yield* events.publish(Event.Updated, {})
|
|
}),
|
|
)
|
|
})
|
|
|
|
yield* Effect.addFinalizer((exit) =>
|
|
Effect.gen(function* () {
|
|
active.clear()
|
|
generation = []
|
|
yield* State.batch(Scope.close(scope, exit))
|
|
}),
|
|
)
|
|
|
|
const service = Service.of({
|
|
activate,
|
|
list: Effect.fn("Plugin.list")(function* () {
|
|
return Array.from(active.keys()).map((id) => ({ id }))
|
|
}),
|
|
})
|
|
host = yield* PluginHost.make(service)
|
|
return service
|
|
}),
|
|
)
|
|
|
|
export const node = makeLocationNode({
|
|
service: Service,
|
|
layer,
|
|
deps: [
|
|
EventV2.node,
|
|
AgentV2.node,
|
|
AISDK.node,
|
|
Catalog.node,
|
|
CommandV2.node,
|
|
Integration.node,
|
|
Location.node,
|
|
Reference.node,
|
|
SkillV2.node,
|
|
ToolRegistry.toolsNode,
|
|
ToolHooks.node,
|
|
PluginRuntime.node,
|
|
],
|
|
})
|