@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-r14cnnrw.js

@@ -0,0 +1,99 @@
+import {
+  Service78
+} from "./repository-x6rcf4cj.js";
+import {
+  Service13,
+  Event2
+} from "./repository-de42ff3x.js";
+
+// src/plugin/models-dev.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Integration } from "@opencode/schema/integration";
+import { Provider } from "@opencode/schema/provider";
+import { Effect, Stream } from "effect";
+var BEDROCK_PROFILE_ONLY_IDS = [
+  "amazon.nova-2-lite-v1:0",
+  "anthropic.claude-fable-5",
+  "anthropic.claude-fable-5-1",
+  "anthropic.claude-haiku-4-5-20251001-v1:0",
+  "anthropic.claude-opus-4-1-20250805-v1:0",
+  "anthropic.claude-opus-4-5-20251101-v1:0",
+  "anthropic.claude-opus-4-7",
+  "anthropic.claude-opus-4-8",
+  "anthropic.claude-opus-5",
+  "anthropic.claude-sonnet-4-5-20250929-v1:0",
+  "anthropic.claude-sonnet-5",
+  "deepseek.r1-v1:0",
+  "mistral.pixtral-large-2502-v1:0"
+];
+var ModelsDevPlugin2 = define({
+  id: "opencode.models.dev",
+  effect: Effect.fn(function* (ctx) {
+    const modelsDev = yield* Service13;
+    const bus = yield* Service78;
+    const loaded = { data: snapshots(yield* modelsDev.get()) };
+    yield* ctx.integration.transform((integrations) => {
+      for (const provider of loaded.data) {
+        if (provider.environment.length === 0)
+          continue;
+        const integrationID = provider.info.id;
+        integrations.update(integrationID, (integration) => integration.name = provider.info.name);
+        integrations.method.update({
+          integrationID,
+          method: { type: "key" }
+        });
+        integrations.method.update({
+          integrationID,
+          method: {
+            type: "env",
+            names: environmentNames(provider)
+          }
+        });
+      }
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      for (const provider of loaded.data) {
+        catalog.provider.update(provider.info.id, (draft) => {
+          Object.assign(draft, copy(provider.info));
+          draft.integrationID = Integration.ID.make(provider.info.id);
+        });
+        for (const model of provider.models) {
+          if (model.status === "deprecated")
+            continue;
+          if (provider.info.id === Provider.ID.amazonBedrock && BEDROCK_PROFILE_ONLY_IDS.includes(model.modelID ?? model.id))
+            continue;
+          catalog.model.update(provider.info.id, model.id, (draft) => Object.assign(draft, copy(model)));
+        }
+      }
+    });
+    yield* bus.subscribe(Event2.Refreshed).pipe(Stream.runForEach(() => modelsDev.get().pipe(Effect.tap((data) => Effect.sync(() => loaded.data = snapshots(data))), Effect.andThen(ctx.integration.reload()), Effect.andThen(ctx.catalog.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function environmentNames(provider) {
+  if (provider.info.id === Provider.ID.azure)
+    return [...provider.environment.filter((name) => name.endsWith("_API_KEY")), "AZURE_COGNITIVE_SERVICES_API_KEY"];
+  if (provider.info.id === Provider.ID.googleVertex)
+    return ["GOOGLE_VERTEX_API_KEY"];
+  return [...provider.environment];
+}
+function snapshots(data) {
+  return data.filter((provider) => provider.info.id !== "azure-cognitive-services" && provider.info.id !== "google-vertex-anthropic");
+}
+function copy(value) {
+  if (Array.isArray(value))
+    return value.map(copy);
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      const copied = copy(value[key]);
+      if (key === "__proto__")
+        Object.defineProperty(result, key, { value: copied, enumerable: true, writable: true, configurable: true });
+      else
+        result[key] = copied;
+    }
+    return result;
+  }
+  return value;
+}
+
+export { ModelsDevPlugin2 };

package/dist/chunks/repository-r2dfp6se.js

@@ -0,0 +1,279 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  ID3
+} from "./repository-qapv375x.js";
+import {
+  Service57,
+  login2,
+  node61
+} from "./repository-3ke3s58r.js";
+import {
+  lazy2
+} from "./repository-88xbtdfr.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/pty.ts
+var exports_pty = {};
+__export(exports_pty, {
+  CreateInput: () => CreateInput3,
+  Event: () => Event5,
+  ExitedError: () => ExitedError2,
+  Info: () => Info5,
+  NotFoundError: () => NotFoundError3,
+  Pty: () => exports_pty,
+  Service: () => Service20,
+  UpdateInput: () => UpdateInput2,
+  node: () => node24
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Pty } from "@opencode/schema/pty";
+import { Event as Event5 } from "@opencode/schema/pty";
+var BUFFER_LIMIT = 1024 * 1024 * 2;
+var EXITED_LIMIT = 25;
+var pty = lazy2(() => import("#pty"));
+var Info5 = Pty.Info;
+var CreateInput3 = Pty.CreateInput;
+var UpdateInput2 = Pty.UpdateInput;
+
+class NotFoundError3 extends Schema.TaggedError()("Pty.NotFoundError", {
+  ptyID: ID3
+}) {
+}
+
+class ExitedError2 extends Schema.TaggedError()("Pty.ExitedError", {
+  ptyID: ID3
+}) {
+}
+
+class Service20 extends Context.Service()("@opencode/Pty") {
+}
+var layer = Layer.effect(Service20, Effect.gen(function* () {
+  const bus = yield* Service78;
+  const location = yield* Service66;
+  const shell = yield* Service57;
+  const context = yield* Effect.context();
+  const runFork = Effect.runForkWith(context);
+  const sessions = new Map;
+  const exitOrder = [];
+  function notifyEnd(session, event) {
+    for (const subscriber of session.subscribers.values()) {
+      if (!subscriber.active) {
+        subscriber.end = event;
+        continue;
+      }
+      try {
+        subscriber.onEnd(event);
+      } catch {}
+    }
+    session.subscribers.clear();
+  }
+  function teardown(session) {
+    for (const listener of session.listeners)
+      listener.dispose();
+    session.listeners.length = 0;
+    if (session.info.status === "running") {
+      try {
+        session.process.kill();
+      } catch {}
+    }
+    notifyEnd(session, {});
+  }
+  yield* Effect.addFinalizer(() => Effect.sync(() => {
+    for (const session of sessions.values())
+      teardown(session);
+    sessions.clear();
+    exitOrder.length = 0;
+  }));
+  const requireSession = Effect.fn("Pty.requireSession")(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return yield* new NotFoundError3({ ptyID: id });
+    return session;
+  });
+  const removeSession = Effect.fnUntraced(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return;
+    sessions.delete(id);
+    const index = exitOrder.indexOf(id);
+    if (index !== -1)
+      exitOrder.splice(index, 1);
+    yield* Effect.logInfo("removing session", { id });
+    teardown(session);
+    yield* bus.publish(Pty.Event.Deleted, { id: session.info.id });
+  });
+  const remove = Effect.fn("Pty.remove")(function* (id) {
+    yield* requireSession(id);
+    yield* removeSession(id);
+  });
+  const list = Effect.fn("Pty.list")(function* () {
+    return Array.from(sessions.values()).map((session) => session.info);
+  });
+  const get = Effect.fn("Pty.get")(function* (id) {
+    return (yield* requireSession(id)).info;
+  });
+  const create = Effect.fn("Pty.create")(function* (input) {
+    const id = ID3.ascending();
+    const command = input.command || (yield* shell.resolve({ priority: "config" }));
+    const args = login2(command) ? [...input.args ?? [], "-l"] : [...input.args ?? []];
+    const cwd = input.cwd || location.directory;
+    const env = {
+      ...process.env,
+      ...input.env,
+      TERM: "xterm-256color",
+      OPENCODE_TERMINAL: "1"
+    };
+    if (process.platform === "win32") {
+      env.LC_ALL = "C.UTF-8";
+      env.LC_CTYPE = "C.UTF-8";
+      env.LANG = "C.UTF-8";
+    }
+    yield* Effect.logInfo("creating session", { id, cmd: command, args, cwd });
+    const { spawn } = yield* Effect.promise(() => pty());
+    const proc = yield* Effect.sync(() => spawn(command, args, { name: "xterm-256color", cwd, env }));
+    const info = {
+      id,
+      title: input.title || `Terminal ${id.slice(-4)}`,
+      command,
+      args,
+      cwd,
+      status: "running",
+      pid: proc.pid
+    };
+    const session = {
+      info,
+      process: proc,
+      buffer: "",
+      bufferCursor: 0,
+      cursor: 0,
+      subscribers: new Map,
+      listeners: []
+    };
+    sessions.set(id, session);
+    session.listeners.push(proc.onData((chunk) => {
+      session.cursor += chunk.length;
+      for (const [token, subscriber] of session.subscribers.entries()) {
+        if (!subscriber.active) {
+          subscriber.pending.push(chunk);
+          continue;
+        }
+        try {
+          subscriber.onData(chunk);
+        } catch {
+          session.subscribers.delete(token);
+        }
+      }
+      session.buffer += chunk;
+      if (session.buffer.length <= BUFFER_LIMIT)
+        return;
+      const excess = session.buffer.length - BUFFER_LIMIT;
+      session.buffer = session.buffer.slice(excess);
+      session.bufferCursor += excess;
+    }), proc.onExit(({ exitCode }) => {
+      if (session.info.status === "exited")
+        return;
+      session.info.status = "exited";
+      session.info.exitCode = exitCode;
+      notifyEnd(session, { exitCode });
+      exitOrder.push(id);
+      runFork(Effect.gen(function* () {
+        yield* Effect.logInfo("session exited", { id, exitCode });
+        yield* bus.publish(Pty.Event.Exited, { id, exitCode });
+        while (exitOrder.length > EXITED_LIMIT) {
+          const oldest = exitOrder[0];
+          if (!oldest)
+            break;
+          yield* removeSession(oldest);
+        }
+      }));
+    }));
+    yield* bus.publish(Pty.Event.Created, { info });
+    return info;
+  });
+  const update = Effect.fn("Pty.update")(function* (id, input) {
+    const session = yield* requireSession(id);
+    if (input.title)
+      session.info.title = input.title;
+    if (input.size && session.info.status === "running")
+      session.process.resize(input.size.cols, input.size.rows);
+    yield* bus.publish(Pty.Event.Updated, { info: session.info });
+    return session.info;
+  });
+  const write = Effect.fn("Pty.write")(function* (id, data) {
+    const session = yield* requireSession(id);
+    if (session.info.status === "running")
+      session.process.write(data);
+  });
+  const attach = Effect.fn("Pty.attach")(function* (id, input) {
+    const session = yield* requireSession(id);
+    if (session.info.status !== "running")
+      return yield* new ExitedError2({ ptyID: id });
+    yield* Effect.logInfo("client attached to session", { id, directory: location.directory });
+    const token = {};
+    const subscriber = {
+      onData: input.onData,
+      onEnd: input.onEnd,
+      active: false,
+      detached: false,
+      pending: []
+    };
+    session.subscribers.set(token, subscriber);
+    const start = session.bufferCursor;
+    const end = session.cursor;
+    const from = input.cursor === -1 ? end : typeof input.cursor === "number" && Number.isSafeInteger(input.cursor) ? Math.max(0, input.cursor) : 0;
+    const replay = (() => {
+      if (!session.buffer || from >= end)
+        return "";
+      const offset = Math.max(0, from - start);
+      if (offset >= session.buffer.length)
+        return "";
+      return session.buffer.slice(offset);
+    })();
+    return {
+      replay,
+      cursor: end,
+      write: (data) => {
+        if (session.info.status === "running")
+          session.process.write(data);
+      },
+      activate: () => {
+        if (subscriber.active || subscriber.detached)
+          return;
+        subscriber.active = true;
+        try {
+          for (const chunk of subscriber.pending)
+            subscriber.onData(chunk);
+          subscriber.pending.length = 0;
+          if (subscriber.end)
+            subscriber.onEnd(subscriber.end);
+        } catch {
+          session.subscribers.delete(token);
+        }
+      },
+      detach: () => {
+        subscriber.detached = true;
+        subscriber.pending.length = 0;
+        subscriber.end = undefined;
+        session.subscribers.delete(token);
+      }
+    };
+  });
+  return Service20.of({ list, get, create, update, remove, write, attach });
+}));
+var node24 = makeLocationNode({
+  service: Service20,
+  layer,
+  deps: [node83, node70, node61]
+});
+
+export { Info5, CreateInput3, UpdateInput2, NotFoundError3, ExitedError2, Service20, node24, exports_pty, Event5 };

package/dist/chunks/repository-r33ff4dw.js

@@ -0,0 +1,84 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/v1/config/lsp.ts
+var exports_lsp = {};
+__export(exports_lsp, {
+  ConfigLSPV1: () => exports_lsp,
+  Disabled: () => Disabled2,
+  Entry: () => Entry4,
+  Info: () => Info17,
+  builtinServerIds: () => builtinServerIds2,
+  requiresExtensionsForCustomServers: () => requiresExtensionsForCustomServers2
+});
+import { Schema } from "effect";
+var Disabled2 = Schema.Struct({
+  disabled: Schema.Literal(true)
+});
+var Entry4 = Schema.Union([
+  Disabled2,
+  Schema.Struct({
+    command: Schema.mutable(Schema.Array(Schema.String)),
+    extensions: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+    disabled: Schema.optional(Schema.Boolean),
+    env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    initialization: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+  })
+]);
+var builtinServerIds2 = [
+  "deno",
+  "typescript",
+  "vue",
+  "eslint",
+  "oxlint",
+  "biome",
+  "gopls",
+  "ruby-lsp",
+  "ty",
+  "pyright",
+  "elixir-ls",
+  "zls",
+  "csharp",
+  "razor",
+  "fsharp",
+  "sourcekit-lsp",
+  "rust",
+  "clangd",
+  "svelte",
+  "astro",
+  "jdtls",
+  "kotlin-ls",
+  "yaml-ls",
+  "lua-ls",
+  "php intelephense",
+  "prisma",
+  "dart",
+  "ocaml-lsp",
+  "bash",
+  "terraform",
+  "texlab",
+  "dockerfile",
+  "gleam",
+  "clojure-lsp",
+  "nixd",
+  "tinymist",
+  "haskell-language-server",
+  "julials"
+];
+var requiresExtensionsForCustomServers2 = Schema.makeFilter((data) => {
+  if (typeof data === "boolean")
+    return;
+  const ids = new Set(builtinServerIds2);
+  const ok = Object.entries(data).every(([id, config]) => {
+    if ("disabled" in config && config.disabled)
+      return true;
+    if (ids.has(id))
+      return true;
+    return "extensions" in config && Boolean(config.extensions);
+  });
+  return ok ? undefined : "For custom LSP servers, 'extensions' array is required.";
+});
+var Info17 = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry4)]).check(requiresExtensionsForCustomServers2);
+
+export { Disabled2, Entry4, builtinServerIds2, requiresExtensionsForCustomServers2, Info17, exports_lsp };

package/dist/chunks/repository-r8xr0va3.js

@@ -0,0 +1,92 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/run-coordinator.ts
+var exports_run_coordinator = {};
+__export(exports_run_coordinator, {
+  SessionRunCoordinator: () => exports_run_coordinator,
+  make: () => make18
+});
+import { Deferred, Effect, Fiber, FiberSet } from "effect";
+var make18 = (options) => Effect.gen(function* () {
+  const executions = new Map;
+  const fork = yield* FiberSet.makeRuntime();
+  const loop = (key, execution, force) => Effect.suspend(() => options.drain(key, force, execution.scope)).pipe(Effect.andThen(Effect.suspend(() => {
+    if (execution.stopping || execution.pendingWake === undefined)
+      return Effect.void;
+    execution.scope = execution.pendingWake;
+    execution.pendingWake = undefined;
+    return Effect.yieldNow.pipe(Effect.andThen(loop(key, execution, false)));
+  })));
+  const start = (key, force, scope) => {
+    const execution = {
+      done: Deferred.makeUnsafe(),
+      scope,
+      stopping: false
+    };
+    executions.set(key, execution);
+    execution.owner = fork(Effect.yieldNow.pipe(Effect.andThen(Effect.uninterruptible(options.started?.(key) ?? Effect.void)), Effect.andThen(loop(key, execution, force)), Effect.onExit((exit) => Effect.sync(() => {
+      execution.owner = undefined;
+    }).pipe(Effect.andThen(options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void))), Effect.onExit((exit) => Effect.sync(() => settle(key, execution, exit))), Effect.exit, Effect.asVoid));
+    return execution;
+  };
+  const settle = (key, execution, exit) => {
+    if (execution.pendingWake)
+      start(key, false, execution.pendingWake);
+    else
+      executions.delete(key);
+    Deferred.doneUnsafe(execution.done, exit);
+  };
+  const isActive = (key) => Effect.sync(() => executions.has(key));
+  const run = (key) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution !== undefined) {
+      if (execution.stopping)
+        return Deferred.await(execution.done).pipe(Effect.ignoreCause, Effect.andThen(run(key)));
+      return Deferred.await(execution.done);
+    }
+    return Deferred.await(start(key, true, "input").done);
+  });
+  const wake = (key, scope = "input") => Effect.sync(() => {
+    const execution = executions.get(key);
+    if (execution !== undefined) {
+      execution.pendingWake = execution.pendingWake === "input" ? "input" : scope;
+      return;
+    }
+    start(key, false, scope);
+  });
+  const interrupt = (key, reason) => Effect.sync(() => {
+    const execution = executions.get(key);
+    if (execution === undefined || execution.stopping)
+      return false;
+    if (execution.owner === undefined) {
+      execution.pendingWake = undefined;
+      return false;
+    }
+    execution.stopping = true;
+    execution.pendingWake = undefined;
+    execution.interruptionReason = reason;
+    fork(Fiber.interrupt(execution.owner));
+    return true;
+  });
+  const awaitIdle = (key) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution === undefined)
+      return Effect.void;
+    return Deferred.await(execution.done).pipe(Effect.ignoreCause, Effect.andThen(awaitIdle(key)));
+  });
+  return {
+    active: Effect.sync(() => new Set(executions.keys())),
+    isActive,
+    run,
+    wake,
+    interrupt: (key, reason, options) => Effect.suspend(() => {
+      const execution = executions.get(key);
+      return interrupt(key, reason).pipe(Effect.tap(() => options?.awaitSettlement && execution ? Deferred.await(execution.done).pipe(Effect.ignoreCause) : Effect.void));
+    }),
+    awaitIdle
+  };
+});
+
+export { make18, exports_run_coordinator };

package/dist/chunks/repository-r94mrtfv.js

@@ -0,0 +1,69 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  PermissionTable2
+} from "./repository-f828m53h.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/permission/saved.ts
+var exports_saved = {};
+__export(exports_saved, {
+  AddInput: () => AddInput2,
+  ID: () => ID8,
+  Info: () => Info20,
+  ListInput: () => ListInput4,
+  PermissionSaved: () => exports_saved,
+  Service: () => Service59,
+  node: () => node63
+});
+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 Service59 extends Context.Service()("@opencode/PermissionSaved") {
+}
+var layer = Layer.effect(Service59, Effect.gen(function* () {
+  const db = (yield* Service79).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 Service59.of({ list, add, remove });
+}));
+var node63 = makeGlobalNode({ service: Service59, layer, deps: [node84] });
+
+export { ID8, Info20, ListInput4, AddInput2, Service59, node63, exports_saved };