saeeol 1.1.0 → 1.1.1

package/src/snapshot/snapshot-core.ts

@@ -0,0 +1,279 @@
+import { Effect, Semaphore } from "effect"
+import path from "path"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+import { Hash } from "@saeeol/core/util/hash"
+import { Config } from "@/config/config"
+import { Global } from "@saeeol/core/global"
+import * as Log from "@saeeol/core/util/log"
+import { Flag } from "@saeeol/core/flag/flag"
+import { InstanceState } from "@/effect/instance-state"
+import { mkGit, mkArgs, feed, locked, coreFlags, cfgFlags, quoteFlags, limit } from "./snapshot-git"
+import type { GitResult, Spawner } from "./snapshot-git"
+import type { Patch } from "./snapshot-types"
+
+const log = Log.create({ service: "snapshot" })
+const prune = "7.days"
+
+type GitFn = (cmd: string[], opts?: { cwd?: string; env?: Record<string, string>; stdin?: any }) => Effect.Effect<GitResult, any, any>
+type FsSvc = {
+  exists: (p: string) => Effect.Effect<boolean, never, never>
+  readFileString: (p: string) => Effect.Effect<string, never, never>
+  ensureDir: (p: string) => Effect.Effect<void, never, never>
+  writeFileString: (p: string, c: string) => Effect.Effect<void, never, never>
+  stat: (p: string) => Effect.Effect<{ type: string; size: number | bigint }, never, never>
+  remove: (p: string) => Effect.Effect<void, never, never>
+}
+type CfgSvc = {
+  get: () => Effect.Effect<{ snapshot?: boolean }>
+}
+
+export interface GitCtx {
+  git: GitFn
+  gitdir: string
+  worktree: string
+  directory: string
+  vcs: string
+  fs: FsSvc
+  config: CfgSvc
+  locks: Map<string, Semaphore.Semaphore>
+}
+
+const doIgnore = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* (files: string[]) {
+    if (!files.length) return new Set<string>()
+    const check = yield* ctx.git(
+      [...quoteFlags, "--git-dir", path.join(ctx.worktree, ".git"), "--work-tree", ctx.worktree, "check-ignore", "--no-index", "--stdin", "-z"],
+      { cwd: ctx.directory, stdin: feed(files) },
+    )
+    if (check.code !== 0 && check.code !== 1) return new Set<string>()
+    return new Set(check.text.split("\0").filter(Boolean))
+  })
+
+export { doIgnore as ignore }
+
+const doDrop = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* (files: string[]) {
+    if (!files.length) return
+    yield* ctx.git(
+      [...cfgFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["rm", "--cached", "-f", "--ignore-unmatch", "--pathspec-from-file=-", "--pathspec-file-nul"])],
+      { cwd: ctx.directory, stdin: feed(files) },
+    )
+  })
+
+const doStage = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* (files: string[]) {
+    if (!files.length) return
+    const result = yield* ctx.git(
+      [...cfgFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["add", "--all", "--sparse", "--pathspec-from-file=-", "--pathspec-file-nul"])],
+      { cwd: ctx.directory, stdin: feed(files) },
+    )
+    if (result.code === 0) return
+    log.warn("failed to add snapshot files", { exitCode: result.code, stderr: result.stderr })
+  })
+
+const doEnabled = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* () {
+    if (ctx.vcs !== "git") return false
+    if (Flag.SAEEOL_CLIENT === "acp") return false
+    return (yield* ctx.config.get()).snapshot !== false
+  })
+
+const doExcludes = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* () {
+    const result = yield* ctx.git(["rev-parse", "--path-format=absolute", "--git-path", "info/exclude"], { cwd: ctx.worktree })
+    const file = result.text.trim()
+    if (!file) return
+    if (!(yield* ctx.fs.exists(file))) return
+    return file
+  })
+
+const doSync = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* (list: string[] = []) {
+    const file = yield* doExcludes(ctx)()
+    const target = path.join(ctx.gitdir, "info", "exclude")
+    const text = [
+      file ? (yield* ctx.fs.readFileString(file)).trimEnd() : "",
+      ...list.map((item) => `/${item.replaceAll("\\", "/")}`),
+    ].filter(Boolean).join("\n")
+    yield* ctx.fs.ensureDir(path.join(ctx.gitdir, "info"))
+    yield* ctx.fs.writeFileString(target, text ? `${text}\n` : "")
+  })
+
+export const add = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* () {
+    yield* doSync(ctx)()
+    const [diff, other] = yield* Effect.all(
+      [
+        ctx.git([...quoteFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["diff-files", "--name-only", "-z", "--", "."])], { cwd: ctx.directory }),
+        ctx.git([...quoteFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["ls-files", "--others", "--exclude-standard", "-z", "--", "."])], { cwd: ctx.directory }),
+      ],
+      { concurrency: 2 },
+    )
+    if (diff.code !== 0 || other.code !== 0) {
+      log.warn("failed to list snapshot files", { diffCode: diff.code, diffStderr: diff.stderr, otherCode: other.code, otherStderr: other.stderr })
+      return
+    }
+    const tracked = diff.text.split("\0").filter(Boolean)
+    const untracked = other.text.split("\0").filter(Boolean)
+    const all = Array.from(new Set([...tracked, ...untracked]))
+    if (!all.length) return
+    const ignored = yield* doIgnore(ctx)(all)
+    if (ignored.size > 0) {
+      log.info("removing gitignored files from snapshot", { count: ignored.size })
+      yield* doDrop(ctx)(Array.from(ignored))
+    }
+    const allow = all.filter((item) => !ignored.has(item))
+    if (!allow.length) return
+    const large = new Set(
+      (yield* Effect.all(
+        allow.map((item) =>
+          ctx.fs.stat(path.join(ctx.directory, item))
+            .pipe(Effect.catch(() => Effect.void))
+            .pipe(Effect.map((stat) => {
+              if (!stat || stat.type !== "File") return
+              const size = typeof stat.size === "bigint" ? Number(stat.size) : stat.size
+              return size > limit ? item : undefined
+            }))
+        ),
+        { concurrency: 8 },
+      )).filter((item): item is string => Boolean(item)),
+    )
+    const block = new Set(untracked.filter((item) => large.has(item)))
+    yield* doSync(ctx)(Array.from(block))
+    yield* doStage(ctx)(allow.filter((item) => !block.has(item)))
+  })
+
+export const cleanup = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* () {
+    return yield* locked(ctx.locks, ctx.gitdir, Effect.gen(function* () {
+      if (!(yield* doEnabled(ctx)())) return
+      if (!(yield* ctx.fs.exists(ctx.gitdir))) return
+      const result = yield* ctx.git(mkArgs(ctx.gitdir, ctx.worktree, ["gc", `--prune=${prune}`]), { cwd: ctx.directory })
+      if (result.code !== 0) { log.warn("cleanup failed", { exitCode: result.code, stderr: result.stderr }); return }
+      log.info("cleanup", { prune })
+    }))
+  })
+
+export const track = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* () {
+    return yield* locked(ctx.locks, ctx.gitdir, Effect.gen(function* () {
+      if (!(yield* doEnabled(ctx)())) return
+      const existed = yield* ctx.fs.exists(ctx.gitdir)
+      yield* ctx.fs.ensureDir(ctx.gitdir)
+      if (!existed) {
+        yield* ctx.git(["init"], { env: { GIT_DIR: ctx.gitdir, GIT_WORK_TREE: ctx.worktree } })
+        yield* ctx.git(["--git-dir", ctx.gitdir, "config", "core.autocrlf", "false"])
+        yield* ctx.git(["--git-dir", ctx.gitdir, "config", "core.longpaths", "true"])
+        yield* ctx.git(["--git-dir", ctx.gitdir, "config", "core.symlinks", "true"])
+        yield* ctx.git(["--git-dir", ctx.gitdir, "config", "core.fsmonitor", "false"])
+        log.info("initialized")
+      }
+      yield* add(ctx)()
+      const result = yield* ctx.git(mkArgs(ctx.gitdir, ctx.worktree, ["write-tree"]), { cwd: ctx.directory })
+      const hash = result.text.trim()
+      log.info("tracking", { hash, cwd: ctx.directory, git: ctx.gitdir })
+      return hash
+    }))
+  })
+
+export const patch = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* (hash: string) {
+    return yield* locked(ctx.locks, ctx.gitdir, Effect.gen(function* () {
+      yield* add(ctx)()
+      const result = yield* ctx.git(
+        [...quoteFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["diff", "--cached", "--no-ext-diff", "--name-only", hash, "--", "."])],
+        { cwd: ctx.directory },
+      )
+      if (result.code !== 0) { log.warn("failed to get diff", { hash, exitCode: result.code }); return { hash, files: [] } }
+      const files = result.text.trim().split("\n").map((x) => x.trim()).filter(Boolean)
+      const ignored = yield* doIgnore(ctx)(files)
+      return { hash, files: files.filter((item) => !ignored.has(item)).map((x) => path.join(ctx.worktree, x).replaceAll("\\", "/")) }
+    }))
+  })
+
+export const restore = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* (snapshot: string) {
+    return yield* locked(ctx.locks, ctx.gitdir, Effect.gen(function* () {
+      log.info("restore", { commit: snapshot })
+      const result = yield* ctx.git([...coreFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["read-tree", snapshot])], { cwd: ctx.worktree })
+      if (result.code === 0) {
+        const checkout = yield* ctx.git([...coreFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["checkout-index", "-a", "-f"])], { cwd: ctx.worktree })
+        if (checkout.code === 0) return
+        log.error("failed to restore snapshot", { snapshot, exitCode: checkout.code, stderr: checkout.stderr })
+        return
+      }
+      log.error("failed to restore snapshot", { snapshot, exitCode: result.code, stderr: result.stderr })
+    }))
+  })
+
+export const revert = (ctx: GitCtx) =>
+  Effect.fnUntraced(function* (patches: Patch[]) {
+    return yield* locked(ctx.locks, ctx.gitdir, Effect.gen(function* () {
+      const ops: { hash: string; file: string; rel: string }[] = []
+      const seen = new Set<string>()
+      for (const item of patches) {
+        for (const file of item.files) {
+          if (seen.has(file)) continue
+          seen.add(file)
+          ops.push({ hash: item.hash, file, rel: path.relative(ctx.worktree, file).replaceAll("\\", "/") })
+        }
+      }
+      const single = Effect.fnUntraced(function* (op: (typeof ops)[number]) {
+        log.info("reverting", { file: op.file, hash: op.hash })
+        const result = yield* ctx.git([...coreFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["checkout", op.hash, "--", op.file])], { cwd: ctx.worktree })
+        if (result.code === 0) return
+        const tree = yield* ctx.git([...coreFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["ls-tree", op.hash, "--", op.rel])], { cwd: ctx.worktree })
+        if (tree.code === 0 && tree.text.trim()) {
+          log.info("file existed in snapshot but checkout failed, keeping", { file: op.file, hash: op.hash })
+          return
+        }
+        log.info("file did not exist in snapshot, deleting", { file: op.file, hash: op.hash })
+        yield* ctx.fs.remove(op.file)
+      })
+      const clash = (a: string, b: string) => a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`)
+      for (let i = 0; i < ops.length;) {
+        const first = ops[i]!
+        const run = [first]
+        let j = i + 1
+        while (j < ops.length && run.length < 100) {
+          const next = ops[j]!
+          if (next.hash !== first.hash) break
+          if (run.some((item) => clash(item.rel, next.rel))) break
+          run.push(next)
+          j += 1
+        }
+        if (run.length === 1) { yield* single(first); i = j; continue }
+        const tree = yield* ctx.git(
+          [...coreFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["ls-tree", "--name-only", first.hash, "--", ...run.map((item) => item.rel)])],
+          { cwd: ctx.worktree },
+        )
+        if (tree.code !== 0) {
+          log.info("batched ls-tree failed, falling back to single-file revert", { hash: first.hash, files: run.length })
+          for (const op of run) yield* single(op)
+          i = j
+          continue
+        }
+        const have = new Set(tree.text.trim().split("\n").map((item) => item.trim()).filter(Boolean))
+        const list = run.filter((item) => have.has(item.rel))
+        if (list.length) {
+          log.info("reverting", { hash: first.hash, files: list.length })
+          const result = yield* ctx.git(
+            [...coreFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["checkout", first.hash, "--", ...list.map((item) => item.file)])],
+            { cwd: ctx.worktree },
+          )
+          if (result.code !== 0) {
+            log.info("batched checkout failed, falling back to single-file revert", { hash: first.hash, files: list.length })
+            for (const op of run) yield* single(op)
+            i = j
+            continue
+          }
+        }
+        for (const op of run) {
+          if (have.has(op.rel)) continue
+          log.info("file did not exist in snapshot, deleting", { file: op.file, hash: op.hash })
+          yield* ctx.fs.remove(op.file)
+        }
+        i = j
+      }
+    }))
+  })

package/src/snapshot/snapshot-diff.ts

@@ -0,0 +1,85 @@
+import { Effect, Semaphore } from "effect"
+import * as Log from "@saeeol/core/util/log"
+import { DiffFull } from "@/saeeol/snapshot/diff-full"
+import { locked, quoteFlags, mkArgs } from "./snapshot-git"
+import type { GitResult } from "./snapshot-git"
+import { ignore } from "./snapshot-core"
+import type { GitCtx } from "./snapshot-core"
+import type { FileDiff } from "./snapshot-types"
+
+const log = Log.create({ service: "snapshot" })
+
+export const diffOp = (ctx: GitCtx, addFn: () => Effect.Effect<void, any, any>) =>
+  Effect.fnUntraced(function* (hash: string) {
+    return yield* locked(ctx.locks, ctx.gitdir, Effect.gen(function* () {
+      yield* addFn()
+      const result = yield* ctx.git(
+        [...quoteFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["diff", "--cached", "--no-ext-diff", hash, "--", "."])],
+        { cwd: ctx.worktree },
+      )
+      if (result.code !== 0) {
+        log.warn("failed to get diff", { hash, exitCode: result.code, stderr: result.stderr })
+        return ""
+      }
+      return result.text.trim()
+    }))
+  })
+
+export const diffFullOp = (ctx: GitCtx, addFn: () => Effect.Effect<void, any, any>) =>
+  Effect.fnUntraced(function* (from: string, to: string) {
+    return yield* locked(ctx.locks, ctx.gitdir, Effect.gen(function* () {
+      const result: FileDiff[] = []
+      const status = new Map<string, "added" | "deleted" | "modified">()
+
+      const statuses = yield* ctx.git(
+        [...quoteFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["diff", "--no-ext-diff", "--name-status", "--no-renames", from, to, "--", "."])],
+        { cwd: ctx.directory },
+      )
+      for (const line of statuses.text.trim().split("\n")) {
+        if (!line) continue
+        const [code, file] = line.split("\t")
+        if (!code || !file) continue
+        status.set(file, code.startsWith("A") ? "added" : code.startsWith("D") ? "deleted" : "modified")
+      }
+
+      const numstat = yield* ctx.git(
+        [...quoteFlags, ...mkArgs(ctx.gitdir, ctx.worktree, ["diff", "--no-ext-diff", "--no-renames", "--numstat", from, to, "--", "."])],
+        { cwd: ctx.directory },
+      )
+
+      type Row = { file: string; status: "added" | "deleted" | "modified"; binary: boolean; additions: number; deletions: number }
+      const rows: Row[] = numstat.text.trim().split("\n").filter(Boolean).flatMap((line) => {
+        const [adds, dels, file] = line.split("\t")
+        if (!file) return []
+        const binary = adds === "-" && dels === "-"
+        return [{
+          file, status: status.get(file) ?? "modified" as const, binary,
+          additions: binary ? 0 : (Number.isFinite(parseInt(adds)) ? parseInt(adds) : 0),
+          deletions: binary ? 0 : (Number.isFinite(parseInt(dels)) ? parseInt(dels) : 0),
+        }]
+      })
+
+      const ignored = yield* ignore(ctx)(rows.map((r) => r.file))
+      if (ignored.size > 0) {
+        const filtered = rows.filter((r) => !ignored.has(r.file))
+        rows.length = 0
+        rows.push(...filtered)
+      }
+
+      const step = 100
+      for (let i = 0; i < rows.length; i += step) {
+        const run = rows.slice(i, i + step)
+        const patches = yield* DiffFull.batch(
+          (cmd) => ctx.git([...quoteFlags, ...mkArgs(ctx.gitdir, ctx.worktree, cmd)], { cwd: ctx.directory }) as any,
+          from, to, run.filter((r) => !r.binary).map((r) => r.file),
+        )
+        for (const row of run) {
+          result.push({
+            file: row.file, patch: row.binary ? "" : (patches.get(row.file) ?? ""),
+            additions: row.additions, deletions: row.deletions, status: row.status,
+          })
+        }
+      }
+      return result
+    }))
+  })

package/src/snapshot/snapshot-git.ts

@@ -0,0 +1,60 @@
+import { Effect, Stream, Semaphore } from "effect"
+import { ChildProcess } from "effect/unstable/process"
+import * as Log from "@saeeol/core/util/log"
+
+const log = Log.create({ service: "snapshot" })
+
+export const coreFlags = ["-c", "core.longpaths=true", "-c", "core.symlinks=true"]
+export const cfgFlags = ["-c", "core.autocrlf=false", ...coreFlags]
+export const quoteFlags = [...cfgFlags, "-c", "core.quotepath=false"]
+export const limit = 2 * 1024 * 1024
+
+export interface GitResult {
+  readonly code: number
+  readonly text: string
+  readonly stderr: string
+}
+
+export interface Spawner {
+  spawn: (proc: any) => Effect.Effect<any, any, any>
+}
+
+export const mkArgs = (gitdir: string, worktree: string, cmd: string[]) =>
+  ["--git-dir", gitdir, "--work-tree", worktree, ...cmd]
+
+export const feed = (list: string[]) =>
+  Stream.make(new TextEncoder().encode(list.join("\0") + "\0"))
+
+export const mkGit = (spawner: Spawner) =>
+  Effect.fnUntraced(
+    function* (
+      cmd: string[],
+      opts?: { cwd?: string; env?: Record<string, string>; stdin?: any },
+    ) {
+      const proc = ChildProcess.make("git", cmd, {
+        cwd: opts?.cwd, env: opts?.env, extendEnv: true, stdin: opts?.stdin,
+      })
+      const handle = yield* spawner.spawn(proc)
+      const [text, stderr] = yield* Effect.all(
+        [Stream.mkString(Stream.decodeText(handle.stdout)), Stream.mkString(Stream.decodeText(handle.stderr))],
+        { concurrency: 2 },
+      )
+      const code = yield* handle.exitCode
+      return { code, text, stderr } as GitResult
+    },
+    Effect.scoped,
+    Effect.catch((err) =>
+      Effect.succeed({ code: 1 as any, text: "", stderr: err instanceof Error ? err.message : String(err) } as GitResult),
+    ),
+  )
+
+export const locked = <A, E, R>(
+  locks: Map<string, Semaphore.Semaphore>,
+  key: string,
+  fx: Effect.Effect<A, E, R>,
+) => {
+  const hit = locks.get(key)
+  const sem = hit ?? Semaphore.makeUnsafe(1)
+  if (!hit) locks.set(key, sem)
+  return sem.withPermits(1)(fx)
+}

package/src/snapshot/snapshot-types.ts

@@ -0,0 +1,43 @@
+import { Effect, Schema, Struct, Context } from "effect"
+import { NonNegativeInt, withStatics } from "@/util/schema"
+import { zod } from "@/util/effect-zod"
+import type { MessageID, SessionID } from "@/session/schema"
+
+export const Patch = Schema.Struct({
+  hash: Schema.String,
+  files: Schema.mutable(Schema.Array(Schema.String)),
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type Patch = typeof Patch.Type
+
+export const FileDiff = Schema.Struct({
+  file: Schema.String,
+  patch: Schema.String,
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt,
+  status: Schema.optional(Schema.Literals(["added", "deleted", "modified"])),
+})
+  .annotate({ identifier: "SnapshotFileDiff" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type FileDiff = typeof FileDiff.Type
+
+export const SummaryFileDiff = FileDiff.mapFields(Struct.omit(["patch"]))
+  .annotate({ identifier: "SnapshotSummaryFileDiff" })
+  .pipe(withStatics((s) => ({ zod: zod(s) })))
+export type SummaryFileDiff = typeof SummaryFileDiff.Type
+
+export interface Interface {
+  readonly init: () => Effect.Effect<void>
+  readonly cleanup: () => Effect.Effect<void>
+  readonly track: (opts?: { sessionID?: SessionID; messageID?: MessageID }) => Effect.Effect<string | undefined>
+  readonly patch: (hash: string) => Effect.Effect<Patch>
+  readonly restore: (snapshot: string) => Effect.Effect<void>
+  readonly revert: (patches: Patch[]) => Effect.Effect<void>
+  readonly diff: (hash: string) => Effect.Effect<string>
+  readonly diffFull: (from: string, to: string) => Effect.Effect<FileDiff[]>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/Snapshot") {}
+
+export const MAX_DIFF_SIZE = 256 * 1024
+export const cache = new Map<string, Promise<FileDiff[]>>()
+export const maxCache = 100

package/src/sql.d.ts

@@ -0,0 +1,4 @@
+declare module "*.sql" {
+  const content: string
+  export default content
+}

package/src/storage/db.bun.ts

@@ -0,0 +1,8 @@
+import { Database } from "bun:sqlite"
+import { drizzle } from "drizzle-orm/bun-sqlite"
+
+export function init(path: string) {
+  const sqlite = new Database(path, { create: true })
+  const db = drizzle({ client: sqlite })
+  return db
+}

package/src/storage/db.node.ts

@@ -0,0 +1,8 @@
+import { DatabaseSync } from "node:sqlite"
+import { drizzle } from "drizzle-orm/node-sqlite"
+
+export function init(path: string) {
+  const sqlite = new DatabaseSync(path)
+  const db = drizzle({ client: sqlite })
+  return db
+}

package/src/storage/db.ts

@@ -0,0 +1,177 @@
+import { type SQLiteBunDatabase } from "drizzle-orm/bun-sqlite"
+import { migrate } from "drizzle-orm/bun-sqlite/migrator"
+import { type SQLiteTransaction } from "drizzle-orm/sqlite-core"
+export * from "drizzle-orm"
+import { LocalContext } from "@/util/local-context"
+import { lazy } from "../util/lazy"
+import { Global } from "@saeeol/core/global"
+import * as Log from "@saeeol/core/util/log"
+import { NamedError } from "@saeeol/core/util/error"
+import z from "zod"
+import path from "path"
+import { readFileSync, readdirSync, existsSync } from "fs"
+import { Flag } from "@saeeol/core/flag/flag"
+import { InstallationChannel } from "@saeeol/core/installation/version"
+import { InstanceState } from "@/effect/instance-state"
+import { iife } from "@/util/iife"
+import { init } from "#db"
+
+declare const SAEEOL_MIGRATIONS: { sql: string; timestamp: number; name: string }[] | undefined
+
+export const NotFoundError = NamedError.create(
+  "NotFoundError",
+  z.object({
+    message: z.string(),
+  }),
+)
+
+const log = Log.create({ service: "db" })
+export function getChannelPath() {
+  return path.join(Global.Path.data, "saeeol.db")
+}
+
+export const Path = iife(() => {
+  if (Flag.SAEEOL_DB) {
+    if (Flag.SAEEOL_DB === ":memory:" || path.isAbsolute(Flag.SAEEOL_DB)) return Flag.SAEEOL_DB
+    return path.join(Global.Path.data, Flag.SAEEOL_DB)
+  }
+  return getChannelPath()
+})
+
+export type Transaction = SQLiteTransaction<"sync", void>
+
+type Client = SQLiteBunDatabase
+
+type Journal = { sql: string; timestamp: number; name: string }[]
+
+// Drizzle's migrate overloads trigger expensive variance checks here; narrow to the journal overload we actually use.
+const migrateFromJournal = migrate as unknown as (db: SQLiteBunDatabase, entries: Journal) => void
+
+function applyMigrations(db: SQLiteBunDatabase, entries: Journal) {
+  migrateFromJournal(db, entries)
+}
+
+function time(tag: string) {
+  const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(tag)
+  if (!match) return 0
+  return Date.UTC(
+    Number(match[1]),
+    Number(match[2]) - 1,
+    Number(match[3]),
+    Number(match[4]),
+    Number(match[5]),
+    Number(match[6]),
+  )
+}
+
+function migrations(dir: string): Journal {
+  const dirs = readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+
+  const sql = dirs
+    .map((name) => {
+      const file = path.join(dir, name, "migration.sql")
+      if (!existsSync(file)) return
+      return {
+        sql: readFileSync(file, "utf-8"),
+        timestamp: time(name),
+        name,
+      }
+    })
+    .filter(Boolean) as Journal
+
+  return sql.sort((a, b) => a.timestamp - b.timestamp)
+}
+
+export const Client = lazy(() => {
+  log.info("opening database", { path: Path })
+
+  const db = init(Path)
+
+  db.run("PRAGMA journal_mode = WAL")
+  db.run("PRAGMA synchronous = NORMAL")
+  db.run("PRAGMA busy_timeout = 5000")
+  db.run("PRAGMA cache_size = -64000")
+  db.run("PRAGMA foreign_keys = ON")
+  db.run("PRAGMA wal_checkpoint(PASSIVE)")
+
+  // Apply schema migrations
+  const entries =
+    typeof SAEEOL_MIGRATIONS !== "undefined"
+      ? SAEEOL_MIGRATIONS
+      : migrations(path.join(import.meta.dirname, "../../migration"))
+  if (entries.length > 0) {
+    log.info("applying migrations", {
+      count: entries.length,
+      mode: typeof SAEEOL_MIGRATIONS !== "undefined" ? "bundled" : "dev",
+    })
+    if (Flag.SAEEOL_SKIP_MIGRATIONS) {
+      for (const item of entries) {
+        item.sql = "select 1;"
+      }
+    }
+    applyMigrations(db, entries)
+  }
+
+  return db
+})
+
+export function close() {
+  Client().$client.close()
+  Client.reset()
+}
+
+export type TxOrDb = Transaction | Client
+
+const ctx = LocalContext.create<{
+  tx: TxOrDb
+  effects: (() => void | Promise<void>)[]
+}>("database")
+
+export function use<T>(callback: (trx: TxOrDb) => T): T {
+  try {
+    return callback(ctx.use().tx)
+  } catch (err) {
+    if (err instanceof LocalContext.NotFound) {
+      const effects: (() => void | Promise<void>)[] = []
+      const result = ctx.provide({ effects, tx: Client() }, () => callback(Client()))
+      for (const effect of effects) effect()
+      return result
+    }
+    throw err
+  }
+}
+
+export function effect(fn: () => any | Promise<any>) {
+  const bound = InstanceState.bind(fn)
+  try {
+    ctx.use().effects.push(bound)
+  } catch {
+    bound()
+  }
+}
+
+type NotPromise<T> = T extends Promise<any> ? never : T
+
+export function transaction<T>(
+  callback: (tx: TxOrDb) => NotPromise<T>,
+  options?: {
+    behavior?: "deferred" | "immediate" | "exclusive"
+  },
+): NotPromise<T> {
+  try {
+    return callback(ctx.use().tx)
+  } catch (err) {
+    if (err instanceof LocalContext.NotFound) {
+      const effects: (() => void | Promise<void>)[] = []
+      const txCallback = InstanceState.bind((tx: TxOrDb) => ctx.provide({ tx, effects }, () => callback(tx)))
+      const result = Client().transaction(txCallback, { behavior: options?.behavior })
+      for (const effect of effects) effect()
+      return result as NotPromise<T>
+    }
+    throw err
+  }
+}
+
+export * as Database from "./db"