npm - @wukazis/euphony - Versions diffs - 0.1.45 → 0.1.46 - Mend

@wukazis/euphony 0.1.45 → 0.1.46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md +10 -2
package/dist/assets/{main-CmldcHcT.js → main-DS3CAMrw.js} +662 -486
package/dist/index.html +1 -1
package/lib/components/app/app.d.ts +23 -4
package/lib/types/common-types.d.ts +15 -2
package/lib/utils/api-manager.d.ts +6 -2
package/package.json +1 -1
package/server-dist/node-main.js +352 -17

package/dist/index.html CHANGED Viewed

@@ -13,7 +13,7 @@
     <title>Euphony: Visualize Chat Data in Your Browser</title>
     <link rel="stylesheet" href="/global.css" />
-    <script type="module" crossorigin src="/assets/main-CmldcHcT.js"></script>
+    <script type="module" crossorigin src="/assets/main-DS3CAMrw.js"></script>
   </head>
   <body>

package/lib/components/app/app.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { LitElement, PropertyValues } from 'lit';
-import { CodexSessionSummary } from '../../types/common-types';
+import { CodexSessionSummary, CodexUsageDay } from '../../types/common-types';
 import { Conversation } from '../../types/harmony-types';
 import { APIManager, BrowserAPIManager } from '../../utils/api-manager';
 import { EuphonyCodex } from '../codex/codex';
@@ -21,10 +21,13 @@ declare enum DataType {
     CONVERSATION = "conversation",
     CODEX = "codex",
     CODEX_SESSION_INDEX = "codex-session-index",
+    CODEX_USAGE = "codex-usage",
     JSON = "json"
 }
-type MenuItems = 'Load without cache' | 'Load Codex sessions' | 'Load from clipboard' | 'Load local file' | 'Editor mode' | 'Leave editor mode' | 'Filter data' | 'Preferences' | 'Code';
+type MenuItems = 'Load without cache' | 'Load Codex sessions' | 'Usage' | 'Load from clipboard' | 'Load local file' | 'Editor mode' | 'Leave editor mode' | 'Filter data' | 'Preferences' | 'Code';
+type CodexUsageRange = '7d' | '30d' | '1y';
 type ConversationViewerElement = EuphonyConversation | EuphonyCodex;
+export declare const isCodexUsageRange: (value: string) => value is CodexUsageRange;
 /**
  * App element.
  *
@@ -35,12 +38,17 @@ export declare class EuphonyApp extends LitElement {
     JSONData: Record<string, unknown>[];
     codexSessionData: unknown[][];
     codexSessionSummaries: CodexSessionSummary[];
+    codexUsageDays: CodexUsageDay[];
+    codexUsageChartDays: CodexUsageDay[];
+    codexUsageRange: CodexUsageRange;
     dataType: DataType;
     isLoadingData: boolean;
     curPage: number;
     globalIsShowingMetadata: boolean;
     globalShouldRenderMarkdown: boolean;
     jmespathQuery: string;
+    codexSearchQuery: string;
+    codexSearchInputValue: string;
     focusModeAuthor: string[];
     focusModeRecipient: string[];
     focusModeContentType: string[];
@@ -114,6 +122,7 @@ export declare class EuphonyApp extends LitElement {
     selectAllButtonClicked(): void;
     updatePageNumber(newPageNumber: number, scrollToTop: boolean): Promise<void>;
     loadCodexSessionsClicked(): Promise<void>;
+    loadCodexUsageClicked(): Promise<void>;
     openCodexSessionSummary(summary: CodexSessionSummary): Promise<void>;
     pageClicked(e: CustomEvent<number>): void;
     itemsPerPageChanged(e: CustomEvent<number>): void;
@@ -133,6 +142,10 @@ export declare class EuphonyApp extends LitElement {
     preferenceWindowTranslateAllClicked(): void;
     preferenceWindowFocusModeSettingsChanged(e: CustomEvent<FocusModeSettings>): void;
     searchWindowQuerySubmitted(e: CustomEvent<string>): Promise<void>;
+    codexSessionSearchInputChanged(e: Event): void;
+    codexSessionSearchSubmitted(e: Event): Promise<void>;
+    clearCodexSessionSearch(): Promise<void>;
+    codexUsageRangeChanged(e: Event): Promise<void>;
     /**
      * Show the token window when user clicks on the harmony render button
      * @param e CustomEvent<string> - The custom event containing the conversation string
@@ -165,21 +178,27 @@ export declare class EuphonyApp extends LitElement {
     loadDataFromFile: (sourceFile: File) => Promise<void>;
     localDataWorkerMessageHandler(e: MessageEvent<LocalDataWorkerMessage>): void;
     localFileInputChanged(e: Event): void;
-    loadData: ({ blobURL, offset, limit, showSuccessToast, noCache, jmespathQuery }: {
+    loadData: ({ blobURL, offset, limit, showSuccessToast, noCache, jmespathQuery, codexSearchQuery, codexUsageRange }: {
         blobURL: string;
         offset: number;
         limit: number;
         showSuccessToast?: boolean;
         noCache?: boolean;
         jmespathQuery?: string;
+        codexSearchQuery?: string;
+        codexUsageRange?: CodexUsageRange;
     }) => Promise<{
         isLoadDataSuccessful: boolean;
         loadDataMessage: string;
         loadedURL: string;
     }>;
-    resetFilter: (filter: "jmespath" | "concept") => Promise<void>;
+    resetFilter: (filter: "jmespath" | "codexSearch" | "concept") => Promise<void>;
     resetHash: () => void;
     buildEuphonyStyle(styleConfig: Record<string, string>): string;
+    getCodexUsageBucketKey(date: Date, range: CodexUsageRange): string;
+    getCodexUsageBucketLabel(bucketKey: string, range?: CodexUsageRange): string;
+    buildCodexUsageChartDays(): CodexUsageDay[];
+    renderCodexUsageChart(): import('lit').TemplateResult<1>;
     getConversationViewerElements(): ConversationViewerElement[];
     render(): import('lit').TemplateResult<1>;
     static styles: import('lit').CSSResult[];

package/lib/types/common-types.d.ts CHANGED Viewed

@@ -49,10 +49,23 @@ export interface CodexSessionSummary {
     timestamp: string | null;
     age_seconds: number | null;
     event_count: number;
+    token_usage: CodexTokenUsage | null;
+    usage_timestamp: string | null;
+}
+export interface CodexTokenUsage {
+    input_tokens: number;
+    cached_input_tokens: number;
+    output_tokens: number;
+    reasoning_output_tokens: number;
+    total_tokens: number;
+}
+export interface CodexUsageDay extends CodexTokenUsage {
+    date: string;
+    session_count: number;
 }
 export interface BlobJSONLPayload {
     total: number;
-    data: string[] | Conversation[] | Record<string, unknown>[] | unknown[][] | CodexSessionSummary[];
+    data: string[] | Conversation[] | Record<string, unknown>[] | unknown[][] | CodexSessionSummary[] | CodexUsageDay[];
     isFiltered: boolean;
     matchedCount: number;
     resolvedURL: string;
@@ -61,7 +74,7 @@ export interface BlobJSONLResponse {
     offset: number;
     limit: number;
     total: number;
-    data: string[] | Conversation[] | Record<string, Conversation | string>[] | unknown[][] | CodexSessionSummary[];
+    data: string[] | Conversation[] | Record<string, Conversation | string>[] | unknown[][] | CodexSessionSummary[] | CodexUsageDay[];
     isFiltered: boolean;
     matchedCount: number;
     resolvedURL: string;

package/lib/utils/api-manager.d.ts CHANGED Viewed

@@ -5,23 +5,27 @@ export declare const extractConversationFromJSONL: (data: unknown[]) => Conversa
 export declare class APIManager {
     apiBaseURL: string;
     constructor(apiBaseURL: string);
-    getJSONL: ({ blobURL, offset, limit, noCache, jmespathQuery }: {
+    getJSONL: ({ blobURL, offset, limit, noCache, jmespathQuery, codexSearchQuery, codexUsageRange }: {
         blobURL: string;
         offset: number;
         limit: number;
         noCache: boolean;
         jmespathQuery: string;
+        codexSearchQuery?: string;
+        codexUsageRange?: string;
     }) => Promise<BlobJSONLPayload>;
     refreshRendererList: () => Promise<string[]>;
     harmonyRender: (conversation: string, renderer: string) => Promise<HarmonyRenderResponse>;
 }
 export declare class BrowserAPIManager {
-    getJSONL: ({ blobURL, offset, limit, noCache, jmespathQuery }: {
+    getJSONL: ({ blobURL, offset, limit, noCache, jmespathQuery, codexSearchQuery, codexUsageRange }: {
         blobURL: string;
         offset: number;
         limit: number;
         noCache: boolean;
         jmespathQuery: string;
+        codexSearchQuery?: string;
+        codexUsageRange?: string;
     }) => Promise<BlobJSONLPayload>;
     validateOpenAIAPIKey(apiKey: string): Promise<boolean>;
     /**

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@wukazis/euphony",
   "private": false,
-  "version": "0.1.45",
+  "version": "0.1.46",
   "type": "module",
   "types": "./lib/euphony.d.ts",
   "exports": {

package/server-dist/node-main.js CHANGED Viewed

@@ -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,17 @@ 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 CODEX_SESSIONS_DIR = resolve(
   process.env.CODEX_SESSIONS_DIR ?? join(process.env.HOME ?? process.cwd(), ".codex", "sessions")
 );
 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 +458,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 +470,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}`);
@@ -498,13 +523,15 @@ 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 resolveCodexSessionPath = (sessionRef) => {
   const relativePath = decodeURIComponent(sessionRef);
@@ -522,6 +549,77 @@ 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 extractTextFromContent = (content) => {
   if (typeof content === "string") {
     const stripped = content.trim();
@@ -567,12 +665,140 @@ 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 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 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 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 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 +822,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 +844,9 @@ 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 findJsonlFiles = async (root) => {
@@ -658,7 +881,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 +894,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 +928,89 @@ 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 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 {
@@ -1146,8 +1462,26 @@ 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 === CODEX_USAGE_URL) {
+    await sendJson(
+      req,
+      res,
+      200,
+      await getCodexUsage(offset, limit, codexUsageRange, noCache)
+    );
     return;
   }
   if (blobURL.startsWith(CODEX_SESSION_URL_PREFIX)) {
@@ -1262,6 +1596,7 @@ const startServer = (options = {}) => {
     console.log(
       `Local Codex sessions: http://${host}:${port}/?path=codex%3Asessions`
     );
+    console.log(`Codex usage: http://${host}:${port}/?path=codex%3Ausage`);
   });
   return server;
 };