@toist/aja 0.7.1 → 0.8.1

package/src/sqlite-runtime.ts

@@ -0,0 +1,135 @@
+// 2121
+import type { Database } from "bun:sqlite"
+import { join } from "node:path"
+import { defaultRegistry, type KindRegistry, type ToistRuntime } from "@toist/core"
+import { makeCache } from "./cache.ts"
+import { openRuntimeDb } from "./runtime-db.ts"
+import { openDataDb } from "./data-db.ts"
+import { openCacheDb } from "./cache-db.ts"
+import { acquireRunnerLock } from "./lock.ts"
+import { loadInstance } from "./instance-metadata.ts"
+import { loadFilesystemResources } from "./resources-fs.ts"
+import {
+  createSqliteLogStore,
+  createSqliteNodeOutputStore,
+  createSqliteRunLedger,
+  createSqliteTaskStore,
+} from "./stores/sqlite.ts"
+
+export interface CreateSqliteRuntimeOptions {
+  rootDir: string
+  dataDir?: string
+  pipelinesDir?: string
+  resourcesDir?: string
+  registry?: KindRegistry
+  skipMigrations?: boolean
+}
+
+interface InternalSqliteRuntime extends ToistRuntime {
+  close(): Promise<void>
+  adminDb: Database
+  rootDir: string
+  pipelinesDir: string
+  dataDir: string
+}
+
+function globToRegExp(glob: string): RegExp {
+  const escaped = glob.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*")
+  return new RegExp(`^${escaped}$`)
+}
+
+function filterKindsByGlob(baseRegistry: KindRegistry, allowlist: string[]) {
+  const matchers = allowlist.map(globToRegExp)
+  return baseRegistry.manifest()
+    .filter((kind) => matchers.some((matcher) => matcher.test(kind.id)))
+    .map((kind) => baseRegistry.get(kind.id))
+    .filter((kind): kind is NonNullable<typeof kind> => !!kind)
+}
+
+function createProjectedRegistry(baseRegistry: KindRegistry, allowlist: string[]): KindRegistry {
+  const registry = new Map(filterKindsByGlob(baseRegistry, allowlist).map((kind) => [kind.id, kind]))
+  return {
+    exclusive: true,
+    register(...kinds) {
+      for (const kind of kinds) registry.set(kind.id, kind)
+    },
+    get(id) {
+      return registry.get(id)
+    },
+    manifest() {
+      return [...registry.values()].map(({ run: _run, ...manifest }) => manifest)
+    },
+    has(id) {
+      return registry.has(id)
+    },
+  }
+}
+
+export async function createSqliteRuntime(
+  opts: CreateSqliteRuntimeOptions,
+): Promise<ToistRuntime & { close(): Promise<void> }> {
+  const dataDir = opts.dataDir ?? join(opts.rootDir, "data")
+  const pipelinesDir = opts.pipelinesDir ?? join(opts.rootDir, "pipelines")
+  const ledgerPath = join(dataDir, "runtime.db")
+  const domainPath = join(dataDir, "data.db")
+  const cachePath = join(dataDir, "cache.db")
+  const lockfilePath = join(dataDir, ".lock")
+
+  const releaseLock = await acquireRunnerLock({ dir: dataDir, lockfilePath })
+
+  let ledgerHandle: Database | null = null
+  let domainHandle: Database | null = null
+  let cacheHandle: Database | null = null
+
+  try {
+    ledgerHandle = openRuntimeDb(ledgerPath, { skipMigrations: opts.skipMigrations })
+    domainHandle = openDataDb(domainPath)
+    cacheHandle = openCacheDb(cachePath)
+
+    const cache = makeCache(cacheHandle)
+    const baseRegistry = opts.registry ?? defaultRegistry
+    const allowlist = loadInstance(opts.rootDir).kindAllowlist
+    const registry = allowlist
+      ? createProjectedRegistry(baseRegistry, allowlist)
+      : baseRegistry
+    const resources = await loadFilesystemResources(opts.rootDir)
+
+    const runtime: InternalSqliteRuntime = {
+      data: domainHandle,
+      cache,
+      runs: createSqliteRunLedger(ledgerHandle),
+      tasks: createSqliteTaskStore(ledgerHandle),
+      logs: createSqliteLogStore(ledgerHandle),
+      outputs: createSqliteNodeOutputStore(ledgerHandle),
+      resources: { resolve: () => resources },
+      registry,
+      adminDb: ledgerHandle,
+      rootDir: opts.rootDir,
+      pipelinesDir,
+      dataDir,
+      async close() {
+        if (ledgerHandle) {
+          ledgerHandle.close()
+          ledgerHandle = null
+        }
+        if (domainHandle) {
+          domainHandle.close()
+          domainHandle = null
+        }
+        if (cacheHandle) {
+          cacheHandle.close()
+          cacheHandle = null
+        }
+        await releaseLock()
+      },
+    }
+
+    return runtime
+  } catch (error) {
+    if (ledgerHandle) ledgerHandle.close()
+    if (domainHandle) domainHandle.close()
+    if (cacheHandle) cacheHandle.close()
+    await releaseLock()
+    throw error
+  }
+}

package/src/startRunner.ts

@@ -1,92 +1,78 @@
 // 2121
-// Public API entry per context/instance-spec.md §4. Hosts that consume
-// `@toist/aja` (post-extraction) call this with options to start a runner
-// instance. The legacy CLI path — `bun src/index.ts` invoked directly by pm2
-// in this repo's dev mode — still works unchanged: index.ts triggers initDbs
-// on its own when import.meta.main is true.
-//
-// Lifecycle (matches instance-spec.md §7, scoped to what this iteration
-// covers):
-//
-//   1. setRootDir(options.rootDir)         — config knows the host's root
-//   2. initDbs()                            — acquire lock, migrate, open dbs
-//   3. dynamic import("./index.ts")         — builds the Hono app (its own
-//                                              initDbs guard is a no-op since
-//                                              import.meta.main is false here)
-//   4. Bun.serve({ port, fetch })           — bind app to host's port
-//   5. return { port, stop }
-//
-// On stop():
-//   - server.stop() — close the HTTP server
-//   - closeDbs()    — close all three handles, release the runner lock
-//
-// What this iteration does NOT yet do (Roadmap, Phase F W2 follow-ups):
-//   - Per-path overrides (pipelineDir, resourceDir, dataDir) as options —
-//     env vars cover them today
-//   - disableUi, disableMcp, disableWatch options — no UI/MCP yet served
-//     from this process; watch is always on
-//   - Custom logger injection — current code goes through console.log
-
 import type { Server } from "bun"
-import { setRootDir, setDisableUi, setDisableWatch, setCorsOrigins } from "./config.ts"
-import { initDbs, closeDbs } from "./db-handles.ts"
+import { join } from "node:path"
+import { createMemoryRuntime, type ToistRuntime } from "@toist/core"
+import { mountApi } from "./server.ts"
+import { createFilesystemPipelineStore } from "./pipeline-store.ts"
+import { createSqliteRuntime } from "./sqlite-runtime.ts"
 
 export interface StartRunnerOptions {
-  /** TCP port for the HTTP server. Required — no default. */
   port: number
-  /** Root directory for all instance-relative paths. Required.
-   *  Resolves: pipelines/, resources/, data/, instance.json. */
   rootDir: string
-  /** Disable the bundled UI static mount. Default: false (UI is served
-   *  from @toist/ui/dist when the build artefacts exist). Set true
-   *  for headless deployments or when fronting with a separate UI server. */
+  storage?: "sqlite" | "memory"
   disableUi?: boolean
-  /** Disable the filesystem watcher on pipelineDir/resourceDir. Default:
-   *  false (watcher is on; pipelines hot-reload on file changes).
-   *  Production deployments may set true to avoid inotify/fsevent overhead
-   *  and prevent accidental reloads from concurrent edits. */
   disableWatch?: boolean
-  /** CORS allow-origin configuration. `string` for a single origin,
-   *  `string[]` for an allowlist, `undefined` for default (permissive `*`).
-   *  Production deployments should typically pin this. */
   corsOrigins?: string | string[]
+  runtime?: ToistRuntime
 }
 
 export interface RunnerHandle {
-  /** The port the runner is actually listening on. */
   port: number
-  /** Stop the runner gracefully — close the HTTP server, close DB handles,
-   *  release the runner lock. */
   stop(): Promise<void>
 }
 
+interface HostedRuntime extends ToistRuntime {
+  close?: () => Promise<void>
+  adminDb?: import("bun:sqlite").Database
+  pipelinesDir?: string
+}
+
 export async function startRunner(options: StartRunnerOptions): Promise<RunnerHandle> {
-  // v1 embedded limit: one runner per process. config/db/registry/server
-  // modules keep process-global state; hosts that need multiple isolated
-  // runners should spawn separate processes until createRunnerInstance-style
-  // state encapsulation lands.
-  setRootDir(options.rootDir)
-  setDisableUi(options.disableUi ?? false)
-  setDisableWatch(options.disableWatch ?? false)
-  setCorsOrigins(options.corsOrigins)
-  await initDbs()
+  const runtime: HostedRuntime = options.runtime
+    ? options.runtime as HostedRuntime
+    : options.storage === "memory"
+      ? createMemoryRuntime()
+      : await createSqliteRuntime({ rootDir: options.rootDir }) as HostedRuntime
+
+  const pipelinesDir = runtime.pipelinesDir ?? join(options.rootDir, "pipelines")
+  let pipelineStore: ReturnType<typeof createFilesystemPipelineStore> | null = null
+  let cachePruneTimer: ReturnType<typeof setInterval> | null = null
+
+  try {
+    pipelineStore = createFilesystemPipelineStore({
+      rootDir: options.rootDir,
+      watch: !options.disableWatch,
+      registry: runtime.registry,
+    })
+
+    cachePruneTimer = setInterval(() => runtime.cache.prune(), 5 * 60 * 1000)
+    cachePruneTimer.unref?.()
 
-  // Dynamic import deferred until after initDbs so server.ts's module-load
-  // expressions that call cacheDb() / dataDb() / runtimeDb() see populated
-  // handles. The static-import alternative would force module evaluation
-  // before initDbs runs.
-  const mod = await import("./server.ts")
-  const fetch = mod.fetch as (req: Request) => Response | Promise<Response>
+    const app = await mountApi(runtime, {
+      rootDir: options.rootDir,
+      pipelinesDir,
+      adminDb: runtime.adminDb,
+      disableUi: options.disableUi ?? false,
+      corsOrigins: options.corsOrigins,
+    })
 
-  const server: Server<undefined> = Bun.serve({ port: options.port, fetch })
-  const port = server.port ?? options.port
-  console.log(`[runner] http://localhost:${port}`)
+    const server: Server<undefined> = Bun.serve({ port: options.port, fetch: app.fetch })
+    const port = server.port ?? options.port
+    console.log(`[runner] http://localhost:${port}`)
 
-  return {
-    port,
-    async stop() {
-      server.stop()
-      await closeDbs()
-    },
+    return {
+      port,
+      async stop() {
+        pipelineStore?.close()
+        if (cachePruneTimer) clearInterval(cachePruneTimer)
+        server.stop()
+        await runtime.close?.()
+      },
+    }
+  } catch (error) {
+    pipelineStore?.close()
+    if (cachePruneTimer) clearInterval(cachePruneTimer)
+    await runtime.close?.()
+    throw error
   }
 }

package/src/stores/sqlite.ts

@@ -0,0 +1,243 @@
+// 2121
+import type { Database } from "bun:sqlite"
+import type {
+  LogStore,
+  NodeOutputStore,
+  RunLedger,
+  RunRow,
+  TaskDescriptor,
+  TaskListItem,
+  TaskStore,
+} from "./types.ts"
+
+export function createSqliteRunLedger(db: Database): RunLedger {
+  return {
+    async create(input) {
+      const row = db.prepare(
+        "INSERT INTO runs (pipeline, status, payload, trigger, updated_at) VALUES (?, 'running', ?, ?, datetime('now')) RETURNING id",
+      ).get(input.pipeline, JSON.stringify(input.payload ?? {}), input.trigger) as { id: number }
+      return row.id
+    },
+
+    async get(runId) {
+      return (db.prepare("SELECT * FROM runs WHERE id = ?").get(runId) as RunRow | undefined) ?? null
+    },
+
+    async list(filter = {}) {
+      const limit = filter.limit ?? 50
+      const rows = filter.pipeline
+        ? db.prepare("SELECT * FROM runs WHERE pipeline = ? ORDER BY id DESC LIMIT ?").all(filter.pipeline, limit)
+        : db.prepare("SELECT * FROM runs ORDER BY id DESC LIMIT ?").all(limit)
+      return rows as RunRow[]
+    },
+
+    async markDone(runId, output, steps) {
+      db.prepare(
+        `UPDATE runs SET status='done', result=?, steps=?, finished_at=datetime('now'),
+                         updated_at=datetime('now'), current_node=NULL WHERE id=?`,
+      ).run(JSON.stringify(output), JSON.stringify(steps), runId)
+    },
+
+    async markSuspended(runId, currentNode, steps) {
+      db.prepare(
+        `UPDATE runs SET status='suspended', steps=?, current_node=?, updated_at=datetime('now') WHERE id=?`,
+      ).run(JSON.stringify(steps), currentNode, runId)
+    },
+
+    async markError(runId, error) {
+      db.prepare(
+        "UPDATE runs SET status='error', error=?, finished_at=datetime('now'), updated_at=datetime('now') WHERE id=?",
+      ).run(error, runId)
+    },
+
+    async markRunning(runId, opts = {}) {
+      if (opts.clearCurrentNode ?? true) {
+        db.prepare(
+          "UPDATE runs SET status='running', trigger=?, current_node=NULL, updated_at=datetime('now') WHERE id=?",
+        ).run(opts.trigger ?? 'resumed', runId)
+      } else {
+        db.prepare(
+          "UPDATE runs SET status='running', trigger=?, updated_at=datetime('now') WHERE id=?",
+        ).run(opts.trigger ?? 'resumed', runId)
+      }
+    },
+
+    lastOutput(pipeline, opts) {
+      const status = opts?.status ?? "done"
+      const row = db.prepare(
+        "SELECT result FROM runs WHERE pipeline = ? AND status = ? ORDER BY id DESC LIMIT 1",
+      ).get(pipeline, status) as { result: string | null } | undefined
+      if (!row || row.result === null) return null
+      try { return JSON.parse(row.result) as unknown } catch { return null }
+    },
+
+    nodeOutput(pipeline, node, opts) {
+      const status = opts?.status ?? "done"
+      const row = db.prepare(
+        `SELECT no.output_json
+           FROM node_outputs no
+           JOIN runs r ON no.run_id = r.id
+          WHERE r.pipeline = ? AND r.status = ? AND no.node_id = ?
+          ORDER BY r.id DESC
+          LIMIT 1`,
+      ).get(pipeline, status, node) as { output_json: string | null } | undefined
+      if (!row || row.output_json === null) return null
+      try { return JSON.parse(row.output_json) as unknown } catch { return null }
+    },
+  }
+}
+
+export function createSqliteTaskStore(db: Database): TaskStore {
+  function get(taskId: number): TaskDescriptor | null {
+    const row = db.prepare(
+      `SELECT t.id, t.run_id, t.node_id, t.kind, t.prompt, t.schema_json, t.assignee,
+              t.response_token, t.status, r.pipeline AS pipeline
+         FROM tasks t LEFT JOIN runs r ON t.run_id = r.id
+        WHERE t.id = ?`,
+    ).get(taskId) as {
+      id: number; run_id: number; node_id: string; kind: string; prompt: string | null
+      schema_json: string | null; assignee: string | null
+      response_token: string; status: string; pipeline: string | null
+    } | undefined
+
+    if (!row) return null
+    return {
+      id: row.id,
+      runId: row.run_id,
+      pipeline: row.pipeline,
+      nodeId: row.node_id,
+      kind: row.kind as TaskDescriptor["kind"],
+      prompt: row.prompt ?? "",
+      schema: row.schema_json ? JSON.parse(row.schema_json) : null,
+      assignee: row.assignee,
+      responseToken: row.response_token,
+      status: row.status as TaskDescriptor["status"],
+    }
+  }
+
+  return {
+    async create(input) {
+      const inserted = db.prepare(
+        `INSERT INTO tasks (run_id, node_id, kind, prompt, schema_json, assignee, response_token)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         RETURNING id`,
+      ).get(
+        input.runId,
+        input.nodeId,
+        input.kind,
+        input.prompt,
+        input.schema != null ? JSON.stringify(input.schema) : null,
+        input.assignee,
+        input.token,
+      ) as { id: number }
+      return inserted.id
+    },
+
+    async get(taskId) {
+      return get(taskId)
+    },
+
+    async list(filter = {}) {
+      const status = filter.status ?? "open"
+      const limit = filter.limit ?? 200
+      const where: string[] = []
+      const args: Array<string | number> = []
+      if (status !== "all") { where.push("t.status = ?"); args.push(status) }
+      if (filter.assignee) { where.push("t.assignee = ?"); args.push(filter.assignee) }
+      if (filter.runId) { where.push("t.run_id = ?"); args.push(filter.runId) }
+      const whereSql = where.length ? `WHERE ${where.join(" AND ")}` : ""
+      args.push(limit)
+      const sql =
+        `SELECT t.id, t.run_id, t.node_id, t.kind, t.prompt, t.assignee, t.status,
+                t.created_at, t.responded_at, r.pipeline AS pipeline
+           FROM tasks t LEFT JOIN runs r ON t.run_id = r.id
+           ${whereSql}
+           ORDER BY t.id DESC LIMIT ?`
+      return db.prepare(sql).all(...args) as TaskListItem[]
+    },
+
+    async findOpenForNode(runId, nodeId) {
+      return (db.prepare(
+        "SELECT id FROM tasks WHERE run_id = ? AND node_id = ? AND status = 'open' ORDER BY id DESC LIMIT 1",
+      ).get(runId, nodeId) as { id: number } | undefined) ?? null
+    },
+
+    async findAnsweredForNode(runId, nodeId) {
+      const row = db.prepare(
+        "SELECT response_json FROM tasks WHERE run_id = ? AND node_id = ? AND status = 'answered' ORDER BY id DESC LIMIT 1",
+      ).get(runId, nodeId) as { response_json: string | null } | undefined
+      if (!row) return null
+      return { response: row.response_json ? JSON.parse(row.response_json) : null }
+    },
+
+    async answer(taskId, token, response, respondedBy) {
+      const task = get(taskId)
+      if (!task) throw new Error(`task ${taskId} not found`)
+      if (task.status !== "open") throw new Error(`task ${taskId} is ${task.status}, cannot answer`)
+      if (task.responseToken !== token) throw new Error(`task ${taskId}: invalid response token`)
+      db.prepare(
+        `UPDATE tasks
+           SET status = 'answered',
+               response_json = ?,
+               responded_by  = ?,
+               responded_at  = datetime('now')
+         WHERE id = ?`,
+      ).run(JSON.stringify(response ?? null), respondedBy, taskId)
+      return { ...task, status: "answered" }
+    },
+  }
+}
+
+export function createSqliteLogStore(db: Database): LogStore {
+  const stmt = db.prepare("INSERT INTO logs (run_id, level, msg) VALUES (?, ?, ?)")
+  return {
+    append(runId, level, msg) {
+      stmt.run(runId, level, msg)
+    },
+    async list(runId) {
+      return db.prepare(
+        "SELECT id, ts, level, msg FROM logs WHERE run_id = ? ORDER BY id ASC",
+      ).all(runId) as Array<{ id: number; ts: string; level: string; msg: string | null }>
+    },
+  }
+}
+
+export function createSqliteNodeOutputStore(db: Database): NodeOutputStore {
+  return {
+    async putMany(runId, outputs) {
+      const stmt = db.prepare(
+        `INSERT OR REPLACE INTO node_outputs (run_id, node_id, output_json, finished_at)
+         VALUES (?, ?, ?, datetime('now'))`,
+      )
+      const tx = db.transaction(() => {
+        for (const [nodeId, output] of Object.entries(outputs)) {
+          stmt.run(runId, nodeId, JSON.stringify(output ?? null))
+        }
+      })
+      tx()
+    },
+
+    async list(runId) {
+      const rows = db.prepare(
+        "SELECT node_id, output_json FROM node_outputs WHERE run_id = ?",
+      ).all(runId) as { node_id: string; output_json: string | null }[]
+      const out: Record<string, unknown> = {}
+      for (const row of rows) out[row.node_id] = row.output_json ? JSON.parse(row.output_json) : null
+      return out
+    },
+
+    async listOrdered(runId) {
+      const rows = db.prepare(
+        "SELECT node_id, output_json, started_at, finished_at FROM node_outputs WHERE run_id = ? ORDER BY started_at ASC",
+      ).all(runId) as Array<{ node_id: string; output_json: string | null; started_at: string; finished_at: string }>
+      return rows.map((row) => ({
+        nodeId: row.node_id,
+        output: row.output_json ? JSON.parse(row.output_json) : null,
+        startedAt: row.started_at,
+        finishedAt: row.finished_at,
+      }))
+    },
+  }
+}
+
+

package/src/stores/types.ts

@@ -0,0 +1,18 @@
+// 2121
+// Backwards-compat shim while aja internals switch to @toist/core as the
+// canonical home for runtime/store interfaces.
+
+export type {
+  ToistRuntime,
+  RunLedger,
+  RunRow,
+  TaskStore,
+  TaskListItem,
+  LogStore,
+  LogRow,
+  NodeOutputStore,
+  NodeOutputRow,
+  ResourceResolver,
+  KindRegistry,
+  TaskDescriptor,
+} from "@toist/core"

package/src/config.ts

@@ -1,129 +0,0 @@
-// 2121
-// Single source of truth for instance-relative paths. Per
-// context/instance-spec.md §3 + §5:
-//
-//   <rootDir>/
-//     instance.json          — optional metadata (§6)
-//     pipelines/             — pipeline YAML files
-//     resources/             — resource YAML files
-//     data/                  — runner-managed runtime state (gitignored):
-//       data.db              — host's domain data (schema-on-write)
-//       runtime.db           — platform ledger (runs/logs/tasks/node_outputs)
-//       cache.db             — TTL-driven cache
-//       .lock                — proper-lockfile holder (single-leader guard)
-//
-// rootDir resolution order:
-//   1. process.env.PLATFORM_ROOT_DIR       — explicit override (used by hosts
-//                                             that bootstrap @toist/aja from
-//                                             a non-cwd-aligned location)
-//   2. join(process.cwd(), "..")            — fallback matching the historic
-//                                             "server cwd is <root>/server"
-//                                             convention
-//
-// Note: the legacy `<rootDir>/.platform/` directory is platform-internal
-// dev-mode coordination (pm2 port handoff in runtime.json, CLI tooling output
-// in generated/). It is NOT part of the instance contract and is not exposed
-// from this module — start.ts and ecosystem.config.cjs handle it on their own.
-
-import { join } from "node:path"
-
-let rootDirOverride: string | null = null
-let uiDisabled = false
-let watchDisabled = false
-let corsOriginsConfig: string | string[] | null = null
-
-/** Set the rootDir explicitly. Used by `startRunner({rootDir, ...})` to
- *  configure paths before the db modules' static imports trigger their
- *  module-load init. Once set, the override wins over PLATFORM_ROOT_DIR
- *  and the cwd-parent fallback. Calling twice is an error — rootDir is
- *  once-set per process. */
-export function setRootDir(dir: string): void {
-  if (rootDirOverride !== null && rootDirOverride !== dir) {
-    throw new Error(
-      `[config] setRootDir(${JSON.stringify(dir)}) called after rootDir ` +
-      `was already set to ${JSON.stringify(rootDirOverride)}. ` +
-      `rootDir is once-set per process.`,
-    )
-  }
-  rootDirOverride = dir
-}
-
-/** Set the disableUi flag. Used by `startRunner({disableUi: true, ...})` to
- *  opt out of the bundled static-UI mount before server.ts's outer app
- *  construction reads the flag. Default: UI is enabled when the dist/
- *  directory in @toist/ui exists. */
-export function setDisableUi(v: boolean): void {
-  uiDisabled = v
-}
-
-export function isUiDisabled(): boolean {
-  return uiDisabled
-}
-
-/** Set the disableWatch flag. Used by `startRunner({disableWatch: true, ...})`
- *  to opt out of the filesystem watcher on pipelineDir/resourceDir. Default:
- *  watcher is enabled. Production deployments may set true to avoid
- *  inotify/fsevent overhead and accidental hot-reloads. */
-export function setDisableWatch(v: boolean): void {
-  watchDisabled = v
-}
-
-export function isWatchDisabled(): boolean {
-  return watchDisabled
-}
-
-/** Set the CORS allow-origin configuration. `string` for a single origin,
- *  `string[]` for an allowlist, `null` for default (permissive `*`).
- *  Per Hono's cors() middleware semantics. */
-export function setCorsOrigins(origins: string | string[] | null | undefined): void {
-  corsOriginsConfig = origins ?? null
-}
-
-export function getCorsOrigins(): string | string[] | null {
-  return corsOriginsConfig
-}
-
-export function resolveRootDir(): string {
-  if (rootDirOverride !== null) return rootDirOverride
-  const override = process.env.PLATFORM_ROOT_DIR
-  if (override && override.length > 0) return override
-  return join(process.cwd(), "..")
-}
-
-export function dataDir(): string {
-  const override = process.env.PLATFORM_DATA_DIR
-  if (override && override.length > 0) return override
-  return join(resolveRootDir(), "data")
-}
-
-export function dataDbPath(): string {
-  return join(dataDir(), "data.db")
-}
-
-export function runtimeDbPath(): string {
-  return join(dataDir(), "runtime.db")
-}
-
-export function cacheDbPath(): string {
-  return join(dataDir(), "cache.db")
-}
-
-export function lockfilePath(): string {
-  return join(dataDir(), ".lock")
-}
-
-export function instanceFilePath(): string {
-  return join(resolveRootDir(), "instance.json")
-}
-
-export function pipelinesDir(): string {
-  const override = process.env.PIPELINES_DIR
-  if (override && override.length > 0) return override
-  return join(resolveRootDir(), "pipelines")
-}
-
-export function resourcesDir(): string {
-  const override = process.env.RESOURCES_DIR
-  if (override && override.length > 0) return override
-  return join(resolveRootDir(), "resources")
-}