@starlove/orbit 1.4.1 → 2.0.0

package/src/core/events.js

@@ -1,314 +0,0 @@
-// Event recording and SSE fan-out. `recordEvent` is always called with the
-// per-board `db` and the owning `boardId`, so events get written to the
-// right per-board DB and SSE listeners only see events for the board they
-// subscribed to.
-//
-// Same-process HTTP mutations can broadcast immediately. MCP/CLI tools mutate
-// the same per-board SQLite DB from separate Node processes, so the web server
-// also keeps a lightweight per-board watcher while SSE clients are connected.
-// Watchers use SQLite `PRAGMA data_version` as the cheap "did another
-// connection commit?" check, then drain semantic rows from the `events` table.
-
-import { localOwnerActor } from "./auth.js";
-import { getBoardByRegistryId, openBoardDb } from "./registry.js";
-import { sendJson, setCors } from "./http.js";
-import { id, now } from "./util.js";
-
-const sseClients = new Set();
-const boardWatchers = new Map();
-const DEFAULT_SSE_POLL_MS = 500;
-const MIN_SSE_POLL_MS = 25;
-const MAX_SSE_POLL_MS = 30_000;
-const EVENT_BATCH_LIMIT = 200;
-// If a client's socket buffers more than this, it's not keeping up. We end
-// the stream so the browser reconnects and replays from Last-Event-ID rather
-// than letting Node's write buffer grow without bound.
-const SSE_MAX_BUFFERED_BYTES = 1_000_000;
-
-// Events written inside a tx() are not visible to other connections until
-// COMMIT, so broadcasting them immediately would tell SSE listeners about a
-// mutation that might still roll back. db.tx() brackets each transaction with
-// __enterEventTx/__settleEventTx; while depth > 0 we queue and only fan out
-// (or drop, on rollback) once the outermost transaction settles.
-let eventTxDepth = 0;
-const bufferedBroadcasts = [];
-
-export function __enterEventTx() {
-  eventTxDepth += 1;
-}
-
-export function __settleEventTx(committed) {
-  eventTxDepth -= 1;
-  if (eventTxDepth > 0) return;
-  const queued = bufferedBroadcasts.splice(0, bufferedBroadcasts.length);
-  if (!committed) return;
-  for (const item of queued) {
-    broadcastSSE(item.payload);
-    advanceWatcherCursorByRowid(item.boardId, item.rowid);
-  }
-}
-
-export function recordEvent(db, boardId, type, ticketId, actor, body) {
-  const eventId = id();
-  const timestamp = now();
-  const result = db.prepare(
-    "INSERT INTO events (id, ticket_id, actor, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-  ).run(eventId, ticketId, actor, type, JSON.stringify(body || {}), timestamp);
-
-  const payload = {
-    id: eventId,
-    type,
-    ticket_id: ticketId,
-    board_id: boardId,
-    actor,
-    data: body || {},
-    timestamp
-  };
-
-  if (eventTxDepth > 0) {
-    bufferedBroadcasts.push({ payload, boardId, rowid: result.lastInsertRowid });
-    return;
-  }
-  broadcastSSE(payload);
-  advanceWatcherCursorByRowid(boardId, result.lastInsertRowid);
-}
-
-export function startSSEStream(req, res, url) {
-  const actor = localOwnerActor();
-
-  const boardId = url.searchParams.get("board_id") || null;
-  let board = null;
-  if (boardId) {
-    board = getBoardByRegistryId(boardId);
-    if (!board) {
-      sendJson(res, 404, { error: "board_not_found" });
-      return;
-    }
-  }
-
-  const lastEventId = req.headers["last-event-id"] || url.searchParams.get("last_event_id") || null;
-  const watcher = board ? getOrCreateBoardWatcher(board) : null;
-
-  setCors(res);
-  res.writeHead(200, {
-    "Content-Type": "text/event-stream",
-    "Cache-Control": "no-cache",
-    Connection: "keep-alive",
-    "X-Accel-Buffering": "no"
-  });
-  res.write(":ok\n\n");
-
-  if (lastEventId && board) {
-    replayEventsForBoard(res, board, lastEventId);
-  }
-
-  const heartbeat = setInterval(() => {
-    if (!res.writableEnded) res.write(":heartbeat\n\n");
-  }, 30_000);
-
-  const client = { res, boardId, boardRow: board, actor, heartbeat, watcher };
-  sseClients.add(client);
-  if (watcher) watcher.clients.add(client);
-
-  req.on("close", () => {
-    clearInterval(heartbeat);
-    sseClients.delete(client);
-    if (watcher) {
-      watcher.clients.delete(client);
-      stopBoardWatcherIfIdle(watcher);
-    }
-  });
-}
-
-function getOrCreateBoardWatcher(boardRow) {
-  const existing = boardWatchers.get(boardRow.id);
-  if (existing) {
-    existing.boardRow = boardRow;
-    return existing;
-  }
-
-  const watcher = {
-    boardId: boardRow.id,
-    boardRow,
-    clients: new Set(),
-    dataVersion: dataVersionForBoard(boardRow),
-    cursor: latestEventCursor(boardRow),
-    timer: null
-  };
-  watcher.timer = setInterval(() => pollBoardWatcher(watcher), ssePollIntervalMs());
-  watcher.timer.unref?.();
-  boardWatchers.set(boardRow.id, watcher);
-  return watcher;
-}
-
-function stopBoardWatcherIfIdle(watcher) {
-  if (watcher.clients.size > 0) return;
-  clearInterval(watcher.timer);
-  boardWatchers.delete(watcher.boardId);
-}
-
-function pollBoardWatcher(watcher) {
-  if (watcher.clients.size === 0) {
-    stopBoardWatcherIfIdle(watcher);
-    return;
-  }
-
-  let nextDataVersion;
-  try {
-    nextDataVersion = dataVersionForBoard(watcher.boardRow);
-  } catch (error) {
-    console.warn(`[orbit] Failed to read data_version for board ${watcher.boardId}: ${error.message}`);
-    return;
-  }
-
-  if (nextDataVersion === watcher.dataVersion) return;
-  watcher.dataVersion = nextDataVersion;
-  drainBoardWatcherEvents(watcher);
-}
-
-function drainBoardWatcherEvents(watcher) {
-  try {
-    while (true) {
-      const rows = eventsAfterCursor(watcher.boardRow, watcher.cursor);
-      if (rows.length === 0) return;
-
-      for (const row of rows) {
-        const event = eventFromRow(watcher.boardRow, row);
-        for (const client of watcher.clients) {
-          writeSSEFrame(client.res, event);
-        }
-        watcher.cursor = eventCursor(row);
-      }
-
-      if (rows.length < EVENT_BATCH_LIMIT) return;
-    }
-  } catch (error) {
-    console.warn(`[orbit] Failed to poll events for board ${watcher.boardId}: ${error.message}`);
-  }
-}
-
-function ssePollIntervalMs() {
-  const raw = process.env.ORBIT_SSE_POLL_MS;
-  const value = raw === undefined ? DEFAULT_SSE_POLL_MS : Number(raw);
-  if (!Number.isFinite(value) || value <= 0) return DEFAULT_SSE_POLL_MS;
-  return Math.min(MAX_SSE_POLL_MS, Math.max(MIN_SSE_POLL_MS, Math.trunc(value)));
-}
-
-function dataVersionForBoard(boardRow) {
-  const row = openBoardDb(boardRow).prepare("PRAGMA data_version").get();
-  return Number(row?.data_version || 0);
-}
-
-function replayEventsForBoard(res, boardRow, afterId) {
-  const db = openBoardDb(boardRow);
-  const anchor = db.prepare("SELECT rowid AS event_rowid FROM events WHERE id = ?").get(afterId);
-  if (!anchor) return latestEventCursor(boardRow);
-
-  let cursor = eventCursor(anchor);
-  const rows = db
-    .prepare(
-      `SELECT e.rowid AS event_rowid, e.id, e.type, e.ticket_id, e.actor, e.body_json, e.created_at
-       FROM events e
-       WHERE e.rowid > ?
-       ORDER BY e.rowid LIMIT ${EVENT_BATCH_LIMIT}`
-    )
-    .all(anchor.event_rowid);
-
-  for (const row of rows) {
-    const event = eventFromRow(boardRow, row);
-    writeSSEFrame(res, event);
-    cursor = eventCursor(row);
-  }
-  return cursor;
-}
-
-function latestEventCursor(boardRow) {
-  const db = openBoardDb(boardRow);
-  const row = db
-    .prepare("SELECT rowid AS event_rowid FROM events ORDER BY rowid DESC LIMIT 1")
-    .get();
-  return eventCursor(row);
-}
-
-function eventCursor(row) {
-  if (!row) return null;
-  return { event_rowid: Number(row.event_rowid) };
-}
-
-function compareCursors(left, right) {
-  if (!left && !right) return 0;
-  if (!left) return -1;
-  if (!right) return 1;
-  if (left.event_rowid > right.event_rowid) return 1;
-  if (left.event_rowid < right.event_rowid) return -1;
-  return 0;
-}
-
-function eventsAfterCursor(boardRow, cursor) {
-  const db = openBoardDb(boardRow);
-  if (!cursor) {
-    return db
-      .prepare(
-        `SELECT e.rowid AS event_rowid, e.id, e.type, e.ticket_id, e.actor, e.body_json, e.created_at
-         FROM events e
-         ORDER BY e.rowid LIMIT ${EVENT_BATCH_LIMIT}`
-      )
-      .all();
-  }
-  return db
-    .prepare(
-      `SELECT e.rowid AS event_rowid, e.id, e.type, e.ticket_id, e.actor, e.body_json, e.created_at
-       FROM events e
-       WHERE e.rowid > ?
-       ORDER BY e.rowid LIMIT ${EVENT_BATCH_LIMIT}`
-    )
-    .all(cursor.event_rowid);
-}
-
-function eventFromRow(boardRow, row) {
-  return {
-    id: row.id,
-    type: row.type,
-    ticket_id: row.ticket_id,
-    board_id: boardRow.id,
-    actor: row.actor,
-    data: parseEventBody(row.body_json),
-    timestamp: row.created_at
-  };
-}
-
-function parseEventBody(bodyJson) {
-  try {
-    return JSON.parse(bodyJson || "{}");
-  } catch {
-    return {};
-  }
-}
-
-function advanceWatcherCursorByRowid(boardId, rowid) {
-  const watcher = boardWatchers.get(boardId);
-  if (!watcher) return;
-  const cursor = { event_rowid: Number(rowid) };
-  if (cursor && compareCursors(cursor, watcher.cursor) > 0) {
-    watcher.cursor = cursor;
-  }
-}
-
-function broadcastSSE(event) {
-  for (const client of sseClients) {
-    if (client.boardId && event.board_id !== client.boardId) continue;
-    writeSSEFrame(client.res, event);
-  }
-}
-
-function writeSSEFrame(res, event) {
-  if (res.writableEnded) return;
-  // A backpressured client (closed laptop, dead tab) would otherwise make
-  // Node buffer every event in memory forever. Cut it loose; the EventSource
-  // client reconnects and replays missed events via Last-Event-ID.
-  if (res.writableLength > SSE_MAX_BUFFERED_BYTES) {
-    res.end();
-    return;
-  }
-  res.write(`id: ${event.id}\nevent: board\ndata: ${JSON.stringify(event)}\n\n`);
-}

package/src/core/http.js

@@ -1,115 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { createReadStream } from "node:fs";
-import { extname, join, resolve as resolvePath } from "node:path";
-import { bundleCss } from "./css-bundle.js";
-import { PUBLIC_DIR, ROOT_DIR } from "./paths.js";
-import { httpError } from "./util.js";
-
-export function setCors(res) {
-  res.setHeader("Access-Control-Allow-Origin", "*");
-  res.setHeader("Access-Control-Allow-Methods", "GET,POST,PATCH,DELETE,OPTIONS");
-  res.setHeader(
-    "Access-Control-Allow-Headers",
-    "Content-Type,Authorization,X-Orbit-Actor-Type,X-Orbit-Actor-Name,X-Orbit-Actor-Id,X-Orbit-Agent-Name,X-File-Name"
-  );
-}
-
-export function sendJson(res, status, body) {
-  setCors(res);
-  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
-  res.end(JSON.stringify(body, null, 2));
-}
-
-export function sendEmpty(res, status) {
-  setCors(res);
-  res.writeHead(status);
-  res.end();
-}
-
-export const MAX_JSON_BODY_BYTES = 100 * 1024 * 1024;
-
-export async function readJson(req, maxBytes = MAX_JSON_BODY_BYTES) {
-  const buffer = await readRaw(req, maxBytes);
-  if (buffer.length === 0) return {};
-  const text = buffer.toString("utf8");
-  if (!text.trim()) return {};
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw httpError(400, "invalid_json");
-  }
-}
-
-export async function readRaw(req, maxBytes) {
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of req) {
-    size += chunk.length;
-    if (size > maxBytes) throw httpError(413, "payload_too_large");
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks);
-}
-
-export function sendFile(res, filePath, mimeType) {
-  setCors(res);
-  res.writeHead(200, {
-    "Content-Type": mimeType || contentType(filePath),
-    "Cache-Control": "private, max-age=3600"
-  });
-  createReadStream(filePath).pipe(res);
-}
-
-function contentType(filePath) {
-  const types = {
-    ".html": "text/html; charset=utf-8",
-    ".css": "text/css; charset=utf-8",
-    ".js": "text/javascript; charset=utf-8",
-    ".json": "application/json; charset=utf-8",
-    ".svg": "image/svg+xml"
-  };
-  return types[extname(filePath)] || "application/octet-stream";
-}
-
-function shouldBundleSourceStyles(pathname, filePath) {
-  return pathname === "/styles.css" && filePath === join(ROOT_DIR, "public", "styles.css");
-}
-
-export function staticAssetPathname(pathname) {
-  return pathname === "/app" || pathname.startsWith("/app/")
-    ? pathname.slice(4) || "/"
-    : pathname;
-}
-
-export async function serveStatic(req, res, pathname) {
-  if (req.method !== "GET" && req.method !== "HEAD") {
-    sendEmpty(res, 405);
-    return;
-  }
-
-  const staticPathname = staticAssetPathname(pathname);
-  const requested = staticPathname === "/" ? "/index.html" : staticPathname;
-  const filePath = resolvePath(PUBLIC_DIR, `.${decodeURIComponent(requested)}`);
-  if (!filePath.startsWith(PUBLIC_DIR)) {
-    sendEmpty(res, 403);
-    return;
-  }
-
-  try {
-    const data = shouldBundleSourceStyles(staticPathname, filePath)
-      ? Buffer.from((await bundleCss({ entryPoint: filePath, outfile: filePath })).cssFile.contents)
-      : await readFile(filePath);
-    res.writeHead(200, {
-      "Content-Type": contentType(filePath),
-      "Cache-Control": "no-store"
-    });
-    if (req.method !== "HEAD") res.end(data);
-    else res.end();
-  } catch {
-    if (pathname !== "/") {
-      await serveStatic(req, res, "/");
-    } else {
-      sendEmpty(res, 404);
-    }
-  }
-}

package/src/core/migrate.js

@@ -1,198 +0,0 @@
-/**
- * migrate.js — one-time startup migration of per-board SQLite files from
- * in-repo .orbit/ directories into the central DATA_DIR/boards/<slug>/ store.
- *
- * Called during board.js startup, before ensureSchemaForEveryBoard, so that
- * by the time per-board connections are opened they are already at their
- * canonical central location.
- *
- * If a migration fails the registry row is NOT updated and Orbit continues
- * to serve from the old in-repo path. A structured warning with agent-actionable
- * manual instructions is printed to stderr.
- */
-import { existsSync, mkdirSync, readdirSync, rmSync, unlinkSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { closeConnection, getRegistry, openConnection } from "./db.js";
-import { BOARDS_DIR } from "./paths.js";
-import { listBoards } from "./registry.js";
-
-/** Normalize to forward slashes for consistent cross-platform prefix checks. */
-const fwd = (p) => p.replace(/\\/g, "/");
-
-/** True when db_path already lives inside the canonical BOARDS_DIR. */
-function isCentral(dbPath) {
-  return fwd(dbPath).startsWith(fwd(BOARDS_DIR) + "/");
-}
-
-/** Canonical central path for a given slug. */
-function centralPathFor(slug) {
-  return join(BOARDS_DIR, slug, "board.db");
-}
-
-/** Delete a file if it exists; silently ignore errors. */
-function tryUnlink(p) {
-  try { if (existsSync(p)) unlinkSync(p); } catch { /* ignore */ }
-}
-
-/**
- * Walk upward from startDir, removing each directory that is now empty.
- * Stops at stopDir (inclusive) or the first non-empty directory.
- * This cleans up empty .orbit/ trees left behind after moving the db out.
- */
-function pruneEmptyAncestors(startDir, stopDir) {
-  const stopFwd = fwd(stopDir);
-  let cur = fwd(startDir);
-  while (cur.startsWith(stopFwd)) {
-    try {
-      if (!existsSync(cur)) {
-        /* already gone, climb */
-      } else if (readdirSync(cur).length > 0) {
-        break; // non-empty — stop here
-      } else {
-        // rmSync({recursive:true, force:true}) works correctly for both files and
-        // empty directories across Node versions and platforms.  We've already
-        // confirmed the directory is empty so nothing is over-deleted.
-        rmSync(cur, { recursive: true, force: true });
-      }
-    } catch {
-      break;
-    }
-    if (cur === stopFwd) break; // reached the limit
-    const parent = fwd(dirname(cur));
-    if (parent === cur) break; // filesystem root
-    cur = parent;
-  }
-}
-
-/**
- * For a db path inside a repo's .orbit directory, return the .orbit parent.
- *   /repo/.orbit/board.db          → /repo/.orbit
- *   /repo/.orbit/boards/x/board.db → /repo/.orbit
- * Returns null if ".orbit" is not found in the path.
- */
-function orbitParentDir(dbPath) {
-  const parts = fwd(dbPath).split("/");
-  const idx = parts.lastIndexOf(".orbit");
-  if (idx < 0) return null;
-  return parts.slice(0, idx + 1).join("/");
-}
-
-function sqlLiteral(v) {
-  return `'${String(v).replace(/'/g, "''")}'`;
-}
-
-/**
- * Attempt to migrate one board from in-repo storage to central storage.
- * Returns a result object with status: 'migrated' | 'failed' | 'missing_source'.
- */
-function migrateOneBoard(boardRow) {
-  const { id, slug, db_path: oldPath } = boardRow;
-
-  if (!existsSync(oldPath)) {
-    // Source file is gone; ensureSchemaForEveryBoard will prune the stale row.
-    return { status: "missing_source", board: boardRow, oldPath };
-  }
-
-  const newPath = centralPathFor(slug);
-  mkdirSync(dirname(newPath), { recursive: true });
-
-  try {
-    // Safety: if the target path is already registered to a *different* board id,
-    // skip rather than overwrite live data (guards against corrupted registries with
-    // duplicate slugs — cannot happen through normal API use but is defensive).
-    const existingOwner = getRegistry().prepare("SELECT id FROM boards WHERE db_path = ?").get(newPath);
-    if (existingOwner && existingOwner.id !== id) {
-      return {
-        status: "failed",
-        board: boardRow,
-        oldPath,
-        newPath,
-        error: new Error(
-          `central path ${newPath} is already registered to board ${existingOwner.id} — skipping to avoid data loss`
-        )
-      };
-    }
-
-    // Remove any stale central copy left by a previous partial migration.
-    if (existsSync(newPath)) tryUnlink(newPath);
-
-    // VACUUM INTO creates a clean, WAL-flushed copy. It captures only committed
-    // data and produces a single-file database (no -wal/-shm at the destination).
-    const db = openConnection(oldPath);
-    db.exec(`VACUUM INTO ${sqlLiteral(newPath)};`);
-    closeConnection(oldPath);
-
-    // Update the registry before deleting the source so the canonical pointer is
-    // always valid: if the process dies between these two steps the old file still
-    // exists and the next run will redo the migration cleanly.
-    getRegistry()
-      .prepare("UPDATE boards SET db_path = ?, updated_at = ? WHERE id = ?")
-      .run(newPath, new Date().toISOString(), id);
-
-    // Remove source files (main db + WAL + SHM + journal).
-    tryUnlink(oldPath);
-    tryUnlink(oldPath + "-wal");
-    tryUnlink(oldPath + "-shm");
-    tryUnlink(oldPath + "-journal");
-
-    // Prune now-empty .orbit/ directories from the repo tree.
-    const orbitDir = orbitParentDir(oldPath);
-    if (orbitDir) pruneEmptyAncestors(dirname(oldPath), orbitDir);
-
-    return { status: "migrated", board: boardRow, oldPath, newPath };
-  } catch (error) {
-    // Ensure no lingering open connection or partial central file on failure.
-    try { closeConnection(oldPath); } catch { /* ignore */ }
-    tryUnlink(newPath);
-    return { status: "failed", board: boardRow, oldPath, newPath, error };
-  }
-}
-
-/**
- * Migrate all boards whose db_path lives outside DATA_DIR into central storage.
- * Called at server/MCP startup before any per-board connections are opened.
- * Prints a concise summary for migrated boards; prints agent-actionable
- * instructions for any failures so a human or AI can complete the migration.
- */
-export function migrateInRepoBoards() {
-  const pending = listBoards().filter((row) => !isCentral(row.db_path));
-  if (pending.length === 0) return;
-
-  const results = pending.map(migrateOneBoard);
-  const migrated = results.filter((r) => r.status === "migrated");
-  const failed = results.filter((r) => r.status === "failed");
-
-  if (migrated.length > 0) {
-    const n = migrated.length;
-    console.log(`[orbit] Migrated ${n} board${n > 1 ? "s" : ""} to central storage (${BOARDS_DIR}):`);
-    for (const r of migrated) {
-      console.log(`  ✓ ${r.board.slug}`);
-      console.log(`    from: ${r.oldPath}`);
-      console.log(`    to:   ${r.newPath}`);
-    }
-  }
-
-  if (failed.length > 0) {
-    const sep = "  │";
-    const n = failed.length;
-    console.error(`\n[orbit] ⚠ Could not auto-migrate ${n} board${n > 1 ? "s" : ""} to central storage.`);
-    console.error(`${sep} These boards continue to work from their current paths.`);
-    console.error(`${sep} To complete the migration manually, run the commands below and`);
-    console.error(`${sep} restart orbit run:\n`);
-    for (const r of failed) {
-      const slash = process.platform === "win32" ? "\\" : "/";
-      const destDir = dirname(r.newPath).replace(/\//g, slash);
-      const src = r.oldPath.replace(/\//g, slash);
-      const dest = r.newPath.replace(/\//g, slash);
-      console.error(`${sep} Board: ${r.board.slug}  (error: ${r.error?.message ?? r.error})`);
-      if (process.platform === "win32") {
-        console.error(`${sep}   md "${destDir}"`);
-        console.error(`${sep}   copy "${src}" "${dest}"`);
-      } else {
-        console.error(`${sep}   mkdir -p '${destDir}'`);
-        console.error(`${sep}   cp '${src}' '${dest}'`);
-      }
-      console.error(sep);
-    }
-  }
-}

package/src/core/paths.js

@@ -1,55 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-export const ROOT_DIR = resolve(__dirname, "..", "..");
-
-const _distFull = join(ROOT_DIR, "dist", "full");
-const _publicDir = join(ROOT_DIR, "public");
-
-/** Where static assets (HTML/JS/CSS) are served from.
- *
- *  public/  — editable source; `pnpm dev` bundles @starlove/ui imports on the fly.
- *  dist/full — prebuilt, hashed bundles from `pnpm build`; what Docker/npm ship.
- *
- *  Auto (default): public/ when it exists, else dist/full. Repo dev therefore
- *  always sees live CSS/JS edits. Docker and other dist-only installs fall back
- *  to the bundle without needing an env var.
- *
- *  Override: ORBIT_USE_DIST=1 force dist/full, ORBIT_USE_DIST=0 force public/. */
-function resolvePublicDir() {
-    const distExists = existsSync(_distFull);
-    const publicExists = existsSync(_publicDir);
-    const pref = process.env.ORBIT_USE_DIST;
-
-    if (pref === "1" && distExists) return _distFull;
-    if (pref === "0" && publicExists) return _publicDir;
-    if (publicExists) return _publicDir;
-    if (distExists) return _distFull;
-    return _publicDir;
-}
-
-export const PUBLIC_DIR = resolvePublicDir();
-export const MCP_SERVER_PATH = join(ROOT_DIR, "src", "mcp-server.js");
-/** Repo root for default board placement; cwd unless PROJECT_ROOT is set. */
-export const PROJECT_ROOT = process.env.PROJECT_ROOT ? resolve(process.env.PROJECT_ROOT) : resolve(process.cwd());
-// Store registry + exports in ~/.orbit so global installs don't write into the package dir.
-export const DATA_DIR = process.env.DATA_DIR || join(homedir(), ".orbit");
-/** Central registry of all boards (metadata + paths to per-board SQLite files). */
-export const REGISTRY_DB_PATH = join(DATA_DIR, "registry.db");
-/** Central directory where every board's SQLite file lives: DATA_DIR/boards/<slug>/board.db */
-export const BOARDS_DIR = join(DATA_DIR, "boards");
-export const EXPORT_DIR = join(DATA_DIR, "exports");
-export const BACKUP_DIR = join(DATA_DIR, "backups");
-/** Central directory for dispatch run artifacts: DATA_DIR/dispatch-runs/<board-slug>/<run-id>/ */
-export const DISPATCH_RUNS_DIR = join(DATA_DIR, "dispatch-runs");
-export const PORT = Number(process.env.PORT || 13701);
-
-mkdirSync(DATA_DIR, { recursive: true });
-mkdirSync(BOARDS_DIR, { recursive: true });
-mkdirSync(EXPORT_DIR, { recursive: true });
-mkdirSync(BACKUP_DIR, { recursive: true });
-mkdirSync(DISPATCH_RUNS_DIR, { recursive: true });