@opencode-ai/core 0.0.0-beta-18743 → 0.0.0-beta-18955

package/dist/chunks/event-logger-2dy05jzf.js

@@ -0,0 +1,206 @@
+import {
+  exports_sdk
+} from "./event-logger-xdbcpqje.js";
+import {
+  exports_module
+} from "./event-logger-r7a2r1m6.js";
+import {
+  exports_update
+} from "./event-logger-dtm6fkaa.js";
+import {
+  exports_internal
+} from "./event-logger-88rtces7.js";
+import {
+  exports_instance
+} from "./event-logger-qf52r0wh.js";
+import {
+  exports_source
+} from "./event-logger-ety6zxes.js";
+import {
+  exports_plugin
+} from "./event-logger-r6n0mc8a.js";
+import {
+  exports_bus
+} from "./event-logger-vw7aptj1.js";
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/plugin/supervisor.ts
+var exports_supervisor = {};
+__export(exports_supervisor, {
+  PluginSupervisor: () => exports_supervisor,
+  layer: () => layer,
+  node: () => node
+});
+import { Event } from "@opencode-ai/schema/config";
+import { Cause, Effect, Layer, PubSub, Stream } from "effect";
+import path from "path";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Npm } from "@opencode-ai/util/npm";
+var resolve = Effect.fn("PluginSupervisor.resolve")(function* (pre, post, operations, install, running) {
+  const matches = (selector, target) => selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target);
+  const definitions = [...pre, ...post];
+  const enabled = new Set(definitions.map((plugin) => plugin.id));
+  const packages = new Map;
+  const pending = new Set;
+  const failures = new Map;
+  const plugins = () => [...definitions, ...packages.values()];
+  for (const operation of operations) {
+    if (operation.type === "remove") {
+      if (operation.target === "*")
+        failures.clear();
+      plugins().filter((plugin2) => matches(operation.target, plugin2.id)).forEach((plugin2) => enabled.delete(plugin2.id));
+      continue;
+    }
+    const matched = plugins().filter((plugin2) => matches(operation.target, plugin2.id));
+    const selectsPlugins = matched.length > 0 || operation.target === "*" || operation.target.endsWith(".*") || operation.target.startsWith("opencode.");
+    if (selectsPlugins) {
+      matched.forEach((plugin2) => enabled.add(plugin2.id));
+      continue;
+    }
+    const plugin = yield* exports_module.load(operation, { install }).pipe(Effect.catchCause((cause) => {
+      const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+      const error = Cause.squash(cause);
+      return Effect.logWarning("failed to load plugin", { target: operation.target, ref, cause }).pipe(Effect.as({ error: error instanceof exports_module.LoadError ? error.message : "Plugin failed to load", ref }));
+    }));
+    if ("pending" in plugin) {
+      pending.add(operation.target);
+      continue;
+    }
+    if ("error" in plugin) {
+      failures.set(operation.target, {
+        source: pluginSource(operation.target),
+        state: { status: "failed", error: plugin.error, ref: plugin.ref },
+        features: { server: true }
+      });
+      const retained = packages.get(operation.target) ?? running.get(operation.target);
+      if (!retained)
+        continue;
+      packages.set(operation.target, retained);
+      enabled.add(retained.id);
+      continue;
+    }
+    failures.delete(operation.target);
+    const previous = packages.get(operation.target);
+    if (previous)
+      enabled.delete(previous.id);
+    packages.set(operation.target, plugin);
+    enabled.add(plugin.id);
+  }
+  const ordered = [
+    ...pre.filter((plugin) => enabled.has(plugin.id)),
+    ...[...packages.values()].filter((plugin) => enabled.has(plugin.id)),
+    ...post.filter((plugin) => enabled.has(plugin.id))
+  ];
+  const duplicate = (plugin, index) => ordered.findIndex((other) => other.id === plugin.id) !== index;
+  return {
+    plugins: ordered.filter((plugin, index) => !duplicate(plugin, index)),
+    packages: new Map([...packages].filter(([, plugin]) => enabled.has(plugin.id))),
+    failures: [
+      ...failures.values(),
+      ...ordered.filter(duplicate).map((plugin) => ({
+        id: exports_plugin.ID.make(plugin.id),
+        source: plugin.source ?? { type: "builtin" },
+        state: { status: "failed", error: `Duplicate plugin ID: ${plugin.id}` },
+        features: { server: true, ...plugin.features }
+      }))
+    ],
+    pending: [...pending]
+  };
+});
+var layer = Layer.effectDiscard(Effect.gen(function* () {
+  const registry = yield* exports_plugin.Service;
+  const sdk = yield* exports_sdk.Service;
+  const instance = yield* exports_instance.Service;
+  const sources = yield* exports_source.Service;
+  const bus = yield* exports_bus.Service;
+  const updates = yield* exports_update.Service;
+  const internal = yield* exports_internal.list();
+  let release = yield* registry.hold();
+  yield* Effect.addFinalizer(() => release ?? Effect.void);
+  yield* Effect.addFinalizer(registry.close);
+  let packages = new Set;
+  let running = new Map;
+  let outdated = new Set;
+  const updating = new Set;
+  let generation = 0;
+  let observed = 0;
+  const refresh = yield* PubSub.unbounded();
+  const activate = Effect.fn("PluginSupervisor.activate")(function* () {
+    const current = ++generation;
+    const pre = [
+      ...internal.pre.map((plugin) => ({ ...plugin, revision: "internal", source: { type: "builtin" } })),
+      ...sdk.all(),
+      ...instance.all()
+    ];
+    const post = internal.post.map((plugin) => ({
+      ...plugin,
+      revision: "internal",
+      source: { type: "builtin" }
+    }));
+    const operations = yield* sources.operations();
+    const immediate = yield* resolve(pre, post, operations, false, running);
+    const source = (source2) => source2.type === "package" ? {
+      ...source2,
+      ...outdated.has(source2.target) ? { outdated: true } : {},
+      ...updating.has(source2.target) ? { updating: true } : {}
+    } : source2;
+    const apply = (resolved2) => registry.activate(resolved2.plugins.map((plugin) => plugin.source ? { ...plugin, source: source(plugin.source) } : plugin), resolved2.failures.map((failure) => ({ ...failure, source: source(failure.source) })));
+    yield* apply(immediate);
+    const resolved = immediate.pending.length ? yield* resolve(pre, post, operations, true, running) : immediate;
+    if (resolved !== immediate)
+      yield* apply(resolved);
+    running = resolved.packages;
+    const targets = new Set([...resolved.plugins, ...resolved.failures].flatMap((plugin) => plugin.source?.type === "package" ? [plugin.source.target] : []));
+    packages = targets;
+    yield* Effect.forEach(targets, (target) => updates.check(target).pipe(Effect.map((available) => [target, available])), { concurrency: "unbounded" }).pipe(Effect.flatMap((checked) => {
+      if (current !== generation)
+        return Effect.void;
+      const next = new Set(checked.flatMap(([target, available]) => available ? [target] : []));
+      if (next.size === outdated.size && [...next].every((target) => outdated.has(target)))
+        return Effect.void;
+      outdated = next;
+      return apply(resolved);
+    }), Effect.forkScoped({ startImmediately: true }));
+  });
+  const reloads = Stream.merge(Stream.merge(Stream.merge(sources.changes(), Stream.fromPubSub(refresh)), bus.subscribe([Event.Updated, exports_sdk.Updated])), updates.changes().pipe(Stream.filter((update) => packages.has(update.target)), Stream.tap((update) => Effect.sync(() => {
+    update.outdated ? outdated.add(update.target) : outdated.delete(update.target);
+    update.updating ? updating.add(update.target) : updating.delete(update.target);
+  })), Stream.map(() => {
+    return;
+  }))).pipe(Stream.mapEffect(() => Effect.gen(function* () {
+    observed++;
+    if (!release)
+      release = yield* registry.hold();
+    return observed;
+  })));
+  yield* Stream.concat(Stream.succeed(0), reloads).pipe(Stream.buffer({ capacity: 1, strategy: "sliding" }), Stream.debounce("100 millis"), Stream.runForEach((target) => Effect.gen(function* () {
+    yield* activate().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause })));
+    if (observed !== target)
+      return;
+    const settled = release;
+    release = undefined;
+    if (settled)
+      yield* settled;
+  })), Effect.forkScoped({ startImmediately: true }));
+  yield* Effect.sleep("24 hours").pipe(Effect.andThen(PubSub.publish(refresh, undefined)), Effect.forever, Effect.forkScoped);
+}));
+var nodeDeps = [
+  exports_plugin.node,
+  exports_sdk.node,
+  exports_instance.node,
+  exports_source.node,
+  exports_update.node,
+  exports_bus.node,
+  Npm.node,
+  exports_internal.requirements
+];
+function pluginSource(target) {
+  if (path.isAbsolute(target))
+    return { type: "local", path: target };
+  return { type: "package", target };
+}
+var node = makeLocationNode({ name: "plugin-supervisor", layer, deps: nodeDeps });
+
+export { layer, node, exports_supervisor };

package/dist/chunks/{websearch-vv04m5r9.js → event-logger-2gjt1w6y.js}

@@ -1,29 +1,26 @@
 import {
   exports_location
-} from "./websearch-mp6zts7p.js";
+} from "./event-logger-90zcexzw.js";
 import {
   exports_project
-} from "./websearch-b22ptp6c.js";
-import {
-  exports_markers
-} from "./websearch-ts88b2w4.js";
+} from "./event-logger-80djagdx.js";
 import {
   AbsolutePath
-} from "./websearch-j07kk359.js";
+} from "./event-logger-j07kk359.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/location-mutation.ts
 var exports_location_mutation = {};
 __export(exports_location_mutation, {
-  resolvePath: () => resolvePath,
-  node: () => node,
-  externalDirectoryPermission: () => externalDirectoryPermission,
-  Service: () => Service,
-  ResolveInput: () => ResolveInput,
+  Kind: () => Kind,
   LocationMutation: () => exports_location_mutation,
-  Kind: () => Kind
+  ResolveInput: () => ResolveInput,
+  Service: () => Service,
+  externalDirectoryPermission: () => externalDirectoryPermission,
+  node: () => node,
+  resolvePath: () => resolvePath
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import path from "path";
@@ -51,7 +48,6 @@ var slash = (value) => value.replaceAll("\\", "/");
 var layer = Layer.effect(Service, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
   const location = yield* exports_location.Service;
-  const markers = yield* exports_markers.Service;
   const resolve = Effect.fnUntraced(function* (input) {
     const absolute = resolvePath(location.directory, input.path);
     const worktree = path.resolve(location.project.directory);
@@ -72,7 +68,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         action: "external_directory",
         directory: externalDirectory,
         resource: externalResource,
-        save: slash(path.join((yield* exports_project.root(fs, AbsolutePath.make(externalDirectory), markers.targets())) ?? externalDirectory, "*"))
+        save: slash(path.join((yield* exports_project.root(fs, AbsolutePath.make(externalDirectory))) ?? externalDirectory, "*"))
       }
     };
   });
@@ -81,7 +77,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
 var node = makeLocationNode({
   service: Service,
   layer,
-  deps: [FSUtil.node, exports_location.node, exports_markers.node]
+  deps: [FSUtil.node, exports_location.node]
 });
 
 export { Kind, ResolveInput, externalDirectoryPermission, resolvePath, Service, node, exports_location_mutation };

package/dist/chunks/{websearch-bswth2jt.js → event-logger-2hktn3e1.js}

@@ -1,21 +1,21 @@
 import {
   exports_entry_observer
-} from "./websearch-kp1t5rcy.js";
+} from "./event-logger-mnyszbxc.js";
 import {
   exports_config
-} from "./websearch-5sc277j1.js";
+} from "./event-logger-6wskbeqw.js";
 import {
   exports_select
-} from "./websearch-bbhffenw.js";
+} from "./event-logger-2qq12ds3.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/config/plugin/shell.ts
 var exports_shell = {};
 __export(exports_shell, {
-  Plugin: () => Plugin,
-  ConfigShellPlugin: () => exports_shell
+  ConfigShellPlugin: () => exports_shell,
+  Plugin: () => Plugin
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
@@ -25,10 +25,10 @@ var Plugin = define({
     const config = yield* exports_config.Service;
     const shell = yield* exports_select.Service;
     const loaded = yield* exports_entry_observer.observe(config, ctx.event, shell.reload());
-    yield* shell.transform((draft) => {
+    yield* shell.transform((editor) => {
       const configured = exports_config.latest(loaded.entries, "shell");
       if (configured)
-        draft.configure(configured);
+        editor.configure(configured);
     });
   })
 });

package/dist/chunks/{websearch-r0c038tz.js → event-logger-2hmmtx2y.js}

@@ -1,24 +1,24 @@
 import {
   exports_markdown
-} from "./websearch-7wcmqxrc.js";
+} from "./event-logger-p5gyct0y.js";
 import {
   exports_config
-} from "./websearch-5sc277j1.js";
+} from "./event-logger-6wskbeqw.js";
 import {
   exports_select
-} from "./websearch-bbhffenw.js";
+} from "./event-logger-2qq12ds3.js";
 import {
   exports_location
-} from "./websearch-mp6zts7p.js";
+} from "./event-logger-90zcexzw.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/config/plugin/command.ts
 var exports_command = {};
 __export(exports_command, {
-  Plugin: () => Plugin,
-  ConfigCommandPlugin: () => exports_command
+  ConfigCommandPlugin: () => exports_command,
+  Plugin: () => Plugin
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Agent } from "@opencode-ai/schema/agent";
@@ -27,7 +27,7 @@ import { Model } from "@opencode-ai/schema/model";
 import { Provider } from "@opencode-ai/schema/provider";
 import { AppProcess } from "@opencode-ai/util/process";
 import path from "path";
-import { Effect, Option, Schema, Stream } from "effect";
+import { Effect, Option, PubSub, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 var decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info);
@@ -52,14 +52,17 @@ var Plugin = define({
     });
     const loaded = { documents: [] };
     const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.command.reload()));
-    const sourceChanges = config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path))));
-    const configUpdates = ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"));
-    yield* Stream.merge(sourceChanges, configUpdates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    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().pipe(Stream.filter((event) => event.type === "config.updated"), 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();
-    yield* ctx.command.transform((draft) => {
+    yield* ctx.command.transform((editor) => {
       for (const document of loaded.documents) {
         for (const [name, command] of Object.entries(document.commands ?? {})) {
-          draft.add({
+          editor.add({
             name,
             description: command.description,
             execute: (input) => Effect.gen(function* () {

package/dist/chunks/{websearch-bbhffenw.js → event-logger-2qq12ds3.js}

@@ -1,29 +1,29 @@
 import {
   which
-} from "./websearch-k3e42drn.js";
+} from "./event-logger-k3e42drn.js";
 import {
   exports_state
-} from "./websearch-x89rah0x.js";
+} from "./event-logger-dyrfpcd0.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/shell/select.ts
 var exports_select = {};
 __export(exports_select, {
-  resolve: () => resolve,
-  ps: () => ps,
-  node: () => node,
-  name: () => name,
-  login: () => login,
-  list: () => list,
-  gitbash: () => gitbash,
-  environment: () => environment,
-  configured: () => configured,
-  args: () => args,
-  ShellSelect: () => exports_select,
+  Options: () => Options,
   Service: () => Service,
-  Options: () => Options
+  ShellSelect: () => exports_select,
+  args: () => args,
+  configured: () => configured,
+  environment: () => environment,
+  gitbash: () => gitbash,
+  list: () => list,
+  login: () => login,
+  name: () => name,
+  node: () => node,
+  ps: () => ps,
+  resolve: () => resolve
 });
 import path from "path";
 import { readFile } from "fs/promises";
@@ -193,9 +193,9 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
   const state = exports_state.create({
     name: "shell-select",
     initial: () => ({}),
-    draft: (draft) => ({
+    editor: (editor) => ({
       configure: (shell) => {
-        draft.shell = shell;
+        editor.shell = shell;
       }
     })
   });

package/dist/chunks/{websearch-cgqn2mrm.js → event-logger-2sqw2jjm.js}

@@ -1,34 +1,34 @@
 import {
   SessionMessage
-} from "./websearch-8rpfd2h6.js";
+} from "./event-logger-8rpfd2h6.js";
 import {
   SessionSchema
-} from "./websearch-bjwj8hwv.js";
+} from "./event-logger-bjwj8hwv.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/session/error.ts
 var exports_error = {};
 __export(exports_error, {
-  UserInterruptedError: () => UserInterruptedError,
-  SyntheticConflictError: () => SyntheticConflictError,
-  StepFailedError: () => StepFailedError,
-  SkillNotFoundError: () => SkillNotFoundError,
-  SessionErrors: () => exports_error,
-  PromptConflictError: () => PromptConflictError,
-  NotFoundError: () => NotFoundError,
-  MessageToolIncompleteError: () => MessageToolIncompleteError,
-  MessageNotFoundError: () => MessageNotFoundError,
-  MessageNotAssistantError: () => MessageNotAssistantError,
-  MessageIncompleteError: () => MessageIncompleteError,
-  MessageDecodeError: () => MessageDecodeError,
-  InboxConflictError: () => InboxConflictError,
-  ForkEmptyError: () => ForkEmptyError,
-  CompactionConflictError: () => CompactionConflictError,
-  BusyError: () => BusyError,
+  AgentNotFoundError: () => AgentNotFoundError,
   AttachmentError: () => AttachmentError,
-  AgentNotFoundError: () => AgentNotFoundError
+  BusyError: () => BusyError,
+  CompactionConflictError: () => CompactionConflictError,
+  ForkEmptyError: () => ForkEmptyError,
+  InboxConflictError: () => InboxConflictError,
+  MessageDecodeError: () => MessageDecodeError,
+  MessageIncompleteError: () => MessageIncompleteError,
+  MessageNotAssistantError: () => MessageNotAssistantError,
+  MessageNotFoundError: () => MessageNotFoundError,
+  MessageToolIncompleteError: () => MessageToolIncompleteError,
+  NotFoundError: () => NotFoundError,
+  PromptConflictError: () => PromptConflictError,
+  SessionErrors: () => exports_error,
+  SkillNotFoundError: () => SkillNotFoundError,
+  StepFailedError: () => StepFailedError,
+  SyntheticConflictError: () => SyntheticConflictError,
+  UserInterruptedError: () => UserInterruptedError
 });
 import { Schema } from "effect";
 import { Agent } from "@opencode-ai/schema/agent";