@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-5pfeh60c.js

@@ -0,0 +1,154 @@
+import {
+  Failed,
+  NotFound,
+  WrongKind
+} from "./permission-zthe9zqc.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/environment/exec-defaults.ts
+var exports_exec_defaults = {};
+__export(exports_exec_defaults, {
+  execDefaults: () => execDefaults,
+  EnvironmentExecDefaults: () => exports_exec_defaults
+});
+import { Effect, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { collectStream } from "@opencode-ai/util/process";
+var MAX_DATA_BYTES = 64 * 1024 * 1024;
+var MAX_ERROR_BYTES = 64 * 1024;
+var NOT_FOUND = 44;
+var WRONG_KIND = 45;
+var FAILED = 46;
+var TAB = "\t";
+var loadMetadata = (flags = "") => `
+metadata=$(stat ${flags} -c '%F${TAB}%s${TAB}%Y' -- "$1" 2>&1) || {
+  case "$metadata" in
+    *'No such file or directory'*|*'Not a directory'*) exit ${NOT_FOUND} ;;
+    *) printf '%s' "$metadata" >&2; exit ${FAILED} ;;
+  esac
+}
+`;
+var statScript = `
+${loadMetadata()}
+printf '%s
+' "$metadata"
+`;
+var readScript = `
+${loadMetadata("-L")}
+kind=\${metadata%%${TAB}*}
+if [ "$kind" != 'regular file' ] && [ "$kind" != 'regular empty file' ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+printf '%s
+' "$metadata"
+if [ "$2" = range ]; then
+  dd if="$1" iflag=skip_bytes,count_bytes skip="$3" count="$4" status=none
+else
+  cat -- "$1"
+fi
+`;
+var listScript = `
+${loadMetadata("-L")}
+kind=\${metadata%%${TAB}*}
+if [ "$kind" != directory ]; then
+  printf '%s' "$kind" >&2
+  exit ${WRONG_KIND}
+fi
+find -H "$1" -mindepth 1 -maxdepth 1 -printf '%y\\0%f\\0'
+`;
+var moveScript = `
+${loadMetadata()}
+mv -- "$1" "$2"
+`;
+var execDefaults = (spawner) => {
+  const run = (path, script, args = [], stdin) => Effect.scoped(Effect.gen(function* () {
+    const command = ChildProcess.make("sh", ["-c", script, "sh", path, ...args], {
+      env: { LC_ALL: "C" },
+      extendEnv: true,
+      stdin: stdin === undefined ? undefined : Stream.make(stdin)
+    });
+    const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed({ path, cause })));
+    const [stdout, stderr, exitCode] = yield* Effect.all([
+      collectStream(handle.stdout, MAX_DATA_BYTES),
+      collectStream(handle.stderr, MAX_ERROR_BYTES),
+      handle.exitCode
+    ], { concurrency: "unbounded" }).pipe(Effect.mapError((cause) => new Failed({ path, cause })));
+    if (stdout.truncated || stderr.truncated) {
+      return yield* new Failed({ path, cause: new Error("Process output exceeded its collection limit") });
+    }
+    return { exitCode, stdout: stdout.buffer, stderr: stderr.buffer };
+  }));
+  const classify = (path, result, success) => {
+    if (result.exitCode === 0)
+      return Effect.sync(() => success(result.stdout));
+    if (result.exitCode === NOT_FOUND)
+      return Effect.fail(new NotFound({ path }));
+    if (result.exitCode === WRONG_KIND) {
+      return Effect.fail(new WrongKind({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }));
+    }
+    return Effect.fail(processFailure(path, result));
+  };
+  const complete = (path, result) => result.exitCode === 0 ? Effect.void : Effect.fail(processFailure(path, result));
+  return {
+    stat: (path) => run(path, statScript).pipe(Effect.flatMap((result) => classifyPlain(path, result, parseInfo))),
+    read: (path, range) => run(path, readScript, range === undefined ? ["whole"] : ["range", String(range.offset), String(range.length)]).pipe(Effect.flatMap((result) => classify(path, result, (stdout) => {
+      const newline = stdout.indexOf(10);
+      if (newline < 0)
+        throw new Error("Missing read metadata header");
+      return {
+        info: parseInfo(stdout.slice(0, newline)),
+        bytes: stdout.slice(newline + 1)
+      };
+    }))),
+    write: (path, bytes) => run(path, `mkdir -p "$(dirname "$1")" && cat > "$1"`, [], bytes).pipe(Effect.flatMap((result) => complete(path, result))),
+    list: (path) => run(path, listScript).pipe(Effect.flatMap((result) => classify(path, result, parseList))),
+    remove: (path) => run(path, `rm -rf -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
+    move: (from, to) => run(from, moveScript, [to]).pipe(Effect.flatMap((result) => classifyPlain(from, result, () => {
+      return;
+    }))),
+    mkdir: (path) => run(path, `mkdir -p -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result)))
+  };
+};
+var classifyPlain = (path, result, success) => {
+  if (result.exitCode === 0)
+    return Effect.sync(() => success(result.stdout));
+  if (result.exitCode === NOT_FOUND)
+    return Effect.fail(new NotFound({ path }));
+  return Effect.fail(processFailure(path, result));
+};
+var processFailure = (path, result) => new Failed({
+  path,
+  cause: new Error(new TextDecoder().decode(result.stderr).trim() || `Process exited with code ${result.exitCode}`)
+});
+var parseInfo = (bytes) => {
+  const [rawType, rawSize, rawMtime] = new TextDecoder().decode(bytes).trim().split(TAB);
+  const size = Number(rawSize);
+  const mtimeMs = Number(rawMtime) * 1000;
+  if (!rawType || !Number.isFinite(size) || !Number.isFinite(mtimeMs))
+    throw new Error("Invalid stat output");
+  return { type: parseType(rawType), size, mtimeMs };
+};
+var parseType = (value) => {
+  if (value === "regular file" || value === "regular empty file" || value === "f")
+    return "file";
+  if (value === "directory" || value === "d")
+    return "directory";
+  if (value === "symbolic link" || value === "l")
+    return "symlink";
+  return "other";
+};
+var parseList = (bytes) => {
+  const fields = new TextDecoder().decode(bytes).split("\x00");
+  fields.pop();
+  if (fields.length % 2 !== 0)
+    throw new Error("Invalid find output");
+  return Array.from({ length: fields.length / 2 }, (_, index) => ({
+    name: fields[index * 2 + 1],
+    type: parseType(fields[index * 2])
+  }));
+};
+
+export { execDefaults, exports_exec_defaults };

package/dist/chunks/permission-5rs65q6p.js

@@ -0,0 +1,65 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/database/sqlite.ts
+var exports_sqlite = {};
+__export(exports_sqlite, {
+  makeConnection: () => makeConnection,
+  makeClient: () => makeClient,
+  Sqlite: () => exports_sqlite,
+  Native: () => Native
+});
+import { Context, Effect, Fiber, Scope, Semaphore, Stream } from "effect";
+import { identity } from "effect/Function";
+import { SqlClient, Statement } from "effect/unstable/sql";
+
+class Native extends Context.Service()("@opencode-ai/core/database/SqliteNative") {
+}
+var makeConnection = (run, runValues, extensions) => identity({
+  execute(query, params, transformRows) {
+    return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params);
+  },
+  executeRaw(query, params) {
+    return run(query, params);
+  },
+  executeValues(query, params) {
+    return runValues(query, params);
+  },
+  executeValuesUnprepared(query, params) {
+    return runValues(query, params);
+  },
+  executeUnprepared(query, params, transformRows) {
+    return this.execute(query, params, transformRows);
+  },
+  executeStream() {
+    return Stream.die("executeStream not implemented");
+  },
+  ...extensions
+});
+var makeClient = (options, connection, typeId, extensions) => Effect.gen(function* () {
+  const semaphore = yield* Semaphore.make(1);
+  const acquirer = semaphore.withPermits(1)(Effect.succeed(connection));
+  const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
+    const fiber = Fiber.getCurrent();
+    const scope = Context.getUnsafe(fiber.context, Scope.Scope);
+    return Effect.as(Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))), connection);
+  });
+  const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames).array : undefined;
+  return Object.assign(yield* SqlClient.make({
+    acquirer,
+    compiler: Statement.makeCompilerSqlite(options.transformQueryNames),
+    transactionAcquirer,
+    spanAttributes: [
+      ...options.spanAttributes ? Object.entries(options.spanAttributes) : [],
+      ["db.system.name", "sqlite"]
+    ],
+    transformRows
+  }), {
+    [typeId]: typeId,
+    config: options,
+    ...extensions(acquirer)
+  });
+});
+
+export { Native, makeConnection, makeClient, exports_sqlite };

package/dist/chunks/permission-5sgbvx3z.js

@@ -0,0 +1,83 @@
+import {
+  Failed,
+  NotFound,
+  WrongKind
+} from "./permission-zthe9zqc.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/environment/local.ts
+var exports_local = {};
+__export(exports_local, {
+  makeLocalDriver: () => makeLocalDriver,
+  EnvironmentLocal: () => exports_local
+});
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Effect } from "effect";
+var makeLocalDriver = (spawner) => {
+  const overrides = {
+    read: (value, range) => Effect.gen(function* () {
+      const info = yield* stat(value, true);
+      if (info.type !== "file")
+        return yield* new WrongKind({ path: value, actual: info.type });
+      if (range === undefined) {
+        const bytes2 = yield* attempt(value, () => fs.readFile(value), true);
+        return { info, bytes: bytes2 };
+      }
+      const bytes = yield* attempt(value, async () => {
+        const handle = await fs.open(value, "r");
+        try {
+          const buffer = new Uint8Array(range.length);
+          const result = await handle.read(buffer, 0, range.length, range.offset);
+          return buffer.subarray(0, result.bytesRead);
+        } finally {
+          await handle.close();
+        }
+      }, true);
+      return { info, bytes };
+    }),
+    stat: (value) => stat(value, false),
+    list: (value) => Effect.gen(function* () {
+      const info = yield* stat(value, true);
+      if (info.type !== "directory")
+        return yield* new WrongKind({ path: value, actual: info.type });
+      const entries = yield* attempt(value, () => fs.readdir(value, { withFileTypes: true }), true);
+      return entries.map((entry) => ({ name: entry.name, type: fileType(entry) }));
+    }),
+    write: (value, bytes) => attempt(value, async () => {
+      await fs.mkdir(path.dirname(value), { recursive: true });
+      await fs.writeFile(value, bytes);
+    }),
+    remove: (value) => attempt(value, () => fs.rm(value, { recursive: true, force: true })),
+    move: (from, to) => Effect.gen(function* () {
+      yield* stat(from, false);
+      const destination = yield* stat(to, false).pipe(Effect.map((info) => info.type === "directory" ? path.join(to, path.basename(from)) : to), Effect.catchIf((error) => error instanceof NotFound, () => Effect.succeed(to)));
+      yield* attempt(from, () => fs.rename(from, destination));
+    }),
+    mkdir: (value) => attempt(value, () => fs.mkdir(value, { recursive: true }).then(() => {
+      return;
+    }))
+  };
+  return { spawner, overrides };
+};
+var stat = (value, follow) => attempt(value, () => follow ? fs.stat(value) : fs.lstat(value), true).pipe(Effect.map((stats) => ({ type: fileType(stats), size: stats.size, mtimeMs: stats.mtimeMs })));
+var fileType = (entry) => {
+  if (entry.isFile())
+    return "file";
+  if (entry.isDirectory())
+    return "directory";
+  if (entry.isSymbolicLink())
+    return "symlink";
+  return "other";
+};
+function attempt(value, run, missing = false) {
+  return Effect.tryPromise({
+    try: run,
+    catch: (cause) => missing && isMissing(cause) ? new NotFound({ path: value }) : new Failed({ path: value, cause })
+  });
+}
+var isMissing = (cause) => cause !== null && typeof cause === "object" && ("code" in cause) && (cause.code === "ENOENT" || cause.code === "ENOTDIR");
+
+export { makeLocalDriver, exports_local };

package/dist/chunks/permission-5va1yh78.js

@@ -0,0 +1,23 @@
+// src/database/migration/20260605003541_add_session_context_snapshot.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260605003541_add_session_context_snapshot",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_context_epoch\` (
+          \`session_id\` text PRIMARY KEY,
+          \`baseline\` text NOT NULL,
+          \`snapshot\` text NOT NULL,
+          \`baseline_seq\` integer NOT NULL,
+          \`replacement_seq\` integer,
+          \`revision\` integer DEFAULT 0 NOT NULL,
+          CONSTRAINT \`fk_session_context_epoch_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260605003541_add_session_context_snapshot_default = migration;
+
+export { _20260605003541_add_session_context_snapshot_default };

package/dist/chunks/permission-6628r0j2.js

@@ -0,0 +1,162 @@
+import {
+  exports_repository
+} from "./permission-1kvtxahz.js";
+import {
+  exports_git
+} from "./permission-z66vzcey.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/repository-cache.ts
+var exports_repository_cache = {};
+__export(exports_repository_cache, {
+  validateBranch: () => validateBranch,
+  node: () => node,
+  isError: () => isError,
+  Service: () => Service,
+  ResetFailedError: () => ResetFailedError,
+  RepositoryCache: () => exports_repository_cache,
+  LockFailedError: () => LockFailedError,
+  InvalidBranchError: () => InvalidBranchError,
+  FetchFailedError: () => FetchFailedError,
+  CloneFailedError: () => CloneFailedError,
+  CheckoutFailedError: () => CheckoutFailedError,
+  CacheOperationError: () => CacheOperationError
+});
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { EffectFlock } from "@opencode-ai/util/effect-flock";
+
+class InvalidBranchError extends Schema.TaggedErrorClass()("RepositoryCacheInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CloneFailedError extends Schema.TaggedErrorClass()("RepositoryCacheCloneFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class FetchFailedError extends Schema.TaggedErrorClass()("RepositoryCacheFetchFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CheckoutFailedError extends Schema.TaggedErrorClass()("RepositoryCacheCheckoutFailedError", {
+  repository: Schema.String,
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class ResetFailedError extends Schema.TaggedErrorClass()("RepositoryCacheResetFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class LockFailedError extends Schema.TaggedErrorClass()("RepositoryCacheLockFailedError", {
+  localPath: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CacheOperationError extends Schema.TaggedErrorClass()("RepositoryCacheOperationError", {
+  operation: Schema.String,
+  path: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service extends Context.Service()("@opencode/RepositoryCache") {
+}
+function isError(error) {
+  return error instanceof InvalidBranchError || error instanceof CloneFailedError || error instanceof FetchFailedError || error instanceof CheckoutFailedError || error instanceof ResetFailedError || error instanceof LockFailedError || error instanceof CacheOperationError;
+}
+var validateBranch = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
+  return yield* Effect.try({
+    try: () => exports_repository.validateBranch(branch),
+    catch: (error) => new InvalidBranchError({ branch, message: errorMessage(error) })
+  });
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  const flock = yield* EffectFlock.Service;
+  const global = yield* Global.Service;
+  return Service.of({
+    ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
+      if (input.branch)
+        yield* validateBranch(input.branch);
+      const repository = input.reference.label;
+      const localPath = exports_repository.cachePath(global.repos, input.reference, input.branch);
+      const cloneTarget = exports_repository.parse(input.reference.remote) ?? input.reference;
+      return yield* flock.withLock(Effect.gen(function* () {
+        yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath);
+        const existing = yield* git.repo.discover(AbsolutePath.make(localPath));
+        const origin = existing ? yield* git.remote.get(existing) : undefined;
+        const originReference = origin ? exports_repository.parse(origin) : undefined;
+        const worktree = existing ? yield* fs.resolve(localPath) : undefined;
+        const reuse = Boolean(existing && existing.worktree === worktree && originReference && exports_repository.same(originReference, cloneTarget));
+        if (!reuse && (yield* fs.existsSafe(localPath))) {
+          yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath);
+        }
+        const status = !reuse ? "cloned" : input.refresh ? "refreshed" : "cached";
+        if (status === "cloned") {
+          yield* git.repo.clone({
+            remote: input.reference.remote,
+            directory: AbsolutePath.make(localPath),
+            branch: input.branch
+          }).pipe(Effect.mapError((error) => new CloneFailedError({ repository, message: error.message })));
+        }
+        if (status === "refreshed") {
+          if (!existing)
+            return yield* new FetchFailedError({ repository, message: "Repository is unavailable" });
+          yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+          if (input.branch) {
+            yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })));
+          }
+          const branch = input.branch ?? (yield* git.history.defaultRemoteBranch(existing));
+          if (branch) {
+            yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError({ repository, branch, message: error.message })));
+          }
+          const target = branch ?? (yield* git.history.branch(existing));
+          yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError({ repository, message: error.message })));
+        }
+        const checkout = yield* git.repo.discover(AbsolutePath.make(localPath));
+        return {
+          repository,
+          host: input.reference.host,
+          remote: input.reference.remote,
+          localPath,
+          status,
+          head: checkout ? yield* git.history.head(checkout) : undefined,
+          branch: checkout ? yield* git.history.branch(checkout) : undefined
+        };
+      }), `repository-cache:${localPath}`).pipe(Effect.mapError((error) => isError(error) ? error : new LockFailedError({ localPath, message: errorMessage(error) })));
+    })
+  });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [EffectFlock.node, FSUtil.node, exports_git.node, Global.node]
+});
+function errorMessage(error) {
+  return error instanceof globalThis.Error ? error.message : String(error);
+}
+function cacheOperation(effect, operation, target) {
+  return effect.pipe(Effect.mapError((error) => new CacheOperationError({ operation, path: target, message: errorMessage(error) })));
+}
+
+export { InvalidBranchError, CloneFailedError, FetchFailedError, CheckoutFailedError, ResetFailedError, LockFailedError, CacheOperationError, Service, isError, validateBranch, node, exports_repository_cache };

package/dist/chunks/permission-69qrqpw0.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260622142730_simplify_session_context_epoch.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622142730_simplify_session_context_epoch",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`agent\`;`);
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`replacement_seq\`;`);
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`revision\`;`);
+    });
+  }
+};
+var _20260622142730_simplify_session_context_epoch_default = migration;
+
+export { _20260622142730_simplify_session_context_epoch_default };