@wukazis/euphony 0.1.45 → 0.1.47

package/server-dist/node-main.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { stat, readFile, readdir } from "node:fs/promises";
+import { stat, readdir, open, readFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { dirname, resolve, join, extname, basename, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -434,12 +434,22 @@ const SERVER_DIR = dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = resolve(SERVER_DIR, "..");
 const DIST_DIR = resolve(PACKAGE_ROOT, "dist");
 const CODEX_SESSIONS_URL = "codex:sessions";
+const CODEX_USAGE_URL = "codex:usage";
 const CODEX_SESSION_URL_PREFIX = "codex:session:";
+const CLAUDE_SESSIONS_URL = "claude:sessions";
+const CLAUDE_SESSION_URL_PREFIX = "claude:session:";
 const CODEX_SESSIONS_DIR = resolve(
   process.env.CODEX_SESSIONS_DIR ?? join(process.env.HOME ?? process.cwd(), ".codex", "sessions")
 );
+const CLAUDE_PROJECTS_DIR = resolve(
+  process.env.CLAUDE_PROJECTS_DIR ?? join(process.env.HOME ?? process.cwd(), ".claude", "projects")
+);
 const MAX_PUBLIC_JSON_BYTES = 25 * 1024 * 1024;
 const MAX_CODEX_SESSION_BYTES = 25 * 1024 * 1024;
+const MAX_CODEX_SEARCH_PREVIEW_BYTES = 256 * 1024;
+const CODEX_USAGE_TAIL_CHUNK_BYTES = 64 * 1024;
+const MAX_CODEX_USAGE_TAIL_BYTES = 2 * 1024 * 1024;
+const CODEX_USAGE_CACHE_TTL_MS = 60 * 1e3;
 const MAX_JSON_BODY_BYTES = 2 * 1024 * 1024;
 const TRANSLATION_CACHE_TTL_MS = 5 * 60 * 60 * 1e3;
 const TRANSLATION_MAX_CONCURRENCY = 1024;
@@ -453,6 +463,8 @@ class HttpError extends Error {
 }
 const translationCache = /* @__PURE__ */ new Map();
 const inflightTranslations = /* @__PURE__ */ new Map();
+const codexUsageCache = /* @__PURE__ */ new Map();
+const inflightCodexUsage = /* @__PURE__ */ new Map();
 let activeTranslations = 0;
 const translationWaiters = [];
 const normalizeLimit = (value, fallback) => {
@@ -463,6 +475,24 @@ const normalizeOffset = (value) => {
   const parsed = Number.parseInt(value ?? "", 10);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 };
+const normalizeCodexUsageRange = (value) => {
+  if (value === "7d" || value === "30d" || value === "1y") {
+    return value;
+  }
+  return "30d";
+};
+const formatNumberPart = (value, length = 2) => value.toString().padStart(length, "0");
+const formatLocalDateBucket = (timestamp) => `${timestamp.getFullYear()}-${formatNumberPart(timestamp.getMonth() + 1)}-${formatNumberPart(timestamp.getDate())}`;
+const codexUsageRangeStart = (range) => {
+  const dayMs = 24 * 60 * 60 * 1e3;
+  const start = /* @__PURE__ */ new Date();
+  const daysBack = range === "7d" ? 6 : range === "30d" ? 29 : 364;
+  start.setHours(0, 0, 0, 0);
+  return new Date(start.getTime() - daysBack * dayMs);
+};
+const codexUsageBucketKey = (timestamp, range) => {
+  return formatLocalDateBucket(timestamp);
+};
 const isInsideDirectory = (root, candidate) => {
   const relative = resolve(candidate).slice(resolve(root).length);
   return candidate === root || relative.startsWith(sep) && !relative.slice(1).startsWith(`..${sep}`);
@@ -486,6 +516,21 @@ const parseJsonl = (text) => {
   }
   return events;
 };
+const parseJsonlTolerant = (text) => {
+  const events = [];
+  for (const line of text.split(/\r?\n/)) {
+    const stripped = line.trim();
+    if (stripped.length === 0) {
+      continue;
+    }
+    try {
+      events.push(JSON.parse(stripped));
+    } catch {
+      continue;
+    }
+  }
+  return events;
+};
 const parseJsonOrJsonl = (text) => {
   const stripped = text.trim();
   if (stripped.length === 0) {
@@ -498,13 +543,18 @@ const parseJsonOrJsonl = (text) => {
     return parseJsonl(text);
   }
 };
-const loadJsonlEvents = async (path) => {
+const loadJsonlText = async (path) => {
   const fileStat = await stat(path);
   if (fileStat.size > MAX_CODEX_SESSION_BYTES) {
     throw new Error(`Codex session file is too large: ${path}`);
   }
-  const text = stripBom(await readFile(path, "utf8"));
-  return parseJsonl(text);
+  return stripBom(await readFile(path, "utf8"));
+};
+const loadJsonlEvents = async (path) => {
+  return parseJsonl(await loadJsonlText(path));
+};
+const loadJsonlEventsTolerant = async (path) => {
+  return parseJsonlTolerant(await loadJsonlText(path));
 };
 const resolveCodexSessionPath = (sessionRef) => {
   const relativePath = decodeURIComponent(sessionRef);
@@ -514,6 +564,14 @@ const resolveCodexSessionPath = (sessionRef) => {
   }
   return candidate;
 };
+const resolveClaudeSessionPath = (sessionRef) => {
+  const relativePath = decodeURIComponent(sessionRef);
+  const candidate = resolve(CLAUDE_PROJECTS_DIR, relativePath);
+  if (!isInsideDirectory(CLAUDE_PROJECTS_DIR, candidate) || extname(candidate) !== ".jsonl") {
+    throw new HttpError(404, "Claude session not found");
+  }
+  return candidate;
+};
 const parseTimestamp = (timestamp) => {
   if (typeof timestamp !== "string" || timestamp.length === 0) {
     return null;
@@ -522,6 +580,122 @@ const parseTimestamp = (timestamp) => {
   const parsed = new Date(normalized);
   return Number.isNaN(parsed.getTime()) ? null : parsed;
 };
+const numberFromUsageField = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+const emptyCodexTokenUsage = () => ({
+  input_tokens: 0,
+  cached_input_tokens: 0,
+  output_tokens: 0,
+  reasoning_output_tokens: 0,
+  total_tokens: 0
+});
+const addCodexTokenUsage = (target, source) => {
+  target.input_tokens += source.input_tokens;
+  target.cached_input_tokens += source.cached_input_tokens;
+  target.output_tokens += source.output_tokens;
+  target.reasoning_output_tokens += source.reasoning_output_tokens;
+  target.total_tokens += source.total_tokens;
+};
+const extractCodexTokenUsage = (value) => {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const usage = {
+    input_tokens: numberFromUsageField(record.input_tokens),
+    cached_input_tokens: numberFromUsageField(
+      record.cached_input_tokens ?? record.cached_tokens
+    ),
+    output_tokens: numberFromUsageField(record.output_tokens),
+    reasoning_output_tokens: numberFromUsageField(
+      record.reasoning_output_tokens
+    ),
+    total_tokens: numberFromUsageField(record.total_tokens)
+  };
+  if (usage.total_tokens === 0 && (usage.input_tokens > 0 || usage.output_tokens > 0)) {
+    usage.total_tokens = usage.input_tokens + usage.output_tokens;
+  }
+  return usage.total_tokens > 0 ? usage : null;
+};
+const extractCodexUsageSnapshotFromEvent = (event) => {
+  if (!event || typeof event !== "object") {
+    return null;
+  }
+  const record = event;
+  const payload = record.payload;
+  if (record.type !== "event_msg" || !payload || typeof payload !== "object") {
+    return null;
+  }
+  const payloadRecord = payload;
+  if (payloadRecord.type !== "token_count") {
+    return null;
+  }
+  const info = payloadRecord.info;
+  if (!info || typeof info !== "object") {
+    return null;
+  }
+  const usage = extractCodexTokenUsage(
+    info.total_token_usage
+  );
+  if (!usage) {
+    return null;
+  }
+  return {
+    usage,
+    timestamp: parseTimestamp(record.timestamp)
+  };
+};
+const extractCodexUsageSnapshotFromEvents = (events) => {
+  let snapshot = null;
+  for (const event of events) {
+    snapshot = extractCodexUsageSnapshotFromEvent(event) ?? snapshot;
+  }
+  return snapshot;
+};
+const extractClaudeUsageSnapshotFromEvents = (events) => {
+  const usage = emptyCodexTokenUsage();
+  const seenUsageIds = /* @__PURE__ */ new Set();
+  let timestamp = null;
+  for (const event of events) {
+    if (!event || typeof event !== "object") {
+      continue;
+    }
+    const record = event;
+    if (record.type !== "assistant") {
+      continue;
+    }
+    const message = record.message;
+    if (!message || typeof message !== "object") {
+      continue;
+    }
+    const messageRecord = message;
+    const rawUsage = messageRecord.usage;
+    if (!rawUsage || typeof rawUsage !== "object") {
+      continue;
+    }
+    const usageId = typeof messageRecord.id === "string" ? messageRecord.id : typeof record.requestId === "string" ? record.requestId : typeof record.uuid === "string" ? record.uuid : null;
+    if (usageId && seenUsageIds.has(usageId)) {
+      continue;
+    }
+    if (usageId) {
+      seenUsageIds.add(usageId);
+    }
+    const usageRecord = rawUsage;
+    const inputTokens = numberFromUsageField(usageRecord.input_tokens);
+    const cacheCreationTokens = numberFromUsageField(
+      usageRecord.cache_creation_input_tokens
+    );
+    const cacheReadTokens = numberFromUsageField(
+      usageRecord.cache_read_input_tokens
+    );
+    const outputTokens = numberFromUsageField(usageRecord.output_tokens);
+    usage.input_tokens += inputTokens;
+    usage.cached_input_tokens += cacheCreationTokens + cacheReadTokens;
+    usage.output_tokens += outputTokens;
+    usage.total_tokens += inputTokens + cacheCreationTokens + cacheReadTokens + outputTokens;
+    timestamp = parseTimestamp(record.timestamp) ?? timestamp;
+  }
+  return usage.total_tokens > 0 ? { usage, timestamp } : null;
+};
 const extractTextFromContent = (content) => {
   if (typeof content === "string") {
     const stripped = content.trim();
@@ -557,6 +731,12 @@ const isDisplayableFirstMessage = (text) => {
     "<collaboration_mode>",
     "<model_switch>",
     "<environment_context>",
+    "<local-command-caveat>",
+    "<local-command-stdout>",
+    "<local-command-stderr>",
+    "<command-name>",
+    "<command-message>",
+    "<command-args>",
     "# AGENTS.md instructions"
   ].some((prefix) => stripped.startsWith(prefix));
 };
@@ -567,12 +747,215 @@ const cleanSummaryText = (text, maxLength = 240) => {
   return cleaned.length <= maxLength ? cleaned : `${cleaned.slice(0, maxLength - 3).trimEnd()}...`;
 };
 const relativeCodexPath = (path) => resolve(path).slice(resolve(CODEX_SESSIONS_DIR).length + 1).split(sep).join("/");
+const relativeClaudePath = (path) => resolve(path).slice(resolve(CLAUDE_PROJECTS_DIR).length + 1).split(sep).join("/");
+const normalizeCodexSearchQuery = (query) => query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+const extractDisplayableUserMessage = (record) => {
+  const payload = record.payload;
+  if (!payload || typeof payload !== "object") {
+    return "";
+  }
+  const payloadRecord = payload;
+  let candidate = "";
+  if (record.type === "response_item" && payloadRecord.role === "user") {
+    candidate = extractTextFromContent(payloadRecord.content) ?? "";
+  } else if (record.type === "event_msg" && payloadRecord.type === "user_message") {
+    candidate = extractTextFromContent(payloadRecord) ?? "";
+  }
+  return candidate.length > 0 && isDisplayableFirstMessage(candidate) ? candidate : "";
+};
+const extractClaudeDisplayableUserMessage = (record) => {
+  if (record.type !== "user" || record.isMeta === true) {
+    return "";
+  }
+  const message = record.message;
+  if (!message || typeof message !== "object") {
+    return "";
+  }
+  const messageRecord = message;
+  if (messageRecord.role !== "user") {
+    return "";
+  }
+  const candidate = extractTextFromContent(messageRecord.content) ?? "";
+  return candidate.length > 0 && isDisplayableFirstMessage(candidate) ? candidate : "";
+};
+const readCodexSessionFirstMessage = async (path) => {
+  const fileStat = await stat(path);
+  const previewByteLength = Math.min(
+    fileStat.size,
+    MAX_CODEX_SEARCH_PREVIEW_BYTES
+  );
+  const fileHandle = await open(path, "r");
+  let text = "";
+  try {
+    const buffer = Buffer.alloc(previewByteLength);
+    const { bytesRead } = await fileHandle.read(
+      buffer,
+      0,
+      previewByteLength,
+      0
+    );
+    text = stripBom(buffer.subarray(0, bytesRead).toString("utf8"));
+  } finally {
+    await fileHandle.close();
+  }
+  const lines = text.split(/\r?\n/);
+  if (fileStat.size > previewByteLength) {
+    lines.pop();
+  }
+  for (const line of lines) {
+    const stripped = line.trim();
+    if (stripped.length === 0) {
+      continue;
+    }
+    let event;
+    try {
+      event = JSON.parse(stripped);
+    } catch {
+      continue;
+    }
+    if (!event || typeof event !== "object") {
+      continue;
+    }
+    const candidate = extractDisplayableUserMessage(
+      event
+    );
+    if (candidate.length > 0) {
+      return cleanSummaryText(candidate, 1e3);
+    }
+  }
+  return "";
+};
+const readClaudeSessionFirstMessage = async (path) => {
+  const fileStat = await stat(path);
+  const previewByteLength = Math.min(
+    fileStat.size,
+    MAX_CODEX_SEARCH_PREVIEW_BYTES
+  );
+  const fileHandle = await open(path, "r");
+  let text = "";
+  try {
+    const buffer = Buffer.alloc(previewByteLength);
+    const { bytesRead } = await fileHandle.read(
+      buffer,
+      0,
+      previewByteLength,
+      0
+    );
+    text = stripBom(buffer.subarray(0, bytesRead).toString("utf8"));
+  } finally {
+    await fileHandle.close();
+  }
+  const lines = text.split(/\r?\n/);
+  if (fileStat.size > previewByteLength) {
+    lines.pop();
+  }
+  for (const line of lines) {
+    const stripped = line.trim();
+    if (stripped.length === 0) {
+      continue;
+    }
+    let event;
+    try {
+      event = JSON.parse(stripped);
+    } catch {
+      continue;
+    }
+    if (!event || typeof event !== "object") {
+      continue;
+    }
+    const candidate = extractClaudeDisplayableUserMessage(
+      event
+    );
+    if (candidate.length > 0) {
+      return cleanSummaryText(candidate, 1e3);
+    }
+  }
+  return "";
+};
+const readCodexUsageSnapshot = async (path) => {
+  const fileStat = await stat(path);
+  if (fileStat.size === 0) {
+    return null;
+  }
+  const fileHandle = await open(path, "r");
+  let cursor = fileStat.size;
+  let scannedBytes = 0;
+  let tailText = "";
+  try {
+    while (cursor > 0 && scannedBytes < MAX_CODEX_USAGE_TAIL_BYTES) {
+      const chunkSize = Math.min(
+        CODEX_USAGE_TAIL_CHUNK_BYTES,
+        cursor,
+        MAX_CODEX_USAGE_TAIL_BYTES - scannedBytes
+      );
+      cursor -= chunkSize;
+      const buffer = Buffer.alloc(chunkSize);
+      const { bytesRead } = await fileHandle.read(
+        buffer,
+        0,
+        chunkSize,
+        cursor
+      );
+      if (bytesRead === 0) {
+        break;
+      }
+      scannedBytes += bytesRead;
+      tailText = buffer.subarray(0, bytesRead).toString("utf8") + tailText;
+      const lines = tailText.split(/\r?\n/);
+      const firstCompleteLineIndex = cursor > 0 ? 1 : 0;
+      for (let i = lines.length - 1; i >= firstCompleteLineIndex; i--) {
+        const stripped = stripBom(lines[i]).trim();
+        if (stripped.length === 0 || !stripped.includes('"token_count"')) {
+          continue;
+        }
+        let event;
+        try {
+          event = JSON.parse(stripped);
+        } catch {
+          continue;
+        }
+        const snapshot = extractCodexUsageSnapshotFromEvent(event);
+        if (snapshot) {
+          return snapshot;
+        }
+      }
+    }
+  } finally {
+    await fileHandle.close();
+  }
+  return null;
+};
+const codexSessionMatchesSearch = async (path, searchTerms) => {
+  if (searchTerms.length === 0) {
+    return true;
+  }
+  const relativePath = relativeCodexPath(path).toLowerCase();
+  if (searchTerms.every((term) => relativePath.includes(term))) {
+    return true;
+  }
+  const searchableText = `${relativePath}
+${await readCodexSessionFirstMessage(path)}`.toLowerCase();
+  return searchTerms.every((term) => searchableText.includes(term));
+};
+const claudeSessionMatchesSearch = async (path, searchTerms) => {
+  if (searchTerms.length === 0) {
+    return true;
+  }
+  const relativePath = relativeClaudePath(path).toLowerCase();
+  if (searchTerms.every((term) => relativePath.includes(term))) {
+    return true;
+  }
+  const searchableText = `${relativePath}
+${await readClaudeSessionFirstMessage(path)}`.toLowerCase();
+  return searchTerms.every((term) => searchableText.includes(term));
+};
 const summarizeCodexSession = async (path) => {
   const events = await loadJsonlEvents(path);
   const relativePath = relativeCodexPath(path);
   const encodedPath = encodeURIComponent(relativePath);
   let sessionTimestamp = null;
   let firstMessage = "";
+  const usageSnapshot = extractCodexUsageSnapshotFromEvents(events);
   for (const event of events) {
     if (!event || typeof event !== "object") {
       continue;
@@ -596,12 +979,7 @@ const summarizeCodexSession = async (path) => {
     if (firstMessage.length > 0) {
       continue;
     }
-    let candidate = "";
-    if (record.type === "response_item" && payloadRecord.role === "user") {
-      candidate = extractTextFromContent(payloadRecord.content) ?? "";
-    } else if (record.type === "event_msg" && payloadRecord.type === "user_message") {
-      candidate = extractTextFromContent(payloadRecord) ?? "";
-    }
+    const candidate = extractDisplayableUserMessage(record);
     if (candidate.length > 0 && isDisplayableFirstMessage(candidate)) {
       firstMessage = cleanSummaryText(candidate);
     }
@@ -623,7 +1001,59 @@ const summarizeCodexSession = async (path) => {
     first_message: firstMessage,
     timestamp: sessionTimestamp.toISOString(),
     age_seconds: ageSeconds,
-    event_count: events.length
+    event_count: events.length,
+    token_usage: usageSnapshot?.usage ?? null,
+    usage_timestamp: usageSnapshot?.timestamp?.toISOString() ?? null
+  };
+};
+const summarizeClaudeSession = async (path) => {
+  const events = await loadJsonlEventsTolerant(path);
+  const relativePath = relativeClaudePath(path);
+  const encodedPath = encodeURIComponent(relativePath);
+  let sessionTimestamp = null;
+  let firstMessage = "";
+  let aiTitle = "";
+  const usageSnapshot = extractClaudeUsageSnapshotFromEvents(events);
+  for (const event of events) {
+    if (!event || typeof event !== "object") {
+      continue;
+    }
+    const record = event;
+    const eventTimestamp = parseTimestamp(record.timestamp) ?? (record.snapshot && typeof record.snapshot === "object" ? parseTimestamp(record.snapshot.timestamp) : null);
+    if (sessionTimestamp === null && eventTimestamp !== null) {
+      sessionTimestamp = eventTimestamp;
+    }
+    if (record.type === "ai-title" && typeof record.aiTitle === "string" && aiTitle.length === 0) {
+      aiTitle = cleanSummaryText(record.aiTitle);
+    }
+    if (firstMessage.length > 0) {
+      continue;
+    }
+    const candidate = extractClaudeDisplayableUserMessage(record);
+    if (candidate.length > 0 && isDisplayableFirstMessage(candidate)) {
+      firstMessage = cleanSummaryText(candidate);
+    }
+  }
+  if (firstMessage.length === 0) {
+    firstMessage = aiTitle || "(no user message)";
+  }
+  if (sessionTimestamp === null) {
+    const fileStat = await stat(path);
+    sessionTimestamp = new Date(fileStat.mtimeMs);
+  }
+  const ageSeconds = Math.max(
+    0,
+    Math.floor((Date.now() - sessionTimestamp.getTime()) / 1e3)
+  );
+  return {
+    path: relativePath,
+    load_url: `${CLAUDE_SESSION_URL_PREFIX}${encodedPath}`,
+    first_message: firstMessage,
+    timestamp: sessionTimestamp.toISOString(),
+    age_seconds: ageSeconds,
+    event_count: events.length,
+    token_usage: usageSnapshot?.usage ?? null,
+    usage_timestamp: usageSnapshot?.timestamp?.toISOString() ?? null
   };
 };
 const findJsonlFiles = async (root) => {
@@ -658,7 +1088,8 @@ const findJsonlFiles = async (root) => {
   withStats.sort((a, b) => b.mtime - a.mtime || b.path.localeCompare(a.path));
   return withStats.map((item) => item.path);
 };
-const getCodexSessions = async (offset, limit) => {
+const getCodexSessions = async (offset, limit, searchQuery = "") => {
+  const searchTerms = normalizeCodexSearchQuery(searchQuery);
   try {
     const rootStat = await stat(CODEX_SESSIONS_DIR);
     if (!rootStat.isDirectory()) {
@@ -670,13 +1101,27 @@ const getCodexSessions = async (offset, limit) => {
       offset,
       limit,
       total: 0,
-      isFiltered: false,
+      isFiltered: searchTerms.length > 0,
       matchedCount: 0,
       resolvedURL: CODEX_SESSIONS_URL
     };
   }
   const files = await findJsonlFiles(CODEX_SESSIONS_DIR);
-  const pageFiles = files.slice(offset, offset + limit);
+  const matchedFiles = [];
+  if (searchTerms.length === 0) {
+    matchedFiles.push(...files);
+  } else {
+    for (const path of files) {
+      try {
+        if (await codexSessionMatchesSearch(path, searchTerms)) {
+          matchedFiles.push(path);
+        }
+      } catch (error) {
+        console.error(`Failed to search Codex session file: ${path}`, error);
+      }
+    }
+  }
+  const pageFiles = matchedFiles.slice(offset, offset + limit);
   const summaries = [];
   for (const path of pageFiles) {
     try {
@@ -690,11 +1135,141 @@ const getCodexSessions = async (offset, limit) => {
     offset,
     limit,
     total: files.length,
-    isFiltered: false,
-    matchedCount: files.length,
+    isFiltered: searchTerms.length > 0,
+    matchedCount: matchedFiles.length,
     resolvedURL: CODEX_SESSIONS_URL
   };
 };
+const getClaudeSessions = async (offset, limit, searchQuery = "") => {
+  const searchTerms = normalizeCodexSearchQuery(searchQuery);
+  try {
+    const rootStat = await stat(CLAUDE_PROJECTS_DIR);
+    if (!rootStat.isDirectory()) {
+      throw new Error("Not a directory");
+    }
+  } catch {
+    return {
+      data: [],
+      offset,
+      limit,
+      total: 0,
+      isFiltered: searchTerms.length > 0,
+      matchedCount: 0,
+      resolvedURL: CLAUDE_SESSIONS_URL
+    };
+  }
+  const files = await findJsonlFiles(CLAUDE_PROJECTS_DIR);
+  const matchedFiles = [];
+  if (searchTerms.length === 0) {
+    matchedFiles.push(...files);
+  } else {
+    for (const path of files) {
+      try {
+        if (await claudeSessionMatchesSearch(path, searchTerms)) {
+          matchedFiles.push(path);
+        }
+      } catch (error) {
+        console.error(`Failed to search Claude session file: ${path}`, error);
+      }
+    }
+  }
+  const pageFiles = matchedFiles.slice(offset, offset + limit);
+  const summaries = [];
+  for (const path of pageFiles) {
+    try {
+      summaries.push(await summarizeClaudeSession(path));
+    } catch (error) {
+      console.error(`Failed to load Claude session file: ${path}`, error);
+    }
+  }
+  return {
+    data: summaries,
+    offset,
+    limit,
+    total: files.length,
+    isFiltered: searchTerms.length > 0,
+    matchedCount: matchedFiles.length,
+    resolvedURL: CLAUDE_SESSIONS_URL
+  };
+};
+const buildCodexUsageDays = async (range) => {
+  try {
+    const rootStat = await stat(CODEX_SESSIONS_DIR);
+    if (!rootStat.isDirectory()) {
+      throw new Error("Not a directory");
+    }
+  } catch {
+    return [];
+  }
+  const files = await findJsonlFiles(CODEX_SESSIONS_DIR);
+  const usageByDay = /* @__PURE__ */ new Map();
+  const rangeStart = codexUsageRangeStart(range);
+  const now = /* @__PURE__ */ new Date();
+  for (const path of files) {
+    try {
+      const snapshot = await readCodexUsageSnapshot(path);
+      if (!snapshot) {
+        continue;
+      }
+      const fileStat = await stat(path);
+      const timestamp = snapshot.timestamp ?? new Date(fileStat.mtimeMs);
+      if (timestamp < rangeStart || timestamp > now) {
+        continue;
+      }
+      const date = codexUsageBucketKey(timestamp, range);
+      const dayUsage = usageByDay.get(date) ?? {
+        date,
+        session_count: 0,
+        ...emptyCodexTokenUsage()
+      };
+      dayUsage.session_count += 1;
+      addCodexTokenUsage(dayUsage, snapshot.usage);
+      usageByDay.set(date, dayUsage);
+    } catch (error) {
+      console.error(`Failed to read Codex usage from file: ${path}`, error);
+    }
+  }
+  const days = [...usageByDay.values()].sort(
+    (a, b) => b.date.localeCompare(a.date)
+  );
+  return days;
+};
+const getCodexUsageDays = async (range, noCache) => {
+  if (noCache) {
+    codexUsageCache.delete(range);
+  }
+  const cached = codexUsageCache.get(range);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.days;
+  }
+  const inflight = inflightCodexUsage.get(range);
+  if (inflight) {
+    return inflight;
+  }
+  const promise = buildCodexUsageDays(range).then((days) => {
+    codexUsageCache.set(range, {
+      expiresAt: Date.now() + CODEX_USAGE_CACHE_TTL_MS,
+      days
+    });
+    return days;
+  }).finally(() => {
+    inflightCodexUsage.delete(range);
+  });
+  inflightCodexUsage.set(range, promise);
+  return promise;
+};
+const getCodexUsage = async (offset, limit, range, noCache) => {
+  const days = await getCodexUsageDays(range, noCache);
+  return {
+    data: days.slice(offset, offset + limit),
+    offset,
+    limit,
+    total: days.length,
+    isFiltered: false,
+    matchedCount: days.length,
+    resolvedURL: CODEX_USAGE_URL
+  };
+};
 const getCodexSession = async (sessionRef, offset, limit) => {
   const path = resolveCodexSessionPath(sessionRef);
   try {
@@ -718,6 +1293,29 @@ const getCodexSession = async (sessionRef, offset, limit) => {
     resolvedURL
   };
 };
+const getClaudeSession = async (sessionRef, offset, limit) => {
+  const path = resolveClaudeSessionPath(sessionRef);
+  try {
+    const fileStat = await stat(path);
+    if (!fileStat.isFile()) {
+      throw new Error("Not a file");
+    }
+  } catch (error) {
+    throw new HttpError(404, "Claude session not found");
+  }
+  const events = await loadJsonlEventsTolerant(path);
+  const relativePath = relativeClaudePath(path);
+  const resolvedURL = `${CLAUDE_SESSION_URL_PREFIX}${encodeURIComponent(relativePath)}`;
+  return {
+    data: events.slice(offset, offset + limit),
+    offset,
+    limit,
+    total: events.length,
+    isFiltered: false,
+    matchedCount: events.length,
+    resolvedURL
+  };
+};
 const readRemoteResponseBody = async (response) => {
   const chunks = [];
   let totalBytes = 0;
@@ -1146,8 +1744,35 @@ const handleBlobJsonl = async (req, res, url) => {
   const limit = normalizeLimit(url.searchParams.get("limit"), 10);
   const noCache = url.searchParams.get("noCache") === "true";
   const jmespathQuery = url.searchParams.get("jmespathQuery") ?? "";
+  const codexSearchQuery = url.searchParams.get("codexSearchQuery") ?? "";
+  const codexUsageRange = normalizeCodexUsageRange(
+    url.searchParams.get("codexUsageRange")
+  );
   if (blobURL === CODEX_SESSIONS_URL) {
-    await sendJson(req, res, 200, await getCodexSessions(offset, limit));
+    await sendJson(
+      req,
+      res,
+      200,
+      await getCodexSessions(offset, limit, codexSearchQuery)
+    );
+    return;
+  }
+  if (blobURL === CLAUDE_SESSIONS_URL) {
+    await sendJson(
+      req,
+      res,
+      200,
+      await getClaudeSessions(offset, limit, codexSearchQuery)
+    );
+    return;
+  }
+  if (blobURL === CODEX_USAGE_URL) {
+    await sendJson(
+      req,
+      res,
+      200,
+      await getCodexUsage(offset, limit, codexUsageRange, noCache)
+    );
     return;
   }
   if (blobURL.startsWith(CODEX_SESSION_URL_PREFIX)) {
@@ -1163,6 +1788,19 @@ const handleBlobJsonl = async (req, res, url) => {
     );
     return;
   }
+  if (blobURL.startsWith(CLAUDE_SESSION_URL_PREFIX)) {
+    await sendJson(
+      req,
+      res,
+      200,
+      await getClaudeSession(
+        blobURL.slice(CLAUDE_SESSION_URL_PREFIX.length),
+        offset,
+        limit
+      )
+    );
+    return;
+  }
   await sendJson(
     req,
     res,
@@ -1262,6 +1900,10 @@ const startServer = (options = {}) => {
     console.log(
       `Local Codex sessions: http://${host}:${port}/?path=codex%3Asessions`
     );
+    console.log(
+      `Local Claude sessions: http://${host}:${port}/?path=claude%3Asessions`
+    );
+    console.log(`Codex usage: http://${host}:${port}/?path=codex%3Ausage`);
   });
   return server;
 };