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

package/dist/chunks/{websearch-mk3z7nc0.js → event-logger-d8f23dkx.js}

@@ -1,26 +1,26 @@
 import {
   RipgrepBinary
-} from "./websearch-rahat93a.js";
+} from "./event-logger-rahat93a.js";
 import {
   exports_environment1 as exports_environment
-} from "./websearch-0xmbntw2.js";
+} from "./event-logger-pvhtfzrc.js";
 import {
   NonNegativeInt,
   PositiveInt,
   RelativePath
-} from "./websearch-j07kk359.js";
+} from "./event-logger-j07kk359.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/ripgrep.ts
 var exports_ripgrep = {};
 __export(exports_ripgrep, {
-  node: () => node,
-  Service: () => Service,
-  Ripgrep: () => exports_ripgrep,
+  Error: () => Error,
   InvalidPatternError: () => InvalidPatternError,
-  Error: () => Error
+  Ripgrep: () => exports_ripgrep,
+  Service: () => Service,
+  node: () => node
 });
 import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
@@ -140,6 +140,8 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         "--json",
         "--hidden",
         "--no-messages",
+        ...input.literal ? ["--fixed-strings"] : [],
+        ...input.caseSensitive === false ? ["--ignore-case"] : [],
         ...input.include ? [`--glob=${input.include}`] : [],
         "--glob=!**/.git/**",
         "--",

package/dist/chunks/{websearch-3vz1ew5q.js → event-logger-db33vhr2.js}

@@ -1,20 +1,20 @@
 import {
   exports_state
-} from "./websearch-x89rah0x.js";
+} from "./event-logger-dyrfpcd0.js";
 import {
   __export,
   __require
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/image.ts
 var exports_image = {};
 __export(exports_image, {
-  node: () => node,
-  SizeError: () => SizeError,
-  Service: () => Service,
-  ResizerUnavailableError: () => ResizerUnavailableError,
+  DecodeError: () => DecodeError,
   Image: () => exports_image,
-  DecodeError: () => DecodeError
+  ResizerUnavailableError: () => ResizerUnavailableError,
+  Service: () => Service,
+  SizeError: () => SizeError,
+  node: () => node
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -54,16 +54,16 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       maxHeight: 2000,
       maxBase64Bytes: 5 * 1024 * 1024
     }),
-    draft: (draft) => ({
+    editor: (editor) => ({
       configure: (limits) => {
         if (limits.autoResize !== undefined)
-          draft.autoResize = limits.autoResize;
+          editor.autoResize = limits.autoResize;
         if (limits.maxWidth !== undefined)
-          draft.maxWidth = limits.maxWidth;
+          editor.maxWidth = limits.maxWidth;
         if (limits.maxHeight !== undefined)
-          draft.maxHeight = limits.maxHeight;
+          editor.maxHeight = limits.maxHeight;
         if (limits.maxBase64Bytes !== undefined)
-          draft.maxBase64Bytes = limits.maxBase64Bytes;
+          editor.maxBase64Bytes = limits.maxBase64Bytes;
       }
     })
   });

package/dist/chunks/{websearch-5rs65q6p.js → event-logger-dexm22yg.js}

@@ -1,14 +1,14 @@
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/database/sqlite.ts
 var exports_sqlite = {};
 __export(exports_sqlite, {
-  makeConnection: () => makeConnection,
-  makeClient: () => makeClient,
+  Native: () => Native,
   Sqlite: () => exports_sqlite,
-  Native: () => Native
+  makeClient: () => makeClient,
+  makeConnection: () => makeConnection
 });
 import { Context, Effect, Fiber, Scope, Semaphore, Stream } from "effect";
 import { identity } from "effect/Function";

package/dist/chunks/event-logger-dn2wztxw.js

@@ -0,0 +1,40 @@
+import {
+  exports_service as exports_service2
+} from "./event-logger-esv5q40e.js";
+import {
+  exports_service
+} from "./event-logger-6bxzghb6.js";
+import {
+  exports_shell
+} from "./event-logger-6x09n4m4.js";
+import {
+  exports_result
+} from "./event-logger-5y5kqjze.js";
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/session/shell.ts
+var exports_shell2 = {};
+__export(exports_shell2, {
+  SessionShell: () => exports_shell2,
+  start: () => start
+});
+import { Effect } from "effect";
+var start = Effect.fn("SessionShell.start")(function* (input) {
+  const instances = yield* exports_service.Service;
+  const shell = yield* exports_service2.awaitActivation.pipe(Effect.andThen(exports_shell.Service), instances.provide(input.session));
+  const info = yield* shell.create({
+    command: input.command,
+    cwd: input.session.location.directory,
+    timeout: 0,
+    metadata: { sessionID: input.session.id, background: true }
+  });
+  return {
+    info,
+    result: shell.result(info),
+    output: shell.output(info.id, { limit: 1024 * 1024 }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(exports_result.unavailable)))
+  };
+});
+
+export { start, exports_shell2 as exports_shell };

package/dist/chunks/event-logger-dtm6fkaa.js

@@ -0,0 +1,54 @@
+import {
+  exports_keyed_mutex
+} from "./event-logger-66mds5ht.js";
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/plugin/update.ts
+var exports_update = {};
+__export(exports_update, {
+  PluginUpdate: () => exports_update,
+  Service: () => Service,
+  node: () => node
+});
+import { Clock, Context, Effect, Exit, Layer, Option, PubSub, Stream } from "effect";
+import { Npm } from "@opencode-ai/util/npm";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var interval = 24 * 60 * 60 * 1000;
+
+class Service extends Context.Service()("@opencode/PluginUpdate") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const npm = yield* Npm.Service;
+  const locks = exports_keyed_mutex.makeUnsafe();
+  const status = new Map;
+  const changes = yield* PubSub.unbounded();
+  return Service.of({
+    check: (target, options) => locks.withLock(target)(Effect.gen(function* () {
+      const checkedAt = yield* Clock.currentTimeMillis;
+      const current = status.get(target);
+      if (!options?.refresh && current && checkedAt - current.checkedAt < interval)
+        return current.outdated;
+      const outdated = yield* npm.check(target).pipe(Effect.tapCause((cause) => Effect.logWarning("failed to check plugin update", { target, cause })), Effect.option);
+      const value = Option.getOrElse(outdated, () => current?.outdated ?? false);
+      status.set(target, { outdated: value, checkedAt });
+      if ((current?.outdated ?? false) !== value)
+        yield* PubSub.publish(changes, { target, outdated: value, updating: false });
+      return value;
+    })),
+    update: (target) => locks.withLock(target)(Effect.gen(function* () {
+      const outdated = status.get(target)?.outdated ?? false;
+      yield* PubSub.publish(changes, { target, outdated, updating: true });
+      yield* npm.update(target).pipe(Effect.tap(() => Effect.sync(() => status.delete(target))), Effect.onExit((exit) => PubSub.publish(changes, {
+        target,
+        outdated: Exit.isSuccess(exit) ? false : outdated,
+        updating: false
+      })));
+    })),
+    changes: () => Stream.fromPubSub(changes)
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [Npm.node] });
+
+export { Service, node, exports_update };

package/dist/chunks/{websearch-cb3xnjzj.js → event-logger-dvcabejh.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_snapshot
-} from "./websearch-azdqaz44.js";
+} from "./event-logger-436nrt40.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/config/plugin/snapshot.ts
 var exports_snapshot2 = {};
 __export(exports_snapshot2, {
-  Plugin: () => Plugin,
-  ConfigSnapshotPlugin: () => exports_snapshot2
+  ConfigSnapshotPlugin: () => exports_snapshot2,
+  Plugin: () => Plugin
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
@@ -25,11 +25,11 @@ var Plugin = define({
     const config = yield* exports_config.Service;
     const snapshot = yield* exports_snapshot.Service;
     const loaded = yield* exports_entry_observer.observe(config, ctx.event, snapshot.reload());
-    yield* snapshot.transform((draft) => {
+    yield* snapshot.transform((editor) => {
       const configured = exports_config.latest(loaded.entries, "snapshots");
       if (configured === undefined)
         return;
-      draft.configure(configured);
+      editor.configure(configured);
     });
   })
 });

package/dist/chunks/{websearch-mxvw03gv.js → event-logger-dyhtrhy2.js}

@@ -1,6 +1,6 @@
 import {
   __require
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/plugin/provider/openai-compatible.ts
 import { Effect } from "effect";

package/dist/chunks/event-logger-dyrfpcd0.js

@@ -0,0 +1,114 @@
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/state.ts
+var exports_state = {};
+__export(exports_state, {
+  State: () => exports_state,
+  batch: () => batch,
+  create: () => create,
+  inherit: () => inherit,
+  reconcile: () => reconcile,
+  shutdown: () => shutdown
+});
+import { Cause, Context, Effect, Exit, Fiber, Scope } from "effect";
+var CurrentBatch = Context.Reference("@opencode/State/CurrentBatch", {
+  defaultValue: () => {
+    return;
+  }
+});
+function batch(effect) {
+  return run(effect, false);
+}
+function shutdown(effect) {
+  return run(effect, true);
+}
+function run(effect, shutdown2) {
+  return Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const current = yield* CurrentBatch;
+    if (current?.active && !shutdown2)
+      return yield* restore(effect);
+    const batch2 = { active: true, shutdown: shutdown2, notifications: new Set };
+    const exit = yield* restore(effect.pipe(Effect.provideService(CurrentBatch, batch2))).pipe(Effect.exit);
+    batch2.active = false;
+    const notifications = yield* Effect.forEach(batch2.notifications, (notify) => restore(notify).pipe(Effect.exit));
+    yield* Exit.asVoidAll([exit, ...notifications]);
+    return yield* exit;
+  }));
+}
+function reconcile(root, fork, work) {
+  return Effect.gen(function* () {
+    const exit = yield* Fiber.await(fork(work()));
+    if (Exit.isFailure(exit) && root.state._tag === "Closed" && Cause.hasInterruptsOnly(exit.cause))
+      return;
+    yield* exit;
+  });
+}
+var inherit = Effect.fnUntraced(function* () {
+  const batch2 = yield* CurrentBatch;
+  return (effect) => Effect.provideService(effect, CurrentBatch, batch2);
+});
+function create(options) {
+  let state = options.initial();
+  const transforms = [];
+  let dirty = false;
+  let closed = false;
+  const get = () => {
+    if (closed || !dirty)
+      return state;
+    const next = options.initial();
+    const editor = options.editor(next);
+    for (const transform of transforms)
+      transform.run(editor);
+    state = next;
+    dirty = false;
+    return state;
+  };
+  const notify = Effect.gen(function* () {
+    if (closed)
+      return;
+    const value = get();
+    if (options.notify)
+      yield* options.notify(value);
+  }).pipe(Effect.withSpan("State.notify"));
+  const changed = Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    if (closed)
+      return;
+    dirty = true;
+    const batch2 = yield* CurrentBatch;
+    if (batch2?.active) {
+      if (batch2.shutdown) {
+        closed = true;
+        return;
+      }
+      batch2.notifications.add(notify);
+      return;
+    }
+    yield* restore(notify);
+  }));
+  return {
+    get,
+    transform: Effect.fn("State.transform")(function* (update) {
+      yield* Effect.annotateCurrentSpan("state", options.name ?? "anonymous");
+      const scope = yield* Scope.Scope;
+      return yield* Effect.uninterruptible(Effect.gen(function* () {
+        const transform = { run: update };
+        const dispose = Effect.uninterruptible(Effect.suspend(() => {
+          const index = transforms.indexOf(transform);
+          if (index < 0)
+            return Effect.void;
+          transforms.splice(index, 1);
+          return changed;
+        }));
+        transforms.push(transform);
+        yield* Scope.addFinalizer(scope, dispose);
+        yield* changed;
+        return { dispose };
+      }));
+    }),
+    reload: () => changed
+  };
+}
+
+export { batch, shutdown, reconcile, inherit, create, exports_state };

package/dist/chunks/{websearch-pdzzmdc7.js → event-logger-dyv1aw3z.js}

@@ -1,35 +1,35 @@
 import {
   ID
-} from "./websearch-tvmhrvfj.js";
+} from "./event-logger-tvmhrvfj.js";
 import {
   lazy
-} from "./websearch-8w9tzfz1.js";
+} from "./event-logger-8w9tzfz1.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 {
   exports_bus
-} from "./websearch-cat9v99r.js";
+} from "./event-logger-vw7aptj1.js";
 import {
   __export,
   __require
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/pty.ts
 var exports_pty = {};
 __export(exports_pty, {
-  node: () => node,
-  UpdateInput: () => UpdateInput,
-  Service: () => Service,
-  Pty: () => exports_pty,
-  NotFoundError: () => NotFoundError,
-  Info: () => Info,
-  ExitedError: () => ExitedError,
+  CreateInput: () => CreateInput,
   Event: () => Event,
-  CreateInput: () => CreateInput
+  ExitedError: () => ExitedError,
+  Info: () => Info,
+  NotFoundError: () => NotFoundError,
+  Pty: () => exports_pty,
+  Service: () => Service,
+  UpdateInput: () => UpdateInput,
+  node: () => node
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";

package/dist/chunks/{websearch-f9wt0tjw.js → event-logger-e0n16vwa.js}

@@ -1,16 +1,16 @@
 import {
   exports_mcp
-} from "./websearch-c4wcb9vc.js";
+} from "./event-logger-etbnsc4s.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/plugin/websearch/exa.ts
 var exports_exa = {};
 __export(exports_exa, {
-  endpoint: () => endpoint,
+  Plugin: () => Plugin,
   WebSearchExa: () => exports_exa,
-  Plugin: () => Plugin
+  endpoint: () => endpoint
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
@@ -31,19 +31,19 @@ var Plugin = define({
   id: "opencode.websearch.exa",
   effect: Effect.fn("WebSearchExa.Plugin")(function* (ctx) {
     const http = yield* HttpClient.HttpClient;
-    yield* ctx.integration.transform((draft) => {
-      draft.update("exa", (integration) => integration.name = "Exa");
-      draft.method.update({
+    yield* ctx.integration.transform((editor) => {
+      editor.update("exa", (integration) => integration.name = "Exa");
+      editor.method.update({
         integrationID: "exa",
         method: { type: "key" }
       });
-      draft.method.update({
+      editor.method.update({
         integrationID: "exa",
         method: { type: "env", names: ["EXA_API_KEY"] }
       });
     });
-    yield* ctx.websearch.transform((draft) => {
-      draft.add({
+    yield* ctx.websearch.transform((editor) => {
+      editor.add({
         id: "exa",
         name: "Exa",
         execute: (input) => Effect.gen(function* () {

package/dist/chunks/{websearch-kww0mg52.js → event-logger-eb87q0yv.js}

@@ -1,6 +1,6 @@
 import {
   exports_provider
-} from "./websearch-fex42j86.js";
+} from "./event-logger-68yag814.js";
 
 // src/plugin/provider/nvidia.ts
 import { Effect } from "effect";

package/dist/chunks/{websearch-djtgymwn.js → event-logger-eccfdzzr.js}

@@ -1,26 +1,25 @@
 import {
   migrations
-} from "./websearch-4qfc90j3.js";
+} from "./event-logger-ke5mv4q1.js";
 import {
   schema_gen_default
-} from "./websearch-39ktntah.js";
+} from "./event-logger-39ktntah.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/database/migration.ts
 var exports_migration = {};
 __export(exports_migration, {
-  applyOnly: () => applyOnly,
+  DatabaseMigration: () => exports_migration,
   apply: () => apply,
-  DatabaseMigration: () => exports_migration
+  applyOnly: () => applyOnly
 });
 import { sql } from "drizzle-orm";
-import { Effect, Semaphore } from "effect";
+import { Effect } from "effect";
 import { supportsForeignKeyToggle } from "#sqlite";
-var lock = Semaphore.makeUnsafe(1);
 function apply(db) {
-  return lock.withPermit(Effect.gen(function* () {
+  return Effect.gen(function* () {
     const tables = yield* db.all(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND substr(name, 1, 1) <> '_'`);
     if (tables.some((table) => table.name === "session" || table.name === "session_v2"))
       return yield* applyOnly(db, migrations);
@@ -37,7 +36,7 @@ function apply(db) {
       migrations: migrations.length,
       durationMs: Date.now() - started
     });
-  }));
+  });
 }
 function applyOnly(db, input) {
   return Effect.gen(function* () {

package/dist/chunks/{websearch-y67x6rf6.js → event-logger-edxnhgvj.js}

@@ -1,12 +1,12 @@
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/util/wildcard.ts
 var exports_wildcard = {};
 __export(exports_wildcard, {
-  match: () => match,
-  Wildcard: () => exports_wildcard
+  Wildcard: () => exports_wildcard,
+  match: () => match
 });
 function match(input, pattern) {
   const normalized = input.replaceAll("\\", "/");

package/dist/chunks/{websearch-62f8vfk8.js → event-logger-efy5rfxh.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_tool_output
-} from "./websearch-sfg41mtw.js";
+} from "./event-logger-f4vqkfbt.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/config/plugin/tool-output.ts
 var exports_tool_output2 = {};
 __export(exports_tool_output2, {
-  Plugin: () => Plugin,
-  ConfigToolOutputPlugin: () => exports_tool_output2
+  ConfigToolOutputPlugin: () => exports_tool_output2,
+  Plugin: () => Plugin
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
@@ -25,11 +25,11 @@ var Plugin = define({
     const config = yield* exports_config.Service;
     const output = yield* exports_tool_output.Service;
     const loaded = yield* exports_entry_observer.observe(config, ctx.event, output.reload());
-    yield* output.transform((draft) => {
+    yield* output.transform((editor) => {
       const configured = exports_config.latest(loaded.entries, "tool_output");
       if (!configured)
         return;
-      draft.configure({
+      editor.configure({
         ...configured.max_lines === undefined ? {} : { maxLines: configured.max_lines },
         ...configured.max_bytes === undefined ? {} : { maxBytes: configured.max_bytes }
       });

package/dist/chunks/event-logger-esv5q40e.js

@@ -0,0 +1,18 @@
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/plugin/service.ts
+var exports_service = {};
+__export(exports_service, {
+  Plugin: () => exports_service,
+  Service: () => Service,
+  awaitActivation: () => awaitActivation
+});
+import { Context } from "effect";
+
+class Service extends Context.Service()("@opencode/Plugin") {
+}
+var awaitActivation = Service.use((plugins) => plugins.awaitActivation);
+
+export { Service, awaitActivation, exports_service };

package/dist/chunks/{websearch-c4wcb9vc.js → event-logger-etbnsc4s.js}

@@ -1,17 +1,17 @@
 import {
   collectBoundedResponseBody
-} from "./websearch-jve7t217.js";
+} from "./event-logger-jve7t217.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/plugin/websearch/mcp.ts
 var exports_mcp = {};
 __export(exports_mcp, {
-  parseResponse: () => parseResponse,
-  call: () => call,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES,
   WebSearchMcp: () => exports_mcp,
-  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES
+  call: () => call,
+  parseResponse: () => parseResponse
 });
 import { Duration, Effect, Schema } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/unstable/http";