@opencode-ai/core 0.0.0-beta-18743 → 0.0.0-beta-18955

package/dist/chunks/event-logger-63yqstqv.js

@@ -0,0 +1,200 @@
+import {
+  exports_service as exports_service2
+} from "./event-logger-esv5q40e.js";
+import {
+  exports_service
+} from "./event-logger-6bxzghb6.js";
+import {
+  exports_mime
+} from "./event-logger-kq3q54gz.js";
+import {
+  exports_skill
+} from "./event-logger-kzzx546a.js";
+import {
+  AttachmentError,
+  SkillNotFoundError
+} from "./event-logger-2sqw2jjm.js";
+import {
+  exports_hooks
+} from "./event-logger-xws7arpm.js";
+import {
+  exports_image
+} from "./event-logger-db33vhr2.js";
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/session/prompt.ts
+var exports_prompt = {};
+__export(exports_prompt, {
+  SessionPrompt: () => exports_prompt,
+  prepare: () => prepare
+});
+import { Base64, FileAttachment, Prompt } from "@opencode-ai/schema/prompt";
+import { SessionInbox } from "@opencode-ai/schema/session-inbox";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Effect } from "effect";
+import path from "path";
+import { fileURLToPath } from "url";
+var prepare = Effect.fn("SessionPrompt.prepare")(function* (request) {
+  const fs = yield* FSUtil.Service;
+  const instances = yield* exports_service.Service;
+  return yield* Effect.gen(function* () {
+    yield* exports_service2.awaitActivation;
+    const hooks = yield* exports_hooks.Service;
+    const event = yield* hooks.trigger("session", "prompt", {
+      sessionID: request.session.id,
+      messageID: request.messageID,
+      prompt: structuredClone({
+        text: request.input.text,
+        files: request.input.files?.slice(),
+        agents: request.input.agents?.slice(),
+        skills: request.input.skills?.slice()
+      }),
+      metadata: structuredClone(request.input.metadata),
+      delivery: request.input.delivery ?? "steer"
+    });
+    const input = event.prompt;
+    const files = input.files ? yield* Effect.forEach(input.files, materializeAttachment, { concurrency: 8 }) : undefined;
+    const requested = input.skills;
+    const selected = yield* Effect.gen(function* () {
+      if (!requested?.length)
+        return;
+      const skillService = yield* exports_skill.Service;
+      const prepared = new Map;
+      return yield* Effect.forEach(requested, (attachment) => Effect.gen(function* () {
+        const name = prepared.get(attachment.id);
+        if (name !== undefined)
+          return { id: attachment.id, name, mention: attachment.mention };
+        const skill = yield* skillService.get(attachment.id);
+        if (!skill)
+          return yield* new SkillNotFoundError({ skill: attachment.id });
+        prepared.set(skill.id, skill.name);
+        return {
+          id: skill.id,
+          name: skill.name,
+          text: (yield* exports_skill.prepare(fs, skill).pipe(Effect.orDie)).output,
+          mention: attachment.mention
+        };
+      }));
+    });
+    return {
+      type: "user",
+      payload: SessionInbox.UserPayload.make({
+        ...Prompt.make({
+          text: input.text,
+          agents: input.agents,
+          files,
+          skills: selected?.length ? selected : undefined
+        }),
+        metadata: event.metadata
+      }),
+      delivery: SessionInbox.Delivery.make(event.delivery)
+    };
+  }).pipe(instances.provide(request.session));
+});
+var materializeAttachment = Effect.fn("SessionPrompt.materializeAttachment")(function* (input) {
+  const resolved = input.uri.startsWith("data:") ? {
+    bytes: yield* decodeDataURL(input.uri),
+    source: { type: "inline" },
+    start: undefined,
+    end: undefined,
+    name: undefined,
+    mime: undefined
+  } : yield* readFileAttachment(input.uri);
+  if (resolved.bytes.byteLength > MAX_ATTACHMENT_BYTES)
+    return yield* new AttachmentError({
+      uri: input.uri,
+      message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${input.uri}`
+    });
+  const mime = resolved.mime ?? exports_mime.detect(resolved.bytes);
+  const content = mime === "text/plain" && resolved.start !== undefined ? Buffer.from(Buffer.from(resolved.bytes).toString("utf8").split(`
+`).slice(resolved.start - 1, resolved.end).join(`
+`)) : resolved.bytes;
+  const normalized = yield* normalizeImageAttachment(input, Buffer.from(content).toString("base64"), mime);
+  return FileAttachment.create({
+    data: normalized.data,
+    mime: normalized.mime,
+    source: resolved.source,
+    name: input.name ?? resolved.name,
+    description: input.description,
+    mention: input.mention
+  });
+});
+var normalizeImageAttachment = Effect.fn("SessionPrompt.normalizeImageAttachment")(function* (input, data, mime) {
+  if (!mime.startsWith("image/"))
+    return { data: Base64.make(data), mime };
+  const image = yield* exports_image.Service;
+  const label = input.name ?? (input.uri.startsWith("data:") ? "inline attachment" : input.uri);
+  const content = { uri: label, content: data, encoding: "base64", mime };
+  const normalized = yield* image.normalize(label, content).pipe(Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(content)), Effect.mapError((error) => new AttachmentError({ uri: label, message: error.message })));
+  return { data: Base64.make(normalized.content), mime: normalized.mime };
+});
+var readFileAttachment = Effect.fn("SessionPrompt.readFileAttachment")(function* (uri) {
+  const fs = yield* FSUtil.Service;
+  const url = yield* Effect.try({
+    try: () => new URL(uri),
+    catch: () => new AttachmentError({ uri, message: `Invalid attachment URI: ${uri}` })
+  });
+  if (url.protocol !== "file:")
+    return yield* new AttachmentError({ uri, message: `Unsupported attachment URI: ${uri}` });
+  const start = positiveInt(url.searchParams.get("start"));
+  const end = positiveInt(url.searchParams.get("end"));
+  const target = yield* Effect.try({
+    try: () => {
+      url.search = "";
+      url.hash = "";
+      return fileURLToPath(url);
+    },
+    catch: () => new AttachmentError({ uri, message: `Invalid file URI: ${uri}` })
+  });
+  const info = yield* fs.stat(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+  if (info.type === "Directory") {
+    const entries = yield* fs.readDirectoryEntries(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+    return {
+      bytes: Buffer.from(entries.filter((entry) => entry.type === "file" || entry.type === "directory").sort((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1).map((entry) => entry.name + (entry.type === "directory" ? path.sep : "")).join(`
+`)),
+      source: { type: "uri", uri },
+      start: undefined,
+      end: undefined,
+      name: path.basename(target),
+      mime: "application/x-directory"
+    };
+  }
+  if (info.type !== "File")
+    return yield* new AttachmentError({ uri, message: `Attachment is not a file: ${uri}` });
+  if (Number(info.size) > MAX_ATTACHMENT_BYTES)
+    return yield* new AttachmentError({
+      uri,
+      message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${uri}`
+    });
+  const bytes = yield* fs.readFile(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
+  return { bytes, source: { type: "uri", uri }, start, end, name: path.basename(target), mime: undefined };
+});
+var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+function decodeDataURL(uri) {
+  return Effect.try({
+    try: () => {
+      const comma = uri.indexOf(",");
+      if (comma === -1)
+        throw new Error("Invalid data URL");
+      const metadata = uri.slice(5, comma);
+      const payload = uri.slice(comma + 1);
+      if (!metadata.split(";").some((part) => part.toLowerCase() === "base64"))
+        return Buffer.from(decodeURIComponent(payload));
+      const bytes = Buffer.from(payload, "base64");
+      if (bytes.toString("base64") !== payload)
+        throw new Error("Non-canonical base64");
+      return bytes;
+    },
+    catch: () => new AttachmentError({ uri, message: "Invalid attachment data URL" })
+  });
+}
+function positiveInt(value) {
+  if (value === null)
+    return;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+export { prepare, exports_prompt };

package/dist/chunks/{websearch-0kvmztkf.js → event-logger-66mds5ht.js}

@@ -1,13 +1,13 @@
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/effect/keyed-mutex.ts
 var exports_keyed_mutex = {};
 __export(exports_keyed_mutex, {
-  makeUnsafe: () => makeUnsafe,
+  KeyedMutex: () => exports_keyed_mutex,
   make: () => make,
-  KeyedMutex: () => exports_keyed_mutex
+  makeUnsafe: () => makeUnsafe
 });
 import { Effect, Semaphore } from "effect";
 var makeUnsafe = () => {

package/dist/chunks/{websearch-fex42j86.js → event-logger-68yag814.js}

@@ -1,24 +1,24 @@
 import {
   __export,
   __require
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/provider.ts
 var exports_provider = {};
 __export(exports_provider, {
-  packageName: () => packageName,
-  mergeOverlay: () => mergeOverlay,
-  mergeHeaders: () => mergeHeaders,
-  loadPackage: () => loadPackage,
-  isAISDK: () => isAISDK,
-  aisdk: () => aisdk,
-  Settings: () => Settings,
-  Request: () => Request,
-  Provider: () => exports_provider,
-  LoadError: () => LoadError,
-  Info: () => Info,
+  AISDK_PREFIX: () => AISDK_PREFIX,
   ID: () => ID,
-  AISDK_PREFIX: () => AISDK_PREFIX
+  Info: () => Info,
+  LoadError: () => LoadError,
+  Provider: () => exports_provider,
+  Request: () => Request,
+  Settings: () => Settings,
+  aisdk: () => aisdk,
+  isAISDK: () => isAISDK,
+  loadPackage: () => loadPackage,
+  mergeHeaders: () => mergeHeaders,
+  mergeOverlay: () => mergeOverlay,
+  packageName: () => packageName
 });
 import { Effect, Schema } from "effect";
 import { Provider } from "@opencode-ai/schema/provider";
@@ -106,7 +106,7 @@ var loadPackage = Effect.fn("Provider.loadPackage")(function* (specifier, npm) {
   const root = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? specifier;
   const installed = yield* npm.add(root).pipe(Effect.mapError((cause) => new LoadError({ package: specifier, cause })));
   const entrypoint = yield* Effect.try({
-    try: () => specifier === root && installed.entrypoint ? installed.entrypoint : resolveModule(specifier, installed.directory),
+    try: () => resolveModule(specifier, installed.directory),
     catch: (cause) => new LoadError({ package: specifier, cause })
   });
   return yield* importPackage(specifier, entrypoint);

package/dist/chunks/{websearch-6wkzvma0.js → event-logger-6a909wmz.js}

@@ -1,35 +1,33 @@
 import {
   exports_state
-} from "./websearch-x89rah0x.js";
+} from "./event-logger-dyrfpcd0.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/filesystem/location-watcher-policy.ts
 var exports_location_watcher_policy = {};
 __export(exports_location_watcher_policy, {
-  node: () => node,
+  LocationWatcherPolicy: () => exports_location_watcher_policy,
   Service: () => Service,
-  LocationWatcherPolicy: () => exports_location_watcher_policy
+  node: () => node
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Scope } from "effect";
 class Service extends Context.Service()("@opencode/LocationWatcherPolicy") {
 }
 var layer = Layer.effect(Service, Effect.gen(function* () {
-  let current = [];
   const listeners = new Set;
   const state = exports_state.create({
     name: "location-watcher-policy",
     initial: () => ({ ignore: [] }),
-    draft: (draft) => ({
-      add: (ignore) => draft.ignore.push(...ignore),
-      list: () => draft.ignore
+    editor: (editor) => ({
+      add: (ignore) => editor.ignore.push(...ignore),
+      list: () => editor.ignore
     }),
-    finalize: (draft) => Effect.sync(() => {
-      current = [...draft.list()];
-    }).pipe(Effect.andThen(Effect.forEach(listeners, (listener) => listener(current), { discard: true })))
+    notify: () => Effect.forEach(listeners, (listener) => listener(current()), { discard: true })
   });
+  const current = () => state.get().ignore;
   const observe = Effect.fn("LocationWatcherPolicy.observe")(function* (listener) {
     const scope = yield* Scope.Scope;
     let active = true;
@@ -46,7 +44,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   return Service.of({
     transform: state.transform,
     reload: state.reload,
-    current: () => current,
+    current,
     observe
   });
 }));

package/dist/chunks/event-logger-6bxzghb6.js

@@ -0,0 +1,20 @@
+import {
+  __export
+} from "./event-logger-vpjkya7h.js";
+
+// src/instance/service.ts
+var exports_service = {};
+__export(exports_service, {
+  Instance: () => exports_service,
+  Service: () => Service,
+  node: () => node
+});
+import { Context } from "effect";
+import { Node } from "@opencode-ai/util/effect/app-node";
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+
+class Service extends Context.Service()("@opencode/Instance") {
+}
+var node = LayerNode.unbound(Service, Node.tags.values.global);
+
+export { Service, node, exports_service };

package/dist/chunks/{websearch-fm3b2wbt.js → event-logger-6hppa3xw.js}

@@ -1,16 +1,16 @@
 import {
   AbsolutePath
-} from "./websearch-j07kk359.js";
+} from "./event-logger-j07kk359.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/skill/discovery.ts
 var exports_discovery = {};
 __export(exports_discovery, {
-  node: () => node,
+  Service: () => Service,
   SkillDiscovery: () => exports_discovery,
-  Service: () => Service
+  node: () => node
 });
 import path from "path";
 import { Context, Effect, Layer, Schedule, Schema } from "effect";

package/dist/chunks/{websearch-d2gk9vpf.js → event-logger-6vbv4je1.js}

@@ -1,15 +1,15 @@
 import {
   InvalidError
-} from "./websearch-nr76rjj3.js";
+} from "./event-logger-89ttfx5q.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/config/variable.ts
 var exports_variable = {};
 __export(exports_variable, {
-  substitute: () => substitute,
-  ConfigVariable: () => exports_variable
+  ConfigVariable: () => exports_variable,
+  substitute: () => substitute
 });
 import os from "os";
 import path from "path";

package/dist/chunks/{websearch-zxe9jjhn.js → event-logger-6wsfy4sp.js}

@@ -2,16 +2,16 @@ import {
   Failed,
   NotFound,
   WrongKind
-} from "./websearch-xczfw7dq.js";
+} from "./event-logger-vynk8zbr.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/environment/local.ts
 var exports_local = {};
 __export(exports_local, {
-  makeLocalDriver: () => makeLocalDriver,
-  EnvironmentLocal: () => exports_local
+  EnvironmentLocal: () => exports_local,
+  makeLocalDriver: () => makeLocalDriver
 });
 import fs from "node:fs/promises";
 import path from "node:path";

package/dist/chunks/{websearch-5sc277j1.js → event-logger-6wskbeqw.js}

@@ -1,43 +1,43 @@
 import {
-  exports_watcher
-} from "./websearch-ns0sdez7.js";
+  exports_normalize
+} from "./event-logger-1j04cwhr.js";
 import {
   exports_variable
-} from "./websearch-d2gk9vpf.js";
-import {
-  exports_normalize
-} from "./websearch-58qy95wc.js";
+} from "./event-logger-6vbv4je1.js";
 import {
-  exports_wellknown
-} from "./websearch-1b8q0qfd.js";
+  exports_watcher
+} from "./event-logger-aqq7me5d.js";
 import {
   exports_credential
-} from "./websearch-xz7tgbq3.js";
+} from "./event-logger-cz4g9a0v.js";
 import {
-  exports_location
-} from "./websearch-mp6zts7p.js";
+  exports_wellknown
+} from "./event-logger-4dptn36j.js";
 import {
-  exports_bus
-} from "./websearch-cat9v99r.js";
+  exports_location
+} from "./event-logger-90zcexzw.js";
 import {
   AbsolutePath
-} from "./websearch-j07kk359.js";
+} from "./event-logger-j07kk359.js";
+import {
+  exports_bus
+} from "./event-logger-vw7aptj1.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/config.ts
 var exports_config = {};
 __export(exports_config, {
-  testLayer: () => testLayer,
-  node: () => node,
-  layer: () => layer,
-  latest: () => latest,
-  configured: () => configured,
-  Test: () => Test,
-  Service: () => Service,
+  Config: () => exports_config,
   Options: () => Options,
-  Config: () => exports_config
+  Service: () => Service,
+  Test: () => Test,
+  configured: () => configured,
+  latest: () => latest,
+  layer: () => layer,
+  node: () => node,
+  testLayer: () => testLayer
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import path from "path";
@@ -165,17 +165,15 @@ var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
     const globalDirectory = AbsolutePath.make(global.config);
     const globalAgentsDirectory = AbsolutePath.make(path.join(global.home, ".agents"));
     const globalClaudeDirectory = AbsolutePath.make(path.join(global.home, ".claude"));
-    const locationIsGlobal = path.resolve(location.directory) === path.resolve(global.config);
+    const globalRoots = yield* Effect.forEach([globalDirectory, globalClaudeDirectory, globalAgentsDirectory], (item) => fs.resolve(item));
+    const locationIsGlobal = (yield* fs.resolve(location.directory)) === globalRoots[0];
     const discovered = locationIsGlobal || options?.project === false ? [] : yield* fs.up({
       targets: [".opencode", ".claude", ".agents", ...names.toReversed()],
       start: location.directory
-    }).pipe(Effect.orDie);
+    }).pipe(Effect.flatMap((items) => Effect.forEach(items, (item) => fs.resolve(item).pipe(Effect.map((resolved) => ({ item, resolved }))))), Effect.orDie);
     const globalEnabled = options?.global !== false;
-    const globalRoots = [globalDirectory, globalClaudeDirectory, globalAgentsDirectory].map((item) => path.resolve(item));
-    const visible = globalEnabled ? discovered : discovered.filter((item) => {
-      const resolved = path.resolve(item);
-      return !globalRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep));
-    });
+    const globalFiles = yield* Effect.forEach(names, (name) => fs.resolve(path.join(globalDirectory, name)));
+    const visible = discovered.filter(({ resolved }) => globalEnabled ? !globalRoots.includes(resolved) && !globalFiles.includes(resolved) : !globalRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep))).map(({ item }) => item);
     const claude = [
       ...new Set([
         ...globalEnabled && (yield* fs.isDir(globalClaudeDirectory)) ? [globalClaudeDirectory] : [],

package/dist/chunks/{websearch-44bp186z.js → event-logger-6x09n4m4.js}

@@ -1,48 +1,48 @@
 import {
   exports_environment as exports_environment2
-} from "./websearch-6ky7rqk7.js";
+} from "./event-logger-zn935gjz.js";
 import {
   exports_config
-} from "./websearch-5sc277j1.js";
+} from "./event-logger-6wskbeqw.js";
+import {
+  exports_select
+} from "./event-logger-2qq12ds3.js";
 import {
   exports_tool_output
-} from "./websearch-sfg41mtw.js";
+} from "./event-logger-f4vqkfbt.js";
 import {
   exports_file_retention
-} from "./websearch-hp6rpdnc.js";
+} from "./event-logger-p1m5qwvv.js";
 import {
   exports_hooks
-} from "./websearch-v2wshkax.js";
+} from "./event-logger-xws7arpm.js";
 import {
-  exports_select
-} from "./websearch-bbhffenw.js";
+  SessionSchema
+} from "./event-logger-bjwj8hwv.js";
 import {
   exports_environment1 as exports_environment
-} from "./websearch-0xmbntw2.js";
+} from "./event-logger-pvhtfzrc.js";
 import {
   exports_location
-} from "./websearch-mp6zts7p.js";
+} from "./event-logger-90zcexzw.js";
 import {
   exports_bus
-} from "./websearch-cat9v99r.js";
-import {
-  SessionSchema
-} from "./websearch-bjwj8hwv.js";
+} from "./event-logger-vw7aptj1.js";
 import {
   __export,
   __require
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/shell.ts
 var exports_shell = {};
 __export(exports_shell, {
-  node: () => node,
-  cleanup: () => cleanup,
-  Shell: () => exports_shell,
-  Service: () => Service,
-  RETENTION: () => RETENTION,
+  DIRECTORY: () => DIRECTORY,
   NotFoundError: () => NotFoundError,
-  DIRECTORY: () => DIRECTORY
+  RETENTION: () => RETENTION,
+  Service: () => Service,
+  Shell: () => exports_shell,
+  cleanup: () => cleanup,
+  node: () => node
 });
 import path from "path";
 import { Context, Deferred, Duration, Effect, Fiber, Latch, Layer, Schema, Schedule, Stream } from "effect";

package/dist/chunks/{websearch-gzkavbc5.js → event-logger-754qx1qh.js}

@@ -1,19 +1,19 @@
 import {
   exports_location
-} from "./websearch-mp6zts7p.js";
+} from "./event-logger-90zcexzw.js";
 import {
   exports_state
-} from "./websearch-x89rah0x.js";
+} from "./event-logger-dyrfpcd0.js";
 import {
   __export
-} from "./websearch-rvfvac9x.js";
+} from "./event-logger-vpjkya7h.js";
 
 // src/formatter.ts
 var exports_formatter = {};
 __export(exports_formatter, {
-  node: () => node,
+  Formatter: () => exports_formatter,
   Service: () => Service,
-  Formatter: () => exports_formatter
+  node: () => node
 });
 import { Context, Effect, Layer } from "effect";
 import { ChildProcess } from "effect/unstable/process";
@@ -29,16 +29,16 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const state = exports_state.create({
     name: "formatter",
     initial: () => ({ formatters: [] }),
-    draft: (draft) => ({
+    editor: (editor) => ({
       set: (formatter) => {
-        const index = draft.formatters.findIndex((item) => item.name === formatter.name);
+        const index = editor.formatters.findIndex((item) => item.name === formatter.name);
         if (index === -1)
-          draft.formatters.push(formatter);
+          editor.formatters.push(formatter);
         else
-          draft.formatters[index] = formatter;
+          editor.formatters[index] = formatter;
       },
       remove: (name) => {
-        draft.formatters = draft.formatters.filter((formatter) => formatter.name !== name);
+        editor.formatters = editor.formatters.filter((formatter) => formatter.name !== name);
       }
     })
   });