fleetlens 0.11.2 → 0.12.0

package/app/apps/web/app/api/events/route.ts

@@ -110,6 +110,44 @@ export async function GET(request: Request) {
         );
       }
 
+      // Workflow journals (`<session>/workflows/wf_*.json`) aren't `.jsonl`
+      // and live a level down, so the main emit() path skips them. Map the
+      // journal back to its parent session, drop the parent's cached meta /
+      // detail (so the list re-reads the spawned-agent aggregate), and emit a
+      // session-updated for the parent — the run itself re-reads journals
+      // fresh, so the detail page reflects new fan-out without a parent write.
+      function emitWorkflow(fullPath: string) {
+        const rel = path.relative(DEFAULT_ROOT, fullPath);
+        const parts = rel.split(path.sep);
+        const wfIdx = parts.lastIndexOf("workflows");
+        if (wfIdx < 2) return;
+        const projectDir = parts[0]!;
+        const sessionId = parts[wfIdx - 1]!;
+        const parentJsonl = path.join(DEFAULT_ROOT, projectDir, `${sessionId}.jsonl`);
+        const prev = pending.get(parentJsonl);
+        if (prev) clearTimeout(prev);
+        pending.set(
+          parentJsonl,
+          setTimeout(async () => {
+            pending.delete(parentJsonl);
+            if (closed) return;
+            invalidateFile(parentJsonl);
+            // Report the JOURNAL's mtime, not the parent .jsonl's. A
+            // journal-only write leaves the parent .jsonl untouched, so its
+            // (stale) mtime would lose LiveRefresher's monotonic-per-source
+            // dedup and the refresh would be silently dropped. The journal we
+            // just saw change always carries a fresh mtime.
+            let mtimeMs = Date.now();
+            try {
+              mtimeMs = (await fs.stat(fullPath)).mtimeMs;
+            } catch {
+              // journal might be gone already — fall back to now.
+            }
+            send({ type: "session-updated", sessionId, projectDir, mtimeMs });
+          }, DEBOUNCE_MS),
+        );
+      }
+
       let watcher: ReturnType<typeof watch> | null = null;
       try {
         watcher = watch(
@@ -118,8 +156,18 @@ export async function GET(request: Request) {
           (_eventType, filename) => {
             if (!filename) return;
             const fullPath = path.join(DEFAULT_ROOT, filename.toString());
-            if (!fullPath.endsWith(".jsonl")) return;
-            emit(fullPath);
+            if (fullPath.endsWith(".jsonl")) {
+              emit(fullPath);
+              return;
+            }
+            const base = path.basename(fullPath);
+            if (
+              base.startsWith("wf_") &&
+              base.endsWith(".json") &&
+              fullPath.includes(`${path.sep}workflows${path.sep}`)
+            ) {
+              emitWorkflow(fullPath);
+            }
           },
         );
       } catch (e) {

package/app/apps/web/app/api/pdf/[key]/route.ts

@@ -0,0 +1,199 @@
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import {
+  readWeekDigest, readMonthDigest,
+  getCurrentWeekDigestFromCache, getCurrentMonthDigestFromCache,
+} from "@claude-lens/entries/node";
+import { currentWeekMonday, currentYearMonth } from "@/lib/entries";
+import { findChrome } from "@/lib/find-chrome";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const KEY = /^(week-(\d{4}-\d{2}-\d{2})|month-(\d{4}-\d{2}))$/;
+
+const RENDER_TIMEOUT_MS = 25_000;
+const STABILITY_MS = 600;
+
+export async function POST(
+  req: Request,
+  { params }: { params: Promise<{ key: string }> },
+) {
+  const { key } = await params;
+  const m = KEY.exec(key);
+  if (!m) {
+    return jsonError(400, `Invalid key: ${key}`);
+  }
+
+  // Pre-check the digest exists in whichever source the /print page would
+  // read from. Without this, Chrome happily captures Next.js's 404 page as
+  // a "successful" PDF, and current-period digests that have aged out of
+  // the in-memory TTL would yield a broken download instead of a clear
+  // error.
+  if (!digestExists(m)) {
+    return jsonError(
+      404,
+      "Digest not found. If this is the current week or month, the in-memory cache may have expired — reload the page and re-generate.",
+    );
+  }
+
+  const chrome = await findChrome();
+  if (!chrome) {
+    return jsonError(
+      500,
+      "Could not find Chrome / Chromium. Install Google Chrome, or set FLEETLENS_CHROME_PATH.",
+    );
+  }
+
+  const origin = new URL(req.url).origin;
+  // Headless Chrome won't carry the user's session cookies, so forward the
+  // current theme via query param. Middleware turns it into a header that
+  // the root layout applies to <html data-theme>.
+  const theme = parseThemeCookie(req.headers.get("cookie"));
+  const targetUrl = theme
+    ? `${origin}/print/${key}?theme=${theme}`
+    : `${origin}/print/${key}`;
+
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "fleetlens-pdf-"));
+  const tmpPath = path.join(tmpDir, "out.pdf");
+  const profileDir = path.join(tmpDir, "profile");
+
+  try {
+    await renderToPdf(chrome, targetUrl, tmpPath, profileDir);
+    const bytes = await fs.readFile(tmpPath);
+    const today = new Date().toISOString().slice(0, 10);
+    return new Response(new Uint8Array(bytes), {
+      status: 200,
+      headers: {
+        "Content-Type": "application/pdf",
+        "Content-Disposition": `attachment; filename="fleetlens-${key}-${today}.pdf"`,
+        "Cache-Control": "no-store",
+      },
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return jsonError(500, `PDF render failed: ${message}`);
+  } finally {
+    fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+function digestExists(match: RegExpExecArray): boolean {
+  const monday = match[2];
+  const yearMonth = match[3];
+  if (monday) {
+    if (monday === currentWeekMonday()) {
+      return !!(getCurrentWeekDigestFromCache(monday, Date.now()) ?? readWeekDigest(monday));
+    }
+    return !!readWeekDigest(monday);
+  }
+  if (yearMonth) {
+    if (yearMonth === currentYearMonth()) {
+      return !!(getCurrentMonthDigestFromCache(yearMonth, Date.now()) ?? readMonthDigest(yearMonth));
+    }
+    return !!readMonthDigest(yearMonth);
+  }
+  return false;
+}
+
+// Chrome on macOS produces the PDF in 2–3s but the parent process keeps
+// running (GoogleUpdater helpers prevent a clean exit). So instead of waiting
+// for the process to close, we poll the output file for stability and kill
+// Chrome once it's stable.
+async function renderToPdf(
+  chrome: string,
+  url: string,
+  out: string,
+  profileDir: string,
+): Promise<void> {
+  // --no-sandbox is required on Linux containers / CI without user namespaces
+  // (Chrome can't drop privileges otherwise), but it's a security weakening
+  // that's not needed on macOS or Windows desktop Chrome. Opt-in via env on
+  // the systems that need it.
+  const noSandbox = process.env.FLEETLENS_CHROME_NO_SANDBOX === "1"
+    || process.platform === "linux";
+  const args = [
+    "--headless=new",
+    "--disable-gpu",
+    ...(noSandbox ? ["--no-sandbox"] : []),
+    "--no-pdf-header-footer",
+    "--hide-scrollbars",
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-background-networking",
+    "--disable-component-update",
+    `--user-data-dir=${profileDir}`,
+    `--print-to-pdf=${out}`,
+    url,
+  ];
+
+  let earlyExit: number | null = null;
+  const proc = spawn(chrome, args, {
+    stdio: "ignore",
+    detached: true,
+  });
+  proc.on("exit", (code) => { earlyExit = code; });
+  proc.unref();
+
+  const deadline = Date.now() + RENDER_TIMEOUT_MS;
+  let lastSize = -1;
+  let stableSince = 0;
+  let lastErr: NodeJS.ErrnoException | null = null;
+
+  while (Date.now() < deadline) {
+    await delay(150);
+    if (earlyExit !== null && earlyExit !== 0) {
+      throw new Error(`Chrome exited early with code ${earlyExit}`);
+    }
+    let size: number;
+    try {
+      size = (await fs.stat(out)).size;
+    } catch (e) {
+      lastErr = e as NodeJS.ErrnoException;
+      continue;
+    }
+    if (size <= 0) continue;
+    if (size === lastSize) {
+      if (!stableSince) stableSince = Date.now();
+      if (Date.now() - stableSince >= STABILITY_MS) {
+        killGroup(proc.pid);
+        return;
+      }
+    } else {
+      lastSize = size;
+      stableSince = 0;
+    }
+  }
+
+  killGroup(proc.pid);
+  throw new Error(
+    `Chrome render timed out after ${RENDER_TIMEOUT_MS / 1000}s` +
+    (lastErr ? ` (no PDF file produced: ${lastErr.code})` : ""),
+  );
+}
+
+// On Unix the negative PID kills the whole process group (Chrome spawns
+// helper processes for GPU, network, renderer). On Windows process.kill(-pid)
+// throws ESRCH — the swallowed exception is intentional, and the fallback
+// kill below at least reaps the root Chrome process.
+function killGroup(pid: number | undefined): void {
+  if (!pid) return;
+  try { process.kill(-pid, "SIGKILL"); } catch { /* group already gone, or Windows */ }
+  try { process.kill(pid, "SIGKILL"); } catch { /* already gone */ }
+}
+
+function parseThemeCookie(header: string | null): "light" | "dark" | null {
+  if (!header) return null;
+  const m = /(?:^|;\s*)claude-lens-theme=(light|dark)/.exec(header);
+  return m ? (m[1] as "light" | "dark") : null;
+}
+
+function jsonError(status: number, message: string): Response {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}

package/app/apps/web/app/api/workflow-agent/route.ts

@@ -0,0 +1,27 @@
+/**
+ * On-demand loader for a single workflow-spawned agent's full transcript —
+ * the ordered step list, full prompt, and final result. Lazy-fetched by the
+ * Workflows tab when an agent row is expanded, so a 200-agent session's detail
+ * page never parses 200 transcripts up front.
+ *
+ * GET /api/workflow-agent?session=<id>&run=<runId>&agent=<agentId>
+ */
+import { loadWorkflowAgentDetail } from "@claude-lens/parser/fs";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const session = url.searchParams.get("session");
+  const run = url.searchParams.get("run");
+  const agent = url.searchParams.get("agent");
+  if (!session || !run || !agent) {
+    return Response.json({ error: "session, run and agent are required" }, { status: 400 });
+  }
+  const detail = await loadWorkflowAgentDetail(session, run, agent);
+  if (!detail) {
+    return Response.json({ error: "not found" }, { status: 404 });
+  }
+  return Response.json(detail);
+}

package/app/apps/web/app/insights/[key]/page.tsx

@@ -58,8 +58,11 @@ export default async function SavedInsightPage({
   const monthMatch = MONTH_KEY.exec(key);
   if (monthMatch) {
     const yearMonth = monthMatch[1]!;
+    // Same in-memory-then-disk fallback as the week branch above:
+    // force-generated current-month digests get persisted by
+    // digest-month-pipeline, so this read survives the 10-min TTL.
     const cached = yearMonth === currentYearMonth()
-      ? getCurrentMonthDigestFromCache(yearMonth, Date.now())
+      ? (getCurrentMonthDigestFromCache(yearMonth, Date.now()) ?? readMonthDigest(yearMonth))
       : readMonthDigest(yearMonth);
 
     const prev = shiftYearMonth(yearMonth, -1);

package/app/apps/web/app/layout.tsx

@@ -1,5 +1,5 @@
 import type { Metadata } from "next";
-import { cookies } from "next/headers";
+import { cookies, headers } from "next/headers";
 import { Sidebar } from "@/components/sidebar";
 import { LiveRefresher } from "@/components/live-refresher";
 import {
@@ -25,6 +25,28 @@ export const metadata: Metadata = {
 export const dynamic = "force-dynamic";
 
 export default async function RootLayout({ children }: { children: React.ReactNode }) {
+  // /print/* is a stripped layout used as the headless-render target for PDF
+  // export. Skip the sidebar, live-sessions widget, and job-queue widget so
+  // the captured PDF contains only the digest content.
+  const reqHeaders = await headers();
+  const pathname = reqHeaders.get("x-fleetlens-pathname") ?? "";
+  if (pathname.startsWith("/print/")) {
+    // Theme priority: header set by middleware from ?theme= (forwarded by
+    // the PDF API), then cookie (for direct browser visits), then dark.
+    const headerTheme = reqHeaders.get("x-fleetlens-theme");
+    const cookieStore = await cookies();
+    const cookieTheme = cookieStore.get("claude-lens-theme")?.value;
+    const theme =
+      headerTheme === "light" || headerTheme === "dark" ? headerTheme :
+      cookieTheme === "light" || cookieTheme === "dark" ? cookieTheme :
+      "dark";
+    return (
+      <html lang="en" data-theme={theme} suppressHydrationWarning>
+        <body>{children}</body>
+      </html>
+    );
+  }
+
   const [projects, allFiles, allSessions, entriesIndex] = await Promise.all([
     listProjects(),
     walkJsonlFiles(),

package/app/apps/web/app/page.tsx

@@ -7,6 +7,8 @@
 
 import {
   groupByProject,
+  dailyActivity,
+  toLocalDay,
   type AgentKind,
   agentMetadata,
   type SessionMeta,
@@ -53,6 +55,23 @@ export default async function DashboardHome({
   const sessions = filterByRange(allSessions, cutoff);
   const conn = readTeamConnection();
 
+  // Headline "Agent time" answers "agent time spent within the selected
+  // window". Summing whole-session airTimeMs over start-day-filtered sessions
+  // diverged from the team rollups at the window edges — it dropped pre-window
+  // sessions that bled into the window and kept the out-of-window tail of
+  // in-window sessions. Compute it the way the team daily_rollups / weekly
+  // digest do: dailyActivity's per-calendar-day clipped agent time over ALL
+  // sessions, kept to the window's days. For "all" this equals the whole-set
+  // total, so it's a no-op there.
+  const windowBuckets = (() => {
+    const buckets = dailyActivity(allSessions);
+    if (cutoff === undefined) return buckets;
+    const cutoffDay = toLocalDay(cutoff);
+    return buckets.filter((b) => b.date >= cutoffDay);
+  })();
+  const windowAgentMs = windowBuckets.reduce((sum, b) => sum + b.airTimeMs, 0);
+  const windowActiveDays = windowBuckets.filter((b) => b.airTimeMs > 0).length;
+
   // Heatmap day summaries — outcome from index, headline + helpfulness from cached digests
   const daySummaries = new Map<string, DaySummary>();
   for (const [date, outcome] of entriesIndex.dayOutcome) {
@@ -143,7 +162,11 @@ export default async function DashboardHome({
           is closed and the digest is final. */}
       <YesterdayHero />
 
-      <DashboardView sessions={sessions} daySummaries={daySummaries} />
+      <DashboardView
+        sessions={sessions}
+        daySummaries={daySummaries}
+        override={{ activeTimeMs: windowAgentMs, activeDayCount: windowActiveDays }}
+      />
 
       {/* Top projects + Recent sessions + Recent days */}
       <section

package/app/apps/web/app/print/[key]/page.tsx

@@ -0,0 +1,91 @@
+import { notFound } from "next/navigation";
+import {
+  readWeekDigest, readMonthDigest,
+  getCurrentWeekDigestFromCache, getCurrentMonthDigestFromCache,
+} from "@claude-lens/entries/node";
+import { WeekDigest } from "@/components/week-digest";
+import { MonthDigest } from "@/components/month-digest";
+import { currentWeekMonday, currentYearMonth } from "@/lib/entries";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+const WEEK_KEY = /^week-(\d{4}-\d{2}-\d{2})$/;
+const MONTH_KEY = /^month-(\d{4}-\d{2})$/;
+
+// Headless-render target for the PDF export. Sits on top of the root layout
+// via a position:fixed overlay (z-index above the floating LiveSessions /
+// JobQueue widgets, which use 99/100). No actions, no auto-fire — the digest
+// must already exist on disk (the API route fails fast if it doesn't).
+export default async function PrintPage({
+  params,
+}: { params: Promise<{ key: string }> }) {
+  const { key } = await params;
+
+  const weekMatch = WEEK_KEY.exec(key);
+  if (weekMatch) {
+    const monday = weekMatch[1]!;
+    const digest = monday === currentWeekMonday()
+      ? (getCurrentWeekDigestFromCache(monday, Date.now()) ?? readWeekDigest(monday))
+      : readWeekDigest(monday);
+    if (!digest) notFound();
+    const prior = readWeekDigest(shiftMonday(monday, -7));
+    return (
+      <PrintShell>
+        <WeekDigest digest={digest} aiEnabled={true} priorDigest={prior} />
+      </PrintShell>
+    );
+  }
+
+  const monthMatch = MONTH_KEY.exec(key);
+  if (monthMatch) {
+    const yearMonth = monthMatch[1]!;
+    // Match the week branch: try in-memory cache for the current month, then
+    // fall back to disk. Force-generated current-month digests get persisted
+    // by digest-month-pipeline so PDF export survives the 10-min TTL.
+    const digest = yearMonth === currentYearMonth()
+      ? (getCurrentMonthDigestFromCache(yearMonth, Date.now()) ?? readMonthDigest(yearMonth))
+      : readMonthDigest(yearMonth);
+    if (!digest) notFound();
+    return (
+      <PrintShell>
+        <MonthDigest digest={digest} aiEnabled={true} />
+      </PrintShell>
+    );
+  }
+
+  notFound();
+}
+
+function PrintShell({ children }: { children: React.ReactNode }) {
+  return (
+    <>
+      <style dangerouslySetInnerHTML={{ __html: PRINT_CSS }} />
+      {children}
+    </>
+  );
+}
+
+// Reset html/body to the digest's own background so the PDF page bleeds
+// edge-to-edge in the same color the digest renders against. @page disables
+// the printer header/margin defaults; Chrome's --print-to-pdf paginates A4.
+// --background is theme-aware (dark / light tokens in globals.css); never
+// hardcode a fallback that would break the light theme.
+const PRINT_CSS = `
+  @page { size: A4; margin: 8mm; }
+  html, body {
+    background: var(--background) !important;
+    color: var(--af-text);
+    margin: 0 !important;
+    padding: 0 !important;
+  }
+`;
+
+function shiftMonday(monday: string, days: number): string {
+  const d = new Date(`${monday}T00:00:00`);
+  d.setDate(d.getDate() + days);
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}

package/app/apps/web/app/projects/[slug]/page.tsx

@@ -2,7 +2,7 @@ import { notFound } from "next/navigation";
 import Link from "next/link";
 import { listSessions, getSession } from "@/lib/data";
 import {
-  canonicalProjectName,
+  projectRepoName,
   detectPrMarkers,
   sessionAirTimeMs,
 } from "@claude-lens/parser";
@@ -39,18 +39,17 @@ export const dynamic = "force-dynamic";
 export default async function ProjectDetail({ params }: { params: Promise<{ slug: string }> }) {
   const { slug } = await params;
   // Slugs are URL-encoded canonical project names (e.g.
-  // `%2FUsers%2Ffoo%2FRepo%2Fbar`). Match any session whose own
-  // canonicalProjectName resolves to the same path — that includes the
-  // parent repo AND any `/.worktrees/<name>` subdirs, so a project detail
-  // page naturally shows all parallel worktree activity in one view.
+  // Slugs are repo names (e.g. `claude-lens`). Match any session in that repo,
+  // which folds the parent repo, every `/.worktrees/<name>` subdir, and the
+  // same repo reached via Conductor / Superset into one view.
   const decodedCanonical = decodeURIComponent(slug);
   const all = await listSessions();
   const projectSessions = all.filter(
-    (s) => canonicalProjectName(s.projectName) === decodedCanonical,
+    (s) => projectRepoName(s.projectName) === decodedCanonical,
   );
   if (projectSessions.length === 0) return notFound();
 
-  // Use the canonical name for display (no `.worktrees/<name>` suffix).
+  // Display the repo name.
   const projectName = decodedCanonical;
 
   // PR detection is per-session — it needs the event stream, so load the

package/app/apps/web/app/projects/page.tsx

@@ -1,5 +1,5 @@
 import { listSessions } from "@/lib/data";
-import { canonicalProjectName, groupByProject } from "@claude-lens/parser";
+import { projectRepoName, groupByProject } from "@claude-lens/parser";
 import type { DayOutcome } from "@claude-lens/entries";
 import { ProjectsView, type ProjectRow } from "./projects-view";
 import { buildEntriesIndex } from "@/lib/entries-index";
@@ -26,8 +26,7 @@ export default async function ProjectsPage() {
   const days = lastNDays(7);
 
   const rows: ProjectRow[] = projects.map((p) => {
-    const canonical = canonicalProjectName(p.projectName);
-    const projectEntries = index.byProject.get(canonical) ?? [];
+    const projectEntries = index.byProject.get(projectRepoName(p.projectName)) ?? [];
     const byDay = new Map<string, typeof projectEntries>();
     for (const e of projectEntries) {
       const arr = byDay.get(e.local_day);