fleetlens 0.15.7 → 0.16.1

package/app/apps/web/components/agent-icon.tsx

@@ -9,17 +9,55 @@ type Props = {
   title?: string;
 };
 
-/** Single-glyph agent indicator: ✦ for Claude, ◆ for Codex (or whatever
- *  the registered metadata declares), painted in the agent's accent color.
- *  Returns null for unknown / undefined agents. */
+/**
+ * Grok mark path data from OpenUsage ProviderIcons/grok.svg (MIT)
+ * https://github.com/robinebers/openusage
+ * viewBox 0 0 527.27 578.68
+ */
+const GROK_MARK_PATH =
+  "M274.67 360.75 L527.27 0 L405.19 0 L213.64 273.58 Z M122.08 578.68 L183.12 491.51 L122.08 404.34 L0 578.68 Z M274.67 578.68 L396.75 578.68 L122.08 186.40 L0 186.40 Z M527.27 43.59 L427.27 186.40 L437.27 578.68 L517.27 578.68 Z";
+
+/** Single-glyph agent indicator painted in the agent's accent color.
+ *  Grok uses the OpenUsage provider mark; other agents use iconChar. */
 export function AgentIcon({ agent, size = 11, title }: Props) {
   if (!agent) return null;
   const meta = getAgentMetadata(agent);
   if (!meta) return null;
+  const label = title ?? meta.displayName;
+
+  if (agent === "grok") {
+    return (
+      <span
+        aria-hidden
+        title={label}
+        style={{
+          display: "inline-flex",
+          alignItems: "center",
+          justifyContent: "center",
+          flexShrink: 0,
+          width: size + 2,
+          height: size + 2,
+          color: meta.accentColor,
+        }}
+      >
+        <svg
+          width={size}
+          height={size}
+          viewBox="0 0 527.27 578.68"
+          fill="currentColor"
+          aria-hidden
+          style={{ display: "block" }}
+        >
+          <path d={GROK_MARK_PATH} />
+        </svg>
+      </span>
+    );
+  }
+
   return (
     <span
       aria-hidden
-      title={title ?? meta.displayName}
+      title={label}
       style={{
         display: "inline-flex",
         alignItems: "center",

package/app/apps/web/components/menubar-install-banner.tsx

@@ -83,7 +83,8 @@ export function MenubarInstallBanner() {
       }}
     >
       <span style={{ flex: 1 }}>
-        Get live Claude Code / Codex / Z.ai usage in your menu bar —{" "}
+        Get live Claude Code / Codex / Z.ai plan usage in your menu bar (Grok
+        sessions live on the dashboard) —{" "}
         <strong>install the Fleetlens widget</strong>.
       </span>
       <button

package/app/apps/web/components/sidebar.tsx

@@ -12,12 +12,10 @@ import {
   PinOff,
   Search,
   Activity,
-  Gauge,
   Lightbulb,
-  Radio,
   Settings,
   CalendarDays,
-  Users,
+  Sparkles,
 } from "lucide-react";
 import { formatRelative, prettyProjectName } from "@/lib/format";
 import { ThemeToggle } from "@/components/theme-toggle";
@@ -204,13 +202,6 @@ export function Sidebar({
         >
           Day
         </NavLink>
-        <NavLink
-          href="/usage"
-          active={pathname === "/usage"}
-          icon={<Gauge size={15} />}
-        >
-          Usage
-        </NavLink>
         <NavLink
           href="/insights"
           active={pathname === "/insights"}
@@ -218,19 +209,15 @@ export function Sidebar({
         >
           Insights
         </NavLink>
+        {/* Usage and Team live in the sidebar widgets below (both already
+            link to their pages); Runs is reachable from the Agent
+            header. Keeping the nav to the primary destinations. */}
         <NavLink
-          href="/runs"
-          active={pathname === "/runs" || pathname.startsWith("/runs/")}
-          icon={<Radio size={15} />}
-        >
-          Runs
-        </NavLink>
-        <NavLink
-          href="/team"
-          active={pathname === "/team" || pathname.startsWith("/team/")}
-          icon={<Users size={15} />}
+          href="/agent"
+          active={pathname === "/agent" || pathname === "/runs" || pathname.startsWith("/runs/")}
+          icon={<Sparkles size={15} />}
         >
-          Team
+          Agent
         </NavLink>
       </nav>
 

package/app/apps/web/components/usage-charts-dashboard.tsx

@@ -48,9 +48,14 @@ const SONNET_WINDOW: WindowConfig = {
 export function UsageChartsDashboard({
   snapshots,
   predicted,
+  /** Override default 5h/7d window labels (e.g. Grok context window). */
+  windows,
+  hideSonnet,
 }: {
   snapshots: UsageSnapshot[];
   predicted?: PredictedSeriesByKey;
+  windows?: WindowConfig[];
+  hideSonnet?: boolean;
 }) {
   const [expanded, setExpanded] = useState<WindowConfig | null>(null);
   const emptyPredicted: PredictedSeriesByKey = {
@@ -59,6 +64,7 @@ export function UsageChartsDashboard({
     seven_day_sonnet: [],
   };
   const pred = predicted ?? emptyPredicted;
+  const mainWindows = windows ?? MAIN_WINDOWS;
 
   // Close on Escape.
   useEffect(() => {
@@ -82,7 +88,7 @@ export function UsageChartsDashboard({
 
   return (
     <>
-      {MAIN_WINDOWS.map((w) => (
+      {mainWindows.map((w) => (
         <section
           key={w.key}
           style={{ display: "flex", flexDirection: "column", gap: 6 }}
@@ -99,6 +105,7 @@ export function UsageChartsDashboard({
         </section>
       ))}
 
+      {!hideSonnet && (
       <OptionalChart storageKey="cclens:usage:show-sonnet" label="Sonnet 7d utilization">
         <section style={{ display: "flex", flexDirection: "column", gap: 6 }}>
           <SectionLabel>{SONNET_WINDOW.label}</SectionLabel>
@@ -112,6 +119,7 @@ export function UsageChartsDashboard({
           />
         </section>
       </OptionalChart>
+      )}
 
       {expanded && (
         <ExpandedModal

package/app/apps/web/lib/agent/chat-model.ts

@@ -0,0 +1,125 @@
+
+export type TextSegment = { kind: "text"; text: string };
+export type ToolSegment = {
+  kind: "tool";
+  id: string;
+  name: string;
+  input: unknown;
+  brief?: string;
+  isError?: boolean;
+  done: boolean;
+};
+export type Segment = TextSegment | ToolSegment;
+
+export type StoredMessage =
+  | { role: "user"; text: string }
+  | { role: "assistant"; segments: Segment[] };
+
+export type ChatStatus = "idle" | "running" | "error";
+
+export type Chat = {
+  version: 1;
+  id: string;
+  title: string;
+  created_at: string;
+  updated_at: string;
+  status: ChatStatus;
+  /** Highest run-event seq folded into this chat — SSE clients resume after it. */
+  lastSeq: number;
+  messages: StoredMessage[];
+};
+
+export type ChatListItem = {
+  id: string;
+  title: string;
+  updated_at: string;
+  status: ChatStatus;
+  messageCount: number;
+};
+
+/** Normalized event emitted by a run. seq is per-run, starting at 1. */
+export type RunEvent =
+  | { seq: number; type: "delta"; text: string }
+  | { seq: number; type: "tool"; id: string; name: string; input: unknown }
+  | { seq: number; type: "tool_result"; id: string; name: string; brief: string; isError: boolean }
+  | { seq: number; type: "done"; totalTokens?: number }
+  | { seq: number; type: "error"; message: string };
+
+/** Omit<union, K> collapses to the common keys; this distributes instead so
+ *  emit sites can pass any variant sans seq. */
+export type RunEventBody = RunEvent extends infer E ? (E extends RunEvent ? Omit<E, "seq"> : never) : never;
+
+const TITLE_MAX = 80;
+
+export function chatTitle(firstUserText: string): string {
+  return firstUserText.replace(/\s+/g, " ").trim().slice(0, TITLE_MAX);
+}
+
+export function createChat(): Chat {
+  const now = new Date().toISOString();
+  return {
+    version: 1,
+    id: crypto.randomUUID(),
+    title: "New conversation",
+    created_at: now,
+    updated_at: now,
+    status: "idle",
+    lastSeq: 0,
+    messages: [],
+  };
+}
+
+export function newAssistantMessage(): StoredMessage {
+  return { role: "assistant", segments: [] };
+}
+
+/** Fold one run event into the chat. Pure; the same reducer runs on the
+ *  server (persistence) and could run client-side, so restore and live
+ *  rendering can never drift apart. Events at or below lastSeq are replays
+ *  and ignored. */
+export function applyRunEvent(chat: Chat, event: RunEvent): Chat {
+  if (event.seq <= chat.lastSeq) return chat;
+  const messages = [...chat.messages];
+  let last = messages[messages.length - 1];
+  if (!last || last.role !== "assistant") {
+    last = newAssistantMessage();
+    messages.push(last);
+  }
+  const assistant = { ...last, segments: [...(last as { segments: Segment[] }).segments] } as Extract<
+    StoredMessage,
+    { role: "assistant" }
+  >;
+  messages[messages.length - 1] = assistant;
+
+  let status: ChatStatus = chat.status;
+  switch (event.type) {
+    case "delta": {
+      const tail = assistant.segments[assistant.segments.length - 1];
+      if (tail?.kind === "text") {
+        assistant.segments[assistant.segments.length - 1] = { kind: "text", text: tail.text + event.text };
+      } else {
+        assistant.segments.push({ kind: "text", text: event.text });
+      }
+      break;
+    }
+    case "tool":
+      assistant.segments.push({ kind: "tool", id: event.id, name: event.name, input: event.input, done: false });
+      break;
+    case "tool_result":
+      assistant.segments = assistant.segments.map((s) =>
+        s.kind === "tool" && s.id === event.id ? { ...s, brief: event.brief, isError: event.isError, done: true } : s,
+      );
+      break;
+    case "done":
+      status = "idle";
+      assistant.segments = assistant.segments.map((s) => (s.kind === "tool" && !s.done ? { ...s, done: true } : s));
+      break;
+    case "error":
+      status = "error";
+      assistant.segments = assistant.segments.map((s) => (s.kind === "tool" && !s.done ? { ...s, done: true } : s));
+      assistant.segments.push({ kind: "text", text: `\n\n**Error:** ${event.message}` });
+      break;
+  }
+
+  return { ...chat, messages, status, lastSeq: event.seq, updated_at: new Date().toISOString() };
+}

package/app/apps/web/lib/agent/chat-store.test.ts

@@ -0,0 +1,125 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  applyRunEvent,
+  chatTitle,
+  createChat,
+  deleteChat,
+  listChats,
+  newAssistantMessage,
+  readChat,
+  writeChat,
+  type Chat,
+  type RunEvent,
+  type RunEventBody,
+} from "./chat-store";
+
+let dir: string;
+let prevHome: string | undefined;
+
+beforeAll(() => {
+  dir = mkdtempSync(join(tmpdir(), "cclens-chat-test-"));
+  prevHome = process.env.CCLENS_HOME;
+  process.env.CCLENS_HOME = dir;
+});
+
+afterAll(() => {
+  if (prevHome === undefined) delete process.env.CCLENS_HOME;
+  else process.env.CCLENS_HOME = prevHome;
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function running(): Chat {
+  const chat = createChat();
+  chat.messages.push({ role: "user", text: "find my daemon work" });
+  chat.messages.push(newAssistantMessage());
+  chat.status = "running";
+  return chat;
+}
+
+const ev = (e: RunEventBody, seq = 1): RunEvent => ({ seq, ...e }) as RunEvent;
+
+describe("applyRunEvent", () => {
+  test("delta appends to the trailing text segment, creating one if needed", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "Hello" }));
+    chat = applyRunEvent(chat, ev({ type: "delta", text: " world" }, 2));
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role).toBe("assistant");
+    expect(last.role === "assistant" && last.segments).toEqual([{ kind: "text", text: "Hello world" }]);
+  });
+
+  test("tool events add tool segments; results resolve them by id", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "Searching. " }));
+    chat = applyRunEvent(chat, ev({ type: "tool", id: "t1", name: "search_sessions", input: { query: "x" } }, 2));
+    chat = applyRunEvent(chat, ev({ type: "tool_result", id: "t1", name: "search_sessions", brief: "3 matching sessions", isError: false }, 3));
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "Found it." }, 4));
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role === "assistant" && last.segments).toEqual([
+      { kind: "text", text: "Searching. " },
+      { kind: "tool", id: "t1", name: "search_sessions", input: { query: "x" }, brief: "3 matching sessions", isError: false, done: true },
+      { kind: "text", text: "Found it." },
+    ]);
+  });
+
+  test("done marks the chat idle and finalizes dangling tools", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "tool", id: "t1", name: "get_session", input: {} }));
+    chat = applyRunEvent(chat, ev({ type: "done", totalTokens: 123 }, 2));
+    expect(chat.status).toBe("idle");
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role === "assistant" && last.segments[0]).toMatchObject({ kind: "tool", done: true });
+    expect(chat.lastSeq).toBe(2);
+  });
+
+  test("error appends an error text segment and marks the chat error", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "error", message: "timed out" }));
+    expect(chat.status).toBe("error");
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role === "assistant" && last.segments.some((s) => s.kind === "text" && s.text.includes("timed out"))).toBe(true);
+  });
+
+  test("stale events (seq <= lastSeq) are ignored", () => {
+    let chat = running();
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "a" }, 5));
+    chat = applyRunEvent(chat, ev({ type: "delta", text: "b" }, 5));
+    const last = chat.messages[chat.messages.length - 1]!;
+    expect(last.role === "assistant" && last.segments).toEqual([{ kind: "text", text: "a" }]);
+  });
+});
+
+describe("chatTitle", () => {
+  test("derives from the first user message, collapsed and clamped", () => {
+    expect(chatTitle("  find   my\ndaemon work  ")).toBe("find my daemon work");
+    expect(chatTitle("x".repeat(200)).length).toBeLessThanOrEqual(80);
+  });
+});
+
+describe("fs round-trip", () => {
+  test("create, write, read, list, delete", () => {
+    const a = createChat();
+    a.messages.push({ role: "user", text: "first chat" });
+    a.title = chatTitle("first chat");
+    writeChat(a);
+    const b = createChat();
+    b.messages.push({ role: "user", text: "second chat" });
+    b.title = chatTitle("second chat");
+    b.updated_at = new Date(Date.now() + 1000).toISOString();
+    writeChat(b);
+
+    expect(readChat(a.id)?.messages[0]).toEqual({ role: "user", text: "first chat" });
+    expect(readChat("nope")).toBeNull();
+
+    const listed = listChats();
+    expect(listed.map((c) => c.id)).toEqual([b.id, a.id]); // newest first
+    expect(listed[0]).toMatchObject({ title: "second chat", status: "idle", messageCount: 1 });
+
+    deleteChat(a.id);
+    expect(readChat(a.id)).toBeNull();
+    expect(listChats().map((c) => c.id)).toEqual([b.id]);
+  });
+});

package/app/apps/web/lib/agent/chat-store.ts

@@ -0,0 +1,59 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { cclensPath } from "@claude-lens/parser/fs";
+import type { Chat, ChatListItem } from "./chat-model";
+
+export * from "./chat-model";
+
+/* ── persistence: one JSON file per conversation ───────────────────── */
+
+function chatsDir(): string {
+  return cclensPath("agent-chats");
+}
+
+function chatPath(id: string): string {
+  return join(chatsDir(), `${id}.json`);
+}
+
+export function writeChat(chat: Chat): void {
+  mkdirSync(chatsDir(), { recursive: true });
+  const final = chatPath(chat.id);
+  const tmp = `${final}.tmp.${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(chat), "utf8");
+  renameSync(tmp, final);
+}
+
+export function readChat(id: string): Chat | null {
+  // Ids come from URLs — resolve strictly inside the chats dir.
+  if (!/^[a-zA-Z0-9-]+$/.test(id)) return null;
+  try {
+    const chat = JSON.parse(readFileSync(chatPath(id), "utf8")) as Chat;
+    return chat.version === 1 ? chat : null;
+  } catch {
+    return null;
+  }
+}
+
+export function listChats(): ChatListItem[] {
+  if (!existsSync(chatsDir())) return [];
+  const out: ChatListItem[] = [];
+  for (const f of readdirSync(chatsDir())) {
+    if (!f.endsWith(".json")) continue;
+    const chat = readChat(f.slice(0, -".json".length));
+    if (!chat) continue;
+    out.push({
+      id: chat.id,
+      title: chat.title,
+      updated_at: chat.updated_at,
+      status: chat.status,
+      messageCount: chat.messages.length,
+    });
+  }
+  out.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+  return out;
+}
+
+export function deleteChat(id: string): void {
+  if (!/^[a-zA-Z0-9-]+$/.test(id)) return;
+  rmSync(chatPath(id), { force: true });
+}

package/app/apps/web/lib/agent/extract.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "vitest";
+import type { SessionDetail, SessionEvent } from "@claude-lens/parser";
+import { extractIndexDoc } from "./extract";
+
+function ev(partial: Partial<SessionEvent> & { role: SessionEvent["role"] }): SessionEvent {
+  return {
+    index: 0,
+    rawType: partial.role,
+    preview: "",
+    blocks: [],
+    raw: null,
+    ...partial,
+  };
+}
+
+function session(events: SessionEvent[], meta: Partial<SessionDetail> = {}): SessionDetail {
+  return {
+    id: "abc-123",
+    filePath: "/tmp/abc-123.jsonl",
+    projectName: "/Users/me/Repo/foo",
+    projectDir: "-Users-me-Repo-foo",
+    sessionId: "abc-123",
+    eventCount: events.length,
+    totalUsage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    status: "idle",
+    firstTimestamp: "2026-07-01T10:00:00.000Z",
+    lastTimestamp: "2026-07-01T11:00:00.000Z",
+    events,
+    ...meta,
+  } as SessionDetail;
+}
+
+const FILE = { mtimeMs: 1000, sizeBytes: 2000 };
+
+describe("extractIndexDoc", () => {
+  test("extracts user and agent text blocks as chunks", () => {
+    const doc = extractIndexDoc(
+      session([
+        ev({ index: 0, role: "user", blocks: [{ type: "text", text: "fix the daemon crash" }] }),
+        ev({ index: 1, role: "agent", blocks: [{ type: "text", text: "Found the crash in pid.ts" }] }),
+        ev({ index: 2, role: "tool-call", blocks: [{ type: "tool_use", id: "t1", name: "Bash", input: { command: "ls secret" } }] }),
+        ev({ index: 3, role: "agent-thinking", blocks: [{ type: "thinking", thinking: "hmm private" }] }),
+      ]),
+      FILE,
+    );
+    expect(doc.chunks).toEqual([
+      { role: "user", text: "fix the daemon crash", idx: 0 },
+      { role: "agent", text: "Found the crash in pid.ts", idx: 1 },
+    ]);
+  });
+
+  test("fills metadata: canonical project, start day, title, agent default", () => {
+    const doc = extractIndexDoc(
+      session(
+        [ev({ index: 0, role: "user", blocks: [{ type: "text", text: "hello world" }] })],
+        { projectName: "/Users/me/Repo/foo/.worktrees/kip-1", firstUserPreview: "hello world" },
+      ),
+      FILE,
+    );
+    expect(doc.sessionId).toBe("abc-123");
+    expect(doc.agent).toBe("claude-code");
+    expect(doc.project).toBe("/Users/me/Repo/foo");
+    expect(doc.repoName).toBeUndefined();
+    expect(doc.day).toBe("2026-07-01");
+    expect(doc.title).toBe("hello world");
+    expect(doc.mtimeMs).toBe(1000);
+    expect(doc.sizeBytes).toBe(2000);
+  });
+
+  test("skips command wrappers, skill loads, and teammate deliveries", () => {
+    const doc = extractIndexDoc(
+      session([
+        ev({ index: 0, role: "user", blocks: [{ type: "text", text: "<command-name>/clear</command-name>" }] }),
+        ev({ index: 1, role: "user", blocks: [{ type: "text", text: "Base directory for this skill: /x\n# Skill" }] }),
+        ev({
+          index: 2,
+          role: "user",
+          blocks: [{ type: "text", text: "ignore me" }],
+          teammateMessage: { teammateId: "t", body: "ignore me", kind: "message" },
+        }),
+        ev({ index: 3, role: "user", blocks: [{ type: "text", text: "real question" }] }),
+      ]),
+      FILE,
+    );
+    expect(doc.chunks).toEqual([{ role: "user", text: "real question", idx: 3 }]);
+  });
+
+  test("strips system-reminder spans inside user text", () => {
+    const doc = extractIndexDoc(
+      session([
+        ev({
+          index: 0,
+          role: "user",
+          blocks: [{ type: "text", text: "before <system-reminder>injected</system-reminder> after" }],
+        }),
+      ]),
+      FILE,
+    );
+    expect(doc.chunks[0]!.text).toBe("before  after");
+  });
+
+  test("caps chunk length and total text, marking truncation", () => {
+    const long = "x".repeat(10_000);
+    const events: SessionEvent[] = [];
+    for (let i = 0; i < 200; i++) {
+      events.push(ev({ index: i, role: "agent", blocks: [{ type: "text", text: long }] }));
+    }
+    const doc = extractIndexDoc(session(events), FILE);
+    expect(Math.max(...doc.chunks.map((c) => c.text.length))).toBeLessThanOrEqual(4000);
+    const total = doc.chunks.reduce((s, c) => s + c.text.length, 0);
+    expect(total).toBeLessThanOrEqual(300_000);
+    expect(doc.truncated).toBe(true);
+  });
+
+  test("drops empty and whitespace-only text", () => {
+    const doc = extractIndexDoc(
+      session([
+        ev({ index: 0, role: "user", blocks: [{ type: "text", text: "  " }] }),
+        ev({ index: 1, role: "agent", blocks: [{ type: "text", text: "" }] }),
+      ]),
+      FILE,
+    );
+    expect(doc.chunks).toEqual([]);
+  });
+
+  test("carries the git repo name when the session has one", () => {
+    const doc = extractIndexDoc(
+      session([ev({ index: 0, role: "user", blocks: [{ type: "text", text: "hi" }] })], { repoName: "fleetlens" }),
+      FILE,
+    );
+    expect(doc.repoName).toBe("fleetlens");
+  });
+
+  test("title falls back to first user chunk when firstUserPreview is absent", () => {
+    const doc = extractIndexDoc(
+      session([ev({ index: 0, role: "user", blocks: [{ type: "text", text: "the actual ask" }] })]),
+      FILE,
+    );
+    expect(doc.title).toBe("the actual ask");
+  });
+});