viewable-one 0.0.0-stage → 0.12.2

package/lib/repomap.mjs

@@ -0,0 +1,323 @@
+// Repo primer: a compact map of the tree plus exported symbols, deterministic,
+// no model call. Built to reduce cache re-reads: a fresh session spends its
+// first turns rediscovering the tree. Reference: tpm-flow's server/src/repomap.ts
+// (idea, bounds, regex on purpose); reimplemented here, license boundary matters.
+//
+// Emits:
+// - The file tree (always)
+// - Top-level exported symbols per source file (functions, classes, consts)
+//   found by regex, capped at ~10KB for the whole map
+// - Symbol detail dropped deepest-first past the cap, with a notice
+//
+// Cached keyed to HEAD sha in a dotfile beside the spawn dir; regenerate when
+// HEAD moved, reuse otherwise.
+
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { BOARD_DIR, segmentsOf } from "./paths.mjs";
+
+const execFileAsync = promisify(execFile);
+
+const MAX_MAP_SIZE = 10_000; // ~10KB cap for the whole map
+
+// Directories to skip (dotdirs, build artifacts, dependencies)
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  "canvas",
+  "inbox",
+  ".next",
+  ".turbo",
+  ".cache",
+  ".DS_Store",
+]);
+
+// Extensions for source files where we extract symbols
+const SOURCE_EXTS = new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"]);
+
+/**
+ * Extract top-level exported symbols from source file content using regex.
+ * Deliberately regex-based (not tree-sitter): fast, deterministic, good enough.
+ * Returns array of symbol names.
+ */
+function extractExports(content) {
+  const symbols = [];
+
+  // export function name(...) or export async function name(...)
+  const funcPattern = /export\s+(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+  for (const match of content.matchAll(funcPattern)) {
+    symbols.push(match[1]);
+  }
+
+  // export class Name
+  const classPattern = /export\s+class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+  for (const match of content.matchAll(classPattern)) {
+    symbols.push(match[1]);
+  }
+
+  // export const name = ... or export let name = ...
+  const constPattern = /export\s+(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+  for (const match of content.matchAll(constPattern)) {
+    symbols.push(match[1]);
+  }
+
+  // export { name1, name2 }
+  const namedExportPattern = /export\s*\{([^}]+)\}/g;
+  for (const match of content.matchAll(namedExportPattern)) {
+    const names = match[1].split(",").map(n => {
+      // Handle "foo as bar" - take the original name
+      const parts = n.trim().split(/\s+as\s+/);
+      return parts[0].trim();
+    }).filter(n => n && /^[a-zA-Z_$]/.test(n));
+    symbols.push(...names);
+  }
+
+  return symbols;
+}
+
+/**
+ * Walk a directory tree, collecting file paths and optionally extracting symbols.
+ * Returns { tree: string[], fileSymbols: Map<string, string[]> }
+ * where tree is relative paths and fileSymbols maps rel path to exported symbols.
+ */
+async function walkTree(root, extractSymbols = true) {
+  const tree = [];
+  const fileSymbols = new Map();
+
+  async function walk(dir, depth = 0) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return; // Skip unreadable directories
+    }
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      // POSIX-SPELLED, ON EVERY PLATFORM (2026-09-07, brief 21, the first
+      // windows-latest run). This map is TEXT handed to a coding agent, and
+      // everything it will be compared against - the import specifiers in the
+      // files themselves, `git` output, the paths a person types into a brief -
+      // spells a separator "/" on Windows too. `relative` returns the host's,
+      // so the map said `src\index.js` and nothing downstream could match it.
+      const relPath = relative(root, fullPath).split(sep).join("/");
+
+      // Skip dotdirs at any depth
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) {
+          continue;
+        }
+        tree.push(`${relPath}/`);
+        await walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        tree.push(relPath);
+
+        // Extract symbols from source files if requested
+        if (extractSymbols && SOURCE_EXTS.has(extOf(entry.name))) {
+          try {
+            const content = await readFile(fullPath, "utf8");
+            const symbols = extractExports(content);
+            if (symbols.length > 0) {
+              fileSymbols.set(relPath, symbols);
+            }
+          } catch {
+            // Skip files we can't read
+          }
+        }
+      }
+    }
+  }
+
+  await walk(root);
+  return { tree, fileSymbols };
+}
+
+function extOf(filename) {
+  const dot = filename.lastIndexOf(".");
+  return dot === -1 ? "" : filename.slice(dot);
+}
+
+/**
+ * Get current HEAD sha for cache keying.
+ * Returns null if not a git repo or HEAD unavailable.
+ */
+async function getHeadSha(root) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: root });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build a compact repo map: file tree + exported symbols per source file.
+ * Respects MAX_MAP_SIZE; past the cap, keeps the tree and drops symbol detail
+ * deepest-first (files furthest from root lose detail first).
+ * Returns the map as a string, with a notice if detail was dropped.
+ */
+async function buildRepoMap(root) {
+  const { tree, fileSymbols } = await walkTree(root);
+
+  // Sort tree for deterministic output
+  tree.sort();
+
+  let output = "# Repository structure\n\n";
+  output += "```\n";
+  output += tree.join("\n");
+  output += "\n```\n\n";
+
+  if (fileSymbols.size === 0) {
+    return output;
+  }
+
+  output += "# Exported symbols by file\n\n";
+
+  // Sort files by depth (shallowest first) so we drop deepest-first if needed
+  const filesByDepth = Array.from(fileSymbols.entries())
+    .map(([path, symbols]) => ({ path, symbols, depth: path.split("/").length }))
+    .sort((a, b) => a.depth - b.depth);
+
+  const symbolLines = [];
+  let droppedCount = 0;
+
+  for (const { path, symbols } of filesByDepth) {
+    const line = `- **${path}**: ${symbols.join(", ")}\n`;
+    const testOutput = output + symbolLines.join("") + line;
+
+    if (testOutput.length > MAX_MAP_SIZE) {
+      droppedCount++;
+    } else {
+      symbolLines.push(line);
+    }
+  }
+
+  output += symbolLines.join("");
+
+  if (droppedCount > 0) {
+    output += `\n*Symbol detail dropped for ${droppedCount} file(s) to stay under size cap.*\n`;
+  }
+
+  return output;
+}
+
+/**
+ * Get or build the cached repo map.
+ * Cache is keyed to HEAD sha and stored in inbox/spawn/.repomap-{sha}.txt
+ * Returns null if not a git repo (no HEAD sha to key on).
+ */
+export async function getRepoMap(root, log = () => {}) {
+  const headSha = await getHeadSha(root);
+  if (!headSha) {
+    log("Not a git repo or HEAD unavailable; no repo map generated");
+    return null;
+  }
+
+  const cacheDir = join(root, ...segmentsOf(`${BOARD_DIR}/inbox/spawn`));
+  const cacheFile = join(cacheDir, `.repomap-${headSha}.txt`);
+
+  // Try to read cached version
+  try {
+    const cached = await readFile(cacheFile, "utf8");
+    log(`Repo map cache hit for ${headSha.slice(0, 7)}`);
+    return cached;
+  } catch {
+    // Cache miss; build it
+  }
+
+  log(`Building repo map for ${headSha.slice(0, 7)}...`);
+  const map = await buildRepoMap(root);
+
+  // Write to cache (best effort; don't fail if we can't write)
+  try {
+    await mkdir(cacheDir, { recursive: true });
+    await writeFile(cacheFile, map, "utf8");
+    log(`Repo map cached (${map.length} chars)`);
+    await pruneRepoMapCache(cacheDir, log);
+  } catch (err) {
+    log(`Could not cache repo map: ${err.message}`);
+  }
+
+  return map;
+}
+
+/** How many HEAD shas' worth of cached map to keep. */
+export const REPOMAP_CACHE_KEEP = 5;
+
+/** Drop all but the newest `REPOMAP_CACHE_KEEP` cached maps.
+ *
+ * The cache is keyed to HEAD sha and NOTHING removed the old ones. One entry
+ * per commit, up to 10KB each, written into the board's own spawn folder for
+ * ever: a repo that sees a hundred commits between spawns leaves a hundred
+ * files behind, and every one of them is a map of a tree nobody will ask
+ * about again. Keyed to a sha is the right cache key; keeping every sha is
+ * not a cache, it is a log.
+ *
+ * Newest by mtime rather than by name, because a sha sorts alphabetically and
+ * that has nothing to do with when it was HEAD. Best-effort throughout: a
+ * failed prune must never fail a spawn. */
+export async function pruneRepoMapCache(cacheDir, log = () => {}, keep = REPOMAP_CACHE_KEEP) {
+  let names;
+  try {
+    names = (await readdir(cacheDir)).filter((n) => n.startsWith(".repomap-") && n.endsWith(".txt"));
+  } catch {
+    return;
+  }
+  if (names.length <= keep) return;
+  const dated = [];
+  for (const name of names) {
+    try {
+      dated.push({ name, mtimeMs: (await stat(join(cacheDir, name))).mtimeMs });
+    } catch {
+      /* vanished under us: nothing to prune */
+    }
+  }
+  dated.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const doomed = dated.slice(keep);
+  for (const { name } of doomed) {
+    await rm(join(cacheDir, name), { force: true }).catch(() => {});
+  }
+  if (doomed.length > 0) log(`Pruned ${doomed.length} stale repo map cache file(s)`);
+}
+
+/**
+ * Format the repo primer section for a session prompt.
+ * Returns null if no map available or if we're over the combined bound.
+ *
+ * Combined bound: primer + attempts together must not exceed ~16KB.
+ * Primer is trimmed first if needed.
+ */
+export function formatRepoPrimer(repoMap, attemptsLength = 0) {
+  if (!repoMap) return null;
+
+  const MAX_COMBINED = 16_000; // ~16KB for primer + attempts together
+  const availableForPrimer = MAX_COMBINED - attemptsLength;
+
+  if (availableForPrimer < 500) {
+    // Not enough room for a useful primer
+    return null;
+  }
+
+  let primer = "# Repository primer\n\n";
+  primer += "This map shows the repository structure and exported symbols. ";
+  primer += "It may be stale versus your working branch.\n\n";
+  primer += repoMap;
+
+  if (primer.length > availableForPrimer) {
+    // Truncate the map portion, keep the header
+    const header = "# Repository primer\n\nThis map shows the repository structure and exported symbols. It may be stale versus your working branch.\n\n";
+    const mapPortion = repoMap.slice(0, availableForPrimer - header.length - 100);
+    primer = header + mapPortion + "\n\n*[Primer truncated to fit size bound]*\n";
+  }
+
+  return primer;
+}

package/lib/restartPass.mjs

@@ -0,0 +1,151 @@
+// Recover a coding run whose computer lost its lease (#1252).
+// The reaper keeps its error row and null result; the app shows that as a
+// wait only for marked runs or legacy note sessions, with no age limit.
+// The first returning watcher settles it with a
+// write-once result and attempt nonce, then files one child in the same
+// conversation and copy. Every child can itself be recovered later.
+// Stop lives in stop_requested_at, including on a reaped row; both the
+// candidate check and the hosted resume op honour it. The existing SQL
+// row lock serializes competing settles. No migration is needed.
+
+import { randomUUID } from "node:crypto";
+import { stat } from "node:fs/promises";
+import * as runnerApiModule from "./runnerApi.mjs";
+import { acceptsMessages, agentFor } from "./agents.mjs";
+import { fromIdOf } from "./boardside.mjs";
+import { wallClockFor, isChatTurn } from "./spawn.mjs";
+
+/** What the continued session is told. */
+export const RESTART_MESSAGE = "Your computer restarted while you were working. Carry on from where you were.";
+/** What the idea reads when the session cannot carry on by itself. */
+export const RESTART_ENDED_REPLY = "Your computer restarted during this session, so it stopped.";
+
+/** The runs THIS process is running right now. A second watcher in the same
+ *  process (multiwatch rebuilds a folder's watcher while the old one drains)
+ *  must not mistake them for orphans. */
+export const liveRuns = new Set();
+
+/** The second look: after the lease has run out and the reaper has run. */
+export const RESTART_RECHECK_MS = 7 * 60_000;
+
+const timeOf = (value) => (value ? Date.parse(value) : NaN);
+const isReaped = (row) => row.status === "error" && Boolean(row.recovery_reason) && (row.result === null || row.result === undefined);
+
+/** Is this row one the last process left behind? Pure. */
+export function restartCandidate(row, { now = Date.now() } = {}) {
+  const request = row?.request;
+  if (!request || typeof request !== "object" || liveRuns.has(row.id)) return false;
+  // Older Run-button runs already ended in the app. Never start paid work
+  // again for those rows. Older note sessions have always waited for recovery.
+  if (row.sidecar?.restartable !== true && !(typeof request.note?.noteId === "string" && request.note.noteId.length > 0)) return false;
+  if (row.sidecar?.restarted === true) return false;
+  if (isChatTurn(request) || request.planMode === "draft") return false;
+  if (!fromIdOf(request) && !row.from_id) return false;
+  // A person pressed Stop and the computer died before it was heard: the
+  // stop stands. Nothing is carried on that a person ended.
+  if (row.stop_requested_at) return false;
+  if (row.status === "running") {
+    // A lease still running belongs to a live process (the server leases for
+    // five minutes and a process renews every thirty seconds); only one that
+    // ran out is an orphan. The reaper turns it into an error soon after, and
+    // the second look catches that too.
+    const lease = timeOf(row.lease_expires_at);
+    return !(Number.isFinite(lease) && lease > now);
+  }
+  return isReaped(row) || (row.status === "error" && row.sidecar?.recoveryPending === true);
+}
+
+const isDirectory = async (path) => {
+  try { return (await stat(path)).isDirectory(); } catch { return false; }
+};
+
+/** One pass over one folder. Returns what it did, for the log and the test:
+ *  `{resumed: [runId], ended: [runId], skipped: [runId]}`. Never throws. */
+export async function restartPass(project, settings, { log = () => {}, now = Date.now } = {}) {
+  const done = { resumed: [], ended: [], skipped: [] };
+  const api = settings.runnerApi ?? runnerApiModule;
+  const opts = { env: settings.env, fetchImpl: settings.fetchImpl };
+
+  let rows;
+  try {
+    const [running, errored] = await Promise.all([
+      api.runs({ projectIds: [project.id], status: "running" }, opts),
+      api.runs({ projectIds: [project.id], status: "error" }, opts),
+    ]);
+    if (!running.ok) { log(`restart pass: could not list the running sessions: ${running.error}`); return done; }
+    rows = [...(running.runs ?? []), ...(errored.ok ? errored.runs ?? [] : [])];
+  } catch (error) {
+    log(`restart pass failed: ${error instanceof Error ? error.message : String(error)}`);
+    return done;
+  }
+
+  for (const row of rows.filter((r) => restartCandidate(r, { now: now() }))) {
+    try {
+      const outcome = await carryOn(row, { api, opts, log, now });
+      done[outcome].push(row.id);
+    } catch (error) {
+      log(`[${row.id}] restart pass failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return done;
+}
+
+async function carryOn(row, { api, opts, log, now }) {
+  const request = row.request;
+  const sidecar = row.sidecar && typeof row.sidecar === "object" ? row.sidecar : {};
+  const treeKept = typeof sidecar.worktreePath === "string" && await isDirectory(sidecar.worktreePath);
+  const engine = agentFor(request.agent);
+  const sessionId = (engine === "codex" ? [sidecar.codexThreadId, request.resumeSessionId] : [sidecar.claudeSessionId, request.resumeSessionId, request.sessionId])
+    .find((v) => typeof v === "string" && v.trim() !== "")?.trim();
+  const canResume = ["claude", "codex"].includes(engine) && acceptsMessages(request) && treeKept && sessionId !== undefined;
+  // A running row without its copy gets a second look after the reaper.
+  if (!canResume && acceptsMessages(request) && !treeKept && row.status === "running") {
+    log(`[${row.id}] restart pass: no kept worktree to carry on in; leaving it to the reaper`);
+    return "skipped";
+  }
+
+  // Lease timestamps are server time: the final successful renewal is the
+  // last confirmed working instant, never the reaper's five-minute deadline.
+  // Each child inherits the remaining budget, so previous segments are not
+  // counted again. Tail work since the last successful renewal is unconfirmed.
+  const claimed = timeOf(row.claimed_at);
+  const lastWorking = timeOf(row.lease_expires_at) - 300_000;
+  const workingMs = Number.isFinite(claimed) && Number.isFinite(lastWorking)
+    ? Math.max(0, lastWorking - claimed) : 0;
+  const remainingMs = Math.max(0, wallClockFor(request) - workingMs);
+  const settledSidecar = sidecar.recoveryPending === true ? sidecar : { ...sidecar, recoveryPending: true, ...(!canResume || remainingMs <= 0 ? { recoveryFailed: true } : {}), remainingWorkingMs: remainingMs, ...(canResume ? { [engine === "codex" ? "codexThreadId" : "claudeSessionId"]: sessionId } : {}), restartedAt: new Date(now()).toISOString(), restartAttempt: randomUUID() };
+  const settled = sidecar.recoveryPending === true ? { ok: true } : await api.update({
+    runId: row.id,
+    patch: {
+      sidecar: settledSidecar,
+      // No "carried on" claim here (round 2, item 59): the resume does not
+      // exist yet, and result is write-once; the card says it from restartedTo.
+      result: `ERROR\n\nYour computer restarted while this session was working.\n`,
+      ...(row.status === "running" ? { status: "error", finished_at: new Date(now()).toISOString() } : {}),
+    },
+  }, opts);
+  if (!settled.ok) {
+    log(`[${row.id}] restart pass: another process already took this row (${settled.error})`);
+    return "skipped";
+  }
+
+  if (canResume && remainingMs > 0) {
+    // A Stop that lands between the listing and here wins (the op looks).
+    const resumed = await api.resume({ runId: row.id, message: RESTART_MESSAGE, unlessStopped: true }, opts);
+    const childId = resumed.run?.id ?? resumed.id;
+    if (resumed.ok && childId) {
+      log(`[${row.id}] restart pass: carried on as ${childId}`);
+      await api.update({ runId: row.id, patch: { sidecar: { ...settledSidecar, recoveryPending: false, restarted: true, restartedTo: childId } } }, opts)
+        .catch(() => {});
+      return "resumed";
+    }
+    if (resumed.transient) return "skipped";
+    log(`[${row.id}] restart pass: could not resume (${resumed.error ?? "no run came back"}); telling the idea instead`);
+  }
+
+  // Persist the outcome on the row. Every app tab derives the same ending;
+  // there is no racing generic comment with different words or missing chips.
+  await api.update({ runId: row.id, patch: { sidecar: { ...settledSidecar, recoveryPending: false, restarted: true, recoveryFailed: true } } }, opts);
+  log(`[${row.id}] restart pass: this session cannot carry on`);
+  return "ended";
+}

package/lib/retired-address.mjs

@@ -0,0 +1,78 @@
+// Previous production app addresses. Saved credentials and agent configs
+// move to Viewable without losing tokens or unrelated configuration (#2197).
+// The Worker keeps machine calls on app.glytch.ai working during rollout.
+
+export const RETIRED_APP_URL = "https://prompt.glytch.ai";
+export const RETIRED_APP_URLS = [RETIRED_APP_URL, "https://app.glytch.ai"];
+const MOVED_FIELDS = ["appUrl", "mcpUrl", "tokenEndpoint"];
+
+/** `~/.glytch/auth.json` as read, with every address on the retired origin
+ *  moved to `to`. The token is kept: one issued for the old address is still
+ *  accepted at the new one until it expires
+ *  (supabase/functions/_shared/publicOrigin.mjs). */
+export function movedAuth(stored, to) {
+  const out = { ...stored };
+  for (const key of MOVED_FIELDS) {
+    const value = out[key];
+    const retired = typeof value === "string" && RETIRED_APP_URLS.find(origin => value === origin || value.startsWith(`${origin}/`));
+    if (retired) {
+      out[key] = to + value.slice(retired.length);
+    }
+  }
+  return out;
+}
+
+/** Where `claude mcp get` says an entry lives. Verified 2026-10-03 on
+ *  2.1.288: the output has a "Scope: Local config (...)" / "Scope: User
+ *  config (...)" / "Scope: Project config (...)" line, a "URL: <address>"
+ *  line, and (for an entry added with a header) the "Authorization: Bearer
+ *  <token>" line under "Headers:"; `claude mcp remove <name> -s <scope>`
+ *  takes local, user or project. A project entry is the folder's
+ *  `.mcp.json`, which `viewable init` rewrites itself (lib/mcpjson.mjs), so it
+ *  is never removed from here. */
+export function claudeRegistration(text) {
+  const scope = /^\s*Scope:\s*(Local|User|Project)\b/im.exec(text)?.[1]?.toLowerCase() ?? null;
+  const url = /^\s*URL:\s*(\S+)/im.exec(text)?.[1] ?? null;
+  const bearer = /^\s*Authorization:\s*Bearer\s+(\S+)/im.exec(text)?.[1] ?? null;
+  return { scope, url, bearer };
+}
+
+/** Replace a Claude Code registration at the retired address: remove it at
+ *  the scope it lives in, then add it back at `boardUrl` through the same
+ *  exec seam. The new entry keeps a bearer: at local scope the one `init` was
+ *  handed, else the old entry's own; at user scope only the old entry's own.
+ *  An entry without one signs in again. If the add fails after the remove
+ *  worked, the old entry is put back, so a failed move loses nothing.
+ *
+ *  Returns `{status: "ok" | "fail", message}` when the step is settled, or
+ *  `{status: "relogin", message}` when the new entry still needs a sign-in. */
+export async function moveClaudeRegistration({ exec, bin, env, serverKey, scope, url, bearer, token, boardUrl, addArgs, stderrOf }) {
+  const carried = scope === "local" ? (token ?? bearer) : bearer;
+  const argsFor = (address, header) => header
+    ? addArgs(address, header, scope)
+    : ["mcp", "add", "-s", scope, "--transport", "http", serverKey, address];
+  const args = argsFor(boardUrl, carried);
+  let removed;
+  let added;
+  try {
+    removed = await exec(bin, ["mcp", "remove", serverKey, "-s", scope], { env });
+  } catch (error) {
+    return { status: "fail", message: error instanceof Error ? error.message : String(error) };
+  }
+  if (!removed?.ok) {
+    return { status: "fail", message: `could not remove the old ${scope} registration at ${url}: ${stderrOf(removed)}` };
+  }
+  added = await exec(bin, args, { env }).catch(() => null);
+  if (!added?.ok) {
+    const why = added ? stderrOf(added) : "the add did not run";
+    const restored = await exec(bin, argsFor(url, bearer), { env }).catch(() => null);
+    return {
+      status: "fail",
+      message: restored?.ok
+        ? `could not add the new registration (${why}); the old one was put back`
+        : `could not add the new registration (${why}) or put the old one back: run \`claude mcp add -s ${scope} --transport http ${serverKey} ${boardUrl}\``,
+    };
+  }
+  if (carried) return { status: "ok", message: `moved from ${url} to ${boardUrl} (${scope} scope, access token kept)` };
+  return { status: "relogin", message: `Moved the ${scope} ${serverKey} registration from ${url} to ${boardUrl}.` };
+}