@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-y5pstp70.js

@@ -0,0 +1,113 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  ID16,
+  isAISDK2
+} from "./repository-pye8sh6e.js";
+import {
+  iife2
+} from "./repository-1kg9ymc8.js";
+import {
+  configuredSettings2
+} from "./repository-5b88mxz1.js";
+
+// src/plugin/provider/cloudflare-workers-ai.ts
+import os from "os";
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Form } from "@opencode/schema/form";
+var providerID = ID16.make("cloudflare-workers-ai");
+var CloudflareWorkersAIPlugin2 = define({
+  id: "opencode.provider.cloudflare.workers.ai",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings2(providerID);
+    const form = iife2(() => {
+      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((editor) => {
+      editor.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 (!isAISDK2(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 isAISDK2(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": `${useragent2(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 { CloudflareWorkersAIPlugin2 };

package/dist/chunks/repository-y6f0p4jw.js

@@ -0,0 +1,7 @@
+// src/session/schema.ts
+import * as SessionSchema2 from "@opencode/schema/session";
+import { Session } from "@opencode/schema/session";
+var ID10 = Session.ID;
+var Info23 = Session.Info;
+
+export { ID10, Info23, SessionSchema2 };

package/dist/chunks/repository-y71avatq.js

@@ -0,0 +1,31 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/effect/keyed-mutex.ts
+var exports_keyed_mutex = {};
+__export(exports_keyed_mutex, {
+  KeyedMutex: () => exports_keyed_mutex,
+  make: () => make22,
+  makeUnsafe: () => makeUnsafe2
+});
+import { Effect, Semaphore } from "effect";
+var makeUnsafe2 = () => {
+  const locks = new Map;
+  const withLock = (key) => (effect) => Effect.suspend(() => {
+    const current = locks.get(key);
+    const entry = current ?? { semaphore: Semaphore.makeUnsafe(1), users: 0 };
+    if (!current)
+      locks.set(key, entry);
+    entry.users++;
+    return entry.semaphore.withPermit(effect).pipe(Effect.ensuring(Effect.sync(() => {
+      entry.users--;
+      if (entry.users === 0)
+        locks.delete(key);
+    })));
+  });
+  return { size: Effect.sync(() => locks.size), withLock };
+};
+var make22 = () => Effect.sync(makeUnsafe2);
+
+export { makeUnsafe2, make22, exports_keyed_mutex };

package/dist/chunks/repository-y8cydn3q.js

@@ -0,0 +1,68 @@
+// src/effect/websocket-constructor.ts
+import { NodeWS } from "@effect/platform-node/NodeSocket";
+import { HttpProxyAgent } from "http-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { Layer } from "effect";
+import { Socket } from "effect/unstable/socket";
+var environmentValue = (environment, name) => environment[name] ?? environment[name.toLowerCase()];
+var bypassesProxy = (url, value) => {
+  if (!value)
+    return false;
+  const port = url.port || (url.protocol === "wss:" ? "443" : "80");
+  const hostname = url.hostname.toLowerCase();
+  return value.split(/[\s,]+/).some((entry) => {
+    if (!entry)
+      return false;
+    if (entry === "*")
+      return true;
+    const match = entry.match(/^(.+?):(\d+)$/);
+    if (match?.[2] && match[2] !== port)
+      return false;
+    const host = (match?.[1] ?? entry).toLowerCase().replace(/^\*/, "");
+    return host.startsWith(".") ? hostname.endsWith(host) : hostname === host;
+  });
+};
+var proxy = (value, environment = process.env) => {
+  const url = new URL(value);
+  if (["127.0.0.1", "localhost", "::1"].includes(url.hostname))
+    return;
+  if (bypassesProxy(url, environmentValue(environment, "NO_PROXY")))
+    return;
+  const protocolProxy = url.protocol === "wss:" ? "WSS_PROXY" : "WS_PROXY";
+  const standardProxy = url.protocol === "wss:" ? "HTTPS_PROXY" : "HTTP_PROXY";
+  return environmentValue(environment, protocolProxy) ?? environmentValue(environment, standardProxy) ?? environmentValue(environment, "ALL_PROXY");
+};
+var constructorOptions = (input) => {
+  if (typeof input === "string" || Array.isArray(input))
+    return { protocols: input };
+  return input ?? {};
+};
+var proxyAgent = (url, selectedProxy) => {
+  if (!selectedProxy)
+    return;
+  if (url.startsWith("wss:") || selectedProxy.startsWith("https:"))
+    return new HttpsProxyAgent(selectedProxy);
+  return new HttpProxyAgent(selectedProxy);
+};
+var layer = Layer.succeed(Socket.WebSocketConstructor, (url, input) => {
+  const config = constructorOptions(input);
+  const selectedProxy = proxy(url);
+  if (typeof Bun !== "undefined") {
+    const WebSocket = globalThis.WebSocket;
+    return new WebSocket(url, {
+      headers: config.headers,
+      protocols: config.protocols,
+      ...selectedProxy ? { proxy: selectedProxy } : {}
+    });
+  }
+  const native = {
+    headers: config.headers,
+    agent: proxyAgent(url, selectedProxy),
+    followRedirects: false
+  };
+  const socket = config.protocols ? new NodeWS.WebSocket(url, config.protocols, native) : new NodeWS.WebSocket(url, native);
+  return socket;
+});
+var WebSocketConstructor2 = { layer, proxy };
+
+export { WebSocketConstructor2 };

package/dist/chunks/repository-y8f7s663.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260910120000_clear_v1_session_permission.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260910120000_clear_v1_session_permission",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`UPDATE \`session_v2\` SET \`permission\` = NULL;`);
+    });
+  }
+};
+var _20260910120000_clear_v1_session_permission_default = migration;
+
+export { _20260910120000_clear_v1_session_permission_default };

package/dist/chunks/repository-y973e7aq.js

@@ -0,0 +1,97 @@
+import {
+  VariantUnavailableError3,
+  UnsupportedPackageError3,
+  ModelConfigurationError3,
+  ModelInitializationError3,
+  UnresolvedProviderVariablesError3,
+  UnsupportedCompactionError3,
+  Service71,
+  node75
+} from "./repository-fmdgzt8c.js";
+import {
+  SessionSchema2
+} from "./repository-y6f0p4jw.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/runner/model.ts
+var exports_model = {};
+__export(exports_model, {
+  ModelConfigurationError: () => ModelConfigurationError2,
+  ModelInitializationError: () => ModelInitializationError2,
+  ModelNotSelectedError: () => ModelNotSelectedError2,
+  ModelUnavailableError: () => ModelUnavailableError2,
+  Service: () => Service51,
+  SessionRunnerModel: () => exports_model,
+  UnresolvedProviderVariablesError: () => UnresolvedProviderVariablesError2,
+  UnsupportedCompactionError: () => UnsupportedCompactionError2,
+  UnsupportedPackageError: () => UnsupportedPackageError2,
+  VariantUnavailableError: () => VariantUnavailableError2,
+  node: () => node55,
+  resolved: () => resolved2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Model } from "@opencode/schema/model";
+import { Provider } from "@opencode/schema/provider";
+import { Context, Effect, Layer, Schema } from "effect";
+class ModelNotSelectedError2 extends Schema.TaggedError()("SessionRunnerModel.ModelNotSelectedError", { sessionID: SessionSchema2.ID }) {
+  get message() {
+    return `No model is available for session ${this.sessionID}`;
+  }
+}
+
+class ModelUnavailableError2 extends Schema.TaggedError()("SessionRunnerModel.ModelUnavailableError", { providerID: Provider.ID, modelID: Model.ID }) {
+  get message() {
+    if (this.providerID === "azure-cognitive-services")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use azure/${this.modelID} instead.`;
+    if (this.providerID === "google-vertex-anthropic")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use google-vertex/${this.modelID} instead.`;
+    return `Model unavailable: ${this.providerID}/${this.modelID}`;
+  }
+}
+var VariantUnavailableError2 = VariantUnavailableError3;
+var UnsupportedPackageError2 = UnsupportedPackageError3;
+var ModelConfigurationError2 = ModelConfigurationError3;
+var ModelInitializationError2 = ModelInitializationError3;
+var UnresolvedProviderVariablesError2 = UnresolvedProviderVariablesError3;
+var UnsupportedCompactionError2 = UnsupportedCompactionError3;
+
+class Service51 extends Context.Service()("@opencode/SessionRunnerModel") {
+}
+var resolved2 = (model, options) => ({
+  model,
+  ref: Model.Ref.make({
+    id: Model.ID.make(model.id),
+    providerID: Provider.ID.make(model.provider),
+    ...options.variant === undefined ? {} : { variant: options.variant }
+  }),
+  capabilities: options.capabilities,
+  cost: options.cost,
+  limit: options.limit,
+  compaction: options.compaction,
+  websocket: options.websocket ?? false
+});
+var layer = Layer.effect(Service51, Effect.gen(function* () {
+  const resolver = yield* Service71;
+  return Service51.of({
+    resolve: Effect.fn("SessionRunnerModel.resolve")(function* (session, available) {
+      if (!session.model) {
+        const resolved = yield* resolver.resolve();
+        if (resolved)
+          return resolved;
+        return yield* new ModelNotSelectedError2({ sessionID: session.id });
+      }
+      const selected = (yield* available()).find((model) => model.providerID === session.model?.providerID && model.id === session.model.id);
+      if (!selected)
+        return yield* new ModelUnavailableError2({
+          providerID: session.model.providerID,
+          modelID: session.model.id
+        });
+      return yield* resolver.resolveModel(selected, session.model.variant);
+    })
+  });
+}));
+var node55 = makeLocationNode({ service: Service51, layer, deps: [node75] });
+
+export { ModelNotSelectedError2, ModelUnavailableError2, VariantUnavailableError2, UnsupportedPackageError2, ModelConfigurationError2, ModelInitializationError2, UnresolvedProviderVariablesError2, UnsupportedCompactionError2, Service51, resolved2, node55, exports_model };

package/dist/chunks/repository-yahs3f01.js

@@ -0,0 +1,260 @@
+import {
+  NonNegativeInt2
+} from "./repository-922hggd3.js";
+import {
+  latest2,
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  typeFollowing2
+} from "./repository-2a5m3afh.js";
+import {
+  Service65
+} from "./repository-3mdgf1e2.js";
+import {
+  Service54
+} from "./repository-mw6spqsr.js";
+import {
+  Service58
+} from "./repository-ykpr0q7c.js";
+import {
+  Service19,
+  resolvePath2
+} from "./repository-pvp1cs2e.js";
+import {
+  output2,
+  notice2,
+  metadata2,
+  notification2
+} from "./repository-fxbjtjnd.js";
+import {
+  Service57,
+  name15
+} from "./repository-3ke3s58r.js";
+import {
+  NotFoundError5,
+  Service42
+} from "./repository-rsbh8q26.js";
+import {
+  Service26
+} from "./repository-51cmmk6m.js";
+import {
+  scan2
+} from "./repository-g9cr3d5v.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/shell.ts
+var exports_shell2 = {};
+__export(exports_shell2, {
+  DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS2,
+  Input: () => Input7,
+  Plugin: () => Plugin24,
+  ShellTool: () => exports_shell2,
+  name: () => name7
+});
+import { ToolFailure } from "@opencode/ai";
+import { Deferred, Effect, Schema, Scope } from "effect";
+var name7 = "shell";
+var DEFAULT_TIMEOUT_MS2 = 2 * 60 * 1000;
+var BACKGROUND_INSTRUCTION = "You will be notified automatically when the command finishes. The notification will include the command's output. Unless the user explicitly asks otherwise, DO NOT poll for completion, even if you need the final result to continue. Repeatedly sleeping and reading or searching the output file is polling, not useful work. You may read the current output if it lets you do useful work now, but do not repeatedly check it while waiting for the command to finish. Keep working on anything that does not depend on the result. If you have nothing else to do, end your response; you will be resumed automatically when the command finishes.";
+var OS = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : process.platform === "linux" ? "Linux" : process.platform;
+var description = (shell) => [
+  "Execute a shell command and return its output.",
+  ...shell ? [`Commands run on ${OS} using ${shell}.`] : [],
+  "Quote file paths containing spaces or special characters.",
+  "Prefer dedicated tools over shell commands when possible.",
+  "When output is large, the full result is saved to a file and a truncated preview is returned.",
+  "Rely on automatic truncation unless filtering the output is more useful.",
+  "Commands accept an optional timeout, background commands have no timeout by default.",
+  "Background commands return immediately, and you will be notified when they complete."
+].join(" ");
+var Input7 = Schema.Struct({
+  command: Schema.String.annotate({ description: "Shell command string to execute" }),
+  workdir: Schema.optionalKey(Schema.String).annotate({
+    description: "Working directory to execute the command in. Defaults to the current working directory. When possible, avoid changing directories in the command and set the working directory here instead."
+  }),
+  timeout: Schema.optionalKey(NonNegativeInt2).annotate({
+    description: `Timeout in milliseconds. Set to 0 to disable the timeout. Defaults to ${DEFAULT_TIMEOUT_MS2} for foreground commands. Background commands have no timeout by default.`
+  }),
+  background: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Run the command in the background and return immediately (useful for dev servers and long-running builds). You do not need to use '&' at the end of the command when using this parameter. You will be notified when it completes. DO NOT poll for completion."
+  })
+});
+var StructuredOutput = Schema.Struct({
+  exit: Schema.optionalKey(Schema.Number),
+  shellID: Schema.optionalKey(Schema.String),
+  truncated: Schema.Boolean,
+  timeout: Schema.optionalKey(Schema.Boolean)
+});
+var Output = Schema.Struct({
+  ...StructuredOutput.fields,
+  output: Schema.String,
+  status: Schema.optionalKey(Schema.Literals(["completed", "running"]))
+});
+var resultMessages = (output) => {
+  const notice = output.status === "running" ? BACKGROUND_INSTRUCTION : notice2(output);
+  return [output.output, ...notice ? [notice] : []];
+};
+var toolResult = (output) => {
+  return {
+    output,
+    content: resultMessages(output).map((text) => ({ type: "text", text })),
+    metadata: {
+      status: output.status,
+      ...metadata2(output),
+      ...output.shellID !== undefined ? { shellID: output.shellID } : {}
+    }
+  };
+};
+var backgroundResult = (shellID, file) => ({
+  output: `Command moved to the background (shell ID: ${shellID}).
+Output is streaming to: ${file}`,
+  shellID,
+  truncated: false,
+  status: "running"
+});
+var Plugin24 = {
+  id: "opencode.tool.shell",
+  effect: Effect.fn("ShellTool.Plugin")(function* (ctx) {
+    const sessions = yield* Service26;
+    const jobs = yield* Service54;
+    const scope = yield* Scope.Scope;
+    const environment = yield* Service65;
+    const access = yield* Service19;
+    const shell = yield* Service42;
+    const shellSelect = yield* Service57;
+    const compatibleShell = shellSelect.resolve({ priority: "compat" });
+    const permission = yield* Service58;
+    const config = yield* Service44;
+    const prepare = Effect.fn("ShellTool.prepare")(function* (invocation, context) {
+      const source = {
+        type: "tool",
+        messageID: context.messageID,
+        id: context.id
+      };
+      const target = yield* access.resolve({ path: invocation.cwd, kind: "directory" });
+      invocation.cwd = target.absolute;
+      const timeout = invocation.timeout;
+      const portable = latest2(yield* config.entries(), "experimental")?.portable_shell_scanner === true;
+      const parsed = yield* scan2(invocation.command, invocation.shell, target.absolute, { portable });
+      const directories = yield* Effect.forEach(parsed.directories, (directory) => access.resolve({
+        path: resolvePath2(target.absolute, directory),
+        kind: "directory"
+      }));
+      yield* access.authorizeExternal([target, ...directories], context);
+      if (parsed.commands.length > 0)
+        yield* permission.assert({
+          action: name7,
+          resources: parsed.commands.map((command) => command.resource),
+          save: parsed.commands.map((command) => command.save),
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+      const workdir = yield* typeFollowing2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new Error(`Working directory does not exist: ${target.absolute}`))));
+      if (workdir !== "directory")
+        return yield* Effect.fail(new Error(`Working directory is not a directory: ${target.absolute}`));
+      return timeout;
+    });
+    const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (sessionID, id, shellID, command, settled) {
+      const info = (yield* jobs.wait({ id })).info;
+      if (!info || info.status === "running")
+        return;
+      const output = info.status === "completed" ? yield* Deferred.await(settled) : undefined;
+      const text = output ? resultMessages(output).join(`
+
+`) : info.status === "error" ? info.error ?? "Command failed" : "Command cancelled";
+      yield* sessions.synthetic({
+        ...info.notificationID ? { id: info.notificationID } : {},
+        sessionID,
+        description: command,
+        ...notification2({
+          jobID: id,
+          shellID,
+          command,
+          state: info.status,
+          text,
+          output
+        })
+      });
+      if (info.notificationID)
+        yield* jobs.completeBackground(info.notificationID);
+    }, Effect.forkIn(scope, { startImmediately: true }));
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name7,
+      options: { codemode: false },
+      description: description(),
+      input: Input7,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const timeout = input.background === true ? input.timeout ?? 0 : input.timeout ?? DEFAULT_TIMEOUT_MS2;
+        let finalTimeout = timeout;
+        const info = yield* shell.create({
+          command: input.command,
+          cwd: input.workdir,
+          timeout,
+          shell: yield* compatibleShell,
+          metadata: { sessionID: context.sessionID }
+        }, (invocation) => Effect.gen(function* () {
+          finalTimeout = yield* prepare(invocation, context);
+        }));
+        yield* context.progress({ shellID: info.id });
+        const settled = yield* Deferred.make();
+        const run = Effect.gen(function* () {
+          const result = yield* shell.result(info);
+          if (!result.capture)
+            return yield* new NotFoundError5({ id: info.id });
+          const output = output2(result);
+          return {
+            ...output,
+            output: output.timeout ? `${output.output}
+
+Command exceeded timeout of ${finalTimeout} ms. Retry with a larger timeout if the command is expected to take longer.` : output.output,
+            status: "completed"
+          };
+        }).pipe(Effect.tap((output) => Deferred.succeed(settled, output)), Effect.map((output) => resultMessages(output).join(`
+
+`)), Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)));
+        const job = yield* jobs.start({
+          id: info.id,
+          type: name7,
+          title: info.command,
+          metadata: { sessionID: context.sessionID, shellID: info.id },
+          recovery: {
+            kind: "shell",
+            sessionID: context.sessionID,
+            shellID: info.id,
+            command: info.command
+          },
+          run
+        });
+        if (input.background === true) {
+          yield* jobs.background(job.id);
+          yield* notifyWhenDone(context.sessionID, job.id, info.id, info.command, settled);
+          return backgroundResult(info.id, info.file);
+        }
+        const result = yield* jobs.block({ id: job.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => jobs.cancel(job.id).pipe(Effect.ignore)));
+        if (result?.type === "backgrounded") {
+          yield* shell.timeout(info.id, 0);
+          yield* notifyWhenDone(context.sessionID, job.id, info.id, info.command, settled);
+          return backgroundResult(info.id, info.file);
+        }
+        if (result?.info.status === "error")
+          return yield* Effect.fail(new Error(result.info.error ?? "Command failed"));
+        if (result?.info.status === "cancelled")
+          return yield* Effect.fail(new Error("Command cancelled"));
+        return yield* Deferred.await(settled);
+      }).pipe(Effect.map(toolResult), Effect.mapError((error) => new ToolFailure({ message: `Unable to execute command: ${input.command}`, error })))
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const tool = event.tools[name7];
+      if (!tool)
+        return;
+      tool.description = description(name15(yield* compatibleShell));
+    }));
+  })
+};
+
+export { name7, DEFAULT_TIMEOUT_MS2, Input7, Plugin24, exports_shell2 };

package/dist/chunks/repository-ygaqb7jw.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260611035744_credential.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260611035744_credential",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`connector_id\` text NOT NULL,
+          \`method_id\` text NOT NULL,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`active\` integer DEFAULT false NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`CREATE UNIQUE INDEX \`credential_connector_active_idx\` ON \`credential\` (\`connector_id\`) WHERE "credential"."active" = 1;`);
+    });
+  }
+};
+var _20260611035744_credential_default = migration;
+
+export { _20260611035744_credential_default };

package/dist/chunks/repository-yjknk9j9.js

@@ -0,0 +1,31 @@
+import {
+  managesTransactionsNatively2,
+  EffectSQLiteSession2,
+  EffectSQLiteTransaction2
+} from "./repository-hrncarcf.js";
+import {
+  EffectSQLiteDatabase2,
+  DefaultServices2,
+  make23,
+  makeWithDefaults2
+} from "./repository-f78hydwg.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/database/drizzle/index.ts
+var exports_drizzle = {};
+__export(exports_drizzle, {
+  DefaultServices: () => DefaultServices2,
+  EffectDrizzleSqlite: () => exports_drizzle,
+  EffectLogger: () => EffectLogger2,
+  EffectSQLiteDatabase: () => EffectSQLiteDatabase2,
+  EffectSQLiteSession: () => EffectSQLiteSession2,
+  EffectSQLiteTransaction: () => EffectSQLiteTransaction2,
+  make: () => make23,
+  makeWithDefaults: () => makeWithDefaults2,
+  managesTransactionsNatively: () => managesTransactionsNatively2
+});
+import { EffectLogger as EffectLogger2 } from "drizzle-orm/effect-core";
+
+export { exports_drizzle, EffectLogger2 };