@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-ed4jjjcc.js

@@ -0,0 +1,171 @@
+import {
+  Failed,
+  NotFound,
+  WrongKind
+} from "./permission-zthe9zqc.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/environment/memory.ts
+var exports_memory = {};
+__export(exports_memory, {
+  makeMemoryDriver: () => makeMemoryDriver,
+  EnvironmentMemory: () => exports_memory
+});
+import path from "node:path";
+import { Effect, PlatformError } from "effect";
+import { make } from "effect/unstable/process/ChildProcessSpawner";
+var makeMemoryDriver = () => {
+  const nodes = new Map([["/", { type: "directory", mtimeMs: Date.now() }]]);
+  const key = (value) => path.posix.resolve("/", value);
+  const info = (node) => ({
+    type: node.type,
+    size: node.type === "file" ? node.bytes.length : node.type === "symlink" ? new TextEncoder().encode(node.target).length : 0,
+    mtimeMs: node.mtimeMs
+  });
+  const resolveKey = (value, followFinal, seen = new Set) => {
+    const normalized = key(value);
+    const parts = normalized.split("/").filter(Boolean);
+    const base = "/";
+    const walk = (current, index) => {
+      if (index === parts.length)
+        return current;
+      const part = parts[index];
+      const candidate = path.posix.join(current, part);
+      const node = nodes.get(candidate);
+      if (node?.type !== "symlink" || !followFinal && index === parts.length - 1)
+        return walk(candidate, index + 1);
+      if (seen.has(candidate))
+        return;
+      seen.add(candidate);
+      const target = path.posix.resolve(path.posix.dirname(candidate), node.target);
+      return resolveKey(path.posix.join(target, ...parts.slice(index + 1)), followFinal, seen);
+    };
+    return walk(base, 0);
+  };
+  const lookup = (value) => nodes.get(resolveKey(value, false) ?? key(value));
+  const requireParent = (value) => {
+    const parentPath = path.posix.dirname(key(value));
+    const parent = nodes.get(resolveKey(parentPath, true) ?? parentPath);
+    if (!parent)
+      throw new Error(`Parent directory does not exist: ${path.posix.dirname(value)}`);
+    if (parent.type !== "directory")
+      throw new Error(`Parent is not a directory: ${path.posix.dirname(value)}`);
+  };
+  const mkdirSync = (value) => {
+    const target = resolveKey(value, false) ?? key(value);
+    const existing = nodes.get(target);
+    if (existing?.type === "directory")
+      return;
+    if (existing)
+      throw new Error(`Path is not a directory: ${value}`);
+    const parent = path.posix.dirname(target);
+    if (parent !== target)
+      mkdirSync(parent);
+    nodes.set(target, { type: "directory", mtimeMs: Date.now() });
+  };
+  const failed = (value, cause) => new Failed({ path: value, cause });
+  const overrides = {
+    stat: (value) => {
+      const node = lookup(value);
+      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }));
+    },
+    read: (value, range) => {
+      const original = lookup(value);
+      if (!original)
+        return Effect.fail(new NotFound({ path: value }));
+      if (original.type === "directory")
+        return Effect.fail(new WrongKind({ path: value, actual: "directory" }));
+      const resolved = resolveKey(value, true);
+      const node = resolved === undefined ? undefined : nodes.get(resolved);
+      if (!node)
+        return Effect.fail(new NotFound({ path: value }));
+      if (node.type !== "file")
+        return Effect.fail(new WrongKind({ path: value, actual: node.type }));
+      const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length);
+      return Effect.succeed({ info: info(node), bytes: bytes.slice() });
+    },
+    write: (value, bytes) => Effect.try({
+      try: () => {
+        mkdirSync(path.posix.dirname(key(value)));
+        const existing = lookup(value);
+        if (existing?.type === "directory")
+          throw new Error(`Path is a directory: ${value}`);
+        const target = existing?.type === "symlink" ? resolveKey(value, true) : resolveKey(value, false);
+        if (!target)
+          throw new Error(`Cannot resolve symlink: ${value}`);
+        requireParent(target);
+        nodes.set(target, { type: "file", bytes: bytes.slice(), mtimeMs: Date.now() });
+      },
+      catch: (cause) => failed(value, cause)
+    }),
+    list: (value) => {
+      const target = resolveKey(value, true) ?? key(value);
+      const node = nodes.get(target);
+      if (!node)
+        return Effect.fail(new NotFound({ path: value }));
+      if (node.type !== "directory")
+        return Effect.fail(new WrongKind({ path: value, actual: node.type }));
+      const entries = [...nodes.entries()].filter(([entry]) => entry !== target && path.posix.dirname(entry) === target).map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type })).sort((a, b) => a.name.localeCompare(b.name));
+      return Effect.succeed(entries);
+    },
+    remove: (value) => Effect.sync(() => {
+      const target = resolveKey(value, false) ?? key(value);
+      for (const entry of nodes.keys()) {
+        if (entry === target || entry.startsWith(`${target}/`))
+          nodes.delete(entry);
+      }
+    }),
+    move: (from, to) => {
+      const source = resolveKey(from, false) ?? key(from);
+      const node = nodes.get(source);
+      if (!node)
+        return Effect.fail(new NotFound({ path: from }));
+      return Effect.try({
+        try: () => {
+          const requested = resolveKey(to, false) ?? key(to);
+          const destination = nodes.get(requested)?.type === "directory" ? path.posix.join(requested, path.posix.basename(source)) : requested;
+          if (node.type === "directory" && destination.startsWith(`${source}/`)) {
+            throw new Error(`Cannot move a directory into itself: ${from}`);
+          }
+          const existing = nodes.get(destination);
+          if (node.type === "directory" && existing && existing.type !== "directory") {
+            throw new Error(`Cannot overwrite a non-directory with a directory: ${to}`);
+          }
+          requireParent(destination);
+          const moved = [...nodes.entries()].filter(([entry]) => entry === source || entry.startsWith(`${source}/`));
+          for (const [entry] of moved)
+            nodes.delete(entry);
+          for (const [entry, child] of moved)
+            nodes.set(`${destination}${entry.slice(source.length)}`, child);
+        },
+        catch: (cause) => failed(from, cause)
+      });
+    },
+    mkdir: (value) => Effect.try({ try: () => mkdirSync(value), catch: (cause) => failed(value, cause) })
+  };
+  const spawner = make((command) => Effect.suspend(() => {
+    const description = command._tag === "StandardCommand" ? command.command : "pipeline";
+    return Effect.fail(PlatformError.systemError({
+      _tag: "Unknown",
+      module: "EnvironmentMemory",
+      method: "spawn",
+      pathOrDescriptor: description,
+      cause: failed(description, new Error("The memory driver cannot spawn processes"))
+    }));
+  }));
+  return {
+    spawner,
+    overrides,
+    symlink: (target, value) => Effect.try({
+      try: () => {
+        requireParent(value);
+        nodes.set(resolveKey(value, false) ?? key(value), { type: "symlink", target, mtimeMs: Date.now() });
+      },
+      catch: (cause) => failed(value, cause)
+    })
+  };
+};
+
+export { makeMemoryDriver, exports_memory };

package/dist/chunks/permission-ehj9csmv.js

@@ -0,0 +1,6 @@
+// src/util/iife.ts
+function iife(fn) {
+  return fn();
+}
+
+export { iife };

package/dist/chunks/permission-erj4j75s.js

@@ -0,0 +1,129 @@
+import {
+  getTableColumnsRuntime,
+  mapUpdateSet,
+  orderSelectedFields
+} from "./permission-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/insert.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { Param, SQL, sql } from "drizzle-orm/sql/sql";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+import { haveSameKeys } from "drizzle-orm/utils";
+import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
+class SQLiteEffectInsertBuilder {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectInsertBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  values(values) {
+    values = Array.isArray(values) ? values : [values];
+    if (values.length === 0) {
+      throw new Error("values() must be called with at least one value");
+    }
+    const mappedValues = values.map((entry) => {
+      const result = {};
+      const cols = getTableColumnsRuntime(this.table);
+      for (const colKey of Object.keys(entry)) {
+        const colValue = entry[colKey];
+        result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+      }
+      return result;
+    });
+    return new SQLiteEffectInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
+  }
+  select(selectQuery) {
+    const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder) : selectQuery;
+    if (!is(select, SQL) && !haveSameKeys(getTableColumnsRuntime(this.table), select._.selectedFields)) {
+      throw new Error("Insert select error: selected fields are not the same or are in a different order compared to the table definition");
+    }
+    return new SQLiteEffectInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+  }
+}
+
+class SQLiteEffectInsertBase {
+  table;
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectInsert";
+  config;
+  constructor(table, values, effectSession, effectDialect, withList, select) {
+    this.table = table;
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { table, values, withList, select };
+  }
+  returning(fields = getTableColumnsRuntime(this.config.table)) {
+    this.config.returning = orderSelectedFields(fields);
+    return this;
+  }
+  onConflictDoNothing(config = {}) {
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    if (config.target === undefined) {
+      this.config.onConflict.push(sql` on conflict do nothing`);
+      return this;
+    }
+    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
+    const whereSql = config.where ? sql` where ${config.where}` : sql``;
+    this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);
+    return this;
+  }
+  onConflictDoUpdate(config) {
+    if (config.where && (config.targetWhere || config.setWhere)) {
+      throw new Error('You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.');
+    }
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    const whereSql = config.where ? sql` where ${config.where}` : undefined;
+    const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
+    const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
+    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
+    const setSql = this.effectDialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
+    this.config.onConflict.push(sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildInsertQuery(this.config);
+  }
+  toSQL() {
+    return this.effectDialect.sqlToQuery(this.getSQL());
+  }
+  _prepare(isOneTimeQuery = true) {
+    return this.effectSession[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.effectDialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", undefined, {
+      type: "insert",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  execute = (placeholderValues) => {
+    return this._prepare().execute(placeholderValues);
+  };
+  $dynamic() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectInsertBase);
+
+export { SQLiteEffectInsertBuilder, SQLiteEffectInsertBase };

package/dist/chunks/permission-eyk9wdct.js

@@ -0,0 +1,61 @@
+import {
+  InvalidError
+} from "./permission-nr76rjj3.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/config/variable.ts
+var exports_variable = {};
+__export(exports_variable, {
+  substitute: () => substitute,
+  ConfigVariable: () => exports_variable
+});
+import os from "os";
+import path from "path";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var substitute = Effect.fn("ConfigVariable.substitute")(function* (input) {
+  const text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => (input.env?.[varName] ?? process.env[varName]) || "");
+  if (!text.includes("{file:"))
+    return text;
+  return yield* substituteFiles(input, text);
+});
+var substituteFiles = Effect.fnUntraced(function* (input, text) {
+  const fs = yield* FSUtil.Service;
+  const configDir = input.type === "path" ? path.dirname(input.path) : input.dir;
+  const configSource = input.type === "path" ? input.path : input.source;
+  const matches = Array.from(text.matchAll(/\{file:[^}]+\}/g));
+  let out = "";
+  let cursor = 0;
+  for (const match of matches) {
+    const token = match[0];
+    const index = match.index;
+    out += text.slice(cursor, index);
+    const lineStart = text.lastIndexOf(`
+`, index - 1) + 1;
+    const prefix = text.slice(lineStart, index).trimStart();
+    if (prefix.startsWith("//")) {
+      out += token;
+      cursor = index + token.length;
+      continue;
+    }
+    const filePath = token.replace(/^\{file:/, "").replace(/\}$/, "");
+    const expandedPath = filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath;
+    const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(configDir, expandedPath);
+    const fileContent = yield* fs.readFileString(resolvedPath).pipe(Effect.catch((error) => {
+      if (input.missing === "empty")
+        return Effect.succeed("");
+      const message = `bad file reference: "${token}"`;
+      return Effect.fail(new InvalidError({
+        path: configSource,
+        message: error._tag === "PlatformError" && error.reason._tag === "NotFound" ? `${message} ${resolvedPath} does not exist` : message
+      }, { cause: error }));
+    }));
+    out += JSON.stringify(fileContent.trim()).slice(1, -1);
+    cursor = index + token.length;
+  }
+  return out + text.slice(cursor);
+});
+
+export { substitute, exports_variable };

package/dist/chunks/permission-ezs3tagn.js

@@ -0,0 +1,54 @@
+// src/github-copilot/chat/openai-compatible-prepare-tools.ts
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+function prepareTools({
+  tools,
+  toolChoice
+}) {
+  tools = tools?.length ? tools : undefined;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+  const openaiCompatTools = [];
+  for (const tool of tools) {
+    if (tool.type === "provider") {
+      toolWarnings.push({ type: "unsupported", feature: `tool type: ${tool.type}` });
+    } else {
+      openaiCompatTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiCompatTools, toolChoice: undefined, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiCompatTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+export { prepareTools };

package/dist/chunks/permission-ezvn03y4.js

@@ -0,0 +1,12 @@
+import {
+  migrate
+} from "./permission-s27a5c5r.js";
+
+// src/database/drizzle/effect-sqlite/migrator.ts
+import { readMigrationFiles } from "drizzle-orm/migrator";
+function migrate2(db, config) {
+  const migrations = readMigrationFiles(config);
+  return migrate(migrations, db.session, config);
+}
+
+export { migrate2 as migrate };

package/dist/chunks/permission-f05p34aa.js

@@ -0,0 +1,80 @@
+import {
+  exports_mcp
+} from "./permission-1c00jchy.js";
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/websearch/firecrawl.ts
+var exports_firecrawl = {};
+__export(exports_firecrawl, {
+  endpoint: () => endpoint,
+  WebSearchFirecrawl: () => exports_firecrawl,
+  Plugin: () => Plugin
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Option, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+var endpoint = "https://mcp.firecrawl.dev/v2/mcp";
+var McpInput = Schema.Struct({
+  query: Schema.String,
+  limit: Schema.Number.pipe(Schema.optional)
+});
+var McpOutput = Schema.Struct({
+  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String }))
+});
+var SearchResponse = Schema.fromJsonString(Schema.Struct({
+  success: Schema.Boolean,
+  data: Schema.Struct({
+    web: Schema.Array(Schema.Struct({
+      url: Schema.String,
+      title: Schema.NullOr(Schema.String).pipe(Schema.optional),
+      description: Schema.NullOr(Schema.String).pipe(Schema.optional)
+    }))
+  })
+}));
+var decodeSearchResponse = Schema.decodeUnknownOption(SearchResponse);
+var Plugin = define({
+  id: "opencode.websearch.firecrawl",
+  effect: Effect.fn("WebSearchFirecrawl.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((draft) => {
+      draft.update("firecrawl", (integration) => integration.name = "Firecrawl");
+      draft.method.update({
+        integrationID: "firecrawl",
+        method: { type: "key" }
+      });
+      draft.method.update({
+        integrationID: "firecrawl",
+        method: { type: "env", names: ["FIRECRAWL_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((draft) => {
+      draft.add({
+        id: "firecrawl",
+        name: "Firecrawl",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("firecrawl");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const result = yield* exports_mcp.call(http, endpoint, "firecrawl_search", { input: McpInput, output: McpOutput }, { query: input.query, limit: 8 }, {
+            "User-Agent": exports_app.useragent(ctx.app),
+            ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}
+          });
+          const content = result?.content.find((item) => item.text);
+          const response = content ? Option.getOrUndefined(decodeSearchResponse(content.text)) : undefined;
+          return response?.data.web.map((item) => ({
+            url: item.url,
+            ...item.title ? { title: item.title } : {},
+            ...item.description ? { content: item.description } : {},
+            time: {}
+          })) ?? [];
+        })
+      });
+    });
+  })
+});
+
+export { endpoint, Plugin, exports_firecrawl };

package/dist/chunks/permission-f0sqeedm.js

@@ -0,0 +1,68 @@
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  __export,
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/image.ts
+var exports_image = {};
+__export(exports_image, {
+  node: () => node,
+  SizeError: () => SizeError,
+  Service: () => Service,
+  ResizerUnavailableError: () => ResizerUnavailableError,
+  Image: () => exports_image,
+  DecodeError: () => DecodeError
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+class ResizerUnavailableError extends Schema.TaggedErrorClass()("Image.ResizerUnavailableError", {}) {
+}
+
+class DecodeError extends Schema.TaggedErrorClass()("Image.DecodeError", {
+  resource: Schema.String
+}) {
+  get message() {
+    return `Image could not be decoded: ${this.resource}`;
+  }
+}
+
+class SizeError extends Schema.TaggedErrorClass()("Image.SizeError", {
+  resource: Schema.String,
+  width: Schema.Number,
+  height: Schema.Number,
+  bytes: Schema.Number,
+  maxWidth: Schema.Number,
+  maxHeight: Schema.Number,
+  maxBytes: Schema.Number
+}) {
+  get message() {
+    return `Image ${this.resource} is ${this.width}x${this.height} with base64 size ${this.bytes}, exceeding configured limits ${this.maxWidth}x${this.maxHeight}/${this.maxBytes} bytes`;
+  }
+}
+
+class Service extends Context.Service()("@opencode/Image") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const config = yield* exports_config.Service;
+  const loadAdapter = yield* Effect.cached(Effect.tryPromise({
+    try: () => import("../image/photon.js"),
+    catch: () => new ResizerUnavailableError
+  }).pipe(Effect.flatMap((adapter) => adapter.make)));
+  const normalize = Effect.fn("Image.normalize")(function* (resource, content) {
+    const image = Object.assign({}, ...(yield* config.entries()).flatMap((entry) => entry.type === "document" && entry.info.media?.image ? [entry.info.media.image] : []));
+    const normalize2 = yield* loadAdapter;
+    return yield* normalize2(resource, content, {
+      autoResize: image.auto_resize ?? true,
+      maxWidth: image.max_width ?? 2000,
+      maxHeight: image.max_height ?? 2000,
+      maxBase64Bytes: image.max_base64_bytes ?? 5 * 1024 * 1024
+    });
+  });
+  return Service.of({ normalize });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_config.node] });
+
+export { ResizerUnavailableError, DecodeError, SizeError, Service, node, exports_image };