@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-jjc9qbmx.js

@@ -0,0 +1,182 @@
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  Service74
+} from "./worktree-z82wee6n.js";
+import {
+  Service69
+} from "./worktree-13bmfrpk.js";
+import {
+  Service6
+} from "./worktree-m6vfy410.js";
+import {
+  NotFound2
+} from "./worktree-2a5m3afh.js";
+import {
+  MEDIA_MIMES2,
+  BinaryFileError2,
+  MediaIngestLimitError2,
+  OffsetOutOfRangeError2,
+  PathKindError2,
+  PageInput2,
+  FileContent2,
+  TextPage2,
+  ListPage2,
+  Service7
+} from "./worktree-11zk2b76.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool/plugin/read.ts
+var exports_read = {};
+__export(exports_read, {
+  Input: () => Input9,
+  Plugin: () => Plugin10,
+  ReadTool: () => exports_read,
+  name: () => name9,
+  toModelContent: () => toModelContent5
+});
+import { basename, dirname, join } from "path";
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+var name9 = "read";
+var FILENAME = "AGENTS.md";
+var LocationInput = Schema.Struct({
+  path: Schema.String.annotate({ description: "File or directory to read" }),
+  offset: PageInput2.fields.offset.annotate({
+    description: "The line or directory entry to start reading from (1-based)"
+  }),
+  limit: PageInput2.fields.limit.annotate({
+    description: "The maximum number of lines or directory entries to read (defaults to 2000)"
+  })
+});
+var Input9 = LocationInput;
+var Output = Schema.Union([FileContent2, TextPage2, ListPage2]);
+var Plugin10 = {
+  id: "opencode.tool.read",
+  effect: Effect.fn("ReadTool.Plugin")(function* (ctx) {
+    const reader = yield* Service7;
+    const access = yield* Service69;
+    const sessionInstructions = yield* Service6;
+    const fs = yield* FSUtil.Service;
+    const location = yield* Service74;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name9,
+      options: { codemode: false },
+      description: "Read the contents of a file or directory. Supports text files, images, and PDFs. Images and PDFs are presented directly to the model. Each text line is prefixed by its 1-based line number as <line>: <content>. The prefix is for reference and is not part of the file content. Directory entries are returned one per line. Use offset and limit to read large files or directories in sections. Prefer one larger read over many small slices, and use grep to find specific content in large files.",
+      input: Input9,
+      output: Output,
+      execute: (input, context) => {
+        return Effect.gen(function* () {
+          const read = (target) => reader.read(target.absolute, target.resource, {
+            offset: input.offset,
+            limit: input.limit
+          });
+          const requested = yield* access.authorizeRead(input.path, context);
+          const result = yield* read(requested).pipe(Effect.map((content) => ({ content, target: requested, path: input.path })), Effect.catchIf((error) => error instanceof NotFound2, () => Effect.gen(function* () {
+            const alternate = yield* alternatePath(requested.absolute).pipe(Effect.orElseSucceed(() => {
+              return;
+            }));
+            if (!alternate)
+              return yield* missing(input.path, requested.absolute);
+            const target = yield* access.authorizeRead(alternate, context, { siblingOf: requested });
+            const content = yield* read(target).pipe(Effect.catchIf((error) => error instanceof NotFound2, () => missing(input.path, requested.absolute)));
+            if (content.type === "list-page")
+              return yield* missing(input.path, requested.absolute);
+            return {
+              content,
+              target,
+              path: join(dirname(input.path), basename(alternate))
+            };
+          })));
+          yield* Effect.gen(function* () {
+            if (result.target.externalDirectory !== undefined)
+              return;
+            const resolved = yield* fs.resolve(result.target.absolute);
+            const root = yield* fs.resolve(location.directory);
+            const discovered = yield* fs.up({
+              targets: [FILENAME],
+              start: result.content.type === "list-page" ? resolved : dirname(resolved),
+              stop: root
+            });
+            const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter((file) => dirname(file) !== root);
+            if (candidates.length === 0)
+              return;
+            yield* sessionInstructions.load({ sessionID: context.sessionID, paths: candidates });
+          }).pipe(Effect.catch(() => Effect.void), Effect.catchDefect(() => Effect.void));
+          if (result.content.type === "file" && result.content.encoding === "base64" && !MEDIA_MIMES2.has(result.content.mime))
+            return yield* Effect.fail(new BinaryFileError2({ resource: result.target.resource }));
+          return { output: result.content, path: result.path };
+        }).pipe(Effect.map((result) => ({
+          output: result.output,
+          content: toModelContent5(result.path, input.offset, result.output),
+          metadata: { truncated: result.output.type === "file" ? false : result.output.truncated }
+        })), Effect.mapError((error) => {
+          if (error instanceof ToolFailure)
+            return error;
+          const message = error instanceof BinaryFileError2 || error instanceof MediaIngestLimitError2 || error instanceof OffsetOutOfRangeError2 || error instanceof PathKindError2 ? error.message : `Unable to read ${input.path}`;
+          return new ToolFailure({ message, error });
+        }));
+      }
+    })).pipe(Effect.orDie);
+    const alternatePath = Effect.fn("ReadTool.alternatePath")(function* (absolute) {
+      const base = basename(absolute).replace(/[\u00a0\u202f]/g, " ");
+      const matches = (yield* reader.list(AbsolutePath2.make(dirname(absolute)))).filter((entry) => entry.type === "file" && entry.name.replace(/[\u00a0\u202f]/g, " ") === base);
+      if (matches.length !== 1)
+        return;
+      return join(dirname(absolute), matches[0].name);
+    });
+    const missing = Effect.fn("ReadTool.missing")(function* (input, absolute) {
+      const base = basename(input).toLowerCase();
+      const suggestions = yield* fs.readDirectory(dirname(absolute)).pipe(Effect.map((entries) => entries.filter((entry) => {
+        const candidate = entry.toLowerCase();
+        return candidate.includes(base) || base.includes(candidate);
+      }).map((entry) => join(dirname(input), entry)).slice(0, 3)), Effect.orElseSucceed(() => []));
+      const message = suggestions.length === 0 ? `File not found: ${input}` : `File not found: ${input}
+
+Did you mean one of these?
+${suggestions.join(`
+`)}`;
+      return yield* new ToolFailure({ message });
+    });
+  })
+};
+var toModelContent5 = (path, offset, output) => {
+  if (output.type === "file" && output.encoding === "base64")
+    return [
+      { type: "text", text: output.mime === "application/pdf" ? "PDF read successfully" : "Image read successfully" },
+      {
+        type: "file",
+        uri: `data:${output.mime};base64,${output.content}`,
+        mime: output.mime,
+        name: path
+      }
+    ];
+  if (output.type === "list-page") {
+    const start = offset || 1;
+    const content = [
+      output.entries.length === 0 ? `Read directory ${path}, 0 entries` : `Read directory ${path}, entries ${start}-${start + output.entries.length - 1}`
+    ];
+    output.entries.forEach((entry) => content.push(entry.path));
+    if (output.truncated && output.next !== undefined)
+      content.push(`[Output truncated. Continue reading with offset: ${output.next}]`);
+    return content.join(`
+`);
+  }
+  const start = output.type === "text-page" ? output.offset : 1;
+  const lines = output.content === "" ? [] : output.content.replace(/\n$/, "").split(`
+`);
+  const content = [
+    lines.length === 0 ? `Read file ${path}, 0 lines` : `Read file ${path}, lines ${start}-${start + lines.length - 1}`
+  ];
+  lines.forEach((line, index) => content.push(`${start + index}: ${line}`));
+  if (output.type === "text-page" && output.truncated && output.next !== undefined)
+    content.push(`[Output truncated. Continue reading with offset: ${output.next}]`);
+  return content.join(`
+`);
+};
+
+export { name9, Input9, Plugin10, toModelContent5, exports_read };

package/dist/chunks/worktree-jr7sbwjy.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260309230000_move_org_to_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260309230000_move_org_to_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`account_state\` ADD \`active_org_id\` text;`);
+      yield* tx.run(`UPDATE \`account_state\` SET \`active_org_id\` = (SELECT \`selected_org_id\` FROM \`account\` WHERE \`account\`.\`id\` = \`account_state\`.\`active_account_id\`);`);
+      yield* tx.run(`ALTER TABLE \`account\` DROP COLUMN \`selected_org_id\`;`);
+    });
+  }
+};
+var _20260309230000_move_org_to_state_default = migration;
+
+export { _20260309230000_move_org_to_state_default };

package/dist/chunks/worktree-jrra6jmc.js

@@ -0,0 +1,42 @@
+import {
+  jitCompatCheck2
+} from "./worktree-emrn6kk6.js";
+import {
+  SQLiteEffectDatabase2
+} from "./worktree-d57x1pyx.js";
+import {
+  EffectSQLiteSession2
+} from "./worktree-zjhmce52.js";
+
+// src/database/drizzle/effect-sqlite/driver.ts
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { EffectCache } from "drizzle-orm/cache/core/cache-effect";
+import { EffectLogger } from "drizzle-orm/effect-core";
+import { entityKind } from "drizzle-orm/entity";
+import { SQLiteDialect } from "drizzle-orm/sqlite-core/dialect";
+class EffectSQLiteDatabase2 extends SQLiteEffectDatabase2 {
+  static [entityKind] = "EffectSQLiteDatabase";
+}
+var DefaultServices2 = Layer.merge(EffectCache.Default, EffectLogger.Default);
+var make23 = Effect.fn("SQLiteDrizzle.make")(function* (config = {}) {
+  const client = yield* SqlClient;
+  const cache = yield* EffectCache;
+  const logger = yield* EffectLogger;
+  const useJitMappers = jitCompatCheck2(config.jit);
+  const dialect = new SQLiteDialect({ useJitMappers });
+  const relations = config.relations ?? {};
+  const session = new EffectSQLiteSession2(client, dialect, relations, {
+    logger,
+    cache,
+    useJitMappers
+  });
+  const db = new EffectSQLiteDatabase2(dialect, session, relations);
+  db.$client = client;
+  db.$cache.invalidate = cache.onMutate;
+  return db;
+});
+var makeWithDefaults2 = (config = {}) => make23(config).pipe(Effect.provide(DefaultServices2));
+
+export { EffectSQLiteDatabase2, DefaultServices2, make23, makeWithDefaults2 };

package/dist/chunks/worktree-jvt1mp6m.js

@@ -0,0 +1,93 @@
+import {
+  latest2,
+  Service54
+} from "./worktree-r82b328h.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/warming.ts
+var exports_warming = {};
+__export(exports_warming, {
+  Plugin: () => Plugin43,
+  WarmingPlugin: () => exports_warming
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Clock, Duration, Effect, Scope } from "effect";
+var defaults = {
+  prompt: "This is a keep-alive request. Do not perform any work or use tools. Reply with exactly: OK",
+  interval: Duration.minutes(4),
+  duration: Duration.minutes(30)
+};
+var Plugin43 = define({
+  id: "opencode.warming",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service54;
+    const loadSettings = Effect.fn("WarmingPlugin.loadSettings")(function* () {
+      const warming = latest2(yield* config.entries(), "warming");
+      if (!warming)
+        return;
+      const settings = warming === true ? defaults : { ...defaults, ...warming };
+      const interval = Duration.toMillis(settings.interval);
+      const duration = Duration.toMillis(settings.duration);
+      if (Number.isFinite(interval) && interval > 0 && Number.isFinite(duration) && duration > 0)
+        return settings;
+      yield* Effect.logWarning("warming interval and duration must be finite positive durations");
+    });
+    const scope = yield* Scope.Scope;
+    const sessions = new Map;
+    const loop = Effect.fn("WarmingPlugin.loop")(function* (sessionID) {
+      const current = sessions.get(sessionID);
+      if (!current)
+        return;
+      const now = yield* Clock.currentTimeMillis;
+      const next = Math.min(current.last + Duration.toMillis(current.settings.interval), current.expires);
+      if (now < next) {
+        yield* Effect.sleep(Duration.millis(next - now));
+        return yield* loop(sessionID);
+      }
+      if (now >= current.expires) {
+        sessions.delete(sessionID);
+        return;
+      }
+      const last = current.last;
+      yield* Effect.logInfo("warming session", { sessionID, last });
+      yield* ctx.session.generate({ sessionID, prompt: current.settings.prompt }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to warm session", { sessionID, cause })));
+      const latest = sessions.get(sessionID);
+      if (latest === current && latest.last === last)
+        latest.last = yield* Clock.currentTimeMillis;
+      return yield* loop(sessionID);
+    });
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const active = sessions.get(event.sessionID);
+      const settings = yield* loadSettings();
+      if (!settings) {
+        sessions.delete(event.sessionID);
+        return;
+      }
+      const message = event.messages.at(-1);
+      if (message?.role === "user" && message.content.length === 1 && message.content[0]?.type === "text" && (message.content[0].text === active?.settings.prompt || message.content[0].text === settings.prompt)) {
+        if (active)
+          active.settings = settings;
+        return;
+      }
+      const now = yield* Clock.currentTimeMillis;
+      const duration = Duration.toMillis(settings.duration);
+      if (active) {
+        active.last = now;
+        active.expires = now + duration;
+        active.settings = settings;
+        return;
+      }
+      sessions.set(event.sessionID, { last: now, expires: now + duration, settings });
+      yield* Effect.logInfo("scheduled session warming", {
+        sessionID: event.sessionID,
+        interval: settings.interval,
+        expires: now + duration
+      });
+      yield* loop(event.sessionID).pipe(Effect.catchCause((cause) => Effect.logError("session warming loop failed", { sessionID: event.sessionID, cause })), Effect.forkIn(scope));
+    }));
+  })
+});
+
+export { Plugin43, exports_warming };

package/dist/chunks/worktree-jwd18bs2.js

@@ -0,0 +1,304 @@
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  environment2
+} from "./worktree-w55j1d38.js";
+import {
+  makeDaemonTransport2
+} from "./worktree-sk3qaz4a.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/persistent-pty/index.ts
+var exports_persistent_pty = {};
+__export(exports_persistent_pty, {
+  Handoff: () => Handoff2,
+  NotFoundError: () => NotFoundError4,
+  Options: () => Options4,
+  PersistentPty: () => exports_persistent_pty,
+  Service: () => Service43,
+  UnavailableError: () => UnavailableError2,
+  configured: () => configured4,
+  layer: () => layer16,
+  node: () => node46
+});
+import os from "node:os";
+import path from "node:path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { Added, Handoff, ReadLines, Removed } from "@opencode/schema/persistent-pty";
+import { Session } from "@opencode/schema/session";
+import { Pty } from "@opencode/schema/pty";
+import { Global } from "@opencode/util/global";
+import { resolveBinary } from "#persistent-pty-binary";
+import { Handoff as Handoff2 } from "@opencode/schema/persistent-pty";
+var Options4 = Schema.Struct({ handoff: Schema.optional(Handoff) });
+
+class UnavailableError2 extends Schema.TaggedError()("PersistentPty.UnavailableError", {
+  message: Schema.String
+}) {
+}
+
+class NotFoundError4 extends Schema.TaggedError()("PersistentPty.NotFoundError", {
+  ptyID: Pty.ID
+}) {
+}
+
+class Service43 extends Context.Service()("@opencode/PersistentPty") {
+}
+var makeLayer = (options = {}) => Layer.effect(Service43, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const global = yield* Global.Service;
+  const context = yield* Effect.context();
+  const runFork = Effect.runForkWith(context);
+  let binary;
+  const daemon = yield* makeDaemonTransport2(options.handoff?.directory ?? runtimeDirectory(), () => binary ??= resolveBinary(global.bin).catch((error) => {
+    binary = undefined;
+    throw error;
+  }), options.handoff).pipe(Effect.mapError(unavailable));
+  const removing = new Set;
+  const current = new Map;
+  const list = Effect.fn("PersistentPty.list")(function* (sessionID) {
+    const response = yield* optionalRequest(daemon, { op: "list" });
+    if (!response)
+      return [];
+    if (response.type !== "terminals")
+      return yield* unexpected(response);
+    return response.terminals.map(toInfo).filter((terminal) => sessionID === undefined || terminal.sessionID === sessionID);
+  });
+  const get = Effect.fn("PersistentPty.get")(function* (id) {
+    const found = (yield* list()).find((terminal) => terminal.id === id);
+    if (!found)
+      return yield* new NotFoundError4({ ptyID: id });
+    return found;
+  });
+  const create = Effect.fn("PersistentPty.create")(function* (sessionID, input) {
+    const response = yield* request(daemon, {
+      op: "create",
+      program: input.command ?? environment2(global.bin),
+      args: input.args,
+      cwd: input.cwd ?? path.resolve("/"),
+      title: input.title,
+      group_id: sessionID,
+      env: input.env,
+      cols: input.cols ?? 80,
+      rows: input.rows ?? 24
+    }, true);
+    if (response.type !== "created")
+      return yield* unexpected(response);
+    const terminal = toInfo(response.terminal);
+    yield* bus.publish(Added, { sessionID, terminal });
+    return terminal;
+  });
+  const write = Effect.fn("PersistentPty.write")(function* (id, data, attachmentID) {
+    yield* get(id);
+    const response = yield* request(daemon, {
+      op: "write",
+      id: fromID(id),
+      attachment_id: attachmentID ?? null,
+      data_base64: Buffer.from(data).toString("base64")
+    });
+    if (response.type !== "ok")
+      return yield* unexpected(response);
+    return;
+  });
+  const resize = Effect.fn("PersistentPty.resize")(function* (id, cols, rows, attachmentID) {
+    const terminal = yield* get(id);
+    const response = yield* request(daemon, {
+      op: "resize",
+      id: fromID(id),
+      attachment_id: attachmentID ?? null,
+      cols,
+      rows
+    });
+    if (response.type !== "ok")
+      return yield* unexpected(response);
+    current.set(terminal.sessionID, id);
+    return;
+  });
+  const control = Effect.fn("PersistentPty.control")(function* (id, attachmentID, cols, rows) {
+    const terminal = yield* get(id);
+    const response = yield* request(daemon, {
+      op: "control",
+      id: fromID(id),
+      attachment_id: attachmentID,
+      cols,
+      rows
+    });
+    if (response.type !== "ok")
+      return yield* unexpected(response);
+    current.set(terminal.sessionID, id);
+    return;
+  });
+  const input = Effect.fn("PersistentPty.input")(function* (id, attachmentID, cols, rows, data) {
+    const terminal = yield* get(id);
+    const response = yield* request(daemon, {
+      op: "input",
+      id: fromID(id),
+      attachment_id: attachmentID,
+      cols,
+      rows,
+      data_base64: Buffer.from(data).toString("base64")
+    });
+    if (response.type !== "ok")
+      return yield* unexpected(response);
+    current.set(terminal.sessionID, id);
+    return;
+  });
+  const snapshot = Effect.fn("PersistentPty.snapshot")(function* (id) {
+    yield* get(id);
+    const response = yield* request(daemon, { op: "snapshot", id: fromID(id) });
+    if (response.type !== "snapshot")
+      return yield* unexpected(response);
+    return {
+      info: toInfo(response.terminal),
+      text: response.text,
+      checkpoint: Buffer.from(response.checkpoint_base64, "base64"),
+      cursor: { x: response.cursor_x, y: response.cursor_y }
+    };
+  });
+  const read = Effect.fn("PersistentPty.read")(function* (sessionID, lines) {
+    if (lines !== undefined && !Schema.is(ReadLines)(lines))
+      return yield* new UnavailableError2({ message: "lines must be an integer between 1 and 65535" });
+    const id = current.get(sessionID);
+    if (!id)
+      return null;
+    const terminal = yield* get(id).pipe(Effect.catchTag("PersistentPty.NotFoundError", () => Effect.succeed(null)));
+    if (!terminal || terminal.sessionID !== sessionID) {
+      if (current.get(sessionID) === id)
+        current.delete(sessionID);
+      return null;
+    }
+    const response = yield* request(daemon, { op: "read_rows", id: fromID(id), rows: lines });
+    if (response.type !== "rows")
+      return yield* unexpected(response);
+    const info = toInfo(response.terminal);
+    return {
+      ptyID: info.id,
+      title: info.title,
+      cwd: info.cwd,
+      foregroundProcess: info.foregroundProcess,
+      screen: {
+        text: response.lines.join(`
+`),
+        cols: info.size.cols,
+        rows: info.size.rows,
+        cursor: { x: response.cursor_x, y: response.cursor_y }
+      }
+    };
+  });
+  const remove = Effect.fn("PersistentPty.remove")(function* (id) {
+    const terminal = yield* get(id);
+    const response = yield* request(daemon, { op: "terminate", id: fromID(id) });
+    if (response.type !== "ok")
+      return yield* unexpected(response);
+    if (current.get(terminal.sessionID) === id)
+      current.delete(terminal.sessionID);
+    yield* bus.publish(Removed, { sessionID: terminal.sessionID, ptyID: id });
+    return;
+  });
+  const shutdown = Effect.fn("PersistentPty.shutdown")(function* () {
+    const response = yield* daemon.shutdown.pipe(Effect.mapError(unavailable));
+    current.clear();
+    if (!response)
+      return;
+    if (response.type !== "ok")
+      return yield* unexpected(response);
+  });
+  const handoff = Effect.fn("PersistentPty.handoff")(() => daemon.handoff.pipe(Effect.mapError(unavailable)));
+  const removeVisibleExit = (id) => {
+    if (removing.has(id))
+      return;
+    removing.add(id);
+    runFork(remove(id).pipe(Effect.catchTags({
+      "PersistentPty.NotFoundError": () => Effect.void,
+      "PersistentPty.UnavailableError": (error) => Effect.logWarning("failed to remove visible exited terminal", { id, error: error.message })
+    }), Effect.ensuring(Effect.sync(() => removing.delete(id)))));
+  };
+  const attach = Effect.fn("PersistentPty.attach")(function* (id, input) {
+    yield* get(id);
+    const attachment = yield* daemon.subscribe(fromID(id), {
+      ...input,
+      onEvent: (event) => {
+        if (event.type === "exited")
+          removeVisibleExit(id);
+        input.onEvent(event);
+      }
+    }).pipe(Effect.mapError(unavailable));
+    if (attachment.role === "controller")
+      current.set(Session.ID.make(attachment.terminal.group_id), id);
+    return {
+      info: toInfo(attachment.terminal),
+      role: attachment.role,
+      generation: attachment.generation,
+      replay: attachment.replay,
+      activate: attachment.activate,
+      detach: attachment.detach
+    };
+  });
+  return Service43.of({
+    list,
+    get,
+    create,
+    write,
+    resize,
+    control,
+    input,
+    snapshot,
+    read,
+    remove,
+    shutdown,
+    handoff,
+    attach
+  });
+}));
+var layer16 = makeLayer();
+var configured4 = (options) => makeGlobalNode({
+  service: Service43,
+  layer: options === undefined ? layer16 : makeLayer(options),
+  deps: [node84, Global.node]
+});
+var node46 = configured4();
+var request = (daemon, value, start = false) => daemon.request(value, start).pipe(Effect.mapError(unavailable));
+var optionalRequest = (daemon, value) => daemon.requestIfRunning(value).pipe(Effect.mapError(unavailable));
+var unexpected = (response) => Effect.fail(new UnavailableError2({ message: `unexpected opencode-pty response: ${response.type}` }));
+var unavailable = (error) => new UnavailableError2({ message: error instanceof Error ? error.message : String(error) });
+var runtimeDirectory = () => {
+  const root = process.env.OPENCODE_PTY_RUNTIME_DIR ?? (process.env.XDG_RUNTIME_DIR ? path.join(process.env.XDG_RUNTIME_DIR, "opencode-pty") : path.join(os.tmpdir(), `opencode-pty-${typeof process.getuid === "function" ? process.getuid() : process.env.USER || "unknown"}`));
+  return path.join(root, crypto.randomUUID());
+};
+function toInfo(value) {
+  const status = value.lifecycle.status;
+  return {
+    ...Pty.Info.make({
+      id: toID(value.id),
+      title: value.title,
+      command: value.command[0] || "",
+      args: value.command.slice(1),
+      cwd: value.cwd,
+      status: status === "running" ? "running" : "exited",
+      pid: value.pid ?? 0,
+      ...status === "exited" ? { exitCode: value.lifecycle.exit_code ?? undefined } : {}
+    }),
+    sessionID: Session.ID.make(value.group_id),
+    foregroundProcess: value.foreground_process,
+    size: { cols: value.cols, rows: value.rows },
+    output: { head: value.output_head, tail: value.output_tail }
+  };
+}
+function toID(value) {
+  return Pty.ID.make(`pty_persistent_${value}`);
+}
+function fromID(value) {
+  if (!value.startsWith("pty_persistent_"))
+    throw new Error(`invalid persistent PTY ID: ${value}`);
+  const parsed = Number(value.slice("pty_persistent_".length));
+  if (!Number.isSafeInteger(parsed) || parsed < 1)
+    throw new Error(`invalid persistent PTY ID: ${value}`);
+  return parsed;
+}
+
+export { Options4, UnavailableError2, NotFoundError4, Service43, layer16, configured4, node46, exports_persistent_pty, Handoff2 };

package/dist/chunks/worktree-jwfs4k6c.js

@@ -0,0 +1,41 @@
+// src/database/migration/20260604172448_event_sourced_session_input.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260604172448_event_sourced_session_input",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL;`);
+      yield* tx.run(`DELETE FROM \`workspace\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`event_aggregate_seq_idx\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`event_aggregate_seq_idx\` ON \`event\` (\`aggregate_id\`,\`seq\`);`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_seq_idx\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`PRAGMA foreign_keys=OFF;`);
+      yield* tx.run(`
+        CREATE TABLE \`__new_session_input\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`prompt\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`admitted_seq\` integer NOT NULL,
+          \`promoted_seq\` integer,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_input_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`DROP TABLE \`session_input\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_session_input\` RENAME TO \`session_input\`;`);
+      yield* tx.run(`PRAGMA foreign_keys=ON;`);
+      yield* tx.run(`CREATE INDEX \`session_input_session_pending_delivery_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`,\`delivery\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_input_session_admitted_seq_idx\` ON \`session_input\` (\`session_id\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_input_session_promoted_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`);`);
+    });
+  }
+};
+var _20260604172448_event_sourced_session_input_default = migration;
+
+export { _20260604172448_event_sourced_session_input_default };