@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/{integration-97jhpj9f.js → command-mznxs8d6.js}

@@ -1,65 +1,68 @@
 import {
-  exports_git as exports_git2
-} from "./integration-3mc1hhwa.js";
+  AbsolutePath2
+} from "./command-p8qxwesx.js";
 import {
-  DirectoryUnavailableError,
-  canonical
-} from "./integration-gc513wew.js";
+  node73
+} from "./command-mhsg1yty.js";
 import {
-  Slug
-} from "./integration-df3v2q6j.js";
+  ID13
+} from "./command-dqwszdkc.js";
 import {
-  exports_location
-} from "./integration-gpa7n6yh.js";
+  Slug2
+} from "./command-gebd4c9n.js";
 import {
-  exports_schema
-} from "./integration-m7jtgrng.js";
+  Service80,
+  node84
+} from "./command-mh85gtv1.js";
 import {
-  WorktreeTable
-} from "./integration-gb1z7yet.js";
+  Service79,
+  node83
+} from "./command-pdae5shs.js";
 import {
-  ProjectTable
-} from "./integration-c8ya26sa.js";
+  ProjectTable2
+} from "./command-9qm9egsn.js";
 import {
-  exports_git
-} from "./integration-qz5gwjr7.js";
+  WorktreeTable2
+} from "./command-ajtjthsy.js";
 import {
-  AbsolutePath
-} from "./integration-j07kk359.js";
+  Service68,
+  node71
+} from "./command-4jcgzkct.js";
 import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
+  DirectoryUnavailableError2,
+  canonical2
+} from "./command-93a8yfjt.js";
 import {
-  exports_database
-} from "./integration-3dyzk5zr.js";
+  make17
+} from "./command-q8rpcfw0.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/worktree.ts
 var exports_worktree = {};
 __export(exports_worktree, {
-  CreateInput: () => CreateInput,
-  DestinationExistsError: () => DestinationExistsError,
-  DirectoryUnavailableError: () => DirectoryUnavailableError,
-  DuplicateStrategyError: () => DuplicateStrategyError,
-  Event: () => Event,
-  Info: () => Info,
-  InvalidDirectoryError: () => InvalidDirectoryError,
-  List: () => List,
-  ListEntry: () => ListEntry,
-  ListInput: () => ListInput,
-  RefreshInput: () => RefreshInput,
-  RefreshResult: () => RefreshResult,
-  RemoveInput: () => RemoveInput,
-  Service: () => Service,
-  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError,
-  StrategyID: () => StrategyID,
-  StrategyUnavailableError: () => StrategyUnavailableError,
+  CreateInput: () => CreateInput2,
+  DestinationExistsError: () => DestinationExistsError2,
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  DuplicateStrategyError: () => DuplicateStrategyError2,
+  Event: () => Event8,
+  Info: () => Info10,
+  InvalidDirectoryError: () => InvalidDirectoryError2,
+  List: () => List2,
+  ListEntry: () => ListEntry3,
+  ListInput: () => ListInput6,
+  RefreshInput: () => RefreshInput2,
+  RefreshResult: () => RefreshResult2,
+  RemoveInput: () => RemoveInput2,
+  Service: () => Service56,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError2,
+  StrategyID: () => StrategyID2,
+  StrategyUnavailableError: () => StrategyUnavailableError2,
   Worktree: () => exports_worktree,
-  node: () => node,
-  refreshAfterBoot: () => refreshAfterBoot,
-  refreshNode: () => refreshNode
+  node: () => node58,
+  refreshAfterBoot: () => refreshAfterBoot2,
+  refreshNode: () => refreshNode2
 });
 import { Context, Effect, Layer, Schema } from "effect";
 import { and, asc, desc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
@@ -69,45 +72,45 @@ import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-n
 import { Worktree } from "@opencode-ai/schema/worktree";
 import { AppProcess } from "@opencode-ai/util/process";
 import { ChildProcess } from "effect/unstable/process";
-var StrategyID = Worktree.StrategyID;
-var CreateInput = Worktree.CreateInput;
-var RemoveInput = Worktree.RemoveInput;
-var RefreshInput = Schema.Struct({
-  projectID: exports_schema.ID
+var StrategyID2 = Worktree.StrategyID;
+var CreateInput2 = Worktree.CreateInput;
+var RemoveInput2 = Worktree.RemoveInput;
+var RefreshInput2 = Schema.Struct({
+  projectID: ID13
 }).annotate({ identifier: "Worktree.RefreshInput" });
-var RefreshResult = Schema.Struct({
-  updated: Schema.Array(AbsolutePath),
-  removed: Schema.Array(AbsolutePath)
+var RefreshResult2 = Schema.Struct({
+  updated: Schema.Array(AbsolutePath2),
+  removed: Schema.Array(AbsolutePath2)
 }).annotate({ identifier: "Worktree.RefreshResult" });
-var Info = Worktree.Info;
-var ListInput = Worktree.ListInput;
-var List = Worktree.List;
-var ListEntry = Schema.Struct({
-  directory: AbsolutePath,
+var Info10 = Worktree.Info;
+var ListInput6 = Worktree.ListInput;
+var List2 = Worktree.List;
+var ListEntry3 = Schema.Struct({
+  directory: AbsolutePath2,
   type: Schema.Literals(["root", "worktree"])
 }).annotate({ identifier: "Worktree.ListEntry" });
 
-class SourceDirectoryNotFoundError extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: exports_schema.ID, directory: Schema.optional(AbsolutePath) }) {
+class SourceDirectoryNotFoundError2 extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: ID13, directory: Schema.optional(AbsolutePath2) }) {
 }
 
-class DestinationExistsError extends Schema.TaggedError()("Worktree.DestinationExistsError", { directory: AbsolutePath }) {
+class DestinationExistsError2 extends Schema.TaggedError()("Worktree.DestinationExistsError", { directory: AbsolutePath2 }) {
 }
 
-class InvalidDirectoryError extends Schema.TaggedError()("Worktree.InvalidDirectoryError", { directory: AbsolutePath }) {
+class InvalidDirectoryError2 extends Schema.TaggedError()("Worktree.InvalidDirectoryError", { directory: AbsolutePath2 }) {
 }
 
-class StrategyUnavailableError extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID }) {
+class StrategyUnavailableError2 extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID2 }) {
 }
 
-class DuplicateStrategyError extends Schema.TaggedError()("Worktree.DuplicateStrategyError", { strategy: StrategyID }) {
+class DuplicateStrategyError2 extends Schema.TaggedError()("Worktree.DuplicateStrategyError", { strategy: StrategyID2 }) {
 }
-var Event = Worktree.Event;
+var Event8 = Worktree.Event;
 
-class Service extends Context.Service()("@opencode/v2/Worktree") {
+class Service56 extends Context.Service()("@opencode/v2/Worktree") {
 }
-var refreshAfterBoot = Effect.gen(function* () {
-  const location = yield* exports_location.Service;
-  const worktrees = yield* Service;
+var refreshAfterBoot2 = Effect.gen(function* () {
+  const location = yield* Service68;
+  const worktrees = yield* Service56;
   yield* Effect.gen(function* () {
     yield* Effect.logInfo("worktree refresh started", { projectID: location.project.id });
     const result = yield* worktrees.refresh({ projectID: location.project.id });
@@ -118,69 +121,69 @@ var refreshAfterBoot = Effect.gen(function* () {
     });
   }).pipe(Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })), Effect.forkScoped, Effect.asVoid);
 });
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service56, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
-  const db = (yield* exports_database.Service).db;
-  const bus = yield* exports_bus.Service;
+  const db = (yield* Service80).db;
+  const bus = yield* Service79;
   const processService = yield* AppProcess.Service;
   const changed = Effect.fnUntraced(function* (projectID, update) {
     if (update)
-      yield* bus.publish(Event.Updated, { projectID });
+      yield* bus.publish(Event8.Updated, { projectID });
   });
   const ops = {
     list: Effect.fn("Worktree.list")(function* (projectID) {
-      const rows = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(eq(WorktreeTable.project_id, projectID)).orderBy(desc(WorktreeTable.time_created), asc(WorktreeTable.directory)).all().pipe(Effect.orDie);
+      const rows = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(eq(WorktreeTable2.project_id, projectID)).orderBy(desc(WorktreeTable2.time_created), asc(WorktreeTable2.directory)).all().pipe(Effect.orDie);
       return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
     }),
     find: Effect.fnUntraced(function* (projectID, directory) {
-      const row = yield* db.select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy }).from(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).get().pipe(Effect.orDie);
+      const row = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).get().pipe(Effect.orDie);
       return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
     }),
     primary: Effect.fnUntraced(function* (projectID) {
-      return yield* db.select({ directory: ProjectTable.worktree }).from(ProjectTable).where(eq(ProjectTable.id, projectID)).get().pipe(Effect.orDie);
+      return yield* db.select({ directory: ProjectTable2.worktree }).from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
     }),
-    create: (input, tx) => (tx ?? db).insert(WorktreeTable).values({ project_id: input.projectID, directory: input.directory, strategy: input.strategy }).onConflictDoUpdate({
-      target: [WorktreeTable.project_id, WorktreeTable.directory],
+    create: (input, tx) => (tx ?? db).insert(WorktreeTable2).values({ project_id: input.projectID, directory: input.directory, strategy: input.strategy }).onConflictDoUpdate({
+      target: [WorktreeTable2.project_id, WorktreeTable2.directory],
       set: { strategy: input.strategy ?? null },
-      setWhere: input.strategy ? or(isNull(WorktreeTable.strategy), ne(WorktreeTable.strategy, input.strategy)) : isNotNull(WorktreeTable.strategy)
-    }).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
-    remove: (projectID, directory, tx) => (tx ?? db).delete(WorktreeTable).where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory))).returning({ directory: WorktreeTable.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
+      setWhere: input.strategy ? or(isNull(WorktreeTable2.strategy), ne(WorktreeTable2.strategy, input.strategy)) : isNotNull(WorktreeTable2.strategy)
+    }).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
+    remove: (projectID, directory, tx) => (tx ?? db).delete(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
   };
   const registry = new Map;
   const register = Effect.fn("Worktree.register")(function* (strategy) {
     if (registry.has(strategy.id))
-      return yield* new DuplicateStrategyError({ strategy: strategy.id });
+      return yield* new DuplicateStrategyError2({ strategy: strategy.id });
     registry.set(strategy.id, strategy);
   });
-  const gitStrategy = yield* exports_git2.make;
+  const gitStrategy = yield* make17;
   yield* register(gitStrategy).pipe(Effect.orDie);
   const source = Effect.fnUntraced(function* (input, projectID) {
     const sourceDirectory = input ?? (yield* ops.primary(projectID))?.directory;
     if (!sourceDirectory)
-      return yield* new SourceDirectoryNotFoundError({ projectID });
-    const resolved = yield* canonical(fs, sourceDirectory);
+      return yield* new SourceDirectoryNotFoundError2({ projectID });
+    const resolved = yield* canonical2(fs, sourceDirectory);
     if ((yield* ops.find(projectID, resolved)) === undefined)
-      return yield* new SourceDirectoryNotFoundError({ projectID, directory: resolved });
+      return yield* new SourceDirectoryNotFoundError2({ projectID, directory: resolved });
     return resolved;
   });
   const getStrategy = Effect.fnUntraced(function* (id) {
     const found = registry.get(id);
     if (!found)
-      return yield* new StrategyUnavailableError({ strategy: id });
+      return yield* new StrategyUnavailableError2({ strategy: id });
     return found;
   });
   const create = Effect.fn("Worktree.create")(function* (input) {
     const selected = yield* getStrategy(input.strategy);
     const sourceDirectory = yield* source(input.from, input.projectID);
     yield* fs.makeDirectory(input.directory, { recursive: true }).pipe(Effect.orDie);
-    const name = input.name ?? Slug.create();
+    const name = input.name ?? Slug2.create();
     let suffix = 1;
-    let worktreeDirectory = AbsolutePath.make(path.join(input.directory, name));
+    let worktreeDirectory = AbsolutePath2.make(path.join(input.directory, name));
     while (yield* fs.existsSafe(worktreeDirectory)) {
       suffix++;
       if (suffix > 10)
-        return yield* new DestinationExistsError({ directory: worktreeDirectory });
-      worktreeDirectory = AbsolutePath.make(path.join(input.directory, `${name}-${suffix}`));
+        return yield* new DestinationExistsError2({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath2.make(path.join(input.directory, `${name}-${suffix}`));
     }
     const result = yield* selected.create({
       directory: worktreeDirectory,
@@ -192,7 +195,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       directory: result.directory,
       strategy: input.strategy
     }));
-    const project = yield* db.select({ commands: ProjectTable.commands }).from(ProjectTable).where(eq(ProjectTable.id, input.projectID)).get().pipe(Effect.orDie);
+    const project = yield* db.select({ commands: ProjectTable2.commands }).from(ProjectTable2).where(eq(ProjectTable2.id, input.projectID)).get().pipe(Effect.orDie);
     const command = project?.commands?.start?.trim();
     if (command) {
       const windows = process.platform === "win32";
@@ -210,11 +213,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     return result;
   });
   const remove = Effect.fn("Worktree.remove")(function* (input) {
-    const worktreeDirectory = yield* canonical(fs, input.directory);
+    const worktreeDirectory = yield* canonical2(fs, input.directory);
     const stored = yield* ops.find(input.projectID, worktreeDirectory);
     if (!stored?.strategy)
-      return yield* new InvalidDirectoryError({ directory: worktreeDirectory });
-    const strategy = yield* getStrategy(StrategyID.make(stored.strategy));
+      return yield* new InvalidDirectoryError2({ directory: worktreeDirectory });
+    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy));
     yield* strategy.remove({
       directory: worktreeDirectory,
       force: input.force
@@ -241,7 +244,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     yield* changed(input.projectID, changes.updated.length > 0 || changes.removed.length > 0);
     return changes;
   });
-  return Service.of({
+  return Service56.of({
     register,
     list: ops.list,
     create,
@@ -249,15 +252,15 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     refresh
   });
 }));
-var node = makeGlobalNode({
-  service: Service,
+var node58 = makeGlobalNode({
+  service: Service56,
   layer,
-  deps: [FSUtil.node, exports_git.node, exports_bus.node, exports_database.node, AppProcess.node]
+  deps: [FSUtil.node, node73, node83, node84, AppProcess.node]
 });
-var refreshNode = makeLocationNode({
+var refreshNode2 = makeLocationNode({
   name: "worktree-refresh",
-  layer: Layer.effectDiscard(refreshAfterBoot),
-  deps: [node, exports_location.node]
+  layer: Layer.effectDiscard(refreshAfterBoot2),
+  deps: [node58, node71]
 });
 
-export { StrategyID, CreateInput, RemoveInput, RefreshInput, RefreshResult, Info, ListInput, List, ListEntry, SourceDirectoryNotFoundError, DestinationExistsError, InvalidDirectoryError, StrategyUnavailableError, DuplicateStrategyError, Event, Service, refreshAfterBoot, node, refreshNode, exports_worktree };
+export { StrategyID2, CreateInput2, RemoveInput2, RefreshInput2, RefreshResult2, Info10, ListInput6, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, DuplicateStrategyError2, Event8, Service56, refreshAfterBoot2, node58, refreshNode2, exports_worktree };

package/dist/chunks/{integration-xjwwdzb2.js → command-natwdt6v.js}

@@ -1,70 +1,73 @@
 import {
-  fileDiff
-} from "./integration-c77ad0vh.js";
+  Service55
+} from "./command-4y9deqpk.js";
 import {
-  exports_location_mutation
-} from "./integration-m7ggyfe0.js";
+  Service50,
+  readText2,
+  syncTextBom2
+} from "./command-cxnm9dwg.js";
 import {
-  exports_file_mutation
-} from "./integration-f2xkhd6s.js";
+  Service53
+} from "./command-e5rv1qf4.js";
 import {
-  exports_formatter
-} from "./integration-rs3jxw17.js";
+  externalDirectoryPermission2,
+  Service13
+} from "./command-zpgxjj6y.js";
 import {
-  exports_permission
-} from "./integration-44nx66ev.js";
+  Service42
+} from "./command-nkpkrkfc.js";
 import {
-  exports_environment1 as exports_environment
-} from "./integration-xckxf18q.js";
+  fileDiff2
+} from "./command-6prwharc.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/tool/plugin/write.ts
 var exports_write = {};
 __export(exports_write, {
-  Input: () => Input,
-  Output: () => Output,
-  Plugin: () => Plugin,
+  Input: () => Input8,
+  Output: () => Output5,
+  Plugin: () => Plugin39,
   WriteTool: () => exports_write,
-  name: () => name,
-  toModelContent: () => toModelContent
+  name: () => name8,
+  toModelContent: () => toModelContent3
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import { Bom } from "@opencode-ai/util/bom";
-var name = "write";
-var Input = Schema.Struct({
+var name8 = "write";
+var Input8 = Schema.Struct({
   path: Schema.String.annotate({
     description: "Path to the file to write to"
   }),
   content: Schema.String.annotate({ description: "Content to write to the file" })
 });
-var Output = Schema.Struct({
+var Output5 = Schema.Struct({
   operation: Schema.Literal("write"),
   target: Schema.String,
   resource: Schema.String,
   existed: Schema.Boolean
 });
-var toModelContent = (output) => `${output.existed ? "Wrote" : "Created"} file successfully: ${output.resource}`;
-var Plugin = {
+var toModelContent3 = (output) => `${output.existed ? "Wrote" : "Created"} file successfully: ${output.resource}`;
+var Plugin39 = {
   id: "opencode.tool.write",
   effect: Effect.fn("WriteTool.Plugin")(function* (ctx) {
-    const mutation = yield* exports_location_mutation.Service;
-    const fileMutation = yield* exports_file_mutation.Service;
-    const environment = yield* exports_environment.Service;
-    const formatter = yield* exports_formatter.Service;
-    const permission = yield* exports_permission.Service;
+    const mutation = yield* Service13;
+    const fileMutation = yield* Service50;
+    const environment = yield* Service55;
+    const formatter = yield* Service53;
+    const permission = yield* Service42;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name8,
       options: { codemode: false, permission: "edit" },
       description: `Writes a file to the local filesystem, overwriting if one exists.
 
 Missing parent directories are created automatically.
 
 Use this tool to create new files or overwrite existing files. For partial changes, use the edit tool instead.`,
-      input: Input,
-      output: Output,
+      input: Input8,
+      output: Output5,
       execute: (input, context) => Effect.gen(function* () {
         const source = {
           type: "tool",
@@ -75,14 +78,14 @@ Use this tool to create new files or overwrite existing files. For partial chang
         const external = target.externalDirectory;
         if (external)
           yield* permission.assert({
-            ...exports_location_mutation.externalDirectoryPermission(external),
+            ...externalDirectoryPermission2(external),
             sessionID: context.sessionID,
             agent: context.agent,
             source
           });
-        const current = yield* exports_file_mutation.readText(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.undefined));
+        const current = yield* readText2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.undefined));
         const next = Bom.split(input.content);
-        const preview = fileDiff(target.resource, current?.text ?? "", next.text, current ? "modified" : "added");
+        const preview = fileDiff2(target.resource, current?.text ?? "", next.text, current ? "modified" : "added");
         yield* permission.assert({
           action: "edit",
           resources: [target.resource],
@@ -93,14 +96,14 @@ Use this tool to create new files or overwrite existing files. For partial chang
           source
         });
         const result = yield* fileMutation.writeTextPreservingBom({ target, content: input.content });
-        const bom = (yield* exports_file_mutation.readText(environment.files, target.absolute)).bom;
+        const bom = (yield* readText2(environment.files, target.absolute)).bom;
         if (yield* formatter.file(target.absolute)) {
-          yield* exports_file_mutation.syncTextBom(environment.files, target.absolute, bom);
+          yield* syncTextBom2(environment.files, target.absolute, bom);
         }
         return result;
-      }).pipe(Effect.map((output) => ({ output, content: toModelContent(output) })), Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })))
+      }).pipe(Effect.map((output) => ({ output, content: toModelContent3(output) })), Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })))
     })).pipe(Effect.orDie);
   })
 };
 
-export { name, Input, Output, toModelContent, Plugin, exports_write };
+export { name8, Input8, Output5, toModelContent3, Plugin39, exports_write };

package/dist/chunks/command-nd78q6e5.js

@@ -0,0 +1,37 @@
+import {
+  latest2,
+  Service57
+} from "./command-tr5yhgb5.js";
+import {
+  Service62
+} from "./command-x0pd42vp.js";
+import {
+  observe2
+} from "./command-qsdy395h.js";
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/config/plugin/shell.ts
+var exports_shell = {};
+__export(exports_shell, {
+  ConfigShellPlugin: () => exports_shell,
+  Plugin: () => Plugin18
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin18 = define({
+  id: "opencode.config.shell",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service57;
+    const shell = yield* Service62;
+    const loaded = yield* observe2(config, ctx.event, shell.reload());
+    yield* shell.transform((editor) => {
+      const configured = latest2(loaded.entries, "shell");
+      if (configured)
+        editor.configure(configured);
+    });
+  })
+});
+
+export { Plugin18, exports_shell };

package/dist/chunks/{integration-8jedcdnq.js → command-njfhyprf.js}

@@ -1,43 +1,47 @@
 import {
-  exports_mcp
-} from "./integration-b5zj5y7v.js";
+  Service79,
+  node83
+} from "./command-pdae5shs.js";
 import {
-  exports_tool
-} from "./integration-8hhfhc9z.js";
+  Service36,
+  node38
+} from "./command-pcednt3p.js";
 import {
-  exports_permission
-} from "./integration-44nx66ev.js";
+  Service42,
+  node44
+} from "./command-nkpkrkfc.js";
 import {
-  exports_bus
-} from "./integration-hf9h67zk.js";
+  Service37,
+  node39
+} from "./command-kj8q7mtc.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/tool/mcp.ts
-var exports_mcp2 = {};
-__export(exports_mcp2, {
-  McpTool: () => exports_mcp2,
-  Service: () => Service,
-  layer: () => layer,
-  name: () => name,
-  namespace: () => namespace,
-  node: () => node
+var exports_mcp3 = {};
+__export(exports_mcp3, {
+  McpTool: () => exports_mcp3,
+  Service: () => Service35,
+  layer: () => layer15,
+  name: () => name14,
+  namespace: () => namespace2,
+  node: () => node37
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { McpEvent } from "@opencode-ai/schema/mcp-event";
 import { Context, Effect, Fiber, Layer, PubSub, Semaphore, Stream } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-var namespace = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
-var name = (server, tool) => `${namespace(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+var namespace2 = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
+var name14 = (server, tool) => `${namespace2(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
 
-class Service extends Context.Service()("@opencode/McpTool") {
+class Service35 extends Context.Service()("@opencode/McpTool") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const mcp = yield* exports_mcp.Service;
-  const tools = yield* exports_tool.Service;
-  const bus = yield* exports_bus.Service;
-  const permission = yield* exports_permission.Service;
+var layer15 = Layer.effect(Service35, Effect.gen(function* () {
+  const mcp = yield* Service36;
+  const tools = yield* Service37;
+  const bus = yield* Service79;
+  const permission = yield* Service42;
   const lock = Semaphore.makeUnsafe(1);
   let discovered = [];
   const initial = yield* lock.withPermit(Effect.gen(function* () {
@@ -47,7 +51,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         const schema = tool.inputSchema ?? {};
         editor.add({
           name: tool.name,
-          options: { namespace: namespace(tool.server), codemode: tool.codemode !== false },
+          options: { namespace: namespace2(tool.server), codemode: tool.codemode !== false },
           description: tool.description ?? "",
           input: {
             ...schema,
@@ -58,7 +62,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           output: tool.outputSchema ?? {},
           execute: (input, context) => Effect.gen(function* () {
             yield* permission.assert({
-              action: name(tool.server, tool.name),
+              action: name14(tool.server, tool.name),
               resources: ["*"],
               save: ["*"],
               metadata: {},
@@ -95,7 +99,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
               output: result.structured ?? (text === "" ? null : text),
               ...content.length === 0 ? {} : { content }
             };
-          }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to execute ${name(tool.server, tool.name)}` })))
+          }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to execute ${name14(tool.server, tool.name)}` })))
         });
       }
     });
@@ -108,12 +112,12 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   yield* bus.subscribe(McpEvent.ToolsChanged).pipe(Stream.runForEach(() => PubSub.publish(changes, undefined)), Effect.forkScoped({ startImmediately: true }));
   const updates = yield* PubSub.subscribe(changes);
   yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reconcile), Effect.forkScoped({ startImmediately: true }));
-  return Service.of({ flush: Effect.asVoid(Fiber.await(initial)) });
+  return Service35.of({ flush: Effect.asVoid(Fiber.await(initial)) });
 }));
-var node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [exports_tool.node, exports_mcp.node, exports_bus.node, exports_permission.node]
+var node37 = makeLocationNode({
+  service: Service35,
+  layer: layer15,
+  deps: [node39, node38, node83, node44]
 });
 
-export { namespace, name, Service, layer, node, exports_mcp2 as exports_mcp };
+export { namespace2, name14, Service35, layer15, node37, exports_mcp3 };