fleetlens 0.1.0

package/dist/index.js

@@ -0,0 +1,1556 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/pid.ts
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs";
+import { dirname } from "node:path";
+function writePid(filePath, pid, port) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  const content = port != null ? `${pid}:${port}` : String(pid);
+  writeFileSync(filePath, content, "utf8");
+}
+function readPid(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf8").trim();
+    const [pidStr, portStr] = content.split(":");
+    const pid = parseInt(pidStr, 10);
+    if (Number.isNaN(pid)) return null;
+    const port = portStr ? parseInt(portStr, 10) : void 0;
+    return { pid, port: Number.isNaN(port) ? void 0 : port };
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanStalePid(filePath) {
+  const entry = readPid(filePath);
+  if (entry === null) return false;
+  if (isProcessAlive(entry.pid)) return false;
+  try {
+    unlinkSync(filePath);
+  } catch {
+  }
+  return true;
+}
+function removePid(filePath) {
+  try {
+    unlinkSync(filePath);
+  } catch {
+  }
+}
+var init_pid = __esm({
+  "src/pid.ts"() {
+    "use strict";
+  }
+});
+
+// src/server.ts
+import { spawn } from "node:child_process";
+import { join, dirname as dirname2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+function appDir() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  return join(here, "..", "app", "apps", "web");
+}
+function getServerStatus() {
+  cleanStalePid(PID_FILE);
+  const entry = readPid(PID_FILE);
+  if (entry !== null && isProcessAlive(entry.pid)) {
+    return { running: true, pid: entry.pid, port: entry.port ?? DEFAULT_PORT };
+  }
+  return { running: false };
+}
+async function startServer(opts = {}) {
+  const port = opts.port ?? (parseInt(process.env.CCLENS_PORT ?? "", 10) || DEFAULT_PORT);
+  const serverJs = join(appDir(), "server.js");
+  if (!existsSync(serverJs)) {
+    throw new Error(`Server not found at ${serverJs}. Reinstall with: npm install -g fleetlens`);
+  }
+  const portInUse = await checkPort(port);
+  if (portInUse) {
+    throw new Error(`Port ${port} is in use. Use --port to specify a different port.`);
+  }
+  const dataDir = join(homedir(), ".claude", "projects");
+  const child = spawn(process.execPath, [serverJs], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      PORT: String(port),
+      HOSTNAME: "localhost",
+      CCLENS_DATA_DIR: dataDir
+    },
+    cwd: appDir()
+  });
+  child.unref();
+  const pid = child.pid;
+  writePid(PID_FILE, pid, port);
+  await waitForHealth(`http://localhost:${port}`, 1e4);
+  return { pid, port };
+}
+function stopServer() {
+  cleanStalePid(PID_FILE);
+  const entry = readPid(PID_FILE);
+  if (entry === null) {
+    return { stopped: false };
+  }
+  try {
+    process.kill(entry.pid, "SIGTERM");
+  } catch {
+  }
+  removePid(PID_FILE);
+  return { stopped: true, pid: entry.pid };
+}
+async function checkPort(port) {
+  const { createServer } = await import("node:net");
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", () => resolve(true));
+    server.once("listening", () => {
+      server.close(() => resolve(false));
+    });
+    server.listen(port, "localhost");
+  });
+}
+async function waitForHealth(url, timeoutMs) {
+  const start2 = Date.now();
+  while (Date.now() - start2 < timeoutMs) {
+    try {
+      const res = await fetch(url);
+      if (res.ok) return;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error(`Server did not become healthy within ${timeoutMs / 1e3}s`);
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  spawn(cmd, [url], { detached: true, stdio: "ignore" }).unref();
+}
+var STATE_DIR, PID_FILE, DEFAULT_PORT;
+var init_server = __esm({
+  "src/server.ts"() {
+    "use strict";
+    init_pid();
+    STATE_DIR = join(homedir(), ".cclens");
+    PID_FILE = join(STATE_DIR, "pid");
+    DEFAULT_PORT = 3321;
+  }
+});
+
+// src/updater.ts
+import { execSync, spawnSync } from "node:child_process";
+function shouldUpdate(local, remote) {
+  const l = local.split(".").map(Number);
+  const r = remote.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((r[i] ?? 0) > (l[i] ?? 0)) return true;
+    if ((r[i] ?? 0) < (l[i] ?? 0)) return false;
+  }
+  return false;
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function runNpmInstall() {
+  try {
+    execSync(`npm install -g ${PACKAGE_NAME}@latest`, {
+      stdio: "pipe",
+      timeout: 6e4
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reExec() {
+  const result = spawnSync(process.argv[0], process.argv.slice(1), {
+    stdio: "inherit",
+    env: { ...process.env, __CCLENS_UPDATED: "1" }
+  });
+  process.exit(result.status ?? 0);
+}
+function isDevMode() {
+  const script = process.argv[1] ?? "";
+  return script.includes("packages/cli/") || script.includes("packages\\cli\\");
+}
+async function checkForUpdate() {
+  if (isDevMode()) return;
+  if (process.env.__CCLENS_UPDATED === "1") return;
+  const latest = await fetchLatestVersion();
+  if (latest === null) return;
+  const current = "0.1.0";
+  if (!shouldUpdate(current, latest)) return;
+  console.log(`Updating cclens ${current} \u2192 ${latest}...`);
+  const ok = runNpmInstall();
+  if (ok) {
+    console.log("Updated successfully. Restarting...");
+    reExec();
+  } else {
+    console.warn("Update failed. Starting with current version.");
+  }
+}
+async function forceUpdate() {
+  const latest = await fetchLatestVersion();
+  const current = "0.1.0";
+  if (latest === null) {
+    console.error("Could not reach npm registry. Check your network.");
+    process.exit(1);
+  }
+  if (shouldUpdate(current, latest)) {
+    console.log(`Updating cclens ${current} \u2192 ${latest}...`);
+  } else {
+    console.log(`Already on latest (${current}). Reinstalling...`);
+  }
+  const ok = runNpmInstall();
+  if (ok) {
+    console.log(shouldUpdate(current, latest) ? `Updated to ${latest}.` : "Reinstall complete.");
+  } else {
+    console.error("Update failed.");
+    process.exit(1);
+  }
+}
+var PACKAGE_NAME, CHECK_TIMEOUT_MS;
+var init_updater = __esm({
+  "src/updater.ts"() {
+    "use strict";
+    PACKAGE_NAME = "fleetlens";
+    CHECK_TIMEOUT_MS = 3e3;
+  }
+});
+
+// src/commands/start.ts
+var start_exports = {};
+__export(start_exports, {
+  start: () => start
+});
+async function start(args2) {
+  const portFlag = args2.indexOf("--port");
+  const port = portFlag !== -1 ? parseInt(args2[portFlag + 1], 10) : void 0;
+  const noOpen = args2.includes("--no-open");
+  try {
+    await checkForUpdate();
+  } catch {
+  }
+  const status = getServerStatus();
+  if (status.running) {
+    const url = `http://localhost:${status.port}`;
+    console.log(`Claude Lens is already running on ${url} (PID ${status.pid})`);
+    if (!noOpen) openBrowser(url);
+    return;
+  }
+  console.log("Starting Claude Lens...");
+  try {
+    const result = await startServer({ port });
+    const url = `http://localhost:${result.port}`;
+    console.log(`Claude Lens running on ${url} (PID ${result.pid})`);
+    if (!noOpen) openBrowser(url);
+  } catch (err) {
+    console.error(`Failed to start: ${err.message}`);
+    process.exit(1);
+  }
+}
+var init_start = __esm({
+  "src/commands/start.ts"() {
+    "use strict";
+    init_server();
+    init_updater();
+  }
+});
+
+// src/commands/stop.ts
+var stop_exports = {};
+__export(stop_exports, {
+  stop: () => stop
+});
+async function stop() {
+  const status = getServerStatus();
+  if (!status.running) {
+    console.log("Claude Lens is not running.");
+    return;
+  }
+  const result = stopServer();
+  if (result.stopped) {
+    console.log(`Stopped Claude Lens (PID ${result.pid})`);
+  }
+}
+var init_stop = __esm({
+  "src/commands/stop.ts"() {
+    "use strict";
+    init_server();
+  }
+});
+
+// src/commands/web.ts
+var web_exports = {};
+__export(web_exports, {
+  web: () => web
+});
+async function web(args2) {
+  const noOpen = args2.includes("--no-open");
+  const positional = args2.filter((a) => !a.startsWith("--"));
+  const rawPath = positional[0] ?? "";
+  const path2 = rawPath.startsWith("/") ? rawPath : rawPath ? `/${rawPath}` : "";
+  const status = getServerStatus();
+  if (status.running) {
+    const url = `http://localhost:${status.port}${path2}`;
+    console.log(noOpen ? `Server running at ${url}` : `Opening ${url}`);
+    if (!noOpen) openBrowser(url);
+    return;
+  }
+  console.log("Claude Lens is not running. Starting server...");
+  try {
+    const result = await startServer({});
+    const url = `http://localhost:${result.port}${path2}`;
+    console.log(`Claude Lens running on ${url} (PID ${result.pid})`);
+    if (!noOpen) openBrowser(url);
+  } catch (err) {
+    console.error(`Failed to start: ${err.message}`);
+    process.exit(1);
+  }
+}
+var init_web = __esm({
+  "src/commands/web.ts"() {
+    "use strict";
+    init_server();
+  }
+});
+
+// src/commands/update.ts
+var update_exports = {};
+__export(update_exports, {
+  update: () => update
+});
+async function update() {
+  await forceUpdate();
+}
+var init_update = __esm({
+  "src/commands/update.ts"() {
+    "use strict";
+    init_updater();
+  }
+});
+
+// ../parser/dist/parser.js
+function cleanText(s) {
+  return s.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+}
+function truncate(s, n = 200) {
+  const one = cleanText(s);
+  return one.length > n ? one.slice(0, n - 1) + "\u2026" : one;
+}
+function extractUsage(u) {
+  if (!u || typeof u !== "object")
+    return void 0;
+  const r = u;
+  const toNum = (v) => typeof v === "number" ? v : 0;
+  return {
+    input: toNum(r.input_tokens),
+    output: toNum(r.output_tokens),
+    cacheRead: toNum(r.cache_read_input_tokens),
+    cacheWrite: toNum(r.cache_creation_input_tokens)
+  };
+}
+function toEvent(raw, index) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const r = raw;
+  const rawType = String(r.type ?? "");
+  const uuid = r.uuid;
+  const parentUuid = r.parentUuid ?? null;
+  const timestamp = r.timestamp;
+  if (rawType === "assistant") {
+    const msg = r.message ?? {};
+    const content = msg.content ?? [];
+    const usage2 = extractUsage(msg.usage);
+    const model = msg.model;
+    const requestId = r.requestId;
+    const messageId = msg.id;
+    const stopReason = msg.stop_reason;
+    const first = content[0];
+    let role = "agent";
+    let preview = "";
+    let toolName;
+    let toolUseId;
+    if (first?.type === "thinking") {
+      role = "agent-thinking";
+      preview = "[thinking] " + truncate(first.thinking, 140);
+    } else if (first?.type === "tool_use") {
+      role = "tool-call";
+      toolName = first.name;
+      toolUseId = first.id;
+      preview = `${first.name} ` + truncate(JSON.stringify(first.input ?? {}), 100);
+    } else if (first?.type === "text") {
+      preview = truncate(first.text, 200);
+    } else {
+      preview = `<assistant:${first?.type ?? "empty"}>`;
+    }
+    return {
+      index,
+      uuid,
+      parentUuid,
+      timestamp,
+      role,
+      rawType,
+      preview,
+      blocks: content,
+      usage: usage2,
+      model,
+      requestId,
+      messageId,
+      stopReason,
+      toolName,
+      toolUseId,
+      raw
+    };
+  }
+  if (rawType === "user") {
+    const msg = r.message ?? {};
+    const c = msg.content;
+    if (typeof c === "string") {
+      return {
+        index,
+        uuid,
+        parentUuid,
+        timestamp,
+        role: "user",
+        rawType,
+        preview: truncate(c, 200),
+        blocks: [{ type: "text", text: c }],
+        raw
+      };
+    }
+    if (Array.isArray(c)) {
+      const first = c[0];
+      if (first?.type === "tool_result") {
+        const resultText = typeof first.content === "string" ? first.content : JSON.stringify(first.content);
+        return {
+          index,
+          uuid,
+          parentUuid,
+          timestamp,
+          role: "tool-result",
+          rawType,
+          preview: truncate(resultText, 200),
+          blocks: c,
+          toolUseId: first.tool_use_id,
+          toolResult: r.toolUseResult,
+          raw
+        };
+      }
+      const textBlock = c.find((b) => b?.type === "text");
+      return {
+        index,
+        uuid,
+        parentUuid,
+        timestamp,
+        role: "user",
+        rawType,
+        preview: textBlock ? truncate(textBlock.text, 200) : truncate(JSON.stringify(c), 200),
+        blocks: c,
+        raw
+      };
+    }
+  }
+  if (rawType === "attachment") {
+    const a = r.attachment ?? {};
+    const at = String(a.type ?? "attachment");
+    let preview = `<attachment: ${at}>`;
+    if (typeof a.content === "string" && a.content.length > 0) {
+      preview = `[${at}] ` + truncate(a.content, 140);
+    } else if (Array.isArray(a.addedNames)) {
+      preview = `[${at}] +${a.addedNames.length} names`;
+    }
+    return {
+      index,
+      uuid,
+      parentUuid,
+      timestamp,
+      role: "system",
+      rawType,
+      preview,
+      blocks: [{ type: "text", text: JSON.stringify(a, null, 2) }],
+      attachmentType: at,
+      raw
+    };
+  }
+  return {
+    index,
+    uuid,
+    parentUuid,
+    timestamp,
+    role: "meta",
+    rawType: rawType || "unknown",
+    preview: `${rawType}: ${truncate(JSON.stringify(r), 140)}`,
+    blocks: [{ type: "text", text: JSON.stringify(r, null, 2) }],
+    raw
+  };
+}
+function parseTranscript(rawLines) {
+  const events = [];
+  for (let i = 0; i < rawLines.length; i++) {
+    const ev = toEvent(rawLines[i], i);
+    if (ev)
+      events.push(ev);
+  }
+  const timestamped = events.map((e) => e.timestamp ? Date.parse(e.timestamp) : void 0).filter((n) => typeof n === "number" && !Number.isNaN(n));
+  const startMs = timestamped.length ? Math.min(...timestamped) : void 0;
+  const endMs = timestamped.length ? Math.max(...timestamped) : void 0;
+  const firstTs = startMs !== void 0 ? new Date(startMs).toISOString() : void 0;
+  const lastTs = endMs !== void 0 ? new Date(endMs).toISOString() : void 0;
+  for (const ev of events) {
+    if (!ev.timestamp)
+      continue;
+    const ms = Date.parse(ev.timestamp);
+    if (Number.isNaN(ms))
+      continue;
+    if (startMs !== void 0)
+      ev.tOffsetMs = Math.max(0, ms - startMs);
+  }
+  const isConversational = (r) => r === "user" || r === "agent" || r === "agent-thinking" || r === "tool-call" || r === "tool-result";
+  const chrono = events.filter((e) => e.timestamp && isConversational(e.role)).map((e) => ({ e, ms: Date.parse(e.timestamp) })).filter((x) => !Number.isNaN(x.ms)).sort((a, b) => a.ms - b.ms);
+  for (let i = 1; i < chrono.length; i++) {
+    chrono[i].e.gapMs = Math.max(0, chrono[i].ms - chrono[i - 1].ms);
+  }
+  const IDLE_THRESHOLD_MS = 3 * 60 * 1e3;
+  const allChrono = events.filter((e) => e.timestamp).map((e) => Date.parse(e.timestamp)).filter((ms) => !Number.isNaN(ms)).sort((a, b) => a - b);
+  const activeSegments = [];
+  let airTimeMs = 0;
+  if (allChrono.length > 0) {
+    let segStart = allChrono[0];
+    let segEnd = allChrono[0];
+    for (let i = 1; i < allChrono.length; i++) {
+      const t = allChrono[i];
+      const gap = t - segEnd;
+      if (gap > IDLE_THRESHOLD_MS) {
+        activeSegments.push({ startMs: segStart, endMs: segEnd });
+        segStart = t;
+      } else if (gap > 0) {
+        airTimeMs += gap;
+      }
+      segEnd = t;
+    }
+    activeSegments.push({ startMs: segStart, endMs: segEnd });
+  }
+  const totalUsage = { ...BLANK_USAGE };
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  let model;
+  let sessionId = "";
+  let cwd;
+  let gitBranch;
+  let toolCallCount = 0;
+  let turnCount = 0;
+  let firstUserPreview;
+  let lastAgentPreview;
+  let lastUserPreview;
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  const filesEdited = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.role === "tool-call") {
+      toolCallCount++;
+      const toolBlock = e.blocks.find((b) => b && b.type === "tool_use");
+      if (toolBlock) {
+        const input = toolBlock.input ?? {};
+        const fp = typeof input.file_path === "string" ? input.file_path : void 0;
+        if (toolBlock.name === "Edit" && fp) {
+          filesEdited.add(fp);
+          const oldStr = typeof input.old_string === "string" ? input.old_string : "";
+          const newStr = typeof input.new_string === "string" ? input.new_string : "";
+          const oldLines = oldStr ? oldStr.split("\n").length : 0;
+          const newLines = newStr ? newStr.split("\n").length : 0;
+          linesAdded += Math.max(0, newLines - oldLines);
+          linesRemoved += Math.max(0, oldLines - newLines);
+        } else if (toolBlock.name === "Write" && fp) {
+          filesEdited.add(fp);
+          const content = typeof input.content === "string" ? input.content : "";
+          linesAdded += content ? content.split("\n").length : 0;
+        }
+      }
+    }
+    if (e.role === "user") {
+      const rawMsg = e.raw?.message;
+      const rawContent = typeof rawMsg?.content === "string" ? rawMsg.content : "";
+      const isHidden = rawContent.startsWith("<command-name>") || rawContent.startsWith("Base directory for this skill:") || rawContent.startsWith("<task-notification>");
+      if (!isHidden) {
+        if (!firstUserPreview)
+          firstUserPreview = e.preview;
+        turnCount++;
+        lastUserPreview = e.preview;
+      }
+    }
+    if (e.role === "agent") {
+      lastAgentPreview = e.preview;
+    }
+  }
+  for (const r of rawLines) {
+    if (!r || typeof r !== "object")
+      continue;
+    const o = r;
+    if (typeof o.sessionId === "string" && !sessionId)
+      sessionId = o.sessionId;
+    if (typeof o.cwd === "string" && !cwd)
+      cwd = o.cwd;
+    if (typeof o.gitBranch === "string" && !gitBranch)
+      gitBranch = o.gitBranch;
+    if (o.type === "assistant") {
+      const m = o.message;
+      if (m) {
+        if (typeof m.model === "string" && !model)
+          model = m.model;
+        const mid = typeof m.id === "string" ? m.id : void 0;
+        const rid = typeof o.requestId === "string" ? o.requestId : void 0;
+        const dedupKey = mid != null ? `${mid}:${rid ?? ""}` : void 0;
+        if (dedupKey && seenMessageIds.has(dedupKey))
+          continue;
+        if (dedupKey)
+          seenMessageIds.add(dedupKey);
+        const u = extractUsage(m.usage);
+        if (u) {
+          totalUsage.input += u.input;
+          totalUsage.output += u.output;
+          totalUsage.cacheRead += u.cacheRead;
+          totalUsage.cacheWrite += u.cacheWrite;
+        }
+      }
+    }
+  }
+  return {
+    events,
+    meta: {
+      sessionId,
+      firstTimestamp: firstTs,
+      lastTimestamp: lastTs,
+      durationMs: startMs !== void 0 && endMs !== void 0 ? endMs - startMs : void 0,
+      eventCount: events.length,
+      model,
+      cwd,
+      gitBranch,
+      totalUsage,
+      status: "idle",
+      firstUserPreview,
+      lastUserPreview,
+      lastAgentPreview,
+      toolCallCount,
+      turnCount,
+      airTimeMs,
+      activeSegments,
+      linesAdded,
+      linesRemoved,
+      filesEdited: filesEdited.size
+    }
+  };
+}
+var BLANK_USAGE;
+var init_parser = __esm({
+  "../parser/dist/parser.js"() {
+    "use strict";
+    BLANK_USAGE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  }
+});
+
+// ../parser/dist/analytics.js
+var init_analytics = __esm({
+  "../parser/dist/analytics.js"() {
+    "use strict";
+  }
+});
+
+// ../parser/dist/fs.js
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function decodeProjectName(dir) {
+  if (!dir.startsWith("-"))
+    return dir;
+  return "/" + dir.slice(1).replace(/-/g, "/");
+}
+async function readJsonlFile(filePath) {
+  const raw = await fs.readFile(filePath, "utf8");
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return out;
+}
+async function walkJsonlFiles(root = DEFAULT_ROOT) {
+  if (fileListCache && fileListCache.root === root && Date.now() - fileListCache.capturedAtMs < FILE_LIST_TTL_MS) {
+    return fileListCache.files;
+  }
+  let topEntries = [];
+  try {
+    topEntries = await fs.readdir(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const projectDirs = topEntries.filter((e) => e.isDirectory()).map((e) => e.name);
+  const perProject = await Promise.all(projectDirs.map(async (projectDir) => {
+    const projectPath = path.join(root, projectDir);
+    let files;
+    try {
+      files = await fs.readdir(projectPath);
+    } catch {
+      return [];
+    }
+    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+    const refs = await Promise.all(jsonlFiles.map(async (f) => {
+      const fullPath = path.join(projectPath, f);
+      try {
+        const stat = await fs.stat(fullPath);
+        return {
+          projectDir,
+          fileName: f,
+          fullPath,
+          mtimeMs: stat.mtimeMs,
+          sizeBytes: stat.size
+        };
+      } catch {
+        return null;
+      }
+    }));
+    return refs.filter((r) => r !== null);
+  }));
+  const all = perProject.flat();
+  fileListCache = { files: all, capturedAtMs: Date.now(), root };
+  return all;
+}
+function sessionIdFromFileName(fileName) {
+  return fileName.replace(/\.jsonl$/i, "");
+}
+function aggregateUsageFromLines(lines, seenKeys, usage2) {
+  for (const raw of lines) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const r = raw;
+    if (r.type !== "assistant")
+      continue;
+    const m = r.message;
+    if (!m)
+      continue;
+    const mid = typeof m.id === "string" ? m.id : void 0;
+    const rid = typeof r.requestId === "string" ? r.requestId : void 0;
+    const key = mid != null && rid != null ? `${mid}:${rid}` : void 0;
+    if (key && seenKeys.has(key))
+      continue;
+    if (key)
+      seenKeys.add(key);
+    const u = m.usage;
+    if (u) {
+      const toNum = (v) => typeof v === "number" ? v : 0;
+      usage2.input += toNum(u.input_tokens);
+      usage2.output += toNum(u.output_tokens);
+      usage2.cacheRead += toNum(u.cache_read_input_tokens);
+      usage2.cacheWrite += toNum(u.cache_creation_input_tokens);
+    }
+  }
+}
+async function computeSessionUsageWithSubagents(parentLines, projectDirPath, sessionId) {
+  const usage2 = { ...BLANK_USAGE2 };
+  const seenKeys = /* @__PURE__ */ new Set();
+  aggregateUsageFromLines(parentLines, seenKeys, usage2);
+  const subagentsDir = path.join(projectDirPath, sessionId, "subagents");
+  let entries;
+  try {
+    entries = await fs.readdir(subagentsDir);
+  } catch {
+    return usage2;
+  }
+  const jsonlFiles = entries.filter((f) => f.endsWith(".jsonl"));
+  if (jsonlFiles.length === 0)
+    return usage2;
+  await Promise.all(jsonlFiles.map(async (f) => {
+    try {
+      const lines = await readJsonlFile(path.join(subagentsDir, f));
+      aggregateUsageFromLines(lines, seenKeys, usage2);
+    } catch {
+    }
+  }));
+  return usage2;
+}
+async function getCachedMeta(f) {
+  const cached = metaCache.get(f.fullPath);
+  if (cached && cached.mtimeMs === f.mtimeMs && cached.sizeBytes === f.sizeBytes) {
+    return cached.meta;
+  }
+  try {
+    const rawLines = await readJsonlFile(f.fullPath);
+    const { meta } = parseTranscript(rawLines);
+    const sessionId = sessionIdFromFileName(f.fileName);
+    const projectDirPath = path.dirname(f.fullPath);
+    meta.totalUsage = await computeSessionUsageWithSubagents(rawLines, projectDirPath, sessionId);
+    const full = {
+      ...meta,
+      id: sessionId,
+      filePath: f.fullPath,
+      projectDir: f.projectDir,
+      projectName: meta.cwd ?? decodeProjectName(f.projectDir)
+    };
+    metaCache.set(f.fullPath, { meta: full, mtimeMs: f.mtimeMs, sizeBytes: f.sizeBytes });
+    return full;
+  } catch {
+    return null;
+  }
+}
+async function listSessions(opts = {}) {
+  const { root = DEFAULT_ROOT, limit = 500, projectDir } = opts;
+  let files = await walkJsonlFiles(root);
+  if (projectDir)
+    files = files.filter((f) => f.projectDir === projectDir);
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const sliced = files.slice(0, limit);
+  const metas = await Promise.all(sliced.map((f) => getCachedMeta(f)));
+  return metas.filter((m) => m !== null);
+}
+var DEFAULT_ROOT, metaCache, fileListCache, FILE_LIST_TTL_MS, BLANK_USAGE2;
+var init_fs = __esm({
+  "../parser/dist/fs.js"() {
+    "use strict";
+    init_parser();
+    init_analytics();
+    DEFAULT_ROOT = path.join(os.homedir(), ".claude", "projects");
+    metaCache = /* @__PURE__ */ new Map();
+    fileListCache = null;
+    FILE_LIST_TTL_MS = 1e3;
+    BLANK_USAGE2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  }
+});
+
+// src/pricing.ts
+function findPricing(model) {
+  for (const [prefix, pricing] of PRICING) {
+    if (model.startsWith(prefix)) return pricing;
+  }
+  return null;
+}
+function estimateCost(model, usage2) {
+  const p = findPricing(model);
+  if (!p) return null;
+  return (usage2.input * p.input + usage2.output * p.output + usage2.cacheRead * p.cacheRead + usage2.cacheWrite * p.cacheWrite) / 1e6;
+}
+var PRICING;
+var init_pricing = __esm({
+  "src/pricing.ts"() {
+    "use strict";
+    PRICING = [
+      ["claude-opus-4", { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 }],
+      ["claude-sonnet-4", { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }],
+      ["claude-haiku-4", { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 }],
+      ["claude-3-5-sonnet", { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }],
+      ["claude-3-5-haiku", { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 }],
+      ["claude-3-opus", { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 }]
+    ];
+  }
+});
+
+// src/table.ts
+function fmtNum(n) {
+  return n.toLocaleString("en-US");
+}
+function fmtCost(cost) {
+  if (cost === null) return "\u2014";
+  return `$${cost.toFixed(2)}`;
+}
+function pad(s, width, align = "right") {
+  if (align === "left") return s.padEnd(width);
+  return s.padStart(width);
+}
+function renderTable(rows, title) {
+  const lines = [];
+  lines.push("");
+  lines.push(`${BOLD}${title}${RESET}`);
+  lines.push("");
+  const header = [
+    pad("Date", 12, "left"),
+    pad("Models", 20, "left"),
+    pad("Input", 12),
+    pad("Output", 12),
+    pad("Cache Create", 14),
+    pad("Cache Read", 14),
+    pad("Total", 14),
+    pad("Cost (USD)", 12)
+  ].join("  ");
+  lines.push(`${DIM}${header}${RESET}`);
+  lines.push(`${DIM}${"\u2500".repeat(header.length)}${RESET}`);
+  let hasUnknownCost = false;
+  for (const r of rows) {
+    if (r.cost === null) hasUnknownCost = true;
+    lines.push([
+      pad(r.date, 12, "left"),
+      pad(r.models, 20, "left"),
+      pad(fmtNum(r.input), 12),
+      pad(fmtNum(r.output), 12),
+      pad(fmtNum(r.cacheCreate), 14),
+      pad(fmtNum(r.cacheRead), 14),
+      pad(fmtNum(r.totalTokens), 14),
+      pad(fmtCost(r.cost), 12)
+    ].join("  "));
+  }
+  const totals = rows.reduce(
+    (acc, r) => ({
+      input: acc.input + r.input,
+      output: acc.output + r.output,
+      cacheCreate: acc.cacheCreate + r.cacheCreate,
+      cacheRead: acc.cacheRead + r.cacheRead,
+      totalTokens: acc.totalTokens + r.totalTokens,
+      cost: r.cost !== null && acc.cost !== null ? acc.cost + r.cost : acc.cost
+    }),
+    { input: 0, output: 0, cacheCreate: 0, cacheRead: 0, totalTokens: 0, cost: 0 }
+  );
+  lines.push(`${DIM}${"\u2500".repeat(header.length)}${RESET}`);
+  lines.push(
+    `${BOLD}${[
+      pad("Total", 12, "left"),
+      pad("", 20, "left"),
+      pad(fmtNum(totals.input), 12),
+      pad(fmtNum(totals.output), 12),
+      pad(fmtNum(totals.cacheCreate), 14),
+      pad(fmtNum(totals.cacheRead), 14),
+      pad(fmtNum(totals.totalTokens), 14),
+      pad(fmtCost(totals.cost), 12)
+    ].join("  ")}${RESET}`
+  );
+  if (hasUnknownCost) {
+    lines.push("");
+    lines.push(`${DIM}  Note: some models had unknown pricing (shown as \u2014)${RESET}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+var DIM, BOLD, RESET;
+var init_table = __esm({
+  "src/table.ts"() {
+    "use strict";
+    DIM = "\x1B[2m";
+    BOLD = "\x1B[1m";
+    RESET = "\x1B[0m";
+  }
+});
+
+// src/commands/stats.ts
+var stats_exports = {};
+__export(stats_exports, {
+  stats: () => stats
+});
+async function stats(args2) {
+  const live = args2.includes("--live");
+  const sinceIdx = args2.indexOf("-s");
+  const daysIdx = args2.indexOf("--days");
+  let sinceDate = null;
+  if (sinceIdx !== -1 && args2[sinceIdx + 1]) {
+    const raw = args2[sinceIdx + 1];
+    sinceDate = /* @__PURE__ */ new Date(`${raw.slice(0, 4)}-${raw.slice(4, 6)}-${raw.slice(6, 8)}`);
+  } else if (daysIdx !== -1 && args2[daysIdx + 1]) {
+    const days = parseInt(args2[daysIdx + 1], 10);
+    sinceDate = /* @__PURE__ */ new Date();
+    sinceDate.setDate(sinceDate.getDate() - days);
+    sinceDate.setHours(0, 0, 0, 0);
+  }
+  if (live) {
+    await liveStats(sinceDate);
+  } else {
+    await printStats(sinceDate);
+  }
+}
+async function printStats(sinceDate) {
+  const sessions = await listSessions({ limit: 1e4 });
+  const filtered = sinceDate ? sessions.filter((s) => s.firstTimestamp && new Date(s.firstTimestamp) >= sinceDate) : sessions;
+  const rows = aggregateByDay(filtered);
+  const output = renderTable(rows, "Claude Code Token Usage Report \u2014 Daily");
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const todaySessions = filtered.filter((s) => s.firstTimestamp?.startsWith(today)).length;
+  const status = getServerStatus();
+  const serverLine = status.running ? `Server running on http://localhost:${status.port}` : "Server not running";
+  console.log(output);
+  console.log(`  ${todaySessions} sessions today \xB7 ${serverLine}`);
+  console.log("");
+}
+function aggregateByDay(sessions) {
+  const byDay = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const day = s.firstTimestamp?.slice(0, 10) ?? "unknown";
+    if (!byDay.has(day)) byDay.set(day, { sessions: [], models: /* @__PURE__ */ new Set() });
+    const bucket = byDay.get(day);
+    bucket.sessions.push(s);
+    if (s.model) bucket.models.add(s.model.replace(/-\d{8}$/, ""));
+  }
+  const sorted = [...byDay.entries()].sort((a, b) => b[0].localeCompare(a[0]));
+  return sorted.map(([date, { sessions: sessions2, models }]) => {
+    const usage2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    let cost = 0;
+    for (const s of sessions2) {
+      usage2.input += s.totalUsage.input;
+      usage2.output += s.totalUsage.output;
+      usage2.cacheRead += s.totalUsage.cacheRead;
+      usage2.cacheWrite += s.totalUsage.cacheWrite;
+      if (s.model) {
+        const c = estimateCost(s.model, s.totalUsage);
+        if (c !== null && cost !== null) cost += c;
+        else cost = null;
+      }
+    }
+    const modelNames = [...models].map((m) => m.replace("claude-", "").replace(/-\d+$/, "")).join(", ");
+    return {
+      date,
+      models: modelNames || "\u2014",
+      input: usage2.input,
+      output: usage2.output,
+      cacheCreate: usage2.cacheWrite,
+      cacheRead: usage2.cacheRead,
+      totalTokens: usage2.input + usage2.output + usage2.cacheRead + usage2.cacheWrite,
+      cost
+    };
+  });
+}
+async function liveStats(sinceDate) {
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (data) => {
+      if (data.toString() === "q" || data.toString() === "") {
+        process.stdout.write("\x1B[?25h");
+        process.exit(0);
+      }
+    });
+  }
+  const refresh = async () => {
+    const sessions = await listSessions({ limit: 1e4 });
+    const filtered = sinceDate ? sessions.filter((s) => s.firstTimestamp && new Date(s.firstTimestamp) >= sinceDate) : sessions;
+    const rows = aggregateByDay(filtered);
+    const output = renderTable(rows, "Claude Code Token Usage Report \u2014 Live (q to quit)");
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write("\x1B[?25l");
+    process.stdout.write(output);
+    const running = filtered.filter((s) => s.status === "running");
+    if (running.length > 0) {
+      process.stdout.write("  Active Sessions\n");
+      for (const s of running.slice(0, 5)) {
+        const project = s.projectName.split("/").slice(-2).join("/");
+        const tokens = s.totalUsage.input + s.totalUsage.output;
+        process.stdout.write(`    ${project.padEnd(30)} ${tokens.toLocaleString()} tokens
+`);
+      }
+      process.stdout.write("\n");
+    }
+  };
+  await refresh();
+  setInterval(refresh, 2e3);
+}
+var init_stats = __esm({
+  "src/commands/stats.ts"() {
+    "use strict";
+    init_fs();
+    init_pricing();
+    init_table();
+    init_server();
+  }
+});
+
+// src/usage/token.ts
+import { execFileSync } from "node:child_process";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir2, platform } from "node:os";
+import { join as join2 } from "node:path";
+function readOAuthToken() {
+  if (platform() === "darwin") {
+    return readFromMacKeychain() ?? readFromCredentialsFile();
+  }
+  return readFromCredentialsFile();
+}
+function readFromMacKeychain() {
+  try {
+    const blob = execFileSync(
+      "security",
+      ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
+      { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" }
+    );
+    return extractToken(blob);
+  } catch {
+    return null;
+  }
+}
+function readFromCredentialsFile() {
+  const candidates = [
+    join2(homedir2(), ".claude", ".credentials.json"),
+    join2(homedir2(), ".config", "claude", "credentials.json")
+  ];
+  for (const path2 of candidates) {
+    try {
+      const blob = readFileSync2(path2, "utf8");
+      const token = extractToken(blob);
+      if (token) return token;
+    } catch {
+    }
+  }
+  return null;
+}
+function extractToken(blob) {
+  try {
+    const parsed = JSON.parse(blob);
+    return parsed.claudeAiOauth?.accessToken ?? null;
+  } catch {
+    return null;
+  }
+}
+var init_token = __esm({
+  "src/usage/token.ts"() {
+    "use strict";
+  }
+});
+
+// src/usage/api.ts
+async function fetchUsage() {
+  const token = readOAuthToken();
+  if (!token) {
+    throw new UsageApiError(
+      "No Claude Code OAuth token found. Run `claude` to log in first.",
+      "no_token"
+    );
+  }
+  let res;
+  try {
+    res = await fetch(USAGE_ENDPOINT, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "anthropic-beta": BETA_HEADER
+      }
+    });
+  } catch (err) {
+    throw new UsageApiError(
+      `Network error reaching Anthropic: ${err.message}`,
+      "network"
+    );
+  }
+  if (!res.ok) {
+    throw new UsageApiError(
+      `Usage endpoint returned ${res.status} ${res.statusText}`,
+      "http"
+    );
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch (err) {
+    throw new UsageApiError(`Failed to parse usage response: ${err.message}`, "parse");
+  }
+  const b = body;
+  return {
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    five_hour: normalizeWindow(b.five_hour) ?? { utilization: null, resets_at: null },
+    seven_day: normalizeWindow(b.seven_day) ?? { utilization: null, resets_at: null },
+    seven_day_opus: normalizeWindow(b.seven_day_opus),
+    seven_day_sonnet: normalizeWindow(b.seven_day_sonnet),
+    seven_day_oauth_apps: normalizeWindow(b.seven_day_oauth_apps),
+    seven_day_cowork: normalizeWindow(b.seven_day_cowork),
+    extra_usage: normalizeExtra(b.extra_usage)
+  };
+}
+function normalizeWindow(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  return {
+    utilization: typeof r.utilization === "number" ? r.utilization : null,
+    resets_at: typeof r.resets_at === "string" ? r.resets_at : null
+  };
+}
+function normalizeExtra(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  return {
+    is_enabled: r.is_enabled === true,
+    monthly_limit: typeof r.monthly_limit === "number" ? r.monthly_limit : null,
+    used_credits: typeof r.used_credits === "number" ? r.used_credits : null,
+    utilization: typeof r.utilization === "number" ? r.utilization : null
+  };
+}
+var USAGE_ENDPOINT, BETA_HEADER, UsageApiError;
+var init_api = __esm({
+  "src/usage/api.ts"() {
+    "use strict";
+    init_token();
+    USAGE_ENDPOINT = "https://api.anthropic.com/api/oauth/usage";
+    BETA_HEADER = "oauth-2025-04-20";
+    UsageApiError = class extends Error {
+      constructor(message, code) {
+        super(message);
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/usage/format.ts
+function formatUsage(snapshot) {
+  const rows = [
+    ["5 hour", snapshot.five_hour],
+    ["7 day", snapshot.seven_day],
+    ["7 day (Opus)", snapshot.seven_day_opus],
+    ["7 day (Sonnet)", snapshot.seven_day_sonnet],
+    ["7 day (OAuth apps)", snapshot.seven_day_oauth_apps],
+    ["7 day (Cowork)", snapshot.seven_day_cowork]
+  ];
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${BOLD2}Claude Code Usage${RESET2}`);
+  lines.push("");
+  for (const [label, window] of rows) {
+    if (!window || window.utilization === null) continue;
+    const pct = window.utilization;
+    const bar = renderBar(pct);
+    const pctStr = `${pct.toFixed(1)}%`.padStart(6);
+    const labelStr = label.padEnd(16);
+    lines.push(`  ${labelStr}${bar}  ${BOLD2}${pctStr}${RESET2}`);
+    if (window.resets_at) {
+      lines.push(`  ${" ".repeat(16)}${DIM2}resets ${formatRelative(window.resets_at)}${RESET2}`);
+    }
+    lines.push("");
+  }
+  if (snapshot.extra_usage?.is_enabled) {
+    const extra = snapshot.extra_usage;
+    lines.push(`  ${BOLD2}Extra usage${RESET2}`);
+    if (extra.utilization !== null) {
+      lines.push(`  ${" ".repeat(16)}${extra.utilization.toFixed(1)}%`);
+    }
+    if (extra.used_credits !== null && extra.monthly_limit !== null) {
+      lines.push(`  ${" ".repeat(16)}${extra.used_credits} / ${extra.monthly_limit} credits`);
+    }
+    lines.push("");
+  }
+  lines.push(`  ${DIM2}captured ${formatRelative(snapshot.captured_at)}${RESET2}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderBar(utilization) {
+  const clamped = Math.max(0, Math.min(100, utilization));
+  const color = clamped >= 90 ? RED : clamped >= 70 ? YELLOW : GREEN;
+  const totalEighths = Math.round(clamped / 100 * BAR_WIDTH * 8);
+  const fullBlocks = Math.floor(totalEighths / 8);
+  const remainder = totalEighths % 8;
+  const partial = EIGHTHS[remainder];
+  const filledCells = fullBlocks + (partial ? 1 : 0);
+  const emptyCells = BAR_WIDTH - filledCells;
+  const filled = "\u2588".repeat(fullBlocks) + partial;
+  const empty = "\xB7".repeat(emptyCells);
+  return `${color}${filled}${RESET2}${DIM2}${empty}${RESET2}`;
+}
+function formatRelative(iso) {
+  const then = new Date(iso).getTime();
+  const now = Date.now();
+  const diffSec = Math.round((then - now) / 1e3);
+  const abs = Math.abs(diffSec);
+  const past = diffSec < 0;
+  let value;
+  if (abs < 60) {
+    value = `${abs}s`;
+  } else if (abs < 3600) {
+    value = `${Math.floor(abs / 60)}m`;
+  } else if (abs < 86400) {
+    const h = Math.floor(abs / 3600);
+    const m = Math.floor(abs % 3600 / 60);
+    value = m > 0 ? `${h}h${m}m` : `${h}h`;
+  } else {
+    const d = Math.floor(abs / 86400);
+    const h = Math.floor(abs % 86400 / 3600);
+    value = h > 0 ? `${d}d${h}h` : `${d}d`;
+  }
+  return past ? `${value} ago` : `in ${value}`;
+}
+var DIM2, BOLD2, RESET2, GREEN, YELLOW, RED, BAR_WIDTH, EIGHTHS;
+var init_format = __esm({
+  "src/usage/format.ts"() {
+    "use strict";
+    DIM2 = "\x1B[2m";
+    BOLD2 = "\x1B[1m";
+    RESET2 = "\x1B[0m";
+    GREEN = "\x1B[32m";
+    YELLOW = "\x1B[33m";
+    RED = "\x1B[31m";
+    BAR_WIDTH = 40;
+    EIGHTHS = ["", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589"];
+  }
+});
+
+// src/usage/storage.ts
+import { appendFileSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+function appendSnapshot(filePath, snapshot) {
+  mkdirSync2(dirname3(filePath), { recursive: true });
+  appendFileSync(filePath, JSON.stringify(snapshot) + "\n", "utf8");
+}
+function readSnapshots(filePath) {
+  if (!existsSync2(filePath)) return [];
+  const content = readFileSync3(filePath, "utf8");
+  const snapshots = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      snapshots.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return snapshots;
+}
+function latestSnapshot(filePath) {
+  const all = readSnapshots(filePath);
+  return all.length > 0 ? all[all.length - 1] : null;
+}
+var init_storage = __esm({
+  "src/usage/storage.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/usage.ts
+var usage_exports = {};
+__export(usage_exports, {
+  usage: () => usage
+});
+import { join as join3 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+async function usage(args2) {
+  const save = args2.includes("--save");
+  try {
+    const snapshot = await fetchUsage();
+    if (save) appendSnapshot(USAGE_LOG, snapshot);
+    process.stdout.write(formatUsage(snapshot));
+  } catch (err) {
+    if (err instanceof UsageApiError) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+var USAGE_LOG;
+var init_usage = __esm({
+  "src/commands/usage.ts"() {
+    "use strict";
+    init_api();
+    init_format();
+    init_storage();
+    USAGE_LOG = join3(homedir3(), ".cclens", "usage.jsonl");
+  }
+});
+
+// src/commands/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  daemon: () => daemon
+});
+import { spawn as spawn2 } from "node:child_process";
+import { join as join4, dirname as dirname4 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { existsSync as existsSync3, statSync, readFileSync as readFileSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+function workerPath() {
+  const here = dirname4(fileURLToPath2(import.meta.url));
+  return join4(here, "daemon-worker.js");
+}
+async function daemon(args2) {
+  const sub = args2[0] ?? "status";
+  switch (sub) {
+    case "start":
+      await daemonStart();
+      break;
+    case "stop":
+      daemonStop();
+      break;
+    case "status":
+      daemonStatus();
+      break;
+    case "logs":
+      daemonLogs();
+      break;
+    default:
+      console.error(`Unknown daemon subcommand: ${sub}`);
+      console.error("Usage: cclens daemon <start|stop|status|logs>");
+      process.exit(1);
+  }
+}
+async function daemonStart() {
+  cleanStalePid(DAEMON_PID);
+  const existing = readPid(DAEMON_PID);
+  if (existing !== null && isProcessAlive(existing.pid)) {
+    console.log(`Daemon is already running (PID ${existing.pid})`);
+    return;
+  }
+  const script = workerPath();
+  if (!existsSync3(script)) {
+    console.error(`Daemon worker not found at ${script}. Rebuild with: pnpm -F cclens build`);
+    process.exit(1);
+  }
+  const child = spawn2(process.execPath, [script], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const pid = child.pid;
+  writePid(DAEMON_PID, pid);
+  console.log(`Daemon started (PID ${pid})`);
+  console.log(`Polling every 5 minutes. Logs: ${DAEMON_LOG}`);
+}
+function daemonStop() {
+  cleanStalePid(DAEMON_PID);
+  const entry = readPid(DAEMON_PID);
+  if (entry === null) {
+    console.log("Daemon is not running.");
+    return;
+  }
+  try {
+    process.kill(entry.pid, "SIGTERM");
+  } catch {
+  }
+  removePid(DAEMON_PID);
+  console.log(`Stopped daemon (PID ${entry.pid})`);
+}
+function daemonStatus() {
+  cleanStalePid(DAEMON_PID);
+  const entry = readPid(DAEMON_PID);
+  const running = entry !== null && isProcessAlive(entry.pid);
+  if (running) {
+    console.log(`Daemon: running (PID ${entry.pid})`);
+  } else {
+    console.log("Daemon: not running");
+  }
+  const latest = latestSnapshot(USAGE_LOG2);
+  if (latest) {
+    const age = Math.round((Date.now() - new Date(latest.captured_at).getTime()) / 1e3);
+    const ageStr = age < 60 ? `${age}s` : age < 3600 ? `${Math.round(age / 60)}m` : `${Math.round(age / 3600)}h`;
+    console.log(`Last snapshot: ${ageStr} ago`);
+    console.log(`  5h:    ${latest.five_hour.utilization?.toFixed(1) ?? "\u2014"}%`);
+    console.log(`  7d:    ${latest.seven_day.utilization?.toFixed(1) ?? "\u2014"}%`);
+  } else {
+    console.log("Last snapshot: none yet");
+  }
+  if (existsSync3(USAGE_LOG2)) {
+    const size = statSync(USAGE_LOG2).size;
+    console.log(`Usage log: ${USAGE_LOG2} (${size} bytes)`);
+  }
+}
+function daemonLogs() {
+  if (!existsSync3(DAEMON_LOG)) {
+    console.log("No daemon logs yet.");
+    return;
+  }
+  const content = readFileSync4(DAEMON_LOG, "utf8");
+  const lines = content.trim().split("\n").slice(-20);
+  for (const line of lines) process.stdout.write(line + "\n");
+}
+var STATE_DIR2, DAEMON_PID, USAGE_LOG2, DAEMON_LOG;
+var init_daemon = __esm({
+  "src/commands/daemon.ts"() {
+    "use strict";
+    init_pid();
+    init_storage();
+    STATE_DIR2 = join4(homedir4(), ".cclens");
+    DAEMON_PID = join4(STATE_DIR2, "daemon.pid");
+    USAGE_LOG2 = join4(STATE_DIR2, "usage.jsonl");
+    DAEMON_LOG = join4(STATE_DIR2, "daemon.log");
+  }
+});
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args[0] ?? "help";
+async function main() {
+  switch (command) {
+    case "start": {
+      const { start: start2 } = await Promise.resolve().then(() => (init_start(), start_exports));
+      await start2(args.slice(1));
+      break;
+    }
+    case "stop": {
+      const { stop: stop2 } = await Promise.resolve().then(() => (init_stop(), stop_exports));
+      await stop2();
+      break;
+    }
+    case "web": {
+      const { web: web2 } = await Promise.resolve().then(() => (init_web(), web_exports));
+      await web2(args.slice(1));
+      break;
+    }
+    case "update": {
+      const { update: update2 } = await Promise.resolve().then(() => (init_update(), update_exports));
+      await update2();
+      break;
+    }
+    case "stats": {
+      const { stats: stats2 } = await Promise.resolve().then(() => (init_stats(), stats_exports));
+      await stats2(args.slice(1));
+      break;
+    }
+    case "usage": {
+      const { usage: usage2 } = await Promise.resolve().then(() => (init_usage(), usage_exports));
+      await usage2(args.slice(1));
+      break;
+    }
+    case "daemon": {
+      const { daemon: daemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await daemon2(args.slice(1));
+      break;
+    }
+    case "version":
+    case "--version":
+    case "-v":
+      console.log(`cclens ${"0.1.0"}`);
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(`Usage: cclens <command>
+
+Commands:
+  start [--port N] [--no-open]      Start the dashboard server
+  stop                              Stop the dashboard server
+  web [page] [--no-open]            Open dashboard in browser (e.g. 'web usage')
+  update                            Update to the latest version
+  stats [--live] [-s D] [--days N]  Show token usage statistics
+  usage [--save]                    Show Claude Code plan utilization (5h/7d)
+  daemon <start|stop|status|logs>   Background poller for usage metrics
+  version                           Print version`);
+      break;
+    default:
+      console.error(`Unknown command: ${command}
+Run 'cclens help' for usage.`);
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});