@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-a83yvq99.js

@@ -0,0 +1,5 @@
+// src/session/event.ts
+export * from "@opencode-ai/schema/session-event";
+import * as SessionEvent from "@opencode-ai/schema/session-event";
+
+export { SessionEvent };

package/dist/chunks/location-mutation-ae05h9nh.js

@@ -0,0 +1,70 @@
+import {
+  exports_markdown
+} from "./location-mutation-7wcmqxrc.js";
+import {
+  exports_skill
+} from "./location-mutation-js0qxxzx.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/config/plugin/skill-file.ts
+var exports_skill_file = {};
+__export(exports_skill_file, {
+  parse: () => parse,
+  SkillFile: () => exports_skill_file
+});
+import path from "path";
+import { Result, Schema, SchemaParser } from "effect";
+var Frontmatter = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  slash: Schema.Boolean.pipe(Schema.optional),
+  metadata: Schema.Unknown.pipe(Schema.optional)
+});
+var decodeFrontmatter = SchemaParser.decodeUnknownResult(Frontmatter);
+var metadataBoolean = (metadata, key) => {
+  if (metadata === undefined || metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return;
+  }
+  const value = Reflect.get(metadata, key);
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value !== "string")
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  return;
+};
+function parse(directory, filepath, content) {
+  const markdown = exports_markdown.parseOption(content);
+  if (!markdown)
+    return { _tag: "Skipped", reason: "markdown" };
+  const decoded = decodeFrontmatter(markdown.data);
+  if (Result.isFailure(decoded))
+    return { _tag: "Skipped", reason: "frontmatter", issue: decoded.failure };
+  const frontmatter = decoded.success;
+  const id = path.dirname(filepath) === directory ? path.basename(filepath, ".md") : path.basename(path.dirname(filepath));
+  const slash = metadataBoolean(frontmatter.metadata, "opencode/slash") ?? frontmatter.slash;
+  const autoinvoke = metadataBoolean(frontmatter.metadata, "opencode/autoinvoke");
+  return {
+    _tag: "Parsed",
+    skill: {
+      id: exports_skill.ID.make(id),
+      name: exports_skill.Name.make(frontmatter.name ?? id),
+      ...frontmatter.description === undefined ? {} : { description: frontmatter.description },
+      ...slash === undefined ? {} : { slash },
+      ...autoinvoke === undefined ? {} : { autoinvoke },
+      location: AbsolutePath.make(filepath),
+      content: markdown.content
+    }
+  };
+}
+
+export { parse, exports_skill_file };

package/dist/chunks/location-mutation-afmh0nd1.js

@@ -0,0 +1,178 @@
+import {
+  RipgrepBinary
+} from "./location-mutation-h8ecejt5.js";
+import {
+  exports_environment1 as exports_environment
+} from "./location-mutation-pysc8t9c.js";
+import {
+  NonNegativeInt,
+  PositiveInt,
+  RelativePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/ripgrep.ts
+var exports_ripgrep = {};
+__export(exports_ripgrep, {
+  node: () => node,
+  Service: () => Service,
+  Ripgrep: () => exports_ripgrep,
+  InvalidPatternError: () => InvalidPatternError,
+  Error: () => Error
+});
+import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { Entry, Match } from "@opencode-ai/schema/filesystem";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { collectStream, waitForAbort } from "@opencode-ai/util/process";
+var ERROR_BYTES = 8 * 1024;
+var MAX_SUBMATCHES = 100;
+var RawMatch = Schema.Struct({
+  type: Schema.Literal("match"),
+  data: Schema.Struct({
+    path: Schema.Struct({ text: Schema.String }),
+    lines: Schema.Struct({ text: Schema.String }),
+    line_number: PositiveInt,
+    absolute_offset: NonNegativeInt,
+    submatches: Schema.Array(Schema.Struct({
+      match: Schema.Struct({ text: Schema.String }),
+      start: NonNegativeInt,
+      end: NonNegativeInt
+    }))
+  })
+});
+var decodeJsonRecord = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString);
+
+class Error extends Schema.TaggedErrorClass()("Ripgrep.Error", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class InvalidPatternError extends Schema.TaggedErrorClass()("Ripgrep.InvalidPatternError", {
+  pattern: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Ripgrep") {
+}
+var failure = (message, cause) => new Error({ message, cause });
+var isInvalidPattern = (stderr) => stderr.includes("regex parse error") || stderr.includes("error parsing regex");
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const environment = yield* exports_environment.Service;
+  const binary = yield* RipgrepBinary.Service;
+  const run = (input) => {
+    const program = Effect.scoped(Effect.gen(function* () {
+      const handle = yield* environment.spawner.spawn(ChildProcess.make(yield* binary.filepath, input.args, { cwd: input.cwd, extendEnv: true, stdin: "ignore" }));
+      const stderrFiber = yield* collectStream(handle.stderr, ERROR_BYTES).pipe(Effect.map((output) => output.buffer.toString("utf8")), Effect.forkScoped);
+      let observed = 0;
+      const rows = yield* Stream.decodeText(handle.stdout).pipe(Stream.splitLines, Stream.filter((line) => line.length > 0), Stream.mapEffect(input.parse), Stream.filter((row) => row !== undefined), Stream.tap((row) => {
+        if (!input.onItem || observed++ >= input.limit)
+          return Effect.void;
+        return input.onItem(row);
+      }), Stream.take(input.limit + 1), Stream.runCollect, Effect.map((chunk) => [...chunk]));
+      const truncated = rows.length > input.limit;
+      if (truncated)
+        return { items: rows.slice(0, input.limit), truncated, partial: false };
+      const code = yield* handle.exitCode;
+      const stderr = yield* Fiber.join(stderrFiber);
+      if (input.pattern && code === 2 && isInvalidPattern(stderr)) {
+        return yield* new InvalidPatternError({ pattern: input.pattern, message: stderr.trim() });
+      }
+      if (code !== 0 && code !== 1 && code !== 2) {
+        return yield* failure(stderr.trim() || `ripgrep failed with code ${code}`);
+      }
+      return { items: code === 1 ? [] : rows, truncated: false, partial: code === 2 };
+    }));
+    const abortable = input.signal ? program.pipe(Effect.raceFirst(waitForAbort(input.signal))) : program;
+    return abortable.pipe(Effect.mapError((cause) => cause instanceof Error || cause instanceof InvalidPatternError ? cause : failure("ripgrep execution failed", cause)));
+  };
+  return Service.of({
+    glob: (input) => run({
+      cwd: input.cwd,
+      limit: input.limit,
+      signal: input.signal,
+      args: [
+        "--no-config",
+        "--files",
+        ...input.hidden ? ["--hidden"] : [],
+        ...input.follow ? ["--follow"] : [],
+        `--glob=${input.pattern}`,
+        "--glob=!**/.git/**",
+        "."
+      ],
+      parse: (line) => Effect.succeed(line.replace(/^(?:\.[\\/])+/u, "").replace(/^[\\/]+/u, "").replaceAll("\\", "/"))
+    }).pipe(Effect.map((result) => result.items.map((relative) => Entry.make({
+      path: RelativePath.make(relative),
+      type: "file"
+    }))), Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
+    find: (input) => run({
+      cwd: input.cwd,
+      limit: input.limit,
+      signal: input.signal,
+      args: [
+        "--no-config",
+        "--files",
+        ...input.hidden ? ["--hidden"] : [],
+        ...input.follow ? ["--follow"] : [],
+        ...input.pattern === "*" ? [] : [`--glob=${input.pattern}`],
+        ...(input.exclude ?? []).map((pattern) => `--glob=!${pattern}`),
+        "--glob=!**/.git/**",
+        "."
+      ],
+      parse: (line) => {
+        const relative = line.replace(/^(?:\.[\\/])+/u, "").replace(/^[\\/]+/u, "").replaceAll("\\", "/");
+        return Effect.succeed(Entry.make({
+          path: RelativePath.make(relative),
+          type: "file"
+        }));
+      },
+      onItem: input.onEntry
+    }).pipe(Effect.map((result) => result.items), Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
+    grep: (input) => run({
+      ...input,
+      args: [
+        "--no-config",
+        "--json",
+        "--hidden",
+        "--no-messages",
+        ...input.include ? [`--glob=${input.include}`] : [],
+        "--glob=!**/.git/**",
+        "--",
+        input.pattern,
+        input.file ?? "."
+      ],
+      parse: (line) => decodeJsonRecord(line).pipe(Effect.mapError((cause) => failure("Invalid ripgrep JSON output", cause)), Effect.flatMap((json) => {
+        if (!json || typeof json !== "object" || !("type" in json) || json.type !== "match")
+          return Effect.succeed(undefined);
+        return Schema.decodeUnknownEffect(RawMatch)(json).pipe(Effect.map((match) => ({
+          ...match.data,
+          path: { text: match.data.path.text.replace(/^\.[\\/]/, "") },
+          submatches: match.data.submatches.slice(0, MAX_SUBMATCHES)
+        })), Effect.mapError((cause) => failure("Invalid ripgrep match output", cause)));
+      }))
+    }).pipe(Effect.map((result) => result.items.map((match) => {
+      const relative = match.path.text.replace(/^(?:\.[\\/])+/u, "").replace(/^[\\/]+/u, "").replaceAll("\\", "/");
+      return Match.make({
+        entry: Entry.make({
+          path: RelativePath.make(relative),
+          type: "file"
+        }),
+        line: match.line_number,
+        offset: match.absolute_offset,
+        text: match.lines.text.length > 2000 ? match.lines.text.slice(0, 2000) + "..." : match.lines.text,
+        submatches: match.submatches.map((submatch) => ({
+          text: submatch.match.text,
+          start: submatch.start,
+          end: submatch.end
+        }))
+      });
+    })))
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node, RipgrepBinary.node] });
+
+export { Error, InvalidPatternError, Service, node, exports_ripgrep };

package/dist/chunks/location-mutation-apjvmrx3.js

@@ -0,0 +1,222 @@
+import {
+  exports_mcp
+} from "./location-mutation-ztvvzzvv.js";
+import {
+  exports_select
+} from "./location-mutation-04kwjb53.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_state
+} from "./location-mutation-wt193r4g.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/command.ts
+var exports_command = {};
+__export(exports_command, {
+  node: () => node,
+  layer: () => layer,
+  configured: () => configured,
+  Service: () => Service,
+  NotFoundError: () => NotFoundError,
+  Info: () => Info,
+  Event: () => Event,
+  EvaluationError: () => EvaluationError,
+  Command: () => exports_command
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Command } from "@opencode-ai/schema/command";
+import { AppProcess } from "@opencode-ai/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { Global } from "@opencode-ai/util/global";
+import { Event } from "@opencode-ai/schema/command";
+var Info = Command.Info;
+
+class NotFoundError extends Schema.TaggedErrorClass()("Command.NotFoundError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class EvaluationError extends Schema.TaggedErrorClass()("Command.EvaluationError", {
+  command: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Command") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const mcp = yield* exports_mcp.Service;
+  const bus = yield* exports_bus.Service;
+  const processes = yield* AppProcess.Service;
+  const config = yield* exports_config.Service;
+  const location = yield* exports_location.Service;
+  const global = yield* Global.Service;
+  const state = exports_state.create({
+    name: "command",
+    initial: () => ({ commands: new Map }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.commands.values()),
+      get: (name) => draft.commands.get(name),
+      update: (name, update) => {
+        const current = draft.commands.get(name) ?? { name, template: "" };
+        if (!draft.commands.has(name))
+          draft.commands.set(name, current);
+        update(current);
+        current.name = name;
+      },
+      remove: (name) => {
+        draft.commands.delete(name);
+      }
+    }),
+    finalize: () => bus.publish(Command.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const staticCommand = (name) => state.get().commands.get(name);
+  const mcpCommands = Effect.fnUntraced(function* () {
+    return (yield* mcp.prompts()).map((prompt) => Info.make({
+      name: mcpCommandName(prompt.server, prompt.name),
+      template: "",
+      description: prompt.description
+    }));
+  });
+  return Service.of({
+    reload: state.reload,
+    transform: state.transform,
+    get: Effect.fn("Command.get")(function* (name) {
+      const command = staticCommand(name);
+      if (command)
+        return command;
+      return (yield* mcpCommands()).find((command2) => command2.name === name);
+    }),
+    list: Effect.fn("Command.list")(function* () {
+      const commands = Array.from(state.get().commands.values());
+      const names = new Set(commands.map((command) => command.name));
+      return [...commands, ...(yield* mcpCommands()).filter((command) => !names.has(command.name))];
+    }),
+    evaluate: Effect.fn("Command.evaluate")(function* (input) {
+      const command = staticCommand(input.name);
+      if (command)
+        return yield* evaluateTemplate(input.name, command.template, input.arguments ?? "", {
+          config,
+          location,
+          processes,
+          shell: options,
+          bin: global.bin
+        });
+      const prompt = (yield* mcp.prompts()).find((prompt2) => mcpCommandName(prompt2.server, prompt2.name) === input.name);
+      if (!prompt)
+        return yield* new NotFoundError({ command: input.name, message: `Command not found: ${input.name}` });
+      const result = yield* mcp.prompt({
+        server: prompt.server,
+        name: prompt.name,
+        args: Object.fromEntries((prompt.arguments ?? []).map((argument, index) => [
+          argument.name,
+          parseArguments(input.arguments ?? "")[index] ?? ""
+        ]))
+      }).pipe(Effect.catchTag("MCP.NotFoundError", () => Effect.fail(new EvaluationError({
+        command: input.name,
+        message: `MCP server could not be found while evaluating prompt: ${prompt.server}`
+      }))));
+      if (!result)
+        return yield* new EvaluationError({
+          command: input.name,
+          message: `MCP prompt could not be evaluated: ${prompt.server}:${prompt.name}`
+        });
+      return {
+        text: result.messages.map((message) => promptMessageText(message.content)).join(`
+`).trim()
+      };
+    })
+  });
+}));
+function evaluateTemplate(command, template, input, services) {
+  return Effect.gen(function* () {
+    const expanded = evaluateArguments(template, input);
+    return { text: yield* evaluateShell(command, expanded, services) };
+  });
+}
+function evaluateArguments(template, input) {
+  const args = parseArguments(input);
+  const placeholders = template.match(placeholderRegex) ?? [];
+  const last = Math.max(0, ...placeholders.map((item) => Number(item.slice(1))));
+  const expanded = template.replaceAll(placeholderRegex, (_, index) => {
+    const position = Number(index);
+    const argIndex = position - 1;
+    if (argIndex >= args.length)
+      return "";
+    if (position === last)
+      return args.slice(argIndex).join(" ");
+    return args[argIndex];
+  });
+  const withArguments = expanded.replaceAll("$ARGUMENTS", input);
+  if (placeholders.length === 0 && !template.includes("$ARGUMENTS") && input.trim())
+    return `${withArguments}
+
+${input}`.trim();
+  return withArguments.trim();
+}
+var evaluateShell = Effect.fnUntraced(function* (command, text, services) {
+  const matches = Array.from(text.matchAll(shellRegex));
+  if (matches.length === 0)
+    return text;
+  const shell = exports_select.preferred(exports_config.latest(yield* services.config.entries(), "shell"), services.shell, services.bin);
+  const outputs = yield* Effect.forEach(matches, (match) => {
+    const source = match[1] ?? "";
+    return services.processes.run(ChildProcess.make(shell, exports_select.args(shell, source), {
+      cwd: services.location.directory,
+      stdin: "ignore"
+    }), {
+      combineOutput: true
+    }).pipe(Effect.map((result) => (result.output ?? Buffer.concat([result.stdout, result.stderr])).toString("utf8")), Effect.mapError((error) => new EvaluationError({
+      command,
+      message: `Shell interpolation failed for ${JSON.stringify(source)}: ${error.message}`
+    })));
+  }, { concurrency: 2 });
+  const iterator = outputs[Symbol.iterator]();
+  return text.replace(shellRegex, () => iterator.next().value ?? "");
+});
+function parseArguments(input) {
+  return (input.match(argsRegex) ?? []).map((arg) => arg.replace(quoteTrimRegex, ""));
+}
+function promptMessageText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!content || typeof content !== "object")
+    return "";
+  if (!("type" in content) || content.type !== "text")
+    return "";
+  if (!("text" in content) || typeof content.text !== "string")
+    return "";
+  return content.text;
+}
+function mcpCommandName(server, prompt) {
+  return `${sanitize(server)}:${sanitize(prompt)}`;
+}
+function sanitize(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+var argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
+var placeholderRegex = /\$(\d+)/g;
+var quoteTrimRegex = /^["']|["']$/g;
+var shellRegex = /!`([^`]+)`/g;
+function configured(options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [exports_mcp.node, exports_bus.node, AppProcess.node, exports_config.node, exports_location.node, Global.node]
+  });
+}
+var node = configured();
+
+export { Info, NotFoundError, EvaluationError, Service, layer, configured, node, exports_command, Event };

package/dist/chunks/location-mutation-aq94a2hd.js

@@ -0,0 +1,116 @@
+import {
+  exports_environment1 as exports_environment
+} from "./location-mutation-pysc8t9c.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/mcp/stdio.ts
+var exports_stdio = {};
+__export(exports_stdio, {
+  make: () => make,
+  MCPStdio: () => exports_stdio
+});
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
+import { Cause, Duration, Effect, Queue, Scope, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+var CLOSE_GRACE = Duration.seconds(2);
+var FORCE_KILL_AFTER = Duration.seconds(2);
+var OUTGOING_CAPACITY = 64;
+var MAX_FRAME_BYTES = 16 * 1024 * 1024;
+var make = Effect.fnUntraced(function* (options) {
+  const environment = yield* exports_environment.Service;
+  const scope = yield* Effect.scope;
+  const outgoing = yield* Queue.bounded(OUTGOING_CAPACITY);
+  const buffer = new ReadBuffer;
+  const state = { phase: "ready" };
+  let startup;
+  let closing;
+  let trailingBytes = 0;
+  const stop = (handle) => Effect.gen(function* () {
+    const exit = yield* Effect.timeoutOption(handle.exitCode, CLOSE_GRACE);
+    if (exit._tag === "Some")
+      return;
+    const terminated = yield* Effect.timeoutOption(handle.kill({ killSignal: "SIGTERM" }), FORCE_KILL_AFTER);
+    if (terminated._tag === "None")
+      yield* handle.kill({ killSignal: "SIGKILL" });
+  }).pipe(Effect.ignore);
+  const close = () => closing ??= Effect.runPromise(Effect.gen(function* () {
+    state.phase = "closed";
+    Queue.endUnsafe(outgoing);
+    if (startup)
+      yield* Effect.promise(() => startup.catch(() => {
+        return;
+      }));
+    const handle = state.handle;
+    if (!handle)
+      return;
+    state.handle = undefined;
+    yield* stop(handle);
+  }).pipe(Effect.ensuring(Queue.shutdown(outgoing)), Effect.ensuring(Effect.sync(() => buffer.clear()))));
+  const transport = {
+    start: () => {
+      if (state.phase !== "ready")
+        return Promise.reject(new Error("Stdio transport already started"));
+      state.phase = "starting";
+      startup = Effect.runPromise(Effect.gen(function* () {
+        const handle = yield* environment.spawner.spawn(ChildProcess.make(options.command, [...options.args], {
+          cwd: options.cwd,
+          env: options.environment,
+          extendEnv: true,
+          stdin: { stream: Stream.encodeText(Stream.fromQueue(outgoing)), endOnDone: true },
+          stdout: "pipe",
+          stderr: "pipe",
+          forceKillAfter: FORCE_KILL_AFTER
+        }));
+        state.handle = handle;
+        if (state.phase === "closed") {
+          state.handle = undefined;
+          return yield* stop(handle);
+        }
+        state.phase = "open";
+        yield* startOutput(handle);
+      }).pipe(Scope.provide(scope)));
+      return startup;
+    },
+    send: (message) => state.phase !== "open" ? Promise.reject(new Error("Not connected")) : Effect.runPromise(Queue.offer(outgoing, serializeMessage(message)).pipe(Effect.flatMap((offered) => offered ? Effect.void : Effect.fail(new Error("Not connected"))))),
+    close
+  };
+  const deliver = (chunk) => Effect.gen(function* () {
+    for (const byte of chunk) {
+      trailingBytes = byte === 10 ? 0 : trailingBytes + 1;
+      if (trailingBytes > MAX_FRAME_BYTES)
+        return yield* Effect.fail(new Error("MCP stdio frame exceeded 16 MiB"));
+    }
+    buffer.append(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+    while (true) {
+      const message = yield* Effect.try({
+        try: () => buffer.readMessage(),
+        catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
+      }).pipe(Effect.catch((error) => Effect.sync(() => {
+        transport.onerror?.(error);
+        return;
+      })));
+      if (message === undefined)
+        continue;
+      if (message === null)
+        return;
+      transport.onmessage?.(message);
+    }
+  });
+  const startOutput = (handle) => Effect.gen(function* () {
+    yield* Effect.forkScoped(Stream.runForEach(handle.stdout, deliver).pipe(Effect.tapCause((cause) => Effect.sync(() => {
+      const error = Cause.squash(cause);
+      transport.onerror?.(error instanceof Error ? error : new Error(String(error)));
+    })), Effect.ignore, Effect.ensuring(Effect.gen(function* () {
+      const unexpected = state.phase !== "closed";
+      if (unexpected)
+        yield* Effect.promise(close);
+      transport.onclose?.();
+    }))));
+    yield* Effect.forkScoped(handle.stderr.pipe(Stream.decodeText(), Stream.runForEach((output) => output.trim() === "" ? Effect.void : Effect.logDebug("mcp server stderr", { server: options.server, output })), Effect.ignore));
+  });
+  return transport;
+});
+
+export { make, exports_stdio };

package/dist/chunks/location-mutation-ayevdmef.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/location-mutation-ayfwnm78.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./location-mutation-0zz82cjq.js";
+import {
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/provider/groq.ts
+var GroqPlugin = createProviderPlugin({
+  id: "opencode.provider.groq",
+  package: "@ai-sdk/groq",
+  load: async (options) => {
+    const { createGroq } = await import("@ai-sdk/groq");
+    return createGroq(options);
+  }
+});
+
+export { GroqPlugin };