@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-8w2n8x74.js

@@ -0,0 +1,64 @@
+import {
+  exports_migration
+} from "./permission-4szcs9x3.js";
+import {
+  exports_drizzle
+} from "./permission-yjjxtbjv.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/database/database.ts
+var exports_database = {};
+__export(exports_database, {
+  node: () => node,
+  layerFromClient: () => layerFromClient,
+  layer: () => layer,
+  configured: () => configured,
+  Service: () => Service,
+  Options: () => Options,
+  Database: () => exports_database
+});
+import { sqliteLayer, supportsForeignKeyToggle, supportsTuningPragmas } from "#sqlite";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Global } from "@opencode-ai/util/global";
+import { isAbsolute, join } from "path";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var makeDatabase = exports_drizzle.makeWithDefaults();
+var Options = Schema.Struct({
+  path: Schema.optional(Schema.String)
+});
+
+class Service extends Context.Service()("@opencode/storage/Database") {
+}
+var databaseLayer = Layer.effect(Service, Effect.gen(function* () {
+  const db = yield* makeDatabase;
+  if (supportsTuningPragmas) {
+    yield* db.run("PRAGMA journal_mode = WAL");
+    yield* db.run("PRAGMA synchronous = NORMAL");
+    yield* db.run("PRAGMA busy_timeout = 5000");
+    yield* db.run("PRAGMA cache_size = -64000");
+    yield* db.run("PRAGMA wal_checkpoint(PASSIVE)");
+  }
+  if (supportsForeignKeyToggle)
+    yield* db.run("PRAGMA foreign_keys = ON");
+  yield* exports_migration.apply(db);
+  return { db };
+}).pipe(Effect.orDie));
+function layer(options = { path: ":memory:" }) {
+  return Layer.unwrap(Effect.gen(function* () {
+    const provide = (filename2) => layerFromClient.pipe(Layer.provide(sqliteLayer({ filename: filename2 })));
+    const filename = options.path ?? ":memory:";
+    if (filename === ":memory:" || isAbsolute(filename))
+      return provide(filename);
+    const global = yield* Global.Service;
+    return provide(join(global.data, filename));
+  }));
+}
+var layerFromClient = databaseLayer;
+function configured(options) {
+  return makeGlobalNode({ service: Service, layer: layer(options), deps: [Global.node] });
+}
+var node = configured({ path: ":memory:" });
+
+export { Options, Service, layer, layerFromClient, configured, node, exports_database };

package/dist/chunks/permission-8w9tzfz1.js

@@ -0,0 +1,14 @@
+// src/util/lazy.ts
+function lazy(fn) {
+  let value;
+  let loaded = false;
+  return () => {
+    if (loaded)
+      return value;
+    loaded = true;
+    value = fn();
+    return value;
+  };
+}
+
+export { lazy };

package/dist/chunks/permission-8wv04gvy.js

@@ -0,0 +1,115 @@
+import {
+  iife
+} from "./permission-ehj9csmv.js";
+import {
+  configuredSettings
+} from "./permission-gxp1x3zs.js";
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/cloudflare-workers-ai.ts
+import os from "os";
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Form } from "@opencode-ai/schema/form";
+var providerID = exports_provider.ID.make("cloudflare-workers-ai");
+var CloudflareWorkersAIPlugin = define({
+  id: "opencode.provider.cloudflare-workers-ai",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings(providerID);
+    const form = iife(() => {
+      if (typeof configured?.baseURL === "string" || resolveAccountId(configured ?? {}))
+        return;
+      return Form.Fields.make([
+        {
+          type: "string",
+          key: "accountId",
+          title: "Enter your Cloudflare Account ID",
+          placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+          required: true
+        }
+      ]);
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "API key",
+          form
+        }
+      });
+    });
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(providerID);
+      if (!item)
+        return;
+      evt.provider.update(item.provider.id, (provider) => {
+        if (!exports_provider.isAISDK(provider.package))
+          return;
+        if (typeof provider.settings?.baseURL === "string")
+          return;
+        const accountId = resolveAccountId(provider.settings ?? {});
+        if (accountId)
+          provider.settings = { ...provider.settings, baseURL: workersEndpoint(accountId) };
+      });
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      if (evt.package !== "@ai-sdk/openai-compatible")
+        return;
+      const accountId = resolveAccountId(evt.options);
+      if (!hasWorkersEndpoint(evt.model) && !accountId)
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"));
+      evt.sdk = mod.createOpenAICompatible(sdkOptions({
+        ...evt.options,
+        baseURL: evt.options.baseURL ?? (accountId ? workersEndpoint(accountId) : undefined)
+      }, ctx.app));
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      evt.language = evt.sdk.languageModel(evt.model.modelID ?? evt.model.id);
+    }));
+  })
+});
+function resolveAccountId(options) {
+  return process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId");
+}
+function workersEndpoint(accountId) {
+  return `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/v1`;
+}
+function hasWorkersEndpoint(model) {
+  return exports_provider.isAISDK(model.package) && typeof model.settings?.baseURL === "string";
+}
+function sdkOptions(options, app) {
+  return {
+    ...options,
+    baseURL: expandAccountId(options.baseURL),
+    apiKey: process.env.CLOUDFLARE_API_KEY ?? options.apiKey,
+    headers: {
+      "User-Agent": `${exports_app.useragent(app)} cloudflare-workers-ai (${os.platform()} ${os.release()}; ${os.arch()})`,
+      ...options.headers
+    },
+    name: providerID
+  };
+}
+function expandAccountId(baseURL) {
+  if (typeof baseURL !== "string")
+    return baseURL;
+  return baseURL.replaceAll("${CLOUDFLARE_ACCOUNT_ID}", process.env.CLOUDFLARE_ACCOUNT_ID ?? "${CLOUDFLARE_ACCOUNT_ID}");
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareWorkersAIPlugin };

package/dist/chunks/permission-8ywqk2j9.js

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/usage.ts
+var exports_usage = {};
+__export(exports_usage, {
+  tokens: () => tokens,
+  record: () => record,
+  calculateCost: () => calculateCost,
+  add: () => add,
+  SessionUsage: () => exports_usage
+});
+import { Money } from "@opencode-ai/schema/money";
+var safe = (value) => Math.max(0, Number.isFinite(value) ? value ?? 0 : 0);
+var tokens = (usage) => ({
+  input: safe(usage?.nonCachedInputTokens),
+  output: safe(usage?.visibleOutputTokens),
+  reasoning: safe(usage?.reasoningTokens),
+  cache: {
+    read: safe(usage?.cacheReadInputTokens),
+    write: safe(usage?.cacheWriteInputTokens)
+  }
+});
+function calculateCost(costs, usage) {
+  const context = usage.input + usage.cache.read + usage.cache.write;
+  const tier = costs.filter((cost2) => cost2.tier?.type === "context" && context > cost2.tier.size).toSorted((a, b) => (b.tier?.size ?? 0) - (a.tier?.size ?? 0))[0];
+  const cost = tier ?? costs.find((cost2) => cost2.tier === undefined);
+  if (!cost)
+    return Money.USD.zero;
+  return Money.USD.make((usage.input * cost.input + (usage.output + usage.reasoning) * cost.output + usage.cache.read * cost.cache.read + usage.cache.write * cost.cache.write) / 1e6);
+}
+var record = (usage, costs) => {
+  const normalized = tokens(usage);
+  return { tokens: normalized, cost: calculateCost(costs, normalized) };
+};
+var add = (a, b) => ({
+  cost: Money.USD.make(a.cost + b.cost),
+  tokens: {
+    input: a.tokens.input + b.tokens.input,
+    output: a.tokens.output + b.tokens.output,
+    reasoning: a.tokens.reasoning + b.tokens.reasoning,
+    cache: {
+      read: a.tokens.cache.read + b.tokens.cache.read,
+      write: a.tokens.cache.write + b.tokens.cache.write
+    }
+  }
+});
+
+export { tokens, calculateCost, record, add, exports_usage };

package/dist/chunks/permission-906y0b6d.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260601202201_amazing_prowler.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260601202201_amazing_prowler",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP TABLE \`permission\`;`);
+    });
+  }
+};
+var _20260601202201_amazing_prowler_default = migration;
+
+export { _20260601202201_amazing_prowler_default };

package/dist/chunks/permission-93qdgxxd.js

@@ -0,0 +1,30 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/model-http.ts
+var exports_model_http = {};
+__export(exports_model_http, {
+  middleware: () => middleware,
+  SessionModelHttp: () => exports_model_http
+});
+import { Effect, Stream } from "effect";
+import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var middleware = (hooks, input) => (request, handler) => Effect.gen(function* () {
+  const before = yield* hooks.trigger("session", "http.request", {
+    ...input,
+    request: yield* HttpClientRequest.toWeb(request)
+  });
+  let sent = HttpClientRequest.fromWeb(before.request);
+  if (before.request.body)
+    sent = HttpClientRequest.bodyUint8Array(sent, new Uint8Array(yield* Effect.promise(() => before.request.clone().arrayBuffer())), before.request.headers.get("content-type") ?? undefined);
+  const response = yield* handler(sent);
+  const after = yield* hooks.trigger("session", "http.response", {
+    ...input,
+    request: before.request,
+    response: new Response([204, 205, 304].includes(response.status) ? null : yield* Stream.toReadableStreamEffect(response.stream), { status: response.status, headers: response.headers })
+  });
+  return HttpClientResponse.fromWeb(sent, after.response);
+}).pipe(Effect.mapError((cause) => cause instanceof Error ? cause : new Error(String(cause))));
+
+export { middleware, exports_model_http };

package/dist/chunks/permission-999qd968.js

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

package/dist/chunks/permission-9avt6sfe.js

@@ -0,0 +1,124 @@
+import {
+  exports_filesystem
+} from "./permission-jm82nbh8.js";
+import {
+  exports_ripgrep
+} from "./permission-wvha5myg.js";
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  exports_location_mutation
+} from "./permission-a2yyszsy.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  RelativePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/plugin/glob.ts
+var exports_glob = {};
+__export(exports_glob, {
+  toModelContent: () => toModelContent,
+  name: () => name,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input,
+  GlobTool: () => exports_glob
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name = "glob";
+var Input = Schema.Struct({
+  pattern: exports_filesystem.GlobInput.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
+  path: Schema.optionalKey(RelativePath).annotate({
+    description: "Directory to search. Defaults to the current working directory."
+  }),
+  limit: exports_filesystem.GlobInput.fields.limit.annotate({
+    description: `Maximum number of matching files to return (default: ${exports_filesystem.DEFAULT_SEARCH_LIMIT})`
+  })
+});
+var Output = Schema.Array(exports_filesystem.Entry);
+var toModelContent = (entries, truncated = false) => {
+  const lines = entries.length === 0 ? ["No files found"] : entries.map((item) => item.path);
+  if (truncated)
+    lines.push("", `(Results are truncated: showing first ${entries.length} results. Consider using a more specific path or pattern.)`);
+  return lines.join(`
+`);
+};
+var Plugin = {
+  id: "opencode.tool.glob",
+  effect: Effect.fn("GlobTool.Plugin")(function* (ctx) {
+    const environment = yield* exports_environment.Service;
+    const ripgrep = yield* exports_ripgrep.Service;
+    const location = yield* exports_location.Service;
+    const mutation = yield* exports_location_mutation.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description: 'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path;
+        const source = { type: "tool", messageID: context.messageID, id: context.id };
+        const target = yield* mutation.resolve({ path: searchPath ?? ".", kind: "directory" });
+        const external = target.externalDirectory;
+        if (external)
+          yield* permission.assert({
+            ...exports_location_mutation.externalDirectoryPermission(external),
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+        yield* permission.assert({
+          action: name,
+          resources: [input.pattern],
+          save: ["*"],
+          metadata: {
+            root: searchPath ?? ".",
+            path: searchPath,
+            limit: input.limit
+          },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const type = yield* exports_environment.typeFollowing(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
+        if (type !== "directory")
+          return yield* Effect.fail(new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }));
+        const root = target.absolute;
+        const limit = input.limit ?? exports_filesystem.DEFAULT_SEARCH_LIMIT;
+        const entries = yield* ripgrep.glob({
+          cwd: root,
+          pattern: input.pattern,
+          limit: limit + 1
+        }).pipe(Effect.timeoutOrElse({
+          duration: exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS,
+          orElse: () => Effect.fail(new ToolFailure({
+            message: `Search timed out after ${exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS / 1000} seconds. Consider using a more specific path or pattern.`
+          }))
+        }), Effect.map((result) => result.map((entry) => exports_filesystem.Entry.make({
+          ...entry,
+          path: RelativePath.make(path.relative(location.directory, path.resolve(root, entry.path)))
+        }))));
+        return { entries: entries.slice(0, limit), truncated: entries.length > limit };
+      }).pipe(Effect.map((result) => ({
+        output: result.entries,
+        content: toModelContent(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
+        metadata: { count: result.entries.length, truncated: result.truncated }
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name, Input, Output, toModelContent, Plugin, exports_glob };

package/dist/chunks/permission-9dct5xhx.js

@@ -0,0 +1,21 @@
+// src/database/migration/20260225215848_workspace.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260225215848_workspace",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`branch\` text,
+          \`project_id\` text NOT NULL,
+          \`config\` text NOT NULL,
+          CONSTRAINT \`fk_workspace_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260225215848_workspace_default = migration;
+
+export { _20260225215848_workspace_default };