@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-ghm4673n.js

@@ -0,0 +1,27 @@
+// src/database/migration/20260611192811_lush_chimera.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260611192811_lush_chimera",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`credential_connector_active_idx\`;`);
+      yield* tx.run(`DROP TABLE \`credential\`;`);
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`integration_id\` text,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`connector_id\` text,
+          \`method_id\` text,
+          \`active\` integer,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260611192811_lush_chimera_default = migration;
+
+export { _20260611192811_lush_chimera_default };

package/dist/chunks/ripgrep-ghwjy7my.js

@@ -0,0 +1,41 @@
+// src/database/migration/20260604172448_event_sourced_session_input.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260604172448_event_sourced_session_input",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL;`);
+      yield* tx.run(`DELETE FROM \`workspace\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`event_aggregate_seq_idx\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`event_aggregate_seq_idx\` ON \`event\` (\`aggregate_id\`,\`seq\`);`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_seq_idx\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`PRAGMA foreign_keys=OFF;`);
+      yield* tx.run(`
+        CREATE TABLE \`__new_session_input\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`prompt\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`admitted_seq\` integer NOT NULL,
+          \`promoted_seq\` integer,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_input_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`DROP TABLE \`session_input\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_session_input\` RENAME TO \`session_input\`;`);
+      yield* tx.run(`PRAGMA foreign_keys=ON;`);
+      yield* tx.run(`CREATE INDEX \`session_input_session_pending_delivery_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`,\`delivery\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_input_session_admitted_seq_idx\` ON \`session_input\` (\`session_id\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_input_session_promoted_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`);`);
+    });
+  }
+};
+var _20260604172448_event_sourced_session_input_default = migration;
+
+export { _20260604172448_event_sourced_session_input_default };

package/dist/chunks/ripgrep-gpee7ppy.js

@@ -0,0 +1,254 @@
+import {
+  exports_id
+} from "./ripgrep-tcn24h1d.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/job.ts
+var exports_job = {};
+__export(exports_job, {
+  node: () => node,
+  make: () => make,
+  Service: () => Service,
+  Job: () => exports_job
+});
+import { Cause, Clock, Context, Deferred, Effect, Exit, Layer, Scope, SynchronizedRef } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/Job") {
+}
+function snapshot(job) {
+  return {
+    ...job.info,
+    ...job.info.metadata ? { metadata: { ...job.info.metadata } } : {}
+  };
+}
+function errorText(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+function incrementSession(input, sessionID) {
+  return new Map(input).set(sessionID, (input.get(sessionID) ?? 0) + 1);
+}
+function decrementSession(input, sessionID) {
+  const count = input.get(sessionID);
+  if (count === undefined)
+    return input;
+  const next = new Map(input);
+  if (count <= 1)
+    next.delete(sessionID);
+  else
+    next.set(sessionID, count - 1);
+  return next;
+}
+var make = Effect.gen(function* () {
+  const state = {
+    jobs: yield* SynchronizedRef.make(new Map),
+    scope: yield* Scope.Scope
+  };
+  const settle = Effect.fn("Job.settle")(function* (id, token, exit) {
+    const completed_at = yield* Clock.currentTimeMillis;
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(id);
+      if (!job)
+        return [{}, jobs];
+      if (job.token !== token)
+        return [{}, jobs];
+      if (job.info.status !== "running")
+        return [{ info: snapshot(job) }, jobs];
+      const status = Exit.isSuccess(exit) ? "completed" : Cause.hasInterruptsOnly(exit.cause) ? "cancelled" : "error";
+      const next = {
+        ...job,
+        blockingSessions: new Map,
+        info: {
+          ...job.info,
+          status,
+          completed_at,
+          ...Exit.isSuccess(exit) ? { output: exit.value } : {},
+          ...Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}
+        }
+      };
+      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)];
+    });
+    if (result.info && result.done)
+      yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore);
+    if (result.scope) {
+      yield* Scope.close(result.scope, Exit.void).pipe(Effect.forkIn(state.scope, { startImmediately: true }));
+    }
+    return result.info;
+  });
+  const fork = Effect.fn("Job.fork")(function* (scope, id, token, run) {
+    return yield* run.pipe(Effect.matchCauseEffect({
+      onSuccess: (output) => settle(id, token, Exit.succeed(output)),
+      onFailure: (cause) => settle(id, token, Exit.failCause(cause))
+    }), Effect.asVoid, Effect.forkIn(scope, { startImmediately: true }));
+  });
+  const get = Effect.fn("Job.get")(function* (id) {
+    const job = (yield* SynchronizedRef.get(state.jobs)).get(id);
+    if (!job)
+      return;
+    return snapshot(job);
+  });
+  const start = Effect.fn("Job.start")(function* (input) {
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const id = input.id ?? exports_id.ascending("job");
+      const started_at = yield* Clock.currentTimeMillis;
+      const done = yield* Deferred.make();
+      const backgrounded = yield* Deferred.make();
+      const result = yield* SynchronizedRef.modifyEffect(state.jobs, Effect.fnUntraced(function* (jobs) {
+        const existing = jobs.get(id);
+        if (existing?.info.status === "running") {
+          return [{ info: snapshot(existing) }, jobs];
+        }
+        const scope = yield* Scope.fork(state.scope, "parallel");
+        const token = {};
+        const job = {
+          info: {
+            id,
+            type: input.type,
+            title: input.title,
+            status: "running",
+            started_at,
+            metadata: input.metadata
+          },
+          done,
+          backgrounded,
+          scope,
+          token,
+          blockingSessions: new Map,
+          isBackgrounded: false
+        };
+        return [{ info: snapshot(job), scope, token }, new Map(jobs).set(id, job)];
+      }));
+      if ("scope" in result)
+        yield* fork(result.scope, id, result.token, restore(input.run));
+      return result.info;
+    }));
+  });
+  const wait = Effect.fn("Job.wait")(function* (input) {
+    const job = (yield* SynchronizedRef.get(state.jobs)).get(input.id);
+    if (!job)
+      return { timedOut: false };
+    if (job.info.status !== "running")
+      return { info: snapshot(job), timedOut: false };
+    if (input.timeout === undefined)
+      return { info: yield* Deferred.await(job.done), timedOut: false };
+    if (input.timeout <= 0)
+      return { info: snapshot(job), timedOut: true };
+    const info = yield* Deferred.await(job.done).pipe(Effect.timeoutOption(input.timeout));
+    if (info._tag === "Some")
+      return { info: info.value, timedOut: false };
+    return { info: snapshot(job), timedOut: true };
+  });
+  const removeBlock = Effect.fn("Job.removeBlock")(function* (input) {
+    yield* SynchronizedRef.update(state.jobs, (jobs) => {
+      const job = jobs.get(input.id);
+      if (!job || job.info.status !== "running" || job.isBackgrounded)
+        return jobs;
+      return new Map(jobs).set(input.id, {
+        ...job,
+        blockingSessions: decrementSession(job.blockingSessions, input.sessionID)
+      });
+    });
+  });
+  const block = Effect.fn("Job.block")(function* (input) {
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(input.id);
+      if (!job)
+        return [{ type: "missing" }, jobs];
+      if (job.info.status !== "running")
+        return [{ type: "finished", info: snapshot(job) }, jobs];
+      if (job.isBackgrounded)
+        return [{ type: "backgrounded", info: snapshot(job) }, jobs];
+      return [
+        { type: "wait", wait: { done: job.done, backgrounded: job.backgrounded } },
+        new Map(jobs).set(input.id, {
+          ...job,
+          blockingSessions: incrementSession(job.blockingSessions, input.sessionID)
+        })
+      ];
+    });
+    if (result.type === "missing")
+      return;
+    if (result.type === "finished")
+      return { type: "finished", info: result.info };
+    if (result.type === "backgrounded")
+      return { type: "backgrounded", info: result.info };
+    return yield* Effect.raceFirst(Deferred.await(result.wait.done).pipe(Effect.map((info) => ({ type: "finished", info }))), Deferred.await(result.wait.backgrounded).pipe(Effect.map((info) => ({ type: "backgrounded", info })))).pipe(Effect.ensuring(removeBlock(input)));
+  });
+  const background = Effect.fn("Job.background")(function* (id) {
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(id);
+      if (!job || job.info.status !== "running")
+        return [{}, jobs];
+      if (job.isBackgrounded)
+        return [{ info: snapshot(job) }, jobs];
+      const next = {
+        ...job,
+        isBackgrounded: true,
+        blockingSessions: new Map
+      };
+      return [{ info: snapshot(next), backgrounded: job.backgrounded }, new Map(jobs).set(id, next)];
+    });
+    if (result.info && result.backgrounded)
+      yield* Deferred.succeed(result.backgrounded, result.info).pipe(Effect.ignore);
+    return result.info;
+  });
+  const backgroundAll = Effect.fn("Job.backgroundAll")(function* (input) {
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const results = [];
+      const next = new Map(jobs);
+      for (const [id, job] of jobs) {
+        if (job.info.status !== "running")
+          continue;
+        if (job.isBackgrounded)
+          continue;
+        if (input.type !== undefined && job.info.type !== input.type)
+          continue;
+        if (!job.blockingSessions.has(input.sessionID))
+          continue;
+        const updated = {
+          ...job,
+          isBackgrounded: true,
+          blockingSessions: new Map
+        };
+        results.push({ info: snapshot(updated), backgrounded: job.backgrounded });
+        next.set(id, updated);
+      }
+      return [results, next];
+    });
+    yield* Effect.forEach(result, (item) => item.info && item.backgrounded ? Deferred.succeed(item.backgrounded, item.info) : Effect.void, { discard: true });
+    return result.flatMap((item) => item.info ? [item.info] : []);
+  });
+  const cancel = Effect.fn("Job.cancel")(function* (id) {
+    const completed_at = yield* Clock.currentTimeMillis;
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(id);
+      if (!job)
+        return [{}, jobs];
+      if (job.info.status !== "running")
+        return [{ info: snapshot(job) }, jobs];
+      const next = {
+        ...job,
+        blockingSessions: new Map,
+        info: {
+          ...job.info,
+          status: "cancelled",
+          completed_at
+        }
+      };
+      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)];
+    });
+    if (result.info && result.done)
+      yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore);
+    if (result.scope)
+      yield* Scope.close(result.scope, Exit.void);
+    return result.info;
+  });
+  return Service.of({ get, start, wait, block, background, backgroundAll, cancel });
+});
+var layer = Layer.effect(Service, make);
+var node = makeGlobalNode({ service: Service, layer, deps: [] });
+
+export { Service, make, node, exports_job };

package/dist/chunks/ripgrep-gy500k2r.js

@@ -0,0 +1,17 @@
+// src/github-copilot/responses/tool/web-search.ts
+import { z } from "zod/v4";
+var webSearchArgsSchema = z.object({
+  filters: z.object({
+    allowedDomains: z.array(z.string()).optional()
+  }).optional(),
+  searchContextSize: z.enum(["low", "medium", "high"]).optional(),
+  userLocation: z.object({
+    type: z.literal("approximate"),
+    country: z.string().optional(),
+    city: z.string().optional(),
+    region: z.string().optional(),
+    timezone: z.string().optional()
+  }).optional()
+});
+
+export { webSearchArgsSchema };

package/dist/chunks/ripgrep-gzsf6emb.js

@@ -0,0 +1,116 @@
+import {
+  exports_environment1 as exports_environment
+} from "./ripgrep-bfaw9j5x.js";
+import {
+  __export
+} from "./ripgrep-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/ripgrep-h1aftsxm.js

@@ -0,0 +1,22 @@
+import {
+  exports_exa
+} from "./ripgrep-tenv3kfs.js";
+import {
+  exports_parallel
+} from "./ripgrep-prf9bavk.js";
+import {
+  exports_tavily
+} from "./ripgrep-dyz5q1tb.js";
+import {
+  exports_firecrawl
+} from "./ripgrep-f05p34aa.js";
+
+// src/plugin/websearch/index.ts
+var WebSearchPlugins = [
+  exports_exa.Plugin,
+  exports_firecrawl.Plugin,
+  exports_parallel.Plugin,
+  exports_tavily.Plugin
+];
+
+export { WebSearchPlugins };