@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-8a24hghq.js

@@ -0,0 +1,226 @@
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  makeUnsafe2
+} from "./aisdk-native-y71avatq.js";
+import {
+  Binding2,
+  RegistryService2,
+  node77
+} from "./aisdk-native-4ns3h2re.js";
+import {
+  WorkspaceTable2
+} from "./aisdk-native-faypxj3z.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/workspace.ts
+var exports_workspace = {};
+__export(exports_workspace, {
+  CreateConflict: () => CreateConflict2,
+  ID: () => ID15,
+  Info: () => Info29,
+  NotFound: () => NotFound3,
+  Service: () => Service72,
+  Workspace: () => exports_workspace,
+  configured: () => configured9,
+  node: () => node76
+});
+import { Workspace } from "@opencode/schema/workspace";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { eq } from "drizzle-orm";
+import { Clock, Context, Deferred, Duration, Effect, Exit, FiberSet, Layer, Ref, Schedule, Schema, Scope } from "effect";
+import { systemError } from "effect/PlatformError";
+import { make } from "effect/unstable/process/ChildProcessSpawner";
+var ID15 = Workspace.ID;
+
+class Info29 extends Schema.Class("Workspace.Info")({
+  id: ID15,
+  provider: Schema.String,
+  binding: Binding2,
+  createdAt: Schema.Number,
+  lastUsedAt: Schema.Number
+}) {
+}
+
+class NotFound3 extends Schema.TaggedError()("Workspace.NotFound", { workspaceID: ID15 }) {
+}
+
+class CreateConflict2 extends Schema.TaggedError()("Workspace.CreateConflict", {
+  workspaceID: ID15,
+  provider: Schema.String,
+  existingProvider: Schema.String
+}) {
+}
+
+class Service72 extends Context.Service()("@opencode/Workspace") {
+}
+var configured9 = (options = {}) => makeGlobalNode({
+  service: Service72,
+  layer: layer(options),
+  deps: [node85, node77]
+});
+var layer = (options) => Layer.effect(Service72, Effect.gen(function* () {
+  const db = (yield* Service80).db;
+  const registry = yield* RegistryService2;
+  const lifetime = yield* Scope.Scope;
+  const connections = new Map;
+  const attempts = new Map;
+  const locks = makeUnsafe2();
+  const fork = yield* FiberSet.makeRuntime();
+  const idleThreshold = Duration.toMillis(options.idleThreshold ?? Duration.minutes(20));
+  const find = (workspaceID) => db.select().from(WorkspaceTable2).where(eq(WorkspaceTable2.id, workspaceID)).get().pipe(Effect.orDie);
+  const load = Effect.fn("Workspace.load")(function* (workspaceID) {
+    const row = yield* find(workspaceID);
+    if (!row)
+      return yield* new NotFound3({ workspaceID });
+    return row;
+  });
+  const saveBinding = (workspaceID, binding) => db.update(WorkspaceTable2).set({ binding }).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
+  const info = (row, binding) => new Info29({
+    id: row.id,
+    provider: row.provider,
+    binding,
+    createdAt: row.created_at,
+    lastUsedAt: row.last_used_at
+  });
+  const provision = Effect.fn("Workspace.provision")((workspaceID) => Effect.suspend(() => {
+    const existing = attempts.get(workspaceID);
+    if (existing)
+      return Deferred.await(existing);
+    const attempt = Deferred.makeUnsafe();
+    attempts.set(workspaceID, attempt);
+    fork(locks.withLock(workspaceID)(Effect.gen(function* () {
+      const row = yield* load(workspaceID);
+      if (row.binding)
+        return info(row, row.binding);
+      const driver = yield* registry.get(row.provider);
+      const result = yield* driver.create({ workspaceID });
+      yield* saveBinding(workspaceID, result.binding);
+      return info(row, result.binding);
+    })).pipe(Effect.raceFirst(Deferred.await(attempt)), Effect.onExit((exit) => Effect.sync(() => {
+      if (attempts.get(workspaceID) === attempt)
+        attempts.delete(workspaceID);
+      Deferred.doneUnsafe(attempt, exit);
+    })), Effect.exit, Effect.asVoid));
+    return Deferred.await(attempt);
+  }));
+  const open = Effect.fn("Workspace.open")(function* (workspaceID) {
+    const existing = connections.get(workspaceID);
+    if (existing)
+      return existing;
+    const row = yield* load(workspaceID);
+    if (!row.binding)
+      return yield* Effect.die(`workspace ${workspaceID} has no binding after provision`);
+    const driver = yield* registry.get(row.provider);
+    const persistBinding = (binding) => saveBinding(workspaceID, binding);
+    const scope = yield* Scope.fork(lifetime);
+    const environment = yield* driver.connect({ workspaceID, binding: row.binding, saveBinding: persistBinding }).pipe(Effect.provideService(Scope.Scope, scope), Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))));
+    const now = yield* Clock.currentTimeMillis;
+    const connection = {
+      driver,
+      environment,
+      saveBinding: persistBinding,
+      lastActivity: yield* Ref.make(now),
+      active: yield* Ref.make(0),
+      scope
+    };
+    connections.set(workspaceID, connection);
+    yield* db.update(WorkspaceTable2).set({ last_used_at: now }).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
+    return connection;
+  });
+  yield* Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    yield* Effect.forEach([...connections.entries()], ([workspaceID, expected]) => locks.withLock(workspaceID)(Effect.gen(function* () {
+      const connection = connections.get(workspaceID);
+      if (connection !== expected || (yield* Ref.get(connection.active)) > 0)
+        return;
+      const lastActivity = yield* Ref.get(connection.lastActivity);
+      if (now - lastActivity < idleThreshold)
+        return;
+      const row = yield* load(workspaceID);
+      if (!row.binding)
+        return;
+      yield* connection.driver.suspendForIdle({
+        workspaceID,
+        binding: row.binding,
+        saveBinding: connection.saveBinding
+      });
+      yield* db.update(WorkspaceTable2).set({ last_used_at: lastActivity }).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
+      connections.delete(workspaceID);
+      yield* Scope.close(connection.scope, Exit.void);
+    }).pipe(Effect.catchCause((cause) => Effect.logError("workspace idle suspension failed", cause)))), { concurrency: "unbounded", discard: true });
+  }).pipe(Effect.repeat(Schedule.spaced(options.pollInterval ?? Duration.minutes(1))), Effect.forkScoped);
+  return Service72.of({
+    create: Effect.fn("Workspace.create")(function* (input) {
+      const workspaceID = input.id ?? ID15.create();
+      const existing = yield* db.select({ provider: WorkspaceTable2.provider }).from(WorkspaceTable2).where(eq(WorkspaceTable2.id, workspaceID)).get().pipe(Effect.orDie);
+      if (existing) {
+        if (existing.provider === input.provider)
+          return workspaceID;
+        return yield* new CreateConflict2({
+          workspaceID,
+          provider: input.provider,
+          existingProvider: existing.provider
+        });
+      }
+      yield* registry.get(input.provider);
+      const now = yield* Clock.currentTimeMillis;
+      const inserted = yield* db.insert(WorkspaceTable2).values({ id: workspaceID, provider: input.provider, binding: null, created_at: now, last_used_at: now }).onConflictDoNothing().returning({ id: WorkspaceTable2.id }).get().pipe(Effect.orDie);
+      if (inserted)
+        return workspaceID;
+      const row = yield* load(workspaceID).pipe(Effect.orDie);
+      if (row.provider !== input.provider)
+        return yield* new CreateConflict2({
+          workspaceID,
+          provider: input.provider,
+          existingProvider: row.provider
+        });
+      return workspaceID;
+    }),
+    provision,
+    connect: Effect.fn("Workspace.connect")(function* (workspaceID) {
+      const spawner = make((command) => Effect.acquireRelease(Effect.suspend(() => connections.has(workspaceID) ? Effect.void : provision(workspaceID)).pipe(Effect.andThen(locks.withLock(workspaceID)(Effect.gen(function* () {
+        const connection = yield* open(workspaceID);
+        yield* Ref.set(connection.lastActivity, yield* Clock.currentTimeMillis);
+        yield* Ref.update(connection.active, (active) => active + 1);
+        return connection;
+      }))), Effect.mapError((cause) => systemError({
+        _tag: "Unknown",
+        module: "Workspace",
+        method: "spawn",
+        description: `Failed to wake workspace ${workspaceID}`,
+        cause
+      }))), (connection) => locks.withLock(workspaceID)(Effect.gen(function* () {
+        yield* Ref.update(connection.active, (active) => active - 1);
+        yield* Ref.set(connection.lastActivity, yield* Clock.currentTimeMillis);
+      }))).pipe(Effect.flatMap((connection) => connection.environment.spawner.spawn(command))));
+      return { spawner };
+    }),
+    destroy: Effect.fn("Workspace.destroy")(function* (workspaceID) {
+      const attempt = attempts.get(workspaceID);
+      if (attempt) {
+        attempts.delete(workspaceID);
+        Deferred.doneUnsafe(attempt, Exit.fail(new NotFound3({ workspaceID })));
+      }
+      return yield* locks.withLock(workspaceID)(Effect.gen(function* () {
+        const row = yield* find(workspaceID);
+        if (!row)
+          return { destroyed: false };
+        const connection = connections.get(workspaceID);
+        connections.delete(workspaceID);
+        if (connection)
+          yield* Scope.close(connection.scope, Exit.void);
+        yield* registry.get(row.provider).pipe(Effect.flatMap((driver) => driver.destroy({ workspaceID, binding: row.binding })), Effect.catchTag("WorkspaceDriver.ProviderNotFound", (error) => row.binding ? Effect.fail(error) : Effect.void));
+        yield* db.delete(WorkspaceTable2).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
+        return { destroyed: true };
+      }));
+    })
+  });
+}));
+var node76 = configured9();
+
+export { ID15, Info29, NotFound3, CreateConflict2, Service72, configured9, node76, exports_workspace };

package/dist/chunks/aisdk-native-8d7r5vzw.js

@@ -0,0 +1,106 @@
+import {
+  which2
+} from "./aisdk-native-qaymkmh1.js";
+
+// src/ripgrep/binary.ts
+import path from "path";
+import { Context, Effect, Layer, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { ChildProcess } from "effect/unstable/process";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { CrossSpawnSpawner } from "@opencode/util/cross-spawn-spawner";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var RipgrepBinary2;
+((RipgrepBinary) => {
+  const VERSION = "15.1.0";
+  const PLATFORM = {
+    "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
+    "arm64-linux": { platform: "aarch64-unknown-linux-gnu", extension: "tar.gz" },
+    "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
+    "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
+    "arm64-win32": { platform: "aarch64-pc-windows-msvc", extension: "zip" },
+    "ia32-win32": { platform: "i686-pc-windows-msvc", extension: "zip" },
+    "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" }
+  };
+
+  class Service extends Context.Service()("@opencode/RipgrepBinary") {
+  }
+  RipgrepBinary.Service = Service;
+  const layer = Layer.effect(Service, Effect.gen(function* () {
+    const fs = yield* FSUtil.Service;
+    const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+    const spawner = yield* ChildProcessSpawner;
+    const global = yield* Global.Service;
+    const findExecutable = (name) => which2(name, undefined, global.bin);
+    const run = Effect.fnUntraced(function* (command, args) {
+      const handle = yield* spawner.spawn(ChildProcess.make(command, args, { extendEnv: true, stdin: "ignore" }));
+      const [stdout, stderr, code] = yield* Effect.all([
+        Stream.mkString(Stream.decodeText(handle.stdout)),
+        Stream.mkString(Stream.decodeText(handle.stderr)),
+        handle.exitCode
+      ], { concurrency: "unbounded" });
+      return { stdout, stderr, code };
+    }, Effect.scoped);
+    const extract = Effect.fnUntraced(function* (archive, config, target) {
+      const dir = yield* fs.makeTempDirectoryScoped({ directory: global.bin, prefix: "ripgrep-" });
+      if (config.extension === "zip") {
+        const shell = (yield* Effect.sync(() => findExecutable("powershell.exe") ?? findExecutable("pwsh.exe"))) ?? "powershell.exe";
+        const result = yield* run(shell, [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -LiteralPath '${archive.replaceAll("'", "''")}' -DestinationPath '${dir.replaceAll("'", "''")}' -Force`
+        ]);
+        if (result.code !== 0)
+          throw new Error(result.stderr.trim() || result.stdout.trim() || `ripgrep extraction failed with code ${result.code}`);
+      }
+      if (config.extension === "tar.gz") {
+        const result = yield* run("tar", ["-xzf", archive, "-C", dir]);
+        if (result.code !== 0)
+          throw new Error(result.stderr.trim() || result.stdout.trim() || `ripgrep extraction failed with code ${result.code}`);
+      }
+      const extracted = path.join(dir, `ripgrep-${VERSION}-${config.platform}`, process.platform === "win32" ? "rg.exe" : "rg");
+      if (!(yield* fs.isFile(extracted)))
+        throw new Error(`ripgrep archive did not contain executable: ${extracted}`);
+      yield* fs.copyFile(extracted, target);
+      if (process.platform !== "win32")
+        yield* fs.chmod(target, 493);
+    }, Effect.scoped);
+    return Service.of({
+      filepath: yield* Effect.cached(Effect.gen(function* () {
+        const system = yield* Effect.sync(() => findExecutable(process.platform === "win32" ? "rg.exe" : "rg"));
+        if (system && (yield* fs.isFile(system).pipe(Effect.orDie)))
+          return system;
+        const target = path.join(global.bin, `rg${process.platform === "win32" ? ".exe" : ""}`);
+        if (yield* fs.isFile(target).pipe(Effect.orDie))
+          return target;
+        const platformKey = `${process.arch}-${process.platform}`;
+        const config = PLATFORM[platformKey];
+        if (!config)
+          throw new Error(`unsupported platform for ripgrep: ${platformKey}`);
+        const filename = `ripgrep-${VERSION}-${config.platform}.${config.extension}`;
+        const url = `https://github.com/BurntSushi/ripgrep/releases/download/${VERSION}/${filename}`;
+        const archive = path.join(global.bin, filename);
+        yield* Effect.logInfo("downloading ripgrep", { url });
+        yield* fs.ensureDir(global.bin).pipe(Effect.orDie);
+        const bytes = yield* HttpClientRequest.get(url).pipe(http.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.mapError((cause) => cause instanceof Error ? cause : new Error(String(cause))));
+        if (bytes.byteLength === 0)
+          throw new Error(`failed to download ripgrep from ${url}`);
+        yield* fs.writeWithDirs(archive, new Uint8Array(bytes));
+        yield* extract(archive, config, target);
+        yield* fs.remove(archive, { force: true }).pipe(Effect.ignore);
+        return target;
+      }))
+    });
+  }));
+  RipgrepBinary.node = makeGlobalNode({
+    service: Service,
+    layer,
+    deps: [FSUtil.node, Global.node, httpClient, CrossSpawnSpawner.node]
+  });
+})(RipgrepBinary2 ||= {});
+
+export { RipgrepBinary2 };

package/dist/chunks/aisdk-native-8n3pysct.js

@@ -0,0 +1,27 @@
+// src/database/migration/20260611192811_lush_chimera.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260611192811_lush_chimera",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`credential_connector_active_idx\`;`);
+      yield* tx.run(`DROP TABLE \`credential\`;`);
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`integration_id\` text,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`connector_id\` text,
+          \`method_id\` text,
+          \`active\` integer,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260611192811_lush_chimera_default = migration;
+
+export { _20260611192811_lush_chimera_default };

package/dist/chunks/aisdk-native-8p4f9s12.js

@@ -0,0 +1,41 @@
+import {
+  absoluteColumn2,
+  absoluteArrayColumn2
+} from "./aisdk-native-6msgmcgs.js";
+import {
+  Timestamps2
+} from "./aisdk-native-qfa1cgps.js";
+
+// src/project/sql.ts
+import { isNotNull, isNull, ne, or } from "drizzle-orm";
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
+var ProjectTable2 = sqliteTable("project", {
+  id: text().$type().primaryKey(),
+  worktree: absoluteColumn2().notNull(),
+  vcs: text().$type(),
+  name: text(),
+  icon_url: text(),
+  icon_url_override: text(),
+  icon_color: text(),
+  ...Timestamps2,
+  time_initialized: integer(),
+  sandboxes: absoluteArrayColumn2().notNull(),
+  commands: text({ mode: "json" }).$type()
+});
+var ProjectDirectoryTable2 = sqliteTable("project_directory", {
+  project_id: text().$type().notNull().references(() => ProjectTable2.id, { onDelete: "cascade" }),
+  directory: absoluteColumn2().notNull(),
+  type: text().$type(),
+  strategy: text(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
+function upsertProject2(db, project) {
+  const vcs = project.vcs?.type;
+  return db.insert(ProjectTable2).values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] }).onConflictDoUpdate({
+    target: ProjectTable2.id,
+    set: { vcs: vcs ?? null },
+    setWhere: vcs ? or(isNull(ProjectTable2.vcs), ne(ProjectTable2.vcs, vcs)) : isNotNull(ProjectTable2.vcs)
+  }).run();
+}
+
+export { ProjectTable2, ProjectDirectoryTable2, upsertProject2 };

package/dist/chunks/aisdk-native-8qqh30s3.js

@@ -0,0 +1,63 @@
+import {
+  Service43,
+  node46,
+  canonical2
+} from "./aisdk-native-nhqh66qs.js";
+import {
+  Service42,
+  node45
+} from "./aisdk-native-81rrwt6s.js";
+import {
+  Service45
+} from "./aisdk-native-2se0afp6.js";
+import {
+  layer2
+} from "./aisdk-native-zzet69ff.js";
+
+// src/location-services.ts
+import { Context, Duration, Effect, Exit, Layer, LayerMap, MutableHashMap, Option } from "effect";
+function buildLocationServiceMap2(replacements = []) {
+  return Layer.effect(Service43, Effect.gen(function* () {
+    const owner = yield* Effect.scope;
+    const builds = MutableHashMap.empty();
+    const inner = yield* LayerMap.make((ref) => {
+      const build = {};
+      MutableHashMap.set(builds, ref, build);
+      return Layer.fromBuild((memoMap, scope) => Effect.suspend(() => Layer.buildWithMemoMap(layer2(ref, { replacements: bindings }), memoMap, scope)).pipe(Effect.onExit((exit) => {
+        const finish = Effect.suspend(() => {
+          if (Option.getOrUndefined(MutableHashMap.get(builds, ref)) !== build)
+            return Effect.void;
+          if (Exit.isSuccess(exit)) {
+            build.close = Context.get(exit.value, Service45).close;
+            return Effect.void;
+          }
+          MutableHashMap.remove(builds, ref);
+          return Exit.isFailure(exit) ? inner.invalidate(ref) : Effect.void;
+        });
+        return Exit.isFailure(exit) ? finish.pipe(Effect.forkIn(owner, { startImmediately: true }), Effect.asVoid) : finish;
+      })));
+    }, { idleTimeToLive: Duration.infinity });
+    const map = {
+      ...inner,
+      get: (ref) => inner.get(canonical2(ref)),
+      contextEffect: (ref) => inner.contextEffect(canonical2(ref)),
+      contextEffectOption: (ref) => inner.contextEffectOption(canonical2(ref)),
+      invalidate: (ref) => Effect.suspend(() => {
+        const key = canonical2(ref);
+        const build = Option.getOrUndefined(MutableHashMap.get(builds, key));
+        MutableHashMap.remove(builds, key);
+        return inner.invalidate(key).pipe(Effect.andThen(build?.close ?? Effect.void));
+      })
+    };
+    const bindings = [
+      node45.replace(Layer.succeed(Service42, {
+        provide: (session) => Effect.provide(map.get(session.location))
+      })),
+      ...replacements,
+      node46.replace(Layer.succeed(Service43, map))
+    ];
+    return map;
+  }));
+}
+
+export { buildLocationServiceMap2 };

package/dist/chunks/aisdk-native-8qr4v3ea.js

@@ -0,0 +1,101 @@
+import {
+  Service71
+} from "./aisdk-native-ms882c9x.js";
+import {
+  Service16,
+  readText2,
+  syncTextBom2
+} from "./aisdk-native-aqpgmyrr.js";
+import {
+  Service18
+} from "./aisdk-native-4b9mceyk.js";
+import {
+  Service59
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  Service17
+} from "./aisdk-native-svw2bsx3.js";
+import {
+  fileDiff2
+} from "./aisdk-native-6prwharc.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/tool/plugin/write.ts
+var exports_write = {};
+__export(exports_write, {
+  Input: () => Input12,
+  Output: () => Output8,
+  Plugin: () => Plugin44,
+  WriteTool: () => exports_write,
+  name: () => name12,
+  toModelContent: () => toModelContent6
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import { Bom } from "@opencode/util/bom";
+var name12 = "write";
+var Input12 = 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 Output8 = Schema.Struct({
+  operation: Schema.Literal("write"),
+  target: Schema.String,
+  resource: Schema.String,
+  existed: Schema.Boolean
+});
+var toModelContent6 = (output) => `${output.existed ? "Wrote" : "Created"} file successfully: ${output.resource}`;
+var Plugin44 = {
+  id: "opencode.tool.write",
+  effect: Effect.fn("WriteTool.Plugin")(function* (ctx) {
+    const access = yield* Service17;
+    const fileMutation = yield* Service16;
+    const environment = yield* Service71;
+    const formatter = yield* Service18;
+    const permission = yield* Service59;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name12,
+      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: Input12,
+      output: Output8,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = {
+          type: "tool",
+          messageID: context.messageID,
+          id: context.id
+        };
+        const target = yield* access.resolve({ path: input.path, kind: "file" });
+        yield* access.authorizeExternal([target], context);
+        const current = yield* readText2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.undefined));
+        const next = Bom.split(input.content);
+        const preview = fileDiff2(target.resource, current?.text ?? "", next.text, current ? "modified" : "added");
+        yield* permission.assert({
+          action: "edit",
+          resources: [target.resource],
+          save: ["*"],
+          metadata: { files: [preview] },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const result = yield* fileMutation.writeTextPreservingBom({ target, content: input.content });
+        const bom = (yield* readText2(environment.files, target.absolute)).bom;
+        if (yield* formatter.file(target.absolute)) {
+          yield* syncTextBom2(environment.files, target.absolute, bom);
+        }
+        return result;
+      }).pipe(Effect.map((output) => ({ output, content: toModelContent6(output) })), Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name12, Input12, Output8, toModelContent6, Plugin44, exports_write };

package/dist/chunks/aisdk-native-8y0t5gr9.js

@@ -0,0 +1,69 @@
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  PermissionTable2
+} from "./aisdk-native-f828m53h.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/permission/saved.ts
+var exports_saved = {};
+__export(exports_saved, {
+  AddInput: () => AddInput2,
+  ID: () => ID8,
+  Info: () => Info20,
+  ListInput: () => ListInput4,
+  PermissionSaved: () => exports_saved,
+  Service: () => Service60,
+  node: () => node64
+});
+import { eq } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Project } from "@opencode/schema/project";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { PermissionSaved } from "@opencode/schema/permission-saved";
+var ID8 = PermissionSaved.ID;
+var Info20 = PermissionSaved.Info;
+var ListInput4 = Schema.Struct({
+  projectID: Project.ID.pipe(Schema.optional)
+}).annotate({ identifier: "PermissionSaved.ListInput" });
+var AddInput2 = Schema.Struct({
+  projectID: Project.ID,
+  action: Schema.String,
+  resources: Schema.Array(Schema.String)
+}).annotate({ identifier: "PermissionSaved.AddInput" });
+
+class Service60 extends Context.Service()("@opencode/PermissionSaved") {
+}
+var layer = Layer.effect(Service60, Effect.gen(function* () {
+  const db = (yield* Service80).db;
+  const list = Effect.fnUntraced(function* (input) {
+    const rows = yield* db.select().from(PermissionTable2).where(input?.projectID ? eq(PermissionTable2.project_id, input.projectID) : undefined).all().pipe(Effect.orDie);
+    return rows.map((row) => ({
+      id: row.id,
+      projectID: row.project_id,
+      action: row.action,
+      resource: row.resource
+    }));
+  });
+  const add = Effect.fn("PermissionSaved.add")(function* (input) {
+    if (!input.resources.length)
+      return;
+    yield* db.insert(PermissionTable2).values(input.resources.map((resource) => ({
+      id: ID8.create(),
+      project_id: input.projectID,
+      action: input.action,
+      resource
+    }))).onConflictDoNothing().run().pipe(Effect.orDie);
+  });
+  const remove = Effect.fn("PermissionSaved.remove")(function* (id) {
+    yield* db.delete(PermissionTable2).where(eq(PermissionTable2.id, id)).run().pipe(Effect.orDie);
+  });
+  return Service60.of({ list, add, remove });
+}));
+var node64 = makeGlobalNode({ service: Service60, layer, deps: [node85] });
+
+export { ID8, Info20, ListInput4, AddInput2, Service60, node64, exports_saved };

package/dist/chunks/aisdk-native-922hggd3.js

@@ -0,0 +1,21 @@
+// src/schema.ts
+import { Schema } from "effect";
+import {
+  AbsolutePath as AbsolutePath2,
+  DateTimeUtcFromMillis as DateTimeUtcFromMillis2,
+  NonNegativeInt as NonNegativeInt2,
+  optional as optional2,
+  PositiveInt as PositiveInt2,
+  RelativePath as RelativePath2,
+  statics as statics2
+} from "@opencode/schema/schema";
+function Newtype2() {
+  return (tag, schema) => {
+    class Base {
+    }
+    Object.setPrototypeOf(Base, schema.pipe(Schema.brand(tag)));
+    return Base;
+  };
+}
+
+export { AbsolutePath2, DateTimeUtcFromMillis2, NonNegativeInt2, optional2, PositiveInt2, RelativePath2, statics2, Newtype2 };