@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-wt193r4g.js

@@ -0,0 +1,130 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/state.ts
+var exports_state = {};
+__export(exports_state, {
+  inherit: () => inherit,
+  create: () => create,
+  batch: () => batch,
+  State: () => exports_state
+});
+import { Clock, Context, Deferred, Effect, Scope, Semaphore } from "effect";
+var CurrentBatch = Context.Reference("@opencode/State/CurrentBatch", {
+  defaultValue: () => {
+    return;
+  }
+});
+var reloadDebounce = 500;
+function batch(effect) {
+  return Effect.gen(function* () {
+    const current = yield* CurrentBatch;
+    if (current?.active)
+      return yield* effect;
+    const batch2 = { active: true, reloads: new Set };
+    const exit = yield* effect.pipe(Effect.provideService(CurrentBatch, batch2), Effect.exit);
+    batch2.active = false;
+    yield* Effect.forEach(batch2.reloads, (reload) => reload(), { discard: true });
+    return yield* exit;
+  });
+}
+var inherit = Effect.fnUntraced(function* () {
+  const batch2 = yield* CurrentBatch;
+  return (effect) => Effect.provideService(effect, CurrentBatch, batch2);
+});
+function create(options) {
+  let state = options.initial();
+  let transforms = [];
+  let generation = 0;
+  let requestedAt = 0;
+  let running = false;
+  let waiters = [];
+  const semaphore = Semaphore.makeUnsafe(1);
+  const commit = Effect.fn("State.commit")(function* (next) {
+    state = next;
+    if (options.finalize)
+      yield* options.finalize(options.draft(next));
+  });
+  const apply = (transform, draft) => Effect.sync(() => {
+    transform(draft);
+  });
+  const materialize = Effect.fnUntraced(function* () {
+    const next = options.initial();
+    const api = options.draft(next);
+    for (const transform of transforms)
+      yield* apply(transform.run, api).pipe(Effect.withSpan("State.reload.update", { attributes: { state: options.name ?? "anonymous" } }));
+    yield* commit(next);
+  });
+  const materializeReload = () => semaphore.withPermit(materialize());
+  const rebuild = () => Effect.gen(function* () {
+    const clock = yield* Clock.Clock;
+    const remaining = requestedAt + reloadDebounce - clock.currentTimeMillisUnsafe();
+    if (remaining > 0)
+      yield* Effect.sleep(remaining);
+    if (clock.currentTimeMillisUnsafe() < requestedAt + reloadDebounce)
+      return yield* rebuild();
+    const target = generation;
+    const exit = yield* materializeReload().pipe(Effect.exit);
+    const completed = waiters.filter((waiter) => waiter.generation <= target);
+    waiters = waiters.filter((waiter) => waiter.generation > target);
+    yield* Effect.forEach(completed, (waiter) => Deferred.done(waiter.done, exit), {
+      concurrency: "unbounded",
+      discard: true
+    });
+    if (generation > target)
+      return yield* rebuild();
+    running = false;
+  });
+  const reload = Effect.fnUntraced(function* () {
+    const done = Deferred.makeUnsafe();
+    const clock = yield* Clock.Clock;
+    generation++;
+    requestedAt = clock.currentTimeMillisUnsafe();
+    waiters.push({ generation, done });
+    if (!running) {
+      running = true;
+      yield* rebuild().pipe(Effect.forkDetach);
+    }
+    return yield* Deferred.await(done);
+  });
+  const result = {
+    get: () => state,
+    transform: Effect.fn("State.transform")(function* (update) {
+      yield* Effect.annotateCurrentSpan("state", options.name ?? "anonymous");
+      const scope = yield* Scope.Scope;
+      return yield* Effect.uninterruptible(Effect.gen(function* () {
+        const transform = { run: update };
+        let active = true;
+        const dispose = Effect.uninterruptible(semaphore.withPermit(Effect.suspend(() => {
+          if (!active)
+            return Effect.void;
+          active = false;
+          transforms = transforms.filter((item) => item !== transform);
+          return Effect.gen(function* () {
+            const batch3 = yield* CurrentBatch;
+            if (batch3?.active) {
+              batch3.reloads.add(materializeReload);
+              return;
+            }
+            yield* materialize();
+          });
+        })));
+        yield* semaphore.withPermit(Effect.sync(() => {
+          transforms = [...transforms, transform];
+        }));
+        yield* Scope.addFinalizer(scope, dispose);
+        const batch2 = yield* CurrentBatch;
+        if (batch2?.active)
+          batch2.reloads.add(materializeReload);
+        else
+          yield* materializeReload();
+        return { dispose };
+      }));
+    }),
+    reload
+  };
+  return result;
+}
+
+export { batch, inherit, create, exports_state };

package/dist/chunks/permission-wvha5myg.js

@@ -0,0 +1,178 @@
+import {
+  RipgrepBinary
+} from "./permission-h8ecejt5.js";
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  NonNegativeInt,
+  PositiveInt,
+  RelativePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-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/permission-wwdwn09j.js

@@ -0,0 +1,41 @@
+import {
+  EffectSQLiteSession
+} from "./permission-s7jy4mh3.js";
+import {
+  SQLiteEffectDatabase
+} from "./permission-4zfy2va0.js";
+import {
+  jitCompatCheck
+} from "./permission-ma07p6tt.js";
+
+// src/database/drizzle/effect-sqlite/driver.ts
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { EffectCache } from "drizzle-orm/cache/core/cache-effect";
+import { EffectLogger } from "drizzle-orm/effect-core";
+import { entityKind } from "drizzle-orm/entity";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core/dialect";
+class EffectSQLiteDatabase extends SQLiteEffectDatabase {
+  static [entityKind] = "EffectSQLiteDatabase";
+}
+var DefaultServices = Layer.merge(EffectCache.Default, EffectLogger.Default);
+var make = Effect.fn("SQLiteDrizzle.make")(function* (config = {}) {
+  const client = yield* SqlClient;
+  const cache = yield* EffectCache;
+  const logger = yield* EffectLogger;
+  const dialect = new SQLiteAsyncDialect;
+  const relations = config.relations ?? {};
+  const session = new EffectSQLiteSession(client, dialect, relations, {
+    logger,
+    cache,
+    useJitMappers: jitCompatCheck(config.jit)
+  });
+  const db = new EffectSQLiteDatabase(dialect, session, relations);
+  db.$client = client;
+  db.$cache.invalidate = cache.onMutate;
+  return db;
+});
+var makeWithDefaults = (config = {}) => make(config).pipe(Effect.provide(DefaultServices));
+
+export { EffectSQLiteDatabase, DefaultServices, make, makeWithDefaults };

package/dist/chunks/permission-wwntjmk1.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260211171708_add_project_commands.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260211171708_add_project_commands",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`project\` ADD \`commands\` text;`);
+    });
+  }
+};
+var _20260211171708_add_project_commands_default = migration;
+
+export { _20260211171708_add_project_commands_default };

package/dist/chunks/permission-wx89ywv3.js

@@ -0,0 +1,104 @@
+// src/database/migration/20260805200742_import_legacy_credentials.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { sql } from "drizzle-orm";
+import { Effect, Option, Schema } from "effect";
+import { Credential } from "@opencode-ai/schema/credential";
+import { Integration } from "@opencode-ai/schema/integration";
+import { NonNegativeInt } from "@opencode-ai/schema/schema";
+import { Global } from "@opencode-ai/util/global";
+var LegacyOAuth = Schema.Struct({
+  type: Schema.Literal("oauth"),
+  refresh: Schema.String,
+  access: Schema.String,
+  expires: NonNegativeInt,
+  accountId: Schema.optional(Schema.String),
+  enterpriseUrl: Schema.optional(Schema.String)
+});
+var LegacyKey = Schema.Struct({
+  type: Schema.Literal("api"),
+  key: Schema.String,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String))
+});
+var LegacyWellKnown = Schema.Struct({
+  type: Schema.Literal("wellknown"),
+  key: Schema.String,
+  token: Schema.String
+});
+var LegacyValue = Schema.Union([LegacyOAuth, LegacyKey, LegacyWellKnown]);
+var decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString);
+var decodeValue = Schema.decodeUnknownOption(LegacyValue);
+var wellKnownSourcesKey = "wellknown:sources";
+var migration = {
+  id: "20260805200742_import_legacy_credentials",
+  up(tx) {
+    return Effect.gen(function* () {
+      const global = yield* Global.Service;
+      return yield* importLegacyCredentials(tx, path.join(global.data, "auth.json"));
+    });
+  }
+};
+var _20260805200742_import_legacy_credentials_default = migration;
+function importLegacyCredentials(tx, filepath) {
+  return Effect.gen(function* () {
+    const content = yield* Effect.promise(() => readFile(filepath, "utf8").catch(() => {
+      return;
+    }));
+    if (content === undefined)
+      return;
+    const input = Option.getOrUndefined(decodeJson(content));
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return yield* Effect.fail(new Error("Legacy credential file must contain an object"));
+    }
+    const origins = [];
+    for (const [id, raw] of Object.entries(input)) {
+      const value2 = Option.getOrUndefined(decodeValue(raw));
+      if (!value2)
+        continue;
+      const integrationID = id.replace(/\/+$/, "");
+      if (!integrationID)
+        continue;
+      if (value2.type === "wellknown")
+        origins.push(integrationID);
+      if (yield* tx.get(sql`SELECT id FROM credential WHERE integration_id = ${integrationID}`))
+        continue;
+      const credential = value2.type === "api" ? Credential.Key.make({ type: "key", key: value2.key, metadata: value2.metadata }) : value2.type === "wellknown" ? Credential.Key.make({ type: "key", key: value2.token }) : Credential.OAuth.make({
+        type: "oauth",
+        methodID: Integration.MethodID.make(methodID(integrationID)),
+        refresh: value2.refresh,
+        access: value2.access,
+        expires: value2.expires,
+        metadata: value2.accountId || value2.enterpriseUrl ? {
+          ...value2.accountId ? { accountID: value2.accountId } : {},
+          ...value2.enterpriseUrl ? { enterpriseUrl: value2.enterpriseUrl } : {}
+        } : undefined
+      });
+      const now2 = Date.now();
+      yield* tx.run(sql`
+        INSERT INTO credential (id, integration_id, label, value, time_created, time_updated)
+        VALUES (${Credential.ID.create()}, ${integrationID}, 'default', ${JSON.stringify(credential)}, ${now2}, ${now2})
+      `);
+    }
+    if (!origins.length)
+      return;
+    const stored = yield* tx.get(sql`SELECT value FROM kv WHERE key = ${wellKnownSourcesKey}`);
+    const decoded = stored ? Option.getOrUndefined(decodeJson(stored.value)) : undefined;
+    const current = Array.isArray(decoded) ? decoded.filter((item) => typeof item === "string") : [];
+    const value = JSON.stringify(Array.from(new Set([...current, ...origins])));
+    const now = Date.now();
+    yield* tx.run(sql`
+      INSERT INTO kv (key, value, time_created, time_updated)
+      VALUES (${wellKnownSourcesKey}, ${value}, ${now}, ${now})
+      ON CONFLICT (key) DO UPDATE SET value = excluded.value, time_updated = excluded.time_updated
+    `);
+  });
+}
+function methodID(integrationID) {
+  if (integrationID === "openai")
+    return "chatgpt-browser";
+  if (["github-copilot", "opencode", "xai"].includes(integrationID))
+    return "device";
+  return "oauth";
+}
+
+export { importLegacyCredentials, _20260805200742_import_legacy_credentials_default };

package/dist/chunks/permission-wyqjaaa5.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260603001617_session_message_projection_indexes.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260603001617_session_message_projection_indexes",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_type_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`event_aggregate_seq_idx\` ON \`event\` (\`aggregate_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_time_created_id_idx\` ON \`session_message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_time_created_id_idx\` ON \`session_message\` (\`session_id\`,\`type\`,\`time_created\`,\`id\`);`);
+    });
+  }
+};
+var _20260603001617_session_message_projection_indexes_default = migration;
+
+export { _20260603001617_session_message_projection_indexes_default };

package/dist/chunks/permission-x4q807cx.js

@@ -0,0 +1,26 @@
+// src/database/migration/20260413175956_chief_energizer.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260413175956_chief_energizer",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_entry\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_entry_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE INDEX \`session_entry_session_idx\` ON \`session_entry\` (\`session_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_entry_session_type_idx\` ON \`session_entry\` (\`session_id\`,\`type\`);`);
+      yield* tx.run(`CREATE INDEX \`session_entry_time_created_idx\` ON \`session_entry\` (\`time_created\`);`);
+    });
+  }
+};
+var _20260413175956_chief_energizer_default = migration;
+
+export { _20260413175956_chief_energizer_default };