From d4a5fb4d2a7caa8deca3c8cfd5b9f21b1c4cf318 Mon Sep 17 00:00:00 2001 From: Aiden Cline <63023139+rekram1-node@users.noreply.github.com> Date: Sun, 1 Nov 2026 21:20:13 -0600 Subject: [PATCH] refactor(core): tidy plugin host and config reload wiring (#61176) --- packages/core/src/config/plugin/agent.ts | 47 ++------ packages/core/src/config/plugin/command.ts | 49 ++------- .../core/src/config/plugin/entry-observer.ts | 57 +++++++++- packages/core/src/config/plugin/source.ts | 15 +-- packages/core/src/plugin.ts | 9 +- packages/core/src/plugin/host.ts | 102 ++++++++---------- packages/core/src/plugin/internal.ts | 12 ++- packages/core/src/plugin/module.ts | 17 ++- packages/core/src/plugin/supervisor.ts | 25 +---- 9 files changed, 149 insertions(+), 184 deletions(-) diff --git a/packages/core/src/config/plugin/agent.ts b/packages/core/src/config/plugin/agent.ts index e78ad1243ba..29eb68ea375 100644 --- a/packages/core/src/config/plugin/agent.ts +++ b/packages/core/src/config/plugin/agent.ts @@ -4,10 +4,11 @@ import { define } from "@opencode/plugin/effect/plugin" import { Document, Info, type Entry } from "@opencode/schema/config" import { ConfigAgent } from "@opencode/schema/config/agent" import path from "path" -import { Effect, Option, PubSub, Schema, Stream } from "effect" +import { Effect, Option, Schema } from "effect" import { Agent } from "../../agent.js" import { Config } from "../../config.js" import { ConfigMarkdown } from "../markdown.js" +import { ConfigEntryObserver } from "./entry-observer.js" import { FSUtil } from "@opencode/util/fs-util" import { ConfigAgentV1 } from "../../v1/config/agent.js" import { ConfigMigrateV1 } from "../../v1/config/migrate.js" @@ -52,33 +53,13 @@ export const Plugin = define({ const load = Effect.fn("ConfigAgentPlugin.load")(function* () { return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat())) }) - const loaded = { documents: [] as Document[] } - const reload = load().pipe( - Effect.tap((documents) => Effect.sync(() => (loaded.documents = documents))), - Effect.andThen(ctx.agent.reload()), - ) - // One trigger feed serializes reloads and shares one debounce window; - // subscribing before the initial scan means updates racing the scan still - // trigger a rebuild. Each source is subscribed eagerly on its own fiber - // (Stream.merge and Stream.debounce both open upstream a fiber hop later) - // so no update slips through while the debounce starts its pull. - const changes = yield* PubSub.sliding(1) - const notify = () => PubSub.publish(changes, undefined) - yield* config.changes().pipe( - Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isAgentSource(entries, update.path))), - Stream.runForEach(notify), - Effect.forkScoped({ startImmediately: true }), - ) - yield* ctx.event - .subscribe({ types: ["config.updated"] }) - .pipe(Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true })) - const updates = yield* PubSub.subscribe(changes) - yield* Stream.fromSubscription(updates).pipe( - Stream.debounce("100 millis"), - Stream.runForEach(() => reload), - Effect.forkScoped({ startImmediately: true }), - ) - loaded.documents = yield* load() + const loaded = yield* ConfigEntryObserver.observeSources({ + config, + event: ctx.event, + directories: sourceDirectories, + load, + reload: ctx.agent.reload(), + }) yield* ctx.agent.transform((editor) => { const permissions = expandPermissions( loaded.documents.flatMap((document) => document.info.permissions ?? []), @@ -127,16 +108,6 @@ export const Plugin = define({ }), }) -// Matches anything at or under /{agent,agents,mode,modes}. No file-suffix -// check: directory-level events such as renames carry no per-file paths. -function isAgentSource(entries: Entry[], file: string) { - return entries.some( - (entry) => - entry.type === "directory" && - sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)), - ) -} - function expandPermissions(rules: Permission.Ruleset, home: string): Permission.Ruleset { // Expand only resources tools resolve as filesystem paths. Bash resources are raw shell text: // rewriting `$HOME/private/**` would miss `$HOME/private/key`, and safe expansion needs shell-aware parsing. diff --git a/packages/core/src/config/plugin/command.ts b/packages/core/src/config/plugin/command.ts index c13ff4a5b02..32f59f222ef 100644 --- a/packages/core/src/config/plugin/command.ts +++ b/packages/core/src/config/plugin/command.ts @@ -1,11 +1,11 @@ export * as ConfigCommandPlugin from "./command.js" import { define } from "@opencode/plugin/effect/plugin" -import { Info, type Entry } from "@opencode/schema/config" +import type { Entry } from "@opencode/schema/config" import { ConfigCommand } from "@opencode/schema/config/command" import { AppProcess } from "@opencode/util/process" import path from "path" -import { Effect, Option, PubSub, Schema, Stream } from "effect" +import { Effect, Option, Schema } from "effect" import { ChildProcess } from "effect/process" import { Agent } from "../../agent.js" import { Config } from "../../config.js" @@ -15,6 +15,7 @@ import { SubagentJob } from "../../session/subagent-job.js" import { ShellSelect } from "../../shell/select.js" import { FSUtil } from "@opencode/util/fs-util" import { ConfigMarkdown } from "../markdown.js" +import { ConfigEntryObserver } from "./entry-observer.js" const decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info) @@ -38,33 +39,13 @@ export const Plugin = define({ const load = Effect.fn("ConfigCommandPlugin.load")(function* () { return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat())) }) - const loaded = { documents: [] as { commands: Info["commands"] }[] } - const reload = load().pipe( - Effect.tap((documents) => Effect.sync(() => (loaded.documents = documents))), - Effect.andThen(ctx.command.reload()), - ) - // One trigger feed serializes reloads and shares one debounce window; - // subscribing before the initial scan means updates racing the scan still - // trigger a rebuild. Each source is subscribed eagerly on its own fiber - // (Stream.merge and Stream.debounce both open upstream a fiber hop later) - // so no update slips through while the debounce starts its pull. - const changes = yield* PubSub.sliding(1) - const notify = () => PubSub.publish(changes, undefined) - yield* config.changes().pipe( - Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path))), - Stream.runForEach(notify), - Effect.forkScoped({ startImmediately: true }), - ) - yield* ctx.event - .subscribe({ types: ["config.updated"] }) - .pipe(Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true })) - const updates = yield* PubSub.subscribe(changes) - yield* Stream.fromSubscription(updates).pipe( - Stream.debounce("100 millis"), - Stream.runForEach(() => reload), - Effect.forkScoped({ startImmediately: true }), - ) - loaded.documents = yield* load() + const loaded = yield* ConfigEntryObserver.observeSources({ + config, + event: ctx.event, + directories: sourceDirectories, + load, + reload: ctx.command.reload(), + }) yield* ctx.command.transform((editor) => { for (const document of loaded.documents) { for (const [name, command] of Object.entries(document.commands ?? {})) { @@ -137,16 +118,6 @@ export const Plugin = define({ // Keep in sync with the loadDirectory scan pattern and the name-strip regex in decode. const sourceDirectories = ["command", "commands"] as const -// Matches anything at or under /{command,commands}. No file-suffix check: -// directory-level events such as renames carry no per-file paths. -function isCommandSource(entries: Entry[], file: string) { - return entries.some( - (entry) => - entry.type === "directory" && - sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)), - ) -} - function loadDirectory(fs: FSUtil.Interface, directory: string) { return Effect.gen(function* () { const files = yield* fs diff --git a/packages/core/src/config/plugin/entry-observer.ts b/packages/core/src/config/plugin/entry-observer.ts index 65e77f6b6d6..23ff148d428 100644 --- a/packages/core/src/config/plugin/entry-observer.ts +++ b/packages/core/src/config/plugin/entry-observer.ts @@ -1,7 +1,10 @@ export * as ConfigEntryObserver from "./entry-observer.js" import type { EventDomain } from "@opencode/plugin/effect/event" -import { Effect, Stream } from "effect" +import type { Entry } from "@opencode/schema/config" +import { FSUtil } from "@opencode/util/fs-util" +import { Effect, PubSub, Stream } from "effect" +import path from "path" import { Config } from "../../config.js" export const observe = Effect.fnUntraced(function* ( @@ -22,3 +25,55 @@ export const observe = Effect.fnUntraced(function* ( loaded.entries = yield* config.entries() return loaded }) + +/** + * Loads documents from config entries and reloads them when config is updated or a file changes + * under one of `directories` in a config directory. + */ +export const observeSources = Effect.fnUntraced(function* (input: { + readonly config: Config.Interface + readonly event: EventDomain + readonly directories: readonly string[] + readonly load: () => Effect.Effect + readonly reload: Effect.Effect +}) { + const config = input.config + const loaded = { documents: [] as A[] } + const reload = input.load().pipe( + Effect.tap((documents) => Effect.sync(() => (loaded.documents = documents))), + Effect.andThen(input.reload), + ) + // One trigger feed serializes reloads and shares one debounce window; + // subscribing before the initial scan means updates racing the scan still + // trigger a rebuild. Each source is subscribed eagerly on its own fiber + // (Stream.merge and Stream.debounce both open upstream a fiber hop later) + // so no update slips through while the debounce starts its pull. + const changes = yield* PubSub.sliding(1) + const notify = () => PubSub.publish(changes, undefined) + yield* config.changes().pipe( + Stream.filterEffect((update) => + Effect.map(config.entries(), (entries) => isDirectorySource(entries, update.path, input.directories)), + ), + Stream.runForEach(notify), + Effect.forkScoped({ startImmediately: true }), + ) + yield* input.event + .subscribe({ types: ["config.updated"] }) + .pipe(Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true })) + const updates = yield* PubSub.subscribe(changes) + yield* Stream.fromSubscription(updates).pipe( + Stream.debounce("100 millis"), + Stream.runForEach(() => reload), + Effect.forkScoped({ startImmediately: true }), + ) + loaded.documents = yield* input.load() + return loaded +}) + +// Matches anything at or under / for a config directory. No file-suffix +// check: directory-level events such as renames carry no per-file paths. +export function isDirectorySource(entries: readonly Entry[], file: string, names: readonly string[]) { + return entries.some( + (entry) => entry.type === "directory" && names.some((name) => FSUtil.contains(path.join(entry.path, name), file)), + ) +} diff --git a/packages/core/src/config/plugin/source.ts b/packages/core/src/config/plugin/source.ts index 0e56e44e955..ce26494ffa2 100644 --- a/packages/core/src/config/plugin/source.ts +++ b/packages/core/src/config/plugin/source.ts @@ -12,6 +12,7 @@ import { Config } from "../../config.js" import { Watcher } from "../../filesystem/watcher.js" import { Location } from "../../location.js" import { PluginSourceDirectory } from "../../plugin/source-directory.js" +import { ConfigEntryObserver } from "./entry-observer.js" export type Operation = | { @@ -55,7 +56,7 @@ export const layer = Layer.effect( if (operation.type !== "add" || !path.isAbsolute(operation.target)) continue if (watched.has(operation.target)) continue // The config change feed already covers {plugin,plugins} directories. - if (isPluginSource(entries, operation.target)) continue + if (ConfigEntryObserver.isDirectorySource(entries, operation.target, PluginSourceDirectory.names)) continue watched.add(operation.target) const updates = yield* watcher.subscribe({ path: operation.target, @@ -82,7 +83,9 @@ export const layer = Layer.effect( Stream.merge( config.changes().pipe( Stream.filterEffect((update) => - Effect.map(config.entries(), (entries) => isPluginSource(entries, update.path)), + Effect.map(config.entries(), (entries) => + ConfigEntryObserver.isDirectorySource(entries, update.path, PluginSourceDirectory.names), + ), ), Stream.map(() => undefined), ), @@ -189,11 +192,3 @@ const scan = Effect.fn("ConfigPluginSource.scan")(function* ( }), ).pipe(Effect.map((operations) => operations.flat())) }) - -function isPluginSource(entries: readonly Entry[], file: string) { - return entries.some( - (entry) => - entry.type === "directory" && - PluginSourceDirectory.names.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)), - ) -} diff --git a/packages/core/src/plugin.ts b/packages/core/src/plugin.ts index b7636396b30..ca3175c96a9 100644 --- a/packages/core/src/plugin.ts +++ b/packages/core/src/plugin.ts @@ -13,7 +13,7 @@ import { PluginHost } from "./plugin/host.js" import { type Failure, type Generation, Service } from "./plugin/service.js" import { State } from "./state.js" -export { awaitActivation, type Generation, type Interface, Service } from "./plugin/service.js" +export { awaitActivation, type Failure, type Generation, type Interface, Service } from "./plugin/service.js" const layer = Layer.effect( Service, @@ -40,6 +40,7 @@ const layer = Layer.effect( const pendingFailures = yield* Queue.unbounded() let discovered: readonly Failure[] = [] let inventory: Plugin.Info[] = [] + const snapshot = () => [...Array.from(active.values()).map(slotInfo), ...discovered] // A changed `./gui-experimental` bundle alone restarts nothing; its revision is part of what changes, so the event // tells the app to reload it. const publish = State.changes( @@ -128,7 +129,7 @@ const layer = Layer.effect( if (entry) active.set(definition.id, { ...entry, plugin: definition }) } if (prefix === definitions.length && active.size === definitions.length) { - inventory = [...Array.from(active.values()).map(slotInfo), ...failures] + inventory = snapshot() yield* publish(inventory) return } @@ -180,7 +181,7 @@ const layer = Layer.effect( }) } - inventory = [...Array.from(active.values()).map(slotInfo), ...failures] + inventory = snapshot() }), ) yield* publish(inventory) @@ -204,7 +205,7 @@ const layer = Layer.effect( if (closed) return // Failure is already recorded on its exact activation, so an old queued item // cannot disable a replacement and teardown need not wait for this worker. - inventory = [...Array.from(active.values()).map(slotInfo), ...discovered] + inventory = snapshot() const refreshed = yield* State.batch(item.refresh).pipe(Effect.exit) yield* publish(inventory) if (Exit.isFailure(refreshed)) diff --git a/packages/core/src/plugin/host.ts b/packages/core/src/plugin/host.ts index 41724b235e5..e521b8f93a9 100644 --- a/packages/core/src/plugin/host.ts +++ b/packages/core/src/plugin/host.ts @@ -14,6 +14,7 @@ import { Command } from "../command.js" import { Credential } from "../credential.js" import { Bus } from "../bus.js" import { Integration } from "../integration.js" +import { IntegrationConnection } from "../integration/connection.js" import { KV } from "../kv.js" import { Location } from "../location.js" import { LocationServiceMap } from "../location-service-map.js" @@ -79,11 +80,11 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Pick + const locationInfo = (current: Location.Interface = location) => new Location.Info({ - directory: location.directory, - workspaceID: location.workspaceID, - project: location.project, + directory: current.directory, + workspaceID: current.workspaceID, + project: current.project, }) const locationRef = (input?: { readonly location?: { readonly directory?: string; readonly workspace?: string } }) => input?.location === undefined @@ -97,23 +98,30 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Pick(effect: Effect.Effect) => effect.pipe(Effect.map((data) => ({ location: locationInfo(), data }))) + const atLocation = (ref: Location.Ref, effect: Effect.Effect) => + Effect.gen(function* () { + return { location: locationInfo(yield* Location.Service), data: yield* effect } + }).pipe(Effect.provide(locations.get(ref))) + + const sessionPermission = (input: Parameters[0]) => + permission + .get(input.requestID) + .pipe( + Effect.flatMap((request) => + request?.sessionID === input.sessionID + ? Effect.succeed(request) + : Effect.fail(new Error(`Permission request not found: ${input.requestID}`)), + ), + ) const decodeWorktree = Schema.decodeUnknownEffect(Worktree.Info) const decodeWorktrees = Schema.decodeUnknownEffect(Schema.Array(Worktree.ListEntry)) const listAgents = Effect.fn("PluginHost.listAgents")((ref: Location.Ref) => - Effect.gen(function* () { - const location = yield* Location.Service - const agents = yield* Agent.Service - return { - location: new Location.Info({ - directory: location.directory, - workspaceID: location.workspaceID, - project: location.project, - }), - data: yield* agents.list(), - } - }).pipe(Effect.provide(locations.get(ref)), Effect.orDie), + atLocation( + ref, + Effect.flatMap(Agent.Service, (agents) => agents.list()), + ).pipe(Effect.orDie), ) // Keep the instance graph's inferred types independent of Session handles. @@ -212,10 +220,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Pick editor.add({ ...definition, - sourceConnection: - definition.sourceConnection?.type === "credential" - ? { ...definition.sourceConnection, id: Credential.ID.make(definition.sourceConnection.id) } - : definition.sourceConnection, + sourceConnection: definition.sourceConnection && connectionInfo(definition.sourceConnection), }), update: (id, update) => editor.update(Provider.ID.make(id), update), remove: (id) => editor.remove(Provider.ID.make(id)), @@ -393,17 +398,11 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Pick integration.connection.active(Integration.ID.make(id)), - resolve: (connection) => - integration.connection.resolve( - connection.type === "credential" ? { ...connection, id: Credential.ID.make(connection.id) } : connection, - ), + resolve: (connection) => integration.connection.resolve(connectionInfo(connection)), status: (input) => integration.connection.status({ integrationID: Integration.ID.make(input.integrationID), - connection: - input.connection.type === "credential" - ? { ...input.connection, id: Credential.ID.make(input.connection.id) } - : input.connection, + connection: connectionInfo(input.connection), status: input.status, }), }, @@ -427,18 +426,10 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Pick { const ref = locationRef(input) if (ref && !isCurrentLocation(ref)) - return Effect.gen(function* () { - const location = yield* Location.Service - const mcp = yield* Mcp.Service - return { - location: new Location.Info({ - directory: location.directory, - workspaceID: location.workspaceID, - project: location.project, - }), - data: yield* mcp.servers(), - } - }).pipe(Effect.provide(locations.get(ref))) + return atLocation( + ref, + Effect.flatMap(Mcp.Service, (mcp) => mcp.servers()), + ) return response(mcp.servers()) }, reload: mcp.reload, @@ -456,26 +447,13 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Pick hooks.register("permission", name, callback), list: (input) => permission.forSession(input.sessionID), - get: (input) => - permission - .get(input.requestID) - .pipe( - Effect.flatMap((request) => - request?.sessionID === input.sessionID - ? Effect.succeed(request) - : Effect.fail(new Error(`Permission request not found: ${input.requestID}`)), - ), - ), + get: sessionPermission, reply: (input) => - permission - .get(input.requestID) - .pipe( - Effect.flatMap((request) => - request?.sessionID === input.sessionID - ? permission.reply({ requestID: input.requestID, reply: input.decision, message: input.message }) - : Effect.fail(new Error(`Permission request not found: ${input.requestID}`)), - ), + sessionPermission(input).pipe( + Effect.andThen(() => + permission.reply({ requestID: input.requestID, reply: input.decision, message: input.message }), ), + ), // Plain rejections stay defects, as for built-in tools, so they end the step. assert: (input) => permission.assert(input).pipe( @@ -760,6 +738,14 @@ function methodImplementation(input: IntegrationMethodRegistration): Integration } } +function connectionInfo( + connection: + | (Omit & { readonly id: string }) + | IntegrationConnection.EnvInfo, +): IntegrationConnection.Info { + return connection.type === "credential" ? { ...connection, id: Credential.ID.make(connection.id) } : connection +} + function credential(value: Credential.OAuth) { return Credential.OAuth.make({ ...value, methodID: Integration.MethodID.make(value.methodID) }) } diff --git a/packages/core/src/plugin/internal.ts b/packages/core/src/plugin/internal.ts index b9c00737dc4..074e239a940 100644 --- a/packages/core/src/plugin/internal.ts +++ b/packages/core/src/plugin/internal.ts @@ -3,6 +3,7 @@ export * as PluginInternal from "./internal.js" import { LLMClient } from "@opencode/ai/effect" import type { Plugin } from "@opencode/plugin/effect/plugin" import { LayerNode } from "@opencode/util/effect/layer-node" +import type { Generation } from "./service.js" import { httpClient } from "@opencode/util/effect/app-node-platform" import { AppProcess } from "@opencode/util/process" import { Context, Effect, Scope } from "effect" @@ -303,10 +304,13 @@ export const list = Effect.fn("PluginInternal.list")(function* () { const context = Context.pick(...services)(yield* Effect.context()) const resolve = (plugins: readonly InternalPlugin[]) => plugins.map( - (plugin): Plugin => ({ - id: plugin.id, - effect: (host) => plugin.effect(host).pipe(Effect.provide(context)), - }), + (plugin) => + ({ + id: plugin.id, + effect: (host) => plugin.effect(host).pipe(Effect.provide(context)), + revision: "internal", + source: { type: "builtin" }, + }) satisfies Generation, ) return { pre: resolve(pre), diff --git a/packages/core/src/plugin/module.ts b/packages/core/src/plugin/module.ts index b76edff7d77..e450290f2cf 100644 --- a/packages/core/src/plugin/module.ts +++ b/packages/core/src/plugin/module.ts @@ -2,7 +2,7 @@ export * as PluginModule from "./module.js" import type { Plugin } from "@opencode/plugin/effect/plugin" import { Host } from "@opencode/plugin/host" -import { GuiBundle } from "@opencode/schema/plugin" +import { GuiBundle, type Source } from "@opencode/schema/plugin" import { createPluginSources } from "@opencode/plugin/source" import { Hash } from "@opencode/util/hash" import { Npm } from "@opencode/util/npm" @@ -58,6 +58,12 @@ export const make = Effect.fn("PluginModule.make")(function* () { } }) +// A local plugin's directory (or legacy standalone file), where clients resolve its other parts. +export function source(target: string, version?: string): Source { + if (path.isAbsolute(target)) return { type: "local", path: target } + return { type: "package", target, ...(version ? { version } : {}) } +} + // A missing dependency may have missing parents too. Watch the nearest existing // ancestor recursively so creating the rest of the path can trigger recovery. function watchTarget(file: string): Promise { @@ -154,14 +160,7 @@ const load = Effect.fn("PluginModule.load")(function* ( ? { file: entrypoints.gui, revision: Hash.sha256(JSON.stringify([revision, bundle])), options: guiOptions } : undefined, revision, - // A local plugin's directory (or legacy standalone file), where clients resolve its other parts. - source: local - ? { type: "local" as const, path: operation.target } - : { - type: "package" as const, - target: operation.target, - ...(installed?.version ? { version: installed.version } : {}), - }, + source: source(operation.target, installed?.version), effect: (host) => plugin.effect({ ...host, options: operation.options }), } satisfies Generation }) diff --git a/packages/core/src/plugin/supervisor.ts b/packages/core/src/plugin/supervisor.ts index bba12a83414..c5f320e4c80 100644 --- a/packages/core/src/plugin/supervisor.ts +++ b/packages/core/src/plugin/supervisor.ts @@ -2,7 +2,6 @@ export * as PluginSupervisor from "./supervisor.js" import { Event } from "@opencode/schema/config" import { Cause, Effect, Layer, Queue, Stream } from "effect" -import path from "path" import { ConfigPluginSource } from "../config/plugin/source.js" import { makeLocationNode } from "@opencode/util/effect/app-node" import { Bus } from "../bus.js" @@ -29,10 +28,7 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* ( const enabled = new Set(definitions.map((plugin) => plugin.id)) const packages = new Map() const pending = new Set() - const failures = new Map< - string, - Plugin.Info & { readonly state: Extract } - >() + const failures = new Map() const plugins = () => [...definitions, ...packages.values()] for (const operation of operations) { @@ -77,7 +73,7 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* ( } if ("error" in plugin) { failures.set(operation.target, { - source: pluginSource(operation.target), + source: PluginModule.source(operation.target), state: { status: "failed", error: plugin.error, ref: plugin.ref }, features: { server: true }, }) @@ -147,16 +143,8 @@ export const layer = Layer.effectDiscard( // Combine internal plugins with host-contributed plugins in boot order. // Instance-bound plugins come last: later activation can override earlier // container writes, so the instance's explicit choices win over globals. - const pre = [ - ...internal.pre.map((plugin) => ({ ...plugin, revision: "internal", source: { type: "builtin" as const } })), - ...sdk.all(), - ...instance.all(), - ] - const post = internal.post.map((plugin) => ({ - ...plugin, - revision: "internal", - source: { type: "builtin" as const }, - })) + const pre = [...internal.pre, ...sdk.all(), ...instance.all()] + const post = internal.post const operations = yield* sources.operations() // Activate everything available locally before waiting on missing package installs. const immediate = yield* resolve(modules, pre, post, operations, false, running) @@ -257,9 +245,4 @@ const nodeDeps = [ PluginInternal.requirements, ] as const -function pluginSource(target: string): Plugin.Source { - if (path.isAbsolute(target)) return { type: "local", path: target } - return { type: "package", target } -} - export const node = makeLocationNode({ name: "plugin-supervisor", layer, deps: nodeDeps })