@starlove/orbit 1.4.0 → 2.0.0

package/src/core/util.js

@@ -1,106 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { resolve } from "node:path";
-
-/** Normalize repo paths for registry lookup (trailing slashes, slashes, Windows case). */
-export function normalizePath(raw) {
-  if (raw === null || raw === undefined) return "";
-  let s = String(raw).trim();
-  if (!s) return "";
-  try {
-    s = resolve(s);
-  } catch {
-    return "";
-  }
-  s = s.replace(/\\/g, "/").replace(/\/+$/, "");
-  if (process.platform === "win32") s = s.toLowerCase();
-  return s;
-}
-
-export function id() {
-  return randomUUID();
-}
-
-export function now() {
-  return new Date().toISOString();
-}
-
-export function slugify(value) {
-  return String(value)
-    .toLowerCase()
-    .trim()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 80);
-}
-
-export function titleize(value) {
-  return String(value)
-    .replace(/[-_]+/g, " ")
-    .replace(/\s+/g, " ")
-    .trim()
-    .replace(/\b\w/g, (letter) => letter.toUpperCase());
-}
-
-export function httpError(status, code) {
-  const error = new Error(code);
-  error.status = status;
-  error.code = code;
-  return error;
-}
-
-export function requiredString(value, field) {
-  if (typeof value !== "string" || value.trim() === "") {
-    throw httpError(400, `missing_${field}`);
-  }
-  return value.trim();
-}
-
-export function normalizePriority(value) {
-  const number = Number(value ?? 2);
-  if (!Number.isFinite(number)) return 2;
-  return Math.max(0, Math.min(4, Math.round(number)));
-}
-
-export function normalizeTicketType(value) {
-  const type = String(value || "task").toLowerCase().trim();
-  const allowed = new Set(["epic", "feature", "task", "bug"]);
-  if (!allowed.has(type)) throw httpError(400, "invalid_ticket_type");
-  return type;
-}
-
-export function normalizeProjectEntryType(value) {
-  const type = String(value || "").toLowerCase().trim();
-  const allowed = new Set(["decision", "lesson"]);
-  if (!allowed.has(type)) throw httpError(400, "invalid_project_entry_type");
-  return type;
-}
-
-export function normalizeStateRole(value) {
-  if (value === null || value === undefined || value === "") return null;
-  const role = String(value).toLowerCase().trim();
-  // `done` marks the terminal lane that auto-resolves blockers (relation-row
-  // SSOT — see updateTicket / unresolvedBlockers). The agent-flow roles
-  // (ai_ready/in_progress/review) are anchors the claim-next pipeline keys off.
-  const allowed = new Set(["ai_ready", "in_progress", "review", "done"]);
-  if (!allowed.has(role)) throw httpError(400, "invalid_state_role");
-  return role;
-}
-
-export function appendFieldNote(existing, note, actorName) {
-  void actorName;
-  const text = String(note || "").trim();
-  if (!text) return existing || "";
-  const prior = String(existing || "").trim();
-  return [prior, text].filter(Boolean).join("\n\n");
-}
-
-export function toFtsQuery(q) {
-  return q
-    .toLowerCase()
-    .replace(/[^a-z0-9_ -]/g, " ")
-    .split(/\s+/)
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => `${part}*`)
-    .join(" AND ");
-}

package/src/core/version-check.js

@@ -1,154 +0,0 @@
-// Update checking. The server reads its own version from package.json and
-// compares it against the `version` field of package.json on the project's
-// GitHub default branch. We hit the GitHub *contents API* (not the raw CDN):
-// it honours conditional requests / no-cache so the answer is authoritative,
-// and because only the server polls — not every browser — GitHub's 60 req/hr
-// unauthenticated limit is a non-issue. Results are cached in-memory for
-// ORBIT_UPDATE_TTL minutes; `force` bypasses the cache for a "Check now".
-//
-// Env:
-//   ORBIT_UPDATE_CHECK=0    disable the check entirely (returns enabled:false)
-//   ORBIT_UPDATE_TTL=<min>  cache lifetime, default 60
-//   ORBIT_UPDATE_BRANCH     branch to read, default the repo default (master)
-//   ORBIT_GITHUB_TOKEN      optional PAT (private repos / higher rate limit)
-//   ORBIT_SELF_UPDATE=1     enable the gated POST /api/update self-update
-//   ORBIT_DOCKER=1          force "docker" deploy mode
-
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import { ROOT_DIR, DATA_DIR } from "./paths.js";
-
-const DEFAULT_OWNER = "brucestarlove";
-const DEFAULT_REPO = "ss-orbit";
-const CHECK_TIMEOUT_MS = 5000;
-
-let pkgCache = null;
-function readPackage() {
-  if (pkgCache) return pkgCache;
-  try {
-    pkgCache = JSON.parse(readFileSync(join(ROOT_DIR, "package.json"), "utf8"));
-  } catch {
-    pkgCache = {};
-  }
-  return pkgCache;
-}
-
-/** Parse owner/repo out of package.json repository.url, falling back to the
- *  known Orbit repo so the check still works on odd checkouts. */
-function repoCoordinates() {
-  const url = readPackage()?.repository?.url || "";
-  const match = url.match(/github\.com[/:]([^/]+)\/([^/.]+)/i);
-  return { owner: match?.[1] || DEFAULT_OWNER, repo: match?.[2] || DEFAULT_REPO };
-}
-
-function localVersion() {
-  return readPackage()?.version || "0.0.0";
-}
-
-function updateBranch() {
-  return process.env.ORBIT_UPDATE_BRANCH || "master";
-}
-
-/** How this instance is running, which decides the update instructions the
- *  client shows. Docker images carry no git tree, so they're rebuild-only. */
-function detectDeployMode() {
-  if (process.env.ORBIT_DOCKER === "1" || existsSync("/.dockerenv")) return "docker";
-  if (existsSync(join(ROOT_DIR, ".git"))) return "source";
-  return "dist";
-}
-
-/** Numeric "a.b.c" comparison (ignores any prerelease suffix). Returns true
- *  when `latest` is strictly newer than `current`. */
-function isNewer(latest, current) {
-  const parse = (v) => String(v).replace(/^v/, "").split(/[.+-]/).map((n) => Number(n) || 0);
-  const a = parse(latest);
-  const b = parse(current);
-  for (let i = 0; i < 3; i += 1) {
-    if ((a[i] || 0) > (b[i] || 0)) return true;
-    if ((a[i] || 0) < (b[i] || 0)) return false;
-  }
-  return false;
-}
-
-async function fetchLatestVersion() {
-  const { owner, repo } = repoCoordinates();
-  const branch = updateBranch();
-  const headers = {
-    Accept: "application/vnd.github.raw+json",
-    "User-Agent": "orbit-update-check"
-  };
-  if (process.env.ORBIT_GITHUB_TOKEN) headers.Authorization = `Bearer ${process.env.ORBIT_GITHUB_TOKEN}`;
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
-  try {
-    const res = await fetch(
-      `https://api.github.com/repos/${owner}/${repo}/contents/package.json?ref=${encodeURIComponent(branch)}`,
-      { headers, signal: controller.signal, cache: "no-store" }
-    );
-    if (res.status === 403 || res.status === 429) return { error: "rate_limited" };
-    if (!res.ok) return { error: `http_${res.status}` };
-    const pkg = JSON.parse(await res.text());
-    if (!pkg?.version) return { error: "no_version" };
-    return { latest: String(pkg.version) };
-  } catch (err) {
-    return { error: err?.name === "AbortError" ? "timeout" : "unreachable" };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-let cache = null; // { at: epochMs, payload }
-
-function staticPayload(extra) {
-  const { owner, repo } = repoCoordinates();
-  const branch = updateBranch();
-  return {
-    current: localVersion(),
-    deployMode: detectDeployMode(),
-    selfUpdate: process.env.ORBIT_SELF_UPDATE === "1",
-    repoUrl: `https://github.com/${owner}/${repo}`,
-    changesUrl: `https://github.com/${owner}/${repo}/commits/${branch}`,
-    ...extra
-  };
-}
-
-/** Get current/latest version info, cached for ORBIT_UPDATE_TTL minutes.
- *  Never throws — network problems surface as `{ error, updateAvailable:false }`. */
-export async function getVersionInfo({ force = false } = {}) {
-  if (process.env.ORBIT_UPDATE_CHECK === "0") {
-    return staticPayload({ enabled: false, latest: null, updateAvailable: false, error: null, checkedAt: null });
-  }
-
-  const ttlMs = (Number(process.env.ORBIT_UPDATE_TTL) || 60) * 60 * 1000;
-  if (!force && cache && Date.now() - cache.at < ttlMs) return cache.payload;
-
-  const result = await fetchLatestVersion();
-  const current = localVersion();
-  const payload = staticPayload({
-    enabled: true,
-    latest: result.latest ?? null,
-    updateAvailable: Boolean(result.latest) && isNewer(result.latest, current),
-    error: result.error ?? null,
-    checkedAt: new Date().toISOString()
-  });
-  cache = { at: Date.now(), payload };
-  return payload;
-}
-
-/** Kick off scripts/update.sh detached and hand back immediately. Only ever
- *  reached when ORBIT_SELF_UPDATE=1 (the router gates the route). The script
- *  rebuilds and then signals this process so a supervisor restarts it. */
-export function startSelfUpdate() {
-  const script = join(ROOT_DIR, "scripts", "update.sh");
-  if (!existsSync(script)) return { started: false, error: "script_missing" };
-  const child = spawn("bash", [script], {
-    cwd: ROOT_DIR,
-    detached: true,
-    stdio: "ignore",
-    env: { ...process.env, ORBIT_REPO_DIR: ROOT_DIR, ORBIT_SERVER_PID: String(process.pid), ORBIT_DATA_DIR: DATA_DIR }
-  });
-  child.unref();
-  return { started: true };
-}

package/src/mcp/orbit-client.js

@@ -1,287 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-
-function rpcError(code, message) {
-  const error = new Error(message);
-  error.code = code;
-  return error;
-}
-
-export function orbitMode(env = process.env) {
-  const mode = String(env.ORBIT_MODE || "local").trim().toLowerCase();
-  if (mode === "remote" || mode === "http") return "remote";
-  if (mode === "local" || mode === "") return "local";
-  throw rpcError(-32602, `Unsupported ORBIT_MODE: ${env.ORBIT_MODE}`);
-}
-
-export async function createOrbitClient(env = process.env) {
-  return orbitMode(env) === "remote" ? createHttpOrbitClient(env) : createLocalOrbitClient(env);
-}
-
-export function createHttpOrbitClient(env = process.env, fetchImpl = globalThis.fetch) {
-  const apiUrl = String(env.ORBIT_API_URL || "").trim().replace(/\/+$/, "");
-  let defaultBoard = String(env.ORBIT_DEFAULT_BOARD || "").trim();
-  if (!apiUrl) throw rpcError(-32602, "ORBIT_MODE=remote requires ORBIT_API_URL.");
-  if (typeof fetchImpl !== "function") throw rpcError(-32603, "ORBIT_MODE=remote requires global fetch support.");
-
-  async function request(method, path, { query = {}, body, ok = [200] } = {}) {
-    const url = new URL(`${apiUrl}${path}`);
-    for (const [key, value] of Object.entries(query)) {
-      if (value !== undefined && value !== null && value !== "") url.searchParams.set(key, String(value));
-    }
-    const response = await fetchImpl(url, {
-      method,
-      headers: body === undefined ? undefined : { "Content-Type": "application/json" },
-      body: body === undefined ? undefined : JSON.stringify(body)
-    });
-    let payload = null;
-    const text = await response.text();
-    if (text) {
-      try { payload = JSON.parse(text); } catch { payload = { message: text }; }
-    }
-    if (!ok.includes(response.status)) {
-      const message = payload?.message || payload?.error || `Orbit API ${method} ${url.pathname} failed with HTTP ${response.status}`;
-      throw rpcError(-32000, message);
-    }
-    return payload ?? {};
-  }
-
-  function boardArg(args = {}) {
-    return args.board_id || args.board_slug || args.board || defaultBoard;
-  }
-
-  function requireBoard(args = {}) {
-    const board = boardArg(args);
-    if (!board) throw rpcError(-32602, "Remote Orbit MCP requires board_id/board_slug/board or ORBIT_DEFAULT_BOARD.");
-    return board;
-  }
-
-  const ticketQuery = (args = {}) => ({ board_id: args.board_id, board: args.board_slug || args.board || defaultBoard });
-  const stripBoardSelectors = (args = {}) => {
-    const { board_id, board_slug, board, ...rest } = args;
-    return rest;
-  };
-  const settingsPatch = (args = {}) => {
-    const patch = {};
-    for (const field of ["name", "repo_url", "system_path", "default_branch", "agent_instructions"]) {
-      if (args[field] !== undefined) patch[field] = args[field];
-    }
-    return patch;
-  };
-  const searchQuery = (args = {}) => ({
-    q: args.q,
-    limit: args.limit,
-    board_id: args.board_id,
-    board: args.board_slug || args.board || defaultBoard,
-    mode: args.mode,
-    include_full: args.include_full || args.includeFull ? "true" : undefined,
-    fields: Array.isArray(args.fields) ? args.fields.join(",") : args.fields,
-    max_chars_per_field: args.max_chars_per_field ?? args.maxCharsPerField
-  });
-  const contextQuery = (args = {}) => ({
-    ...ticketQuery(args),
-    depth: args.depth,
-    max_chars_per_field: args.max_chars_per_field ?? args.maxCharsPerField,
-    comment_limit: args.comment_limit ?? args.commentLimit,
-    include_parent_full: args.include_parent_full || args.includeParentFull ? "true" : undefined,
-    include_related_full: args.include_related_full || args.includeRelatedFull ? "true" : undefined
-  });
-
-  return {
-    mode: "remote",
-    sessionLabel: apiUrl,
-    close() {},
-    async boardContext(args = {}) {
-      return request("GET", `/api/boards/${encodeURIComponent(requireBoard(args))}/context`, { query: { include_struck: args.include_struck ? "true" : undefined } });
-    },
-    async boardList() { return request("GET", "/api/boards"); },
-    async boardSetActive(args = {}) { if (!args.slug) throw rpcError(-32602, "slug is required."); defaultBoard = String(args.slug); env.ORBIT_DEFAULT_BOARD = defaultBoard; return { ok: true, slug: defaultBoard, mode: "remote" }; },
-    async claimNext(args = {}) { return request("POST", "/api/agent/claim-next", { body: { ...args, board: requireBoard(args) } }); },
-    async getTicketContext(args = {}) { return request("GET", `/api/tickets/${encodeURIComponent(args.ticket_id)}/context`, { query: { ...contextQuery(args), depth: args.depth || 1 } }); },
-    async getTicketContextFull(args = {}) { return request("GET", `/api/tickets/${encodeURIComponent(args.ticket_id)}/context/full`, { query: { ...contextQuery(args), depth: args.depth || 1 } }); },
-    async getAgentDispatchPacket(args = {}) { return request("GET", `/api/tickets/${encodeURIComponent(args.ticket_id)}/dispatch-packet`, { query: contextQuery(args) }); },
-    async readTicket(args = {}) {
-      if (args.ticket_id) {
-        return request("GET", `/api/tickets/${encodeURIComponent(args.ticket_id)}`, { query: ticketQuery(args) });
-      }
-      if (args.number !== undefined || args.title) {
-        return request("GET", "/api/tickets/lookup", { query: { ...ticketQuery(args), number: args.number, title: args.title } });
-      }
-      throw rpcError(-32602, "ticket_id_or_number_or_title_required");
-    },
-    async readComments(args = {}) {
-      if (args.ticket_id) {
-        return request("GET", `/api/tickets/${encodeURIComponent(args.ticket_id)}/comments`, { query: ticketQuery(args) });
-      }
-      const found = await this.readTicket(args);
-      const ticket = found.ticket || found.results?.find((row) =>
-        (args.number !== undefined && Number(row.number) === Number(args.number)) ||
-        (args.title && String(row.title || "").toLowerCase() === String(args.title).toLowerCase())
-      );
-      if (!ticket?.id) throw rpcError(-32004, "ticket_not_found");
-      return request("GET", `/api/tickets/${encodeURIComponent(ticket.id)}/comments`, { query: ticketQuery(args) });
-    },
-    async getTicketRelations(args = {}) { return request("GET", `/api/tickets/${encodeURIComponent(args.ticket_id)}/relations`, { query: ticketQuery(args) }); },
-    async getTicketBlockers(args = {}) { return request("GET", `/api/tickets/${encodeURIComponent(args.ticket_id)}/blockers`, { query: ticketQuery(args) }); },
-    async search(args = {}) { return request("GET", "/api/search", { query: searchQuery(args) }); },
-    async createTicket(args = {}) { return request("POST", "/api/tickets", { body: { ...args, board: requireBoard(args) }, ok: [201] }); },
-    async updateTicket({ ticket_id, ...patch }) { return request("PATCH", `/api/tickets/${encodeURIComponent(ticket_id)}`, { query: ticketQuery(patch), body: stripBoardSelectors(patch) }); },
-    async uploadMarkdownArtifact({ ticket_id, ...body }) { return request("POST", `/api/tickets/${encodeURIComponent(ticket_id)}/artifacts/markdown`, { query: ticketQuery(body), body: stripBoardSelectors(body), ok: [201] }); },
-    async addComment({ ticket_id, ...body }) { return request("POST", `/api/tickets/${encodeURIComponent(ticket_id)}/comments`, { query: ticketQuery(body), body: stripBoardSelectors(body), ok: [201] }); },
-    async createReviewVerdict({ ticket_id, ...body }) { return request("POST", `/api/tickets/${encodeURIComponent(ticket_id)}/review-verdicts`, { query: ticketQuery(body), body: stripBoardSelectors(body), ok: [201] }); },
-    async listReviewVerdicts(args = {}) { return request("GET", `/api/tickets/${encodeURIComponent(args.ticket_id)}/review-verdicts`, { query: { ...ticketQuery(args), limit: args.limit } }); },
-    async getReviewVerdict(args = {}) { return request("GET", `/api/review-verdicts/${encodeURIComponent(args.review_id)}`, { query: ticketQuery(args) }); },
-    async addBoardEntry(args = {}) { return request("POST", `/api/boards/${encodeURIComponent(requireBoard(args))}/entries`, { body: stripBoardSelectors(args), ok: [201] }); },
-    async checkpoint(args = {}) { const fallback = boardArg(args); return request("POST", "/api/agent/checkpoint", { body: fallback ? { ...args, board: args.board || args.board_slug || fallback } : args }); },
-    async complete(args = {}) { const fallback = boardArg(args); return request("POST", "/api/agent/complete", { body: fallback ? { ...args, board: args.board || args.board_slug || fallback } : args }); },
-    async archiveTicket(args = {}) { return request("POST", `/api/tickets/${encodeURIComponent(args.ticket_id)}/archive`, { query: ticketQuery(args) }); },
-    async restoreTicket(args = {}) { return request("POST", `/api/tickets/${encodeURIComponent(args.ticket_id)}/restore`, { query: ticketQuery(args) }); },
-    async deleteTicket(args = {}) { return request("DELETE", `/api/tickets/${encodeURIComponent(args.ticket_id)}`, { query: ticketQuery(args) }); },
-    async listArchive(args = {}) { return request("GET", `/api/boards/${encodeURIComponent(requireBoard(args))}/archive`); },
-    async exportBoard(args = {}) {
-      return request("GET", `/api/boards/${encodeURIComponent(requireBoard(args))}/export`, {
-        query: { include_attachments: args.include_attachments || args.include_images ? "true" : undefined }
-      });
-    },
-    async updateSettings(args = {}) { return request("PATCH", `/api/boards/${encodeURIComponent(requireBoard(args))}`, { body: settingsPatch(args) }); }
-  };
-}
-
-export async function createLocalOrbitClient(env = process.env) {
-  const board = await import("../core/board.js");
-  const dbMod = await import("../core/db.js");
-  const registry = await import("../core/registry.js");
-  const backups = await import("../core/backups.js");
-  const seed = await import("../core/seed.js");
-  const util = await import("../core/util.js");
-
-  const provision = await import("../core/provision-repo-board.js");
-  let sessionBoardRow = null;
-  const setSessionBoard = (row) => { sessionBoardRow = row; if (row) registry.touchBoardActive(row.id); };
-  const getSessionBoard = () => sessionBoardRow;
-  const walkUp = (startDir, predicate) => { let dir = startDir; while (true) { if (predicate(dir)) return dir; const parent = dirname(dir); if (parent === dir) return null; dir = parent; } };
-
-  const start = util.normalizePath(env.PROJECT_ROOT ? resolve(env.PROJECT_ROOT) : process.cwd());
-  const displayStart = resolve(env.PROJECT_ROOT ? env.PROJECT_ROOT : process.cwd());
-
-  // Find repo root (walk up for .git, fall back to start).
-  const gitRoot = walkUp(start, (dir) => existsSync(join(dir, ".git")));
-  const repoRoot = util.normalizePath(gitRoot || start);
-
-  // 1. Registry-first lookup: walk upward from start so we find boards regardless
-  //    of whether they were registered at the git root, at PROJECT_ROOT, or at any
-  //    ancestor (handles boards originally created from a subdirectory).
-  let foundByRegistry = false;
-  {
-    let dir = start;
-    while (true) {
-      const row = registry.getBoardByRepoPath(dir);
-      if (row && existsSync(row.db_path)) { setSessionBoard(row); foundByRegistry = true; break; }
-      const parent = util.normalizePath(dirname(dir));
-      if (parent === dir) break; // filesystem root
-      dir = parent;
-    }
-  }
-  if (!foundByRegistry) {
-    // 2. Legacy fallback: walk up for an existing in-repo .orbit/board.db.
-    const boardRoot = walkUp(start, (dir) => existsSync(join(dir, ".orbit", "board.db")));
-    if (boardRoot) {
-      const root = util.normalizePath(boardRoot);
-      const existing = registry.getBoardByRepoPath(root);
-      if (existing) {
-        setSessionBoard(existing);
-      } else {
-        const dbPath = join(boardRoot, ".orbit", "board.db");
-        const db = dbMod.openConnection(dbPath);
-        dbMod.createBoardSchema(db);
-        const seeded = seed.seedIfEmpty(db, root);
-        if (seeded) {
-          const t = util.now();
-          registry.insertBoard({ id: seeded.id, slug: seeded.slug, name: seeded.name, repo_path: root, db_path: dbPath, repo_url: seeded.repo_url || "", default_branch: seeded.default_branch || "main", last_active_at: t, created_at: t, updated_at: t });
-        }
-        const fresh = registry.getBoardByRepoPath(root);
-        if (fresh) { registry.syncRegistryFromBoardDb(fresh, db); setSessionBoard(fresh); }
-      }
-    } else {
-      // 3. No board found — auto-create one (goes to central DATA_DIR/boards/).
-      provision.provisionRepoBoard(repoRoot, { enableAi: true });
-      const fresh = registry.getBoardByRepoPath(repoRoot);
-      if (fresh) setSessionBoard(fresh);
-    }
-  }
-
-  const ctxFor = (row, actor) => {
-    if (!row) throw rpcError(-32602, "No board in session; pass board_id or board_slug, or call board_set_active first.");
-    return { actor, board: row, db: registry.openBoardDb(row) };
-  };
-  const backup = (ctx, result) => { backups.scheduleAutomaticBoardBackup(ctx.board, ctx.db); return result; };
-  const explicit = (args = {}) => {
-    if (args.board_id) {
-      const row = registry.getBoardByRegistryId(args.board_id);
-      if (!row) throw rpcError(-32004, `Board id not found: ${args.board_id}`);
-      return row;
-    }
-    if (args.board_slug || args.board) {
-      const slug = args.board_slug || args.board;
-      const row = registry.getBoardBySlug(slug);
-      if (!row) throw rpcError(-32004, `Board slug not found: ${slug}`);
-      return row;
-    }
-    return null;
-  };
-  const rowOrSession = (args = {}) => explicit(args) || getSessionBoard();
-  const stripBoardSelectors = (args = {}) => {
-    const { board_id, board_slug, board: _board, ...rest } = args;
-    return rest;
-  };
-  const settingsPatch = (args = {}) => {
-    const patch = {};
-    for (const field of ["name", "repo_url", "system_path", "default_branch", "agent_instructions"]) {
-      if (args[field] !== undefined) patch[field] = args[field];
-    }
-    return patch;
-  };
-  const actor = () => board.localAgentActor();
-
-  return {
-    mode: "local",
-    sessionLabel: () => {
-      const b = getSessionBoard();
-      return b ? `${displayStart}  target: ${b.repo_path}  db: ${b.db_path}` : "(none)";
-    },
-    close: () => dbMod.closeAllConnections(),
-    boardContext: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.getBoardContext(ctx.board.id, ctx, { includeStruck: Boolean(args.include_struck) }); },
-    boardList: () => ({ boards: registry.listBoards().map((row) => ({ id: row.id, slug: row.slug, name: row.name, repo_path: row.repo_path })) }),
-    boardSetActive: (args = {}) => { const slug = String(args.slug || "").trim(); if (!slug) throw rpcError(-32602, "slug is required."); const row = registry.getBoardBySlug(slug); if (!row) throw rpcError(-32004, `Board slug not found: ${slug}`); setSessionBoard(row); return { ok: true, board_id: row.id, slug: row.slug, name: row.name, db_path: row.db_path }; },
-    claimNext: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return backup(ctx, board.claimNext(args, ctx)); },
-    getTicketContext: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.getContextPack(args.ticket_id, ctx, Number(args.depth || 1), args); },
-    getTicketContextFull: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.getContextPackFull(args.ticket_id, ctx, Number(args.depth || 1), args); },
-    getAgentDispatchPacket: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.getAgentDispatchPacket(args.ticket_id, ctx, args); },
-    readTicket: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.readTicket(args, ctx); },
-    readComments: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.readComments(args, ctx); },
-    getTicketRelations: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.getTicketRelations(args.ticket_id, ctx); },
-    getTicketBlockers: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.getTicketBlockers(args.ticket_id, ctx); },
-    search: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.searchTickets(args, ctx); },
-    createTicket: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); const body = stripBoardSelectors(args); body.board_id = ctx.board.id; return backup(ctx, board.createTicket(body, ctx)); },
-    updateTicket: ({ ticket_id, ...patch }) => { const ctx = ctxFor(rowOrSession(patch), actor()); return backup(ctx, board.updateTicket(ticket_id, stripBoardSelectors(patch), ctx)); },
-    uploadMarkdownArtifact: ({ ticket_id, ...body }) => { const ctx = ctxFor(rowOrSession(body), actor()); return board.storeTicketMarkdownArtifact(ticket_id, stripBoardSelectors(body), ctx); },
-    addComment: ({ ticket_id, ...body }) => { const ctx = ctxFor(rowOrSession(body), actor()); return backup(ctx, board.createComment(ticket_id, stripBoardSelectors(body), ctx)); },
-    createReviewVerdict: ({ ticket_id, ...body }) => { const ctx = ctxFor(rowOrSession(body), actor()); return backup(ctx, board.createReviewVerdict(ticket_id, stripBoardSelectors(body), ctx)); },
-    listReviewVerdicts: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return { review_verdicts: board.listReviewVerdicts(args.ticket_id, ctx, args) }; },
-    getReviewVerdict: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return board.getReviewVerdict(args.review_id, ctx); },
-    addBoardEntry: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return backup(ctx, board.createBoardEntry(ctx.board.id, stripBoardSelectors(args), ctx)); },
-    checkpoint: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return backup(ctx, board.checkpointTicket(stripBoardSelectors(args), ctx)); },
-    complete: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return backup(ctx, board.completeTicket(stripBoardSelectors(args), ctx)); },
-    archiveTicket: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return backup(ctx, board.archiveTicket(args.ticket_id, ctx)); },
-    restoreTicket: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return backup(ctx, board.restoreTicket(args.ticket_id, ctx)); },
-    deleteTicket: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return backup(ctx, board.deleteTicket(args.ticket_id, ctx)); },
-    listArchive: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return { tickets: board.archivedTicketsForBoard(ctx.db, ctx.board.id) }; },
-    exportBoard: (args = {}) => {
-      const ctx = ctxFor(rowOrSession(args), actor());
-      return board.exportBoard(ctx.board.id, ctx, {
-        includeAttachments: Boolean(args.include_attachments || args.include_images)
-      });
-    },
-    updateSettings: (args = {}) => { const ctx = ctxFor(rowOrSession(args), actor()); return backup(ctx, board.updateBoard(ctx.board.id, settingsPatch(args), ctx)); }
-  };
-}

package/src/server.js

@@ -1,115 +0,0 @@
-import { createServer } from "node:http";
-import { networkInterfaces } from "node:os";
-import {
-  boardRuntime,
-  handleApi,
-  serveStatic,
-  sendEmpty,
-  sendJson,
-  startSSEStream,
-  startupSummary
-} from "./core/board.js";
-import { closeAllConnections } from "./core/db.js";
-
-const server = createServer(async (req, res) => {
-  try {
-    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
-
-    if (req.method === "OPTIONS") {
-      sendEmpty(res, 204);
-      return;
-    }
-
-    if (url.pathname === "/api/events/stream" && req.method === "GET") {
-      startSSEStream(req, res, url);
-      return;
-    }
-
-    if (url.pathname.startsWith("/api/")) {
-      await handleApi(req, res, url);
-      return;
-    }
-
-    await serveStatic(req, res, url.pathname);
-  } catch (error) {
-    console.error(error);
-    if (error.status) {
-      sendJson(res, error.status, { error: error.code || "request_error", message: error.message });
-      return;
-    }
-    sendJson(res, 500, { error: "internal_error", message: error.message });
-  }
-});
-
-const requestedPort = boardRuntime.port;
-const requestedHost = process.env.HOST || process.env.ORBIT_HOST || "";
-const hasExplicitPort = Boolean(process.env.PORT);
-const maxAutoPort = requestedPort + 99;
-let currentPort = requestedPort;
-
-function listen(port) {
-  if (requestedHost) {
-    server.listen(port, requestedHost);
-    return;
-  }
-  server.listen(port);
-}
-
-function displayHost(host) {
-  if (!host || host === "::" || host === "0.0.0.0") return "localhost";
-  return host;
-}
-
-function networkUrls(port) {
-  return Object.values(networkInterfaces())
-    .flat()
-    .filter((item) => item && item.family === "IPv4" && !item.internal)
-    .map((item) => `http://${item.address}:${port}`);
-}
-
-server.on("error", (error) => {
-  if (!hasExplicitPort && error?.code === "EADDRINUSE" && currentPort < maxAutoPort) {
-    currentPort += 1;
-    console.warn(`[orbit] Port ${currentPort - 1} is in use; trying ${currentPort}.`);
-    listen(currentPort);
-    return;
-  }
-
-  console.error(error);
-  closeAllConnections();
-  process.exit(1);
-});
-
-listen(currentPort);
-
-server.on("listening", () => {
-  const address = server.address();
-  const port = typeof address === "object" && address ? address.port : currentPort;
-  const host = typeof address === "object" && address ? displayHost(address.address) : displayHost(requestedHost);
-  const summary = startupSummary(port, host);
-  console.log(`Starscape Orbit listening on ${summary.url}`);
-  const urls = networkUrls(port).filter((url) => url !== summary.url);
-  if (urls.length) console.log(`Network: ${urls.join(", ")}`);
-  console.log(`Registry: ${summary.registryPath}`);
-  console.log(`Boards (${summary.boardCount}):`);
-  for (const path of summary.boardPaths) console.log(`  - ${path}`);
-});
-
-let shuttingDown = false;
-
-function shutdown() {
-  if (shuttingDown) return;
-  shuttingDown = true;
-  server.close(() => {
-    closeAllConnections();
-    process.exit(0);
-  });
-  setTimeout(() => {
-    closeAllConnections();
-    process.exit(0);
-  }, 1500).unref();
-}
-
-process.once("SIGINT", shutdown);
-process.once("SIGTERM", shutdown);
-process.once("exit", () => closeAllConnections());