in2-agent-server 0.20260821.185429

package/viewer/server.mjs

@@ -0,0 +1,433 @@
+// IN2 session viewer. A read-only localhost UI over one delivery session's on-disk artifacts,
+// meant to be docked in the Claude Code desktop sidebar while a run executes.
+//
+// It writes NOTHING and talks to NOTHING: every fact on screen is a projection of files the
+// cc-mcp-server already writes atomically (tmp+rename) under the session directory, so polling
+// can never catch a torn write and the viewer can never desync the run. `activate_session` spawns
+// this (src/core/viewer.ts) and returns the URL pinned to ?session=<id>; run by hand, it defaults
+// to the most recently modified session dir.
+//
+// Run:  node apps/cc-mcp-server/viewer/server.mjs           (port 4199)
+// Env:  IN2_VIEWER_PORT, CC_MCP_WORKSPACE_ROOT (same var the server honors)
+
+import { createServer } from "node:http";
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HERE = resolve(fileURLToPath(import.meta.url), "..");
+const PORT = Number(process.env.IN2_VIEWER_PORT || 4199);
+// argv[2] wins so a launch.json entry can point at a replay/scratch root without env plumbing.
+const SESSIONS_ROOT =
+  process.argv[2] ||
+  process.env.CC_MCP_WORKSPACE_ROOT?.trim() ||
+  join(homedir(), ".in2-agent", ".local", "cc-mcp", "sessions");
+
+// The nine chapters, mirrored from core/phases.ts. The viewer renders whatever the ledger says,
+// so drift here only affects the "not yet reached" tail of the stepper.
+const CHAPTERS = [
+  "activation",
+  "intake",
+  "partitioning",
+  "parallel-analysis",
+  "clarification",
+  "scope-approval",
+  "delivery",
+  "review-results",
+  "writeback-close"
+];
+const SKIPPABLE = new Set(["partitioning", "parallel-analysis", "clarification"]);
+
+// ---------- safe readers ------------------------------------------------------
+
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function readText(file) {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+function listDirs(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+function listFiles(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isFile())
+      .map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+// Session ids are opaque `ses_<hex>`; refuse anything path-shaped.
+const SESSION_ID_RE = /^ses_[a-z0-9]+$/;
+
+function sessionDir(id) {
+  if (!SESSION_ID_RE.test(id)) return null;
+  const dir = join(SESSIONS_ROOT, id);
+  return existsSync(dir) ? dir : null;
+}
+
+function newestSessionId() {
+  let best = null;
+  let bestM = -1;
+  for (const name of listDirs(SESSIONS_ROOT)) {
+    if (!SESSION_ID_RE.test(name)) continue;
+    try {
+      const m = statSync(join(SESSIONS_ROOT, name)).mtimeMs;
+      if (m > bestM) {
+        bestM = m;
+        best = name;
+      }
+    } catch {
+      /* raced deletion */
+    }
+  }
+  return best;
+}
+
+// ---------- state projection --------------------------------------------------
+
+function projectPhases(dir) {
+  const raw = readText(join(dir, "phases.jsonl"));
+  const entries = [];
+  if (raw) {
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+        /* partial line */
+      }
+    }
+  }
+  // Head = the chapter the run is currently IN (last `entering`); before any entry it's activation.
+  const head = entries.length ? entries[entries.length - 1].entering : "activation";
+  const completed = new Set(entries.map((e) => e.completed));
+  const chapters = CHAPTERS.map((name) => {
+    let status;
+    if (completed.has(name)) status = "done";
+    else if (name === head) status = "active";
+    else {
+      const headIdx = CHAPTERS.indexOf(head);
+      const idx = CHAPTERS.indexOf(name);
+      // A skippable chapter behind the head that never completed was skipped, not stalled.
+      status = idx < headIdx ? (SKIPPABLE.has(name) ? "skipped" : "done") : "pending";
+    }
+    const entry = entries.find((e) => e.completed === name);
+    return { name, status, at: entry?.at ?? null, note: entry?.note ?? null };
+  });
+  return { chapters, head, hasLedger: entries.length > 0 };
+}
+
+function projectRequirements(dir, head) {
+  const index = readJson(join(dir, "requirements", "index.json")) || [];
+  const analysisUnderway =
+    CHAPTERS.indexOf(head) >= CHAPTERS.indexOf("partitioning") &&
+    CHAPTERS.indexOf(head) <= CHAPTERS.indexOf("clarification");
+  return index.map((r) => {
+    const reqDir = join(dir, "requirements", r.extId);
+    const plan = readJson(join(reqDir, "plan.json"));
+    let status, detail;
+    if (plan) {
+      // A resolved blocker is history, not a live block — only open ones color the row.
+      const openBlockers = (plan.blockers || []).filter((b) => !b.resolved);
+      status = openBlockers.length > 0 ? "blocked" : "analyzed";
+      detail = {
+        summary: plan.summary || null,
+        components: (plan.components || []).map((c) => ({
+          typeName: c.typeName,
+          fullName: c.fullName,
+          intent: c.intent,
+          status: c.status,
+          deployable: c.deployable !== false
+        })),
+        blockers: openBlockers,
+        assumptions: plan.assumptions || []
+      };
+    } else {
+      status = analysisUnderway ? "analyzing" : "queued";
+      detail = null;
+    }
+    return { extId: r.extId, title: r.title, status, detail };
+  });
+}
+
+function projectQuestions(dir) {
+  const qdir = join(dir, "questions");
+  return listFiles(qdir)
+    .filter((f) => f.endsWith(".json"))
+    .sort()
+    .map((f) => {
+      const q = readJson(join(qdir, f));
+      if (!q) return null;
+      return {
+        round: q.round,
+        status: q.status,
+        askedAt: q.askedAt || null,
+        answeredAt: q.answeredAt || null,
+        questions: (q.questions || []).map((x) => ({
+          header: x.header,
+          question: x.question,
+          // answer: { chosenLabels: [...], answeredAt } once the operator has decided.
+          answer: x.answer ?? x.selected ?? null,
+          options: (x.options || []).map((o) => ({
+            label: o.label,
+            description: o.description ?? null
+          }))
+        }))
+      };
+    })
+    .filter(Boolean);
+}
+
+function projectWaves(dir) {
+  const ddir = join(dir, "direct");
+  const report = readJson(join(dir, "batch-report.json"));
+  const reportByWave = new Map((report?.waves || []).map((w) => [w.wave, w]));
+  return listDirs(ddir)
+    .filter((d) => !d.startsWith("teardown-"))
+    .sort()
+    .map((name) => {
+      const wdir = join(ddir, name);
+      const verdict = readJson(join(wdir, "verdict.json"));
+      const request = readJson(join(wdir, "request.json"));
+      const deploy = readJson(join(wdir, "deploy.json"));
+      const rep = reportByWave.get(name);
+      let status;
+      if (verdict) status = "done";
+      else if (deploy) status = "deploying";
+      else if (request) status = "in-progress";
+      else status = "assembling";
+      return {
+        name,
+        status,
+        verdict: verdict?.verdict ?? null,
+        deployStatus: verdict?.deploy?.status ?? deploy?.status ?? null,
+        dryRunStatus: verdict?.dryRun?.status ?? null,
+        lintBlocked: verdict?.lint?.blocked ?? null,
+        components: (request?.edits || []).map((e) => `${e.typeName}:${e.fullName}`),
+        requirementIds: rep?.requirementIds ?? [],
+        diff: verdict
+          ? {
+              added: (verdict.diff?.added || []).length,
+              removed: (verdict.diff?.removed || []).length,
+              changed: (verdict.diff?.changed || []).length
+            }
+          : null,
+        failures: [
+          ...(verdict?.dryRun?.failures || []),
+          ...(verdict?.deploy?.failures || [])
+        ].slice(0, 10)
+      };
+    });
+}
+
+// The results rollup mirrors the original VFP batch-results page: per REQUIREMENT, not per wave.
+// A requirement's outcome is derived from the waves that carried it — the worst wave wins.
+//
+// VOCABULARY NOTE, mirrored from direct/waveGrade.ts: `DELIVERED_WITH_DRIFT` is a member of the
+// DELIVERED set — the batch report counts those waves as delivered with zero needing review. Drift
+// is a fact to explain, not a failure. So drift never demotes a requirement out of "delivered";
+// it only splits delivered into reconciled (the review-results chapter classified the drift, or
+// the batch report closed with the wave counted delivered) vs pending (delivery done, review not).
+const DELIVERED_VERDICTS = new Set(["DIFF_VERIFIED", "DELIVERED_WITH_DRIFT"]);
+
+function projectResults(requirements, waves, driftReviewed, writeback) {
+  const wavesByReq = new Map();
+  for (const w of waves) {
+    for (const id of w.requirementIds) {
+      if (!wavesByReq.has(id)) wavesByReq.set(id, []);
+      wavesByReq.get(id).push(w);
+    }
+  }
+  // Which wave carried each component, for the per-requirement action breakdown. A component may
+  // appear in several waves under the revision model — the LAST done wave listed is shown.
+  const waveByComponent = new Map();
+  for (const w of waves) {
+    for (const key of w.components) waveByComponent.set(key, w);
+  }
+  return requirements.map((r) => {
+    const inWaves = wavesByReq.get(r.extId) || [];
+    const doneWaves = inWaves.filter((w) => w.status === "done");
+    let outcome;
+    if (!inWaves.length) outcome = r.status === "blocked" ? "blocked" : "not-delivered";
+    else if (doneWaves.length < inWaves.length) outcome = "delivering";
+    else if (doneWaves.some((w) => !DELIVERED_VERDICTS.has(w.verdict || ""))) outcome = "problem";
+    else if (doneWaves.some((w) => w.verdict === "DELIVERED_WITH_DRIFT"))
+      outcome = driftReviewed ? "drift-reconciled" : "drift-pending";
+    else outcome = "delivered";
+    // Per-component actions: the plan says what was intended; the wave map says which wave
+    // carried it and how that wave ended.
+    const actions = (r.detail ? r.detail.components : []).map((c) => {
+      const key = `${c.typeName}:${c.fullName}`;
+      const w = waveByComponent.get(key);
+      let status;
+      if (!w) status = c.deployable ? "not-deployed" : "manual";
+      else if (w.status !== "done") status = "deploying";
+      else status = DELIVERED_VERDICTS.has(w.verdict || "") ? "verified" : "failed";
+      return { component: key, intent: c.intent || null, wave: w ? w.name : null, status };
+    });
+    // Null (not a default) when the manifest is absent or does not name this requirement — the UI
+    // reads that as "no per-row truth here" and keeps using the ledger-derived phase.
+    const wb = (writeback && writeback[r.extId]) || null;
+    return {
+      extId: r.extId,
+      title: r.title,
+      outcome,
+      waves: inWaves.map((w) => w.name),
+      components: r.detail ? r.detail.components.length : 0,
+      assumptions: r.detail ? r.detail.assumptions.length : 0,
+      actions,
+      writeback: wb
+    };
+  });
+}
+
+// Per-requirement writeback state, keyed by extId, from `writeback/manifest.json` — written by
+// campfire_write_config_items once before its concurrent upsert loop and once after the read-back.
+// Absent for older sessions and for every run before the writeback starts, in which case the UI
+// falls back to the one-phase-for-all-rows derivation off the chapter ledger.
+function projectWriteback(dir) {
+  const manifest = readJson(join(dir, "writeback", "manifest.json"));
+  const rows = Array.isArray(manifest?.requirements) ? manifest.requirements : [];
+  const out = {};
+  for (const row of rows) {
+    if (!row || typeof row.extId !== "string") continue;
+    out[row.extId] = {
+      status: typeof row.status === "string" ? row.status : "pending",
+      ciCount: Number.isFinite(row.ciCount) ? row.ciCount : 0,
+      writtenAt: row.writtenAt ?? null
+    };
+  }
+  return Object.keys(out).length ? out : null;
+}
+
+function projectState(id) {
+  const dir = sessionDir(id);
+  if (!dir) return null;
+  const session = readJson(join(dir, "session.json")) || {};
+  const { chapters, head, hasLedger } = projectPhases(dir);
+  const requirements = projectRequirements(dir, head);
+  const waves = projectWaves(dir);
+  const questions = projectQuestions(dir);
+  const report = readJson(join(dir, "batch-report.json"));
+  return {
+    sessionId: id,
+    generatedAt: new Date().toISOString(),
+    org: {
+      targetAlias: session.targetOrg?.alias ?? null,
+      targetOrgId: session.targetOrg?.orgId ?? null,
+      operator: session.actors?.targetUsername ?? null
+    },
+    createdAt: session.createdAt ?? null,
+    hasLedger,
+    head,
+    chapters,
+    requirements,
+    counts: {
+      total: requirements.length,
+      analyzed: requirements.filter((r) => r.status === "analyzed").length,
+      blocked: requirements.filter((r) => r.status === "blocked").length,
+      analyzing: requirements.filter((r) => r.status === "analyzing").length
+    },
+    questions,
+    waves,
+    // Drift counts as reconciled once the run has actually reviewed it: the review-results
+    // chapter completed (its ledger note is where drift gets classified), or the batch report
+    // exists (generated at close, after review, with drift waves counted delivered).
+    results: projectResults(
+      requirements,
+      waves,
+      chapters.some((c) => c.name === "review-results" && c.status === "done") || Boolean(report),
+      projectWriteback(dir)
+    ),
+    report: report
+      ? {
+          result: report.result,
+          deliveredWaves: report.deliveredWaves,
+          problemWaves: report.problemWaves,
+          findings: report.findings || [],
+          generatedAt: report.generatedAt
+        }
+      : null
+  };
+}
+
+function listSessions() {
+  return listDirs(SESSIONS_ROOT)
+    .filter((n) => SESSION_ID_RE.test(n))
+    .map((n) => {
+      const dir = join(SESSIONS_ROOT, n);
+      const session = readJson(join(dir, "session.json")) || {};
+      let mtime = 0;
+      try {
+        mtime = statSync(dir).mtimeMs;
+      } catch {
+        /* raced */
+      }
+      return {
+        sessionId: n,
+        createdAt: session.createdAt ?? null,
+        targetAlias: session.targetOrg?.alias ?? null,
+        requirements: (readJson(join(dir, "requirements", "index.json")) || []).length,
+        hasReport: existsSync(join(dir, "batch-report.json")),
+        mtime
+      };
+    })
+    .sort((a, b) => b.mtime - a.mtime);
+}
+
+// ---------- http --------------------------------------------------------------
+
+const server = createServer((req, res) => {
+  const url = new URL(req.url, `http://localhost:${PORT}`);
+  const send = (code, body, type = "application/json") => {
+    res.writeHead(code, { "content-type": `${type}; charset=utf-8`, "cache-control": "no-store" });
+    res.end(type === "application/json" ? JSON.stringify(body) : body);
+  };
+
+  if (url.pathname === "/" || url.pathname === "/index.html") {
+    // Read per request: prototype-stage hot reload beats the microseconds saved by caching.
+    return send(200, readFileSync(join(HERE, "index.html"), "utf8"), "text/html");
+  }
+  if (url.pathname === "/api/sessions") {
+    return send(200, { sessions: listSessions() });
+  }
+  if (url.pathname === "/api/state") {
+    const id = url.searchParams.get("session") || newestSessionId();
+    if (!id) return send(404, { error: "no sessions found", root: SESSIONS_ROOT });
+    const state = projectState(id);
+    if (!state) return send(404, { error: `session not found: ${id}` });
+    return send(200, state);
+  }
+  if (url.pathname === "/healthz") {
+    return send(200, { ok: true, root: SESSIONS_ROOT });
+  }
+  return send(404, { error: "not found" });
+});
+
+server.listen(PORT, () => {
+  console.log(`IN2 session viewer — http://localhost:${PORT}`);
+  console.log(`sessions root: ${SESSIONS_ROOT}`);
+  const newest = newestSessionId();
+  if (newest) console.log(`default session: ${newest}`);
+});