@starlove/orbit 1.0.1

package/src/core/bootstrap.js

@@ -0,0 +1,162 @@
+import { compactTicket, ticketById } from "./queries.js";
+import { canAccessBoard, publicActor } from "./auth.js";
+import { EXPORT_DIR } from "./paths.js";
+import {
+  getBoardByRegistryId,
+  listBoards,
+  openBoardDb,
+  pickDefaultBoard,
+  touchBoardActive
+} from "./registry.js";
+
+function boardSummaryFromRegistry(r) {
+  return {
+    id: r.id,
+    slug: r.slug,
+    name: r.name,
+    repo_url: r.repo_url,
+    default_branch: r.default_branch,
+    repo_path: r.repo_path,
+    system_path: r.repo_path,
+    project_notes: "",
+    agent_instructions: "",
+    ai_enabled: 0,
+    created_at: r.created_at,
+    updated_at: r.updated_at
+  };
+}
+
+/**
+ * Build the bootstrap payload for one board (or just registry metadata if the
+ * actor has no accessible boards). No global state is mutated; the chosen
+ * board's last_active_at is bumped so subsequent default-pick prefers it.
+ *
+ * @param actor authenticated actor
+ * @param requestedBoardId optional board id from `?board_id=` (or null)
+ */
+export function getBootstrap(actor, requestedBoardId = null) {
+  const registryRows = listBoards();
+  const accessible = registryRows.filter((row) => canAccessBoard(actor, { slug: row.slug }));
+
+  if (accessible.length === 0) {
+    return {
+      actor: publicActor(actor),
+      meta: {
+        db_path: null,
+        export_dir: EXPORT_DIR
+      },
+      boards: [],
+      board_entries: [],
+      states: [],
+      labels: [],
+      tickets: []
+    };
+  }
+
+  let chosen = null;
+  if (requestedBoardId) {
+    chosen = accessible.find((row) => row.id === requestedBoardId) || null;
+  }
+  if (!chosen) {
+    const defaultRow = pickDefaultBoard();
+    if (defaultRow && accessible.some((row) => row.id === defaultRow.id)) {
+      chosen = defaultRow;
+    }
+  }
+  if (!chosen) {
+    const sorted = [...accessible].sort(
+      (a, b) =>
+        String(b.last_active_at || "").localeCompare(String(a.last_active_at || "")) ||
+        String(a.name).localeCompare(String(b.name))
+    );
+    chosen = sorted[0];
+  }
+
+  // Re-fetch in case the chosen row came from pickDefaultBoard before the
+  // accessible filter. Either way, this is the row we open.
+  const chosenRow = getBoardByRegistryId(chosen.id);
+  touchBoardActive(chosenRow.id);
+  const db = openBoardDb(chosenRow);
+  const innerBoard = db.prepare("SELECT * FROM boards LIMIT 1").get();
+
+  const boards = accessible.map((r) => {
+    if (innerBoard && r.id === innerBoard.id) {
+      return {
+        ...innerBoard,
+        repo_path: r.repo_path,
+        system_path: innerBoard.system_path || r.repo_path
+      };
+    }
+    return boardSummaryFromRegistry(r);
+  });
+
+  const boardIds = new Set(innerBoard ? [innerBoard.id] : []);
+
+  const states = db
+    .prepare("SELECT * FROM states ORDER BY position")
+    .all()
+    .filter((state) => boardIds.has(state.board_id));
+
+  const tickets = db
+    .prepare(
+      `SELECT t.*, s.name AS state_name, s.role AS state_role,
+              b.slug AS board_slug, b.name AS board_name
+       FROM tickets t
+       JOIN states s ON s.id = t.state_id
+       JOIN boards b ON b.id = t.board_id
+       WHERE t.archived_at IS NULL
+       ORDER BY t.updated_at DESC`
+    )
+    .all()
+    .filter((ticket) => boardIds.has(ticket.board_id));
+
+  const labels = db
+    .prepare("SELECT * FROM labels ORDER BY name")
+    .all()
+    .filter((label) => boardIds.has(label.board_id));
+
+  const ticketLabels = db
+    .prepare(
+      `SELECT tl.ticket_id, l.id, l.name, l.color
+       FROM ticket_labels tl
+       JOIN labels l ON l.id = tl.label_id`
+    )
+    .all()
+    .filter((label) => tickets.some((ticket) => ticket.id === label.ticket_id));
+
+  const commentCounts = db
+    .prepare("SELECT ticket_id, COUNT(*) AS count FROM comments GROUP BY ticket_id")
+    .all()
+    .filter((row) => tickets.some((ticket) => ticket.id === row.ticket_id));
+
+  const childCounts = db
+    .prepare(
+      "SELECT parent_ticket_id AS ticket_id, COUNT(*) AS count FROM tickets WHERE parent_ticket_id IS NOT NULL AND archived_at IS NULL GROUP BY parent_ticket_id"
+    )
+    .all()
+    .filter((row) => tickets.some((ticket) => ticket.id === row.ticket_id));
+
+  const boardEntries = db
+    .prepare("SELECT * FROM board_entries ORDER BY created_at DESC")
+    .all()
+    .filter((entry) => boardIds.has(entry.board_id));
+
+  return {
+    actor: publicActor(actor),
+    meta: {
+      db_path: chosenRow.db_path,
+      export_dir: EXPORT_DIR
+    },
+    boards,
+    board_entries: boardEntries,
+    states,
+    labels,
+    tickets: tickets.map((ticket) => ({
+      ...ticket,
+      labels: ticketLabels.filter((label) => label.ticket_id === ticket.id),
+      comment_count: commentCounts.find((row) => row.ticket_id === ticket.id)?.count || 0,
+      child_count: childCounts.find((row) => row.ticket_id === ticket.id)?.count || 0,
+      parent_ticket: ticket.parent_ticket_id ? compactTicket(ticketById(db, ticket.parent_ticket_id)) : null
+    }))
+  };
+}

package/src/core/db.js

@@ -0,0 +1,237 @@
+// Connection management. There is intentionally no module-level "active board"
+// singleton: every caller resolves a per-board DB connection via openConnection
+// and threads it through. This is what makes the server safe under concurrent
+// HTTP requests for different boards — a global active-pointer would race
+// across requests that interleave around `await readJson`.
+
+import { DatabaseSync } from "node:sqlite";
+import { REGISTRY_DB_PATH } from "./paths.js";
+import { __enterEventTx, __settleEventTx } from "./events.js";
+
+const connections = new Map();
+
+/** Open (or return cached) per-database connection. Safe to share within a process. */
+export function openConnection(dbPath) {
+  if (connections.has(dbPath)) return connections.get(dbPath);
+  const conn = new DatabaseSync(dbPath);
+  conn.exec("PRAGMA foreign_keys = ON;");
+  conn.exec("PRAGMA busy_timeout = 5000;");
+  conn.exec("PRAGMA journal_mode = WAL;");
+  // busy_timeout (set above) makes a second writer from another process (MCP
+  // server, CLI) wait instead of failing immediately with SQLITE_BUSY when an
+  // agent commit and a UI drag overlap. NORMAL is the recommended
+  // durability/throughput tradeoff under WAL (a power-loss can lose the last
+  // commit but never corrupts the DB).
+  conn.exec("PRAGMA synchronous = NORMAL;");
+  connections.set(dbPath, conn);
+  return conn;
+}
+
+export function closeConnection(dbPath) {
+  const conn = connections.get(dbPath);
+  if (!conn) return;
+  conn.close();
+  connections.delete(dbPath);
+}
+
+// Reentrancy depth per connection. Only the outermost tx() issues
+// BEGIN/COMMIT/ROLLBACK; inner calls (a tx-wrapped function calling another)
+// fold into the enclosing transaction. Execution is synchronous and a request
+// never awaits between BEGIN and COMMIT, so per-connection depth is race-free.
+const txDepth = new WeakMap();
+
+/**
+ * Run `fn` inside an IMMEDIATE transaction on `db` so a multi-statement
+ * mutation is atomic: it either fully lands or fully rolls back. BEGIN
+ * IMMEDIATE takes the write lock up front, which also makes read-then-write
+ * sequences (e.g. `MAX(number)+1` ticket numbering) safe against concurrent
+ * writer processes. SSE broadcasts for events recorded inside the transaction
+ * are buffered and only fan out after COMMIT (see events.js).
+ */
+export function tx(db, fn) {
+  const depth = txDepth.get(db) || 0;
+  if (depth === 0) db.exec("BEGIN IMMEDIATE;");
+  txDepth.set(db, depth + 1);
+  __enterEventTx();
+  try {
+    const result = fn();
+    const next = txDepth.get(db) - 1;
+    txDepth.set(db, next);
+    if (next === 0) db.exec("COMMIT;");
+    __settleEventTx(true);
+    return result;
+  } catch (error) {
+    const next = txDepth.get(db) - 1;
+    txDepth.set(db, next);
+    if (next === 0) {
+      try {
+        db.exec("ROLLBACK;");
+      } catch {
+        // A failed BEGIN leaves no transaction to roll back; ignore.
+      }
+    }
+    __settleEventTx(false);
+    throw error;
+  }
+}
+
+export function getRegistry() {
+  return openConnection(REGISTRY_DB_PATH);
+}
+
+/** Registry metadata table (not the per-board `boards` content row). */
+export function createRegistrySchema(reg = getRegistry()) {
+  reg.exec(`
+    CREATE TABLE IF NOT EXISTS boards (
+      id TEXT PRIMARY KEY,
+      slug TEXT NOT NULL UNIQUE,
+      name TEXT NOT NULL,
+      repo_path TEXT NOT NULL DEFAULT '',
+      db_path TEXT NOT NULL,
+      repo_url TEXT NOT NULL DEFAULT '',
+      default_branch TEXT NOT NULL DEFAULT 'main',
+      last_active_at TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_registry_boards_repo_path ON boards(repo_path);
+  `);
+}
+
+/** Full Kanban schema on a per-board database connection. */
+export function createBoardSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS boards (
+      id TEXT PRIMARY KEY,
+      slug TEXT NOT NULL UNIQUE,
+      name TEXT NOT NULL,
+      repo_url TEXT NOT NULL DEFAULT '',
+      system_path TEXT NOT NULL DEFAULT '',
+      default_branch TEXT NOT NULL DEFAULT 'main',
+      project_notes TEXT NOT NULL DEFAULT '',
+      agent_instructions TEXT NOT NULL DEFAULT '',
+      ai_enabled INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS states (
+      id TEXT PRIMARY KEY,
+      board_id TEXT NOT NULL REFERENCES boards(id) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      position INTEGER NOT NULL,
+      is_default INTEGER NOT NULL DEFAULT 0,
+      role TEXT,
+      created_at TEXT NOT NULL,
+      UNIQUE(board_id, name)
+    );
+
+    CREATE TABLE IF NOT EXISTS tickets (
+      id TEXT PRIMARY KEY,
+      board_id TEXT NOT NULL REFERENCES boards(id) ON DELETE CASCADE,
+      number INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      type TEXT NOT NULL DEFAULT 'task',
+      parent_ticket_id TEXT,
+      ai_plan TEXT NOT NULL DEFAULT '',
+      implementation_summary TEXT NOT NULL DEFAULT '',
+      implementation_updates TEXT NOT NULL DEFAULT '',
+      state_id TEXT NOT NULL REFERENCES states(id),
+      priority INTEGER NOT NULL DEFAULT 2,
+      created_by TEXT NOT NULL DEFAULT 'human',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      archived_at TEXT,
+      UNIQUE(board_id, number)
+    );
+
+    CREATE TABLE IF NOT EXISTS comments (
+      id TEXT PRIMARY KEY,
+      ticket_id TEXT NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
+      author TEXT NOT NULL,
+      kind TEXT NOT NULL DEFAULT 'comment',
+      body TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS board_entries (
+      id TEXT PRIMARY KEY,
+      board_id TEXT NOT NULL REFERENCES boards(id) ON DELETE CASCADE,
+      type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      body TEXT NOT NULL DEFAULT '',
+      ticket_id TEXT REFERENCES tickets(id) ON DELETE SET NULL,
+      created_by TEXT NOT NULL DEFAULT 'human',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      struck_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS labels (
+      id TEXT PRIMARY KEY,
+      board_id TEXT NOT NULL REFERENCES boards(id) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      color TEXT NOT NULL DEFAULT '#64748b',
+      created_at TEXT NOT NULL,
+      UNIQUE(board_id, name)
+    );
+
+    CREATE TABLE IF NOT EXISTS ticket_labels (
+      ticket_id TEXT NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
+      label_id TEXT NOT NULL REFERENCES labels(id) ON DELETE CASCADE,
+      PRIMARY KEY(ticket_id, label_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS relations (
+      id TEXT PRIMARY KEY,
+      source_ticket_id TEXT NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
+      target_ticket_id TEXT NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
+      type TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(source_ticket_id, target_ticket_id, type)
+    );
+
+    CREATE TABLE IF NOT EXISTS events (
+      id TEXT PRIMARY KEY,
+      ticket_id TEXT REFERENCES tickets(id) ON DELETE SET NULL,
+      actor TEXT NOT NULL,
+      type TEXT NOT NULL,
+      body_json TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS ticket_fts USING fts5(
+      ticket_id UNINDEXED,
+      title,
+      description,
+      comments
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_states_board ON states(board_id, position);
+    CREATE INDEX IF NOT EXISTS idx_states_role ON states(board_id, role);
+    CREATE INDEX IF NOT EXISTS idx_tickets_board_state ON tickets(board_id, state_id);
+    CREATE INDEX IF NOT EXISTS idx_tickets_archived ON tickets(board_id, archived_at);
+    CREATE INDEX IF NOT EXISTS idx_tickets_parent ON tickets(parent_ticket_id);
+    CREATE INDEX IF NOT EXISTS idx_comments_ticket ON comments(ticket_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_board_entries_board ON board_entries(board_id, type, created_at);
+    CREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_ticket_id);
+    CREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_ticket_id);
+    CREATE INDEX IF NOT EXISTS idx_events_ticket ON events(ticket_id, created_at);
+  `);
+}
+
+export function resetBoard(db) {
+  db.exec(`
+    DELETE FROM ticket_fts;
+    DELETE FROM ticket_labels;
+    DELETE FROM relations;
+    DELETE FROM comments;
+    DELETE FROM board_entries;
+    DELETE FROM events;
+    DELETE FROM tickets;
+    DELETE FROM labels;
+    DELETE FROM states;
+    DELETE FROM boards;
+  `);
+}

package/src/core/delete-board.js

@@ -0,0 +1,53 @@
+import { existsSync, rmSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { requireBoardAccess } from "./auth.js";
+import { backupBoardDatabase, backupRegistry, cancelAutomaticBoardBackup } from "./backups.js";
+import { closeConnection } from "./db.js";
+import { deleteBoard, openBoardDb } from "./registry.js";
+import { httpError, normalizePath } from "./util.js";
+
+function isInside(parent, child) {
+  const rel = relative(parent, child);
+  return rel && !rel.startsWith("..") && !rel.startsWith("/") && rel !== "..";
+}
+
+function boardDbDeleteTargets(boardRow) {
+  const repoRoot = normalizePath(boardRow.repo_path || "");
+  const dbPath = normalizePath(boardRow.db_path || "");
+  const orbitRoot = normalizePath(join(repoRoot, ".orbit"));
+  if (!repoRoot || !dbPath || !isInside(orbitRoot, dbPath) || basename(dbPath) !== "board.db") {
+    throw httpError(409, "unsafe_board_db_path");
+  }
+
+  const boardDir = dirname(dbPath);
+  const boardsRoot = normalizePath(join(orbitRoot, "boards"));
+  const removeBoardDir = isInside(boardsRoot, boardDir);
+  if (removeBoardDir) return [boardDir];
+  return [dbPath, `${dbPath}-wal`, `${dbPath}-shm`, `${dbPath}-journal`];
+}
+
+export function deleteRegisteredBoard(boardRow, body, actor) {
+  requireBoardAccess(actor, { slug: boardRow.slug });
+
+  const confirmation = String(body?.confirm_slug || "").trim();
+  if (confirmation !== boardRow.slug) throw httpError(400, "board_slug_confirmation_required");
+
+  const deleteFiles = body?.delete_files !== false;
+  const targets = deleteFiles ? boardDbDeleteTargets(boardRow) : [];
+  cancelAutomaticBoardBackup(boardRow.id);
+  if (deleteFiles) backupBoardDatabase(boardRow, openBoardDb(boardRow), "pre-board-delete");
+  backupRegistry("pre-board-delete");
+  closeConnection(boardRow.db_path);
+
+  for (const target of targets) {
+    if (existsSync(target)) rmSync(target, { recursive: true, force: true });
+  }
+
+  deleteBoard(boardRow.id);
+  return {
+    ok: true,
+    deleted_board_id: boardRow.id,
+    deleted_board_slug: boardRow.slug,
+    deleted_files: deleteFiles
+  };
+}