@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-2g1pqmbp.js

@@ -0,0 +1,253 @@
+import {
+  exports_mime
+} from "./permission-dhphtf1x.js";
+import {
+  exports_filesystem
+} from "./permission-jm82nbh8.js";
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  NonNegativeInt,
+  PositiveInt,
+  RelativePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/read-filesystem.ts
+var exports_read_filesystem = {};
+__export(exports_read_filesystem, {
+  read: () => read,
+  node: () => node,
+  TextPage: () => TextPage,
+  Service: () => Service,
+  ReadToolFileSystem: () => exports_read_filesystem,
+  PathKindError: () => PathKindError,
+  PageInput: () => PageInput,
+  OffsetOutOfRangeError: () => OffsetOutOfRangeError,
+  MediaIngestLimitError: () => MediaIngestLimitError,
+  MAX_READ_LINES: () => MAX_READ_LINES,
+  MAX_READ_BYTES: () => MAX_READ_BYTES,
+  MAX_MEDIA_INGEST_BYTES: () => MAX_MEDIA_INGEST_BYTES,
+  ListPage: () => ListPage,
+  ListEntry: () => ListEntry,
+  FileContent: () => FileContent,
+  BinaryFileError: () => BinaryFileError
+});
+import path from "path";
+import { pathToFileURL } from "url";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { lookup } from "mime-types";
+var MAX_READ_LINES = 2000;
+var MAX_READ_BYTES = 50 * 1024;
+var MAX_MEDIA_INGEST_BYTES = 20 * 1024 * 1024;
+var FIRST_CHUNK = 256 * 1024;
+var MAX_LINE_LENGTH = 2000;
+var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
+var MEDIA_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"]);
+
+class BinaryFileError extends Schema.TaggedErrorClass()("ReadTool.BinaryFileError", {
+  resource: Schema.String
+}) {
+  get message() {
+    return `Cannot read binary file: ${this.resource}`;
+  }
+}
+
+class MediaIngestLimitError extends Schema.TaggedErrorClass()("ReadTool.MediaIngestLimitError", {
+  resource: Schema.String,
+  maximumBytes: Schema.Number
+}) {
+  get message() {
+    return `Media exceeds ${this.maximumBytes} byte ingestion limit: ${this.resource}`;
+  }
+}
+
+class OffsetOutOfRangeError extends Schema.TaggedErrorClass()("ReadTool.OffsetOutOfRangeError", { offset: Schema.Number }) {
+  get message() {
+    return `Offset ${this.offset} is out of range`;
+  }
+}
+
+class PathKindError extends Schema.TaggedErrorClass()("ReadTool.PathKindError", {
+  resource: Schema.String,
+  expected: Schema.Literals(["a file", "a file or directory"])
+}) {
+  get message() {
+    return `Path is not ${this.expected}: ${this.resource}`;
+  }
+}
+var PageInput = Schema.Struct({
+  offset: Schema.optionalKey(NonNegativeInt),
+  limit: Schema.optionalKey(NonNegativeInt.check(Schema.isLessThanOrEqualTo(MAX_READ_LINES)))
+});
+var FileContent = Schema.Struct({
+  type: Schema.Literal("file"),
+  ...exports_filesystem.Content.fields
+}).annotate({ identifier: "ReadTool.FileContent" });
+
+class TextPage extends Schema.Class("ReadTool.TextPage")({
+  type: Schema.Literal("text-page"),
+  content: Schema.String,
+  mime: Schema.String,
+  offset: PositiveInt,
+  truncated: Schema.Boolean,
+  next: Schema.optionalKey(PositiveInt)
+}) {
+}
+var ListEntry = Schema.Struct({
+  path: RelativePath,
+  type: Schema.Literals(["file", "directory", "symlink"])
+}).annotate({ identifier: "ReadTool.ListEntry" });
+
+class ListPage extends Schema.Class("ReadTool.ListPage")({
+  type: Schema.Literal("list-page"),
+  entries: Schema.Array(ListEntry),
+  truncated: Schema.Boolean,
+  next: Schema.optionalKey(PositiveInt)
+}) {
+}
+
+class Service extends Context.Service()("@opencode/ReadToolFileSystem") {
+}
+var mimeType = (value) => lookup(value) || "application/octet-stream";
+var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page = {}) {
+  const first = yield* files.read(input, { offset: 0, length: FIRST_CHUNK }).pipe(Effect.catchTag("Environment.WrongKind", (error) => {
+    if (error.actual !== "directory")
+      return Effect.fail(new PathKindError({ resource, expected: "a file or directory" }));
+    return files.list(input).pipe(Effect.map((entries) => list(entries, page)), Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file or directory" }))));
+  }));
+  if (first instanceof ListPage)
+    return first;
+  const media = exports_mime.detect(first.bytes);
+  if (MEDIA_MIMES.has(media)) {
+    if (first.info.size > MAX_MEDIA_INGEST_BYTES)
+      return yield* new MediaIngestLimitError({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES });
+    const whole = yield* readFile(files, input, resource);
+    return {
+      type: "file",
+      uri: pathToFileURL(input).href,
+      name: path.basename(input),
+      content: Buffer.from(whole.bytes).toString("base64"),
+      encoding: "base64",
+      mime: media
+    };
+  }
+  const paged = first.info.size > MAX_READ_BYTES || page.offset !== undefined || page.limit !== undefined;
+  if (!paged) {
+    if (first.bytes.includes(0))
+      return yield* new BinaryFileError({ resource });
+    return {
+      type: "file",
+      uri: pathToFileURL(input).href,
+      name: path.basename(input),
+      content: new TextDecoder().decode(first.bytes),
+      encoding: "utf8",
+      mime: mimeType(input)
+    };
+  }
+  const chunks = [first.bytes];
+  while (true) {
+    const bytes = Buffer.concat(chunks);
+    const eof = bytes.length >= first.info.size;
+    const result = textPage(bytes, eof, page);
+    if (result !== undefined)
+      return yield* makeTextPage(bytes, input, resource, result);
+    const next = yield* readFile(files, input, resource, { offset: bytes.length, length: FIRST_CHUNK });
+    if (next.bytes.length === 0) {
+      const result2 = textPage(bytes, true, page);
+      if (result2 === undefined)
+        return yield* Effect.die("Read page did not settle at EOF");
+      return yield* makeTextPage(bytes, input, resource, result2);
+    }
+    chunks.push(next.bytes);
+  }
+});
+var readFile = (files, input, resource, range) => files.read(input, range).pipe(Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file" }))));
+var makeTextPage = Effect.fnUntraced(function* (bytes, input, resource, result) {
+  if (bytes.subarray(0, result.consumed).includes(0))
+    return yield* new BinaryFileError({ resource });
+  if (result.entries.length === 0 && result.offset !== 1)
+    return yield* new OffsetOutOfRangeError({ offset: result.offset });
+  return new TextPage({
+    type: "text-page",
+    content: result.entries.join(`
+`),
+    mime: mimeType(input),
+    offset: result.offset,
+    truncated: result.next !== undefined,
+    ...result.next === undefined ? {} : { next: result.next }
+  });
+});
+var list = (items, page) => {
+  const offset = page.offset || 1;
+  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const visible = items.flatMap((item) => item.type === "other" ? [] : [
+    ListEntry.make({
+      path: RelativePath.make(item.name + (item.type === "directory" ? path.sep : "")),
+      type: item.type
+    })
+  ]).sort((a, b) => a.type === "directory" ? b.type === "directory" ? a.path.localeCompare(b.path) : -1 : b.type === "directory" ? 1 : a.path.localeCompare(b.path));
+  const selected = visible.slice(offset - 1, offset - 1 + limit);
+  const truncated = offset - 1 + selected.length < visible.length;
+  return new ListPage({
+    type: "list-page",
+    entries: selected,
+    truncated,
+    ...truncated ? { next: offset + selected.length } : {}
+  });
+};
+var textPage = (bytes, eof, page) => {
+  const offset = page.offset || 1;
+  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const decoded = new TextDecoder().decode(bytes);
+  const split = decoded.split(`
+`);
+  const complete = eof ? split.at(-1) === "" ? split.slice(0, -1) : split : split.slice(0, -1);
+  const available = complete.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+  const entries = [];
+  let size = 0;
+  let next;
+  for (const [index, value] of available.slice(offset - 1).entries()) {
+    const line = offset + index;
+    if (entries.length >= limit || size >= MAX_READ_BYTES) {
+      next = line;
+      break;
+    }
+    const text = value.length > MAX_LINE_LENGTH ? value.slice(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : value;
+    const lineSize = Buffer.byteLength(text, "utf-8") + (entries.length > 0 ? 1 : 0);
+    if (size + lineSize > MAX_READ_BYTES) {
+      next = line;
+      break;
+    }
+    entries.push(text);
+    size += lineSize;
+  }
+  if (next === undefined && entries.length >= limit && (!eof || offset - 1 + entries.length < available.length))
+    next = offset + entries.length;
+  if (!eof && next === undefined)
+    return;
+  const consumedLines = next === undefined ? available.length : next - 1;
+  const consumed = consumedLines === 0 ? 0 : nthNewline(bytes, consumedLines) ?? bytes.length;
+  return { entries, offset, next, consumed };
+};
+var nthNewline = (bytes, count) => {
+  let found = 0;
+  for (const [index, byte] of bytes.entries()) {
+    if (byte !== 10)
+      continue;
+    found++;
+    if (found === count)
+      return index + 1;
+  }
+};
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const environment = yield* exports_environment.Service;
+  return Service.of({ read: (path2, resource, page) => read(environment.files, path2, resource, page) });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node] });
+
+export { MAX_READ_LINES, MAX_READ_BYTES, MAX_MEDIA_INGEST_BYTES, BinaryFileError, MediaIngestLimitError, OffsetOutOfRangeError, PathKindError, PageInput, FileContent, TextPage, ListEntry, ListPage, Service, read, node, exports_read_filesystem };

package/dist/chunks/permission-2nkse5ac.js

@@ -0,0 +1,62 @@
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  exports_keyed_mutex
+} from "./permission-0kvmztkf.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/file-mutation.ts
+var exports_file_mutation = {};
+__export(exports_file_mutation, {
+  syncTextBom: () => syncTextBom,
+  readText: () => readText,
+  node: () => node,
+  Service: () => Service,
+  FileMutation: () => exports_file_mutation
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Bom } from "@opencode-ai/util/bom";
+class Service extends Context.Service()("@opencode/FileMutation") {
+}
+var readText = Effect.fn("FileMutation.readText")(function* (files, target) {
+  return Bom.decodeBytes((yield* files.read(target)).bytes);
+});
+var syncTextBom = Effect.fn("FileMutation.syncTextBom")(function* (files, target, bom) {
+  const synced = Bom.syncBytes((yield* files.read(target)).bytes, bom);
+  if (synced.bytes)
+    yield* files.write(target, synced.bytes);
+  return synced.text;
+});
+var transactionLocks = exports_keyed_mutex.makeUnsafe();
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const environment = yield* exports_environment.Service;
+  const locks = exports_keyed_mutex.makeUnsafe();
+  const withLock = (targets) => (effect) => [...new Set(targets.map(FSUtil.resolve))].sort().reduceRight((result, target) => transactionLocks.withLock(target)(result), effect);
+  const withTargetLock = (target) => (effect) => locks.withLock(target.absolute)(Effect.uninterruptible(effect));
+  const writeResult = (target, existed) => ({
+    operation: "write",
+    target: target.absolute,
+    resource: target.resource,
+    existed
+  });
+  const write = Effect.fn("FileMutation.write")((input) => withTargetLock(input.target)(Effect.gen(function* () {
+    const existed = yield* environment.files.stat(input.target.absolute).pipe(Effect.as(true), Effect.catchTag("Environment.NotFound", () => Effect.succeed(false)));
+    yield* environment.files.write(input.target.absolute, typeof input.content === "string" ? new TextEncoder().encode(input.content) : input.content);
+    return writeResult(input.target, existed);
+  })));
+  const writeTextPreservingBom = Effect.fn("FileMutation.writeTextPreservingBom")((input) => withTargetLock(input.target)(Effect.gen(function* () {
+    const next = Bom.split(input.content);
+    const current = yield* environment.files.read(input.target.absolute, { offset: 0, length: 3 }).pipe(Effect.map((result) => result.bytes), Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)));
+    yield* environment.files.write(input.target.absolute, new TextEncoder().encode(Bom.join(next.text, Boolean(current && Bom.has(current)) || next.bom)));
+    return writeResult(input.target, current !== undefined);
+  })));
+  return Service.of({ withLock, write, writeTextPreservingBom });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node] });
+
+export { Service, readText, syncTextBom, node, exports_file_mutation };

package/dist/chunks/permission-2nmyybe0.js

@@ -0,0 +1,21 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/formatter.ts
+var exports_formatter = {};
+__export(exports_formatter, {
+  Info: () => Info,
+  Entry: () => Entry,
+  ConfigFormatterV1: () => exports_formatter
+});
+import { Schema } from "effect";
+var Entry = Schema.Struct({
+  disabled: Schema.optional(Schema.Boolean),
+  command: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  extensions: Schema.optional(Schema.mutable(Schema.Array(Schema.String)))
+});
+var Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)]);
+
+export { Entry, Info, exports_formatter };

package/dist/chunks/permission-2qdvkq1m.js

@@ -0,0 +1,223 @@
+import {
+  exports_tool
+} from "./permission-f1ge3yjy.js";
+import {
+  definition,
+  execute,
+  normalizeContent
+} from "./permission-d6s8p2vk.js";
+import {
+  exports_hooks
+} from "./permission-t2j2ttmx.js";
+import {
+  exports_image
+} from "./permission-f0sqeedm.js";
+import {
+  exports_wildcard
+} from "./permission-y67x6rf6.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool.ts
+var exports_tool2 = {};
+__export(exports_tool2, {
+  node: () => node,
+  Tool: () => exports_tool2,
+  TextContent: () => TextContent,
+  Service: () => Service,
+  RegistrationError: () => RegistrationError,
+  FileContent: () => FileContent,
+  Error: () => Error,
+  Content: () => Content,
+  CallID: () => CallID
+});
+import { CallID, Content, Error, FileContent, TextContent } from "@opencode-ai/schema/tool";
+import { Tool } from "@opencode-ai/schema/tool";
+import { Context, Effect, Layer, Schema, Semaphore } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+class RegistrationError extends Schema.TaggedErrorClass()("Tool.RegistrationError", {
+  name: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Tool") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const hooks = yield* exports_hooks.Service;
+  const image = yield* exports_image.Service;
+  const normalizeImages = Effect.fn("Tool.normalizeImages")(function* (content) {
+    const normalized = yield* Effect.forEach(content, (item) => {
+      if (item.type !== "file" || !item.mime.startsWith("image/"))
+        return Effect.succeed(item);
+      const base64 = /^data:[^,]*;base64,(.*)$/s.exec(item.uri)?.[1];
+      if (base64 === undefined)
+        return Effect.succeed(item);
+      const resource = item.name ?? `${item.mime} tool output`;
+      return image.normalize(resource, { uri: resource, content: base64, encoding: "base64", mime: item.mime }).pipe(Effect.map((result) => ({
+        ...item,
+        uri: `data:${result.mime};base64,${result.content}`,
+        mime: result.mime
+      })), Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(item)), Effect.catchTag("Image.DecodeError", () => Effect.succeed("decode")), Effect.catchTag("Image.SizeError", () => Effect.succeed("size")));
+    });
+    const note = (reason, text) => {
+      const count = normalized.filter((item) => item === reason).length;
+      if (count === 0)
+        return [];
+      return [{ type: "text", text: `[${count} image${count === 1 ? "" : "s"} omitted: ${text}]` }];
+    };
+    return [
+      ...normalized.filter((item) => typeof item !== "string"),
+      ...note("decode", "could not be decoded."),
+      ...note("size", "could not be resized below the image size limit.")
+    ];
+  });
+  const local = new Map;
+  const lock = Semaphore.makeUnsafe(1);
+  const executeTool = Effect.fn("Tool.execute")(function* (tool, name, input, context) {
+    const beforeEvent = {
+      tool: name,
+      sessionID: context.sessionID,
+      agent: context.agent,
+      messageID: context.messageID,
+      id: context.id,
+      input
+    };
+    yield* hooks.trigger("tool", "execute.before", beforeEvent);
+    const execution = yield* execute(tool, beforeEvent.input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
+    const base = {
+      tool: name,
+      sessionID: context.sessionID,
+      agent: context.agent,
+      messageID: context.messageID,
+      id: context.id,
+      input: beforeEvent.input
+    };
+    if ("failure" in execution) {
+      const afterEvent2 = {
+        ...base,
+        status: "error",
+        error: execution.failure
+      };
+      yield* hooks.trigger("tool", "execute.after", afterEvent2);
+      return yield* afterEvent2.error;
+    }
+    const afterEvent = {
+      ...base,
+      status: "completed",
+      result: {
+        ...execution.value.output === undefined ? {} : { output: execution.value.output },
+        content: execution.value.content,
+        ...execution.value.metadata === undefined ? {} : { metadata: execution.value.metadata }
+      }
+    };
+    yield* hooks.trigger("tool", "execute.after", afterEvent);
+    const afterContent = yield* normalizeImages(normalizeContent(afterEvent.result.content, afterEvent.result.output));
+    return {
+      ...afterEvent.result.output === undefined ? {} : { output: afterEvent.result.output },
+      content: afterContent,
+      ...afterEvent.result.metadata === undefined ? {} : { metadata: afterEvent.result.metadata }
+    };
+  });
+  const transform = Effect.fn("Tool.transform")(function* (callback) {
+    const tools = [];
+    yield* Effect.sync(() => callback({ add: (tool) => tools.push(tool) }));
+    yield* Effect.forEach(tools.flatMap((tool) => tool.options?.namespace === undefined ? [] : [tool.options.namespace]), validateNamespace, { discard: true });
+    const entries = normalizedEntries(tools);
+    yield* Effect.forEach(entries, (entry) => validateName(normalizedName(entry.tool)), { discard: true });
+    const collision = entries.find((entry, index) => entries.findIndex((candidate) => candidate.key === entry.key) !== index);
+    if (collision)
+      return yield* Effect.fail(new RegistrationError({
+        name: collision.key,
+        message: `Duplicate normalized tool name: ${collision.key}`
+      }));
+    const reserved = entries.find((entry) => entry.tool.options?.codemode === false && entry.key === "execute");
+    if (reserved)
+      return yield* Effect.fail(new RegistrationError({
+        name: reserved.key,
+        message: 'Tool name "execute" is reserved for CodeMode'
+      }));
+    if (entries.length === 0)
+      return;
+    yield* Effect.uninterruptible(lock.withPermit(Effect.gen(function* () {
+      const token = {};
+      for (const entry of entries)
+        local.set(entry.key, [...local.get(entry.key) ?? [], { token, tool: entry.tool }]);
+      yield* Effect.addFinalizer(() => lock.withPermit(Effect.sync(() => {
+        for (const entry of entries) {
+          const remaining = local.get(entry.key)?.filter((item) => item.token !== token) ?? [];
+          if (remaining.length > 0)
+            local.set(entry.key, remaining);
+          else
+            local.delete(entry.key);
+        }
+      })));
+    })));
+  });
+  return Service.of({
+    transform,
+    snapshot: Effect.fn("Tool.snapshot")((permissions) => lock.withPermit(Effect.gen(function* () {
+      const active = new Map;
+      const rules = permissions ?? [];
+      for (const [name, entries] of local) {
+        const tool = entries.at(-1)?.tool;
+        if (!tool)
+          continue;
+        if (whollyDisabled(tool.options?.permission ?? name, rules))
+          continue;
+        active.set(name, tool);
+      }
+      const direct = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode === false));
+      const codemode = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode !== false));
+      const executeRule = rules.findLast((rule) => exports_wildcard.match("execute", rule.action));
+      const codemodeEnabled = executeRule?.resource !== "*" || executeRule.effect !== "deny";
+      const codemodeTool = codemodeEnabled ? exports_tool.create(codemode, (name, tool, input, context) => executeTool(tool, name, input, context)) : undefined;
+      const codeModeCatalog = codemodeEnabled ? exports_tool.catalog(codemode) : undefined;
+      return {
+        ...codeModeCatalog === undefined ? {} : { codeModeCatalog },
+        definitions: [
+          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition(tool)),
+          ...codemodeTool ? [definition(codemodeTool)] : []
+        ],
+        execute: (input) => {
+          const context = {
+            sessionID: input.sessionID,
+            agent: input.agent,
+            messageID: input.messageID,
+            id: Tool.CallID.make(input.call.id),
+            progress: input.progress ?? (() => Effect.void)
+          };
+          if (input.call.name === "execute" && codemodeTool)
+            return executeTool(codemodeTool, input.call.name, input.call.input, context);
+          const tool = direct.get(input.call.name);
+          if (tool)
+            return executeTool(tool, input.call.name, input.call.input, context);
+          return new Tool.Error({ message: `Unknown tool: ${input.call.name}` });
+        }
+      };
+    })))
+  });
+}));
+var whollyDisabled = (action, rules) => {
+  const rule = rules.findLast((rule2) => exports_wildcard.match(action, rule2.action));
+  return rule?.resource === "*" && rule.effect === "deny";
+};
+var validateName = (name) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(name) ? Effect.void : Effect.fail(new RegistrationError({ name, message: `Invalid tool name: ${name}` }));
+var validateNamespace = (namespace) => namespace.split(".").every((segment) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(segment)) ? Effect.void : Effect.fail(new RegistrationError({
+  name: namespace,
+  message: `Invalid tool namespace: ${JSON.stringify(namespace)}`
+}));
+var normalizedName = (tool) => tool.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+var effectiveName = (tool) => tool.options?.namespace === undefined ? normalizedName(tool) : `${tool.options.namespace.replaceAll(".", "_")}_${normalizedName(tool)}`;
+var normalizedEntries = (tools) => tools.map((tool) => ({
+  key: effectiveName(tool),
+  tool
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_hooks.node, exports_image.node]
+});
+
+export { RegistrationError, Service, node, exports_tool2 as exports_tool, CallID, Content, Error, FileContent, TextContent };

package/dist/chunks/permission-2qdx6zz3.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260603160727_jittery_ezekiel_stane.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260603160727_jittery_ezekiel_stane",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_input_session_pending_seq_idx\`;`);
+      yield* tx.run(`CREATE INDEX IF NOT EXISTS \`event_aggregate_type_seq_idx\` ON \`event\` (\`aggregate_id\`,\`type\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX IF NOT EXISTS \`session_input_session_pending_delivery_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`,\`delivery\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX IF NOT EXISTS \`session_message_session_time_created_id_idx\` ON \`session_message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+    });
+  }
+};
+var _20260603160727_jittery_ezekiel_stane_default = migration;
+
+export { _20260603160727_jittery_ezekiel_stane_default };

package/dist/chunks/permission-2zyawa45.js

@@ -0,0 +1,73 @@
+import {
+  exports_history
+} from "./permission-0cm1xtm8.js";
+import {
+  fromRow
+} from "./permission-mya790jh.js";
+import {
+  exports_message
+} from "./permission-25pxtba7.js";
+import {
+  SessionMessageTable,
+  SessionTable
+} from "./permission-zvvp2xr4.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/store.ts
+var exports_store = {};
+__export(exports_store, {
+  node: () => node,
+  SessionStore: () => exports_store,
+  Service: () => Service
+});
+import { and, eq, isNotNull, isNull, sql } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Session } from "@opencode-ai/schema/session";
+class Service extends Context.Service()("@opencode/SessionStore") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  const decodeMessage = Schema.decodeUnknownEffect(exports_message.Info);
+  return Service.of({
+    get: Effect.fn("SessionStore.get")(function* (sessionID) {
+      const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie);
+      return row ? fromRow(row) : undefined;
+    }),
+    context: Effect.fn("SessionStore.context")(function* (sessionID) {
+      return yield* exports_history.load(db, sessionID);
+    }),
+    message: Effect.fn("SessionStore.message")(function* (messageID) {
+      const row = yield* db.select().from(SessionMessageTable).where(eq(SessionMessageTable.id, messageID)).get().pipe(Effect.orDie);
+      return row ? {
+        sessionID: Session.ID.make(row.session_id),
+        message: yield* decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie)
+      } : undefined;
+    }),
+    listSuspended: Effect.fn("SessionStore.listSuspended")(function* () {
+      return yield* db.select({ sessionID: SessionTable.id }).from(SessionTable).where(and(isNotNull(SessionTable.time_suspended), isNull(SessionTable.parent_id))).all().pipe(Effect.orDie, Effect.map((rows) => rows.map((row) => row.sessionID)));
+    }),
+    claim: Effect.fn("SessionStore.claim")(function* (sessionID) {
+      yield* db.update(SessionTable).set({ time_suspended: Date.now(), time_updated: sql`${SessionTable.time_updated}` }).where(and(eq(SessionTable.id, sessionID), isNull(SessionTable.time_suspended))).run().pipe(Effect.orDie);
+    }),
+    release: Effect.fn("SessionStore.release")(function* (sessionID) {
+      yield* db.update(SessionTable).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable.time_updated}` }).where(eq(SessionTable.id, sessionID)).run().pipe(Effect.orDie);
+    }),
+    releaseChildClaims: db.update(SessionTable).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable.time_updated}` }).where(and(isNotNull(SessionTable.time_suspended), isNotNull(SessionTable.parent_id))).run().pipe(Effect.orDie, Effect.asVoid, Effect.withSpan("SessionStore.releaseChildClaims")),
+    countResume: Effect.fn("SessionStore.countResume")(function* (sessionID) {
+      const row = yield* db.update(SessionTable).set({
+        resume_attempts: sql`${SessionTable.resume_attempts} + 1`,
+        time_updated: sql`${SessionTable.time_updated}`
+      }).where(eq(SessionTable.id, sessionID)).returning({ attempts: SessionTable.resume_attempts }).get().pipe(Effect.orDie);
+      return row?.attempts;
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { Service, node, exports_store };