ccstatusline-usage 2.0.30 → 2.0.32

package/dist/ccstatusline.js

@@ -32383,8 +32383,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path6, { windows } = {}) => {
-    const segs = path6.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path7, { windows } = {}) => {
+    const segs = path7.split(windows ? /[\\/]/ : "/");
     const last = segs[segs.length - 1];
     if (last === "") {
       return segs[segs.length - 2];
@@ -50982,18 +50982,18 @@ var SettingsSchema = exports_external.object({
   version: exports_external.number().default(CURRENT_VERSION),
   lines: exports_external.array(exports_external.array(WidgetItemSchema)).min(1).default([
     [
-      { id: "session-usage", type: "custom-command", color: "brightBlue", commandPath: "$PKG/scripts/usage.sh session", timeout: 5000, label: "Session Usage" },
+      { id: "session-usage", type: "session-usage", color: "brightBlue" },
       { id: "sep1", type: "separator" },
-      { id: "weekly-usage", type: "custom-command", color: "brightBlue", commandPath: "$PKG/scripts/usage.sh weekly", timeout: 5000, label: "Weekly Usage" },
+      { id: "weekly-usage", type: "weekly-usage", color: "brightBlue" },
       { id: "sep2", type: "separator" },
-      { id: "reset-timer", type: "custom-command", color: "brightBlue", commandPath: "$PKG/scripts/usage.sh reset", timeout: 5000, label: "Reset Timer" },
+      { id: "reset-timer", type: "reset-timer", color: "brightBlue" },
       { id: "sep3", type: "separator" },
       { id: "model", type: "model", color: "magenta" },
       { id: "sep4", type: "separator" },
       { id: "session-id", type: "claude-session-id", color: "cyan" }
     ],
     [
-      { id: "context-usage", type: "custom-command", color: "blue", commandPath: "$PKG/scripts/context.sh", timeout: 5000, label: "Context Bar" }
+      { id: "context-bar", type: "context-bar", color: "blue" }
     ],
     []
   ]),
@@ -51450,7 +51450,7 @@ import { execSync as execSync3 } from "child_process";
 import * as fs5 from "fs";
 import * as path4 from "path";
 var __dirname = "/Users/peter/Documents/Code/ccstatusline-usage/src/utils";
-var PACKAGE_VERSION = "2.0.30";
+var PACKAGE_VERSION = "2.0.32";
 function getPackageVersion() {
   if (/^\d+\.\d+\.\d+/.test(PACKAGE_VERSION)) {
     return PACKAGE_VERSION;
@@ -53814,11 +53814,14 @@ var CustomTextEditor = ({ widget, onComplete, onCancel }) => {
 import { execSync as execSync7 } from "child_process";
 import * as fs6 from "fs";
 var import_react30 = __toESM(require_react(), 1);
-var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
 import * as path5 from "path";
+var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
 function getPackageDir() {
-  const scriptPath = process.argv[1];
-  if (scriptPath) {
+  const scriptPaths = [
+    process.argv[1],
+    __require.main?.filename
+  ].filter(Boolean);
+  for (const scriptPath of scriptPaths) {
     try {
       const realPath = fs6.realpathSync(scriptPath);
       let dir = path5.dirname(realPath);
@@ -53859,6 +53862,30 @@ function getPackageDir() {
       } catch {}
     }
   }
+  const globalPaths = [
+    "/usr/local/lib/node_modules/ccstatusline-usage",
+    "/usr/lib/node_modules/ccstatusline-usage",
+    path5.join(home, ".nvm", "versions", "node"),
+    path5.join(home, "node_modules", "ccstatusline-usage"),
+    path5.join(home, ".local", "lib", "node_modules", "ccstatusline-usage")
+  ];
+  for (const globalPath of globalPaths) {
+    if (globalPath.includes(".nvm")) {
+      try {
+        if (fs6.existsSync(globalPath)) {
+          const versions2 = fs6.readdirSync(globalPath);
+          for (const ver of versions2) {
+            const pkgDir = path5.join(globalPath, ver, "lib", "node_modules", "ccstatusline-usage");
+            if (fs6.existsSync(path5.join(pkgDir, "scripts", "usage.sh"))) {
+              return pkgDir;
+            }
+          }
+        }
+      } catch {}
+    } else if (fs6.existsSync(path5.join(globalPath, "scripts", "usage.sh"))) {
+      return globalPath;
+    }
+  }
   return "";
 }
 var PKG_DIR = getPackageDir();
@@ -54459,6 +54486,220 @@ class ClaudeSessionIdWidget {
     return true;
   }
 }
+// src/widgets/ApiUsage.tsx
+import { execSync as execSync8 } from "child_process";
+import * as fs7 from "fs";
+import * as path6 from "path";
+var CACHE_FILE = path6.join(process.env.HOME ?? "", ".cache", "ccstatusline-api.json");
+var CACHE_MAX_AGE = 180;
+var cachedData = null;
+var cacheTime = 0;
+function getToken() {
+  try {
+    const isMac = process.platform === "darwin";
+    if (isMac) {
+      const result = execSync8('security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null', { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      const parsed = JSON.parse(result);
+      return parsed?.claudeAiOauth?.accessToken ?? null;
+    } else {
+      const credFile = path6.join(process.env.HOME ?? "", ".claude", ".credentials.json");
+      if (fs7.existsSync(credFile)) {
+        const creds = JSON.parse(fs7.readFileSync(credFile, "utf8"));
+        return creds?.claudeAiOauth?.accessToken ?? null;
+      }
+    }
+  } catch {}
+  return null;
+}
+function fetchApiData() {
+  const now = Math.floor(Date.now() / 1000);
+  if (cachedData && now - cacheTime < CACHE_MAX_AGE) {
+    return cachedData;
+  }
+  try {
+    if (fs7.existsSync(CACHE_FILE)) {
+      const stat = fs7.statSync(CACHE_FILE);
+      const fileAge = now - Math.floor(stat.mtimeMs / 1000);
+      if (fileAge < CACHE_MAX_AGE) {
+        cachedData = JSON.parse(fs7.readFileSync(CACHE_FILE, "utf8"));
+        cacheTime = now;
+        return cachedData;
+      }
+    }
+  } catch {}
+  const token = getToken();
+  if (!token)
+    return null;
+  try {
+    const result = execSync8(`curl -s -H "Authorization: Bearer ${token}" "https://api.claude.ai/api/organizations/me/rate_limits"`, { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+    const data = JSON.parse(result);
+    let apiData = {};
+    for (const item of data) {
+      if (item.type === "daily") {
+        apiData.dailyLimit = item.limit;
+        apiData.dailyUsage = item.usage;
+        apiData.lastResetAt = item.resetAt;
+      } else if (item.type === "weekly") {
+        apiData.weeklyLimit = item.limit;
+        apiData.weeklyUsage = item.usage;
+      }
+    }
+    try {
+      const cacheDir = path6.dirname(CACHE_FILE);
+      if (!fs7.existsSync(cacheDir)) {
+        fs7.mkdirSync(cacheDir, { recursive: true });
+      }
+      fs7.writeFileSync(CACHE_FILE, JSON.stringify(apiData));
+    } catch {}
+    cachedData = apiData;
+    cacheTime = now;
+    return apiData;
+  } catch {
+    return null;
+  }
+}
+function makeProgressBar(percent, width = 15) {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  return "[" + "█".repeat(filled) + "░".repeat(empty) + "]";
+}
+
+class SessionUsageWidget {
+  getDefaultColor() {
+    return "brightBlue";
+  }
+  getDescription() {
+    return "Shows daily/session API usage percentage";
+  }
+  getDisplayName() {
+    return "Session Usage";
+  }
+  getEditorDisplay() {
+    return { displayText: this.getDisplayName() };
+  }
+  render(item, context) {
+    if (context.isPreview)
+      return "Session: [███░░░░░░░░░░░░] 20%";
+    const data = fetchApiData();
+    if (!data || data.dailyLimit === undefined || data.dailyUsage === undefined) {
+      return null;
+    }
+    const percent = data.dailyUsage / data.dailyLimit * 100;
+    return `Session: ${makeProgressBar(percent)} ${percent.toFixed(1)}%`;
+  }
+  supportsRawValue() {
+    return false;
+  }
+  supportsColors() {
+    return true;
+  }
+}
+
+class WeeklyUsageWidget {
+  getDefaultColor() {
+    return "brightBlue";
+  }
+  getDescription() {
+    return "Shows weekly API usage percentage";
+  }
+  getDisplayName() {
+    return "Weekly Usage";
+  }
+  getEditorDisplay() {
+    return { displayText: this.getDisplayName() };
+  }
+  render(item, context) {
+    if (context.isPreview)
+      return "Weekly: [██░░░░░░░░░░░░░] 12%";
+    const data = fetchApiData();
+    if (!data || data.weeklyLimit === undefined || data.weeklyUsage === undefined) {
+      return null;
+    }
+    const percent = data.weeklyUsage / data.weeklyLimit * 100;
+    return `Weekly: ${makeProgressBar(percent)} ${percent.toFixed(1)}%`;
+  }
+  supportsRawValue() {
+    return false;
+  }
+  supportsColors() {
+    return true;
+  }
+}
+
+class ResetTimerWidget {
+  getDefaultColor() {
+    return "brightBlue";
+  }
+  getDescription() {
+    return "Shows time until daily limit reset";
+  }
+  getDisplayName() {
+    return "Reset Timer";
+  }
+  getEditorDisplay() {
+    return { displayText: this.getDisplayName() };
+  }
+  render(item, context) {
+    if (context.isPreview)
+      return "4:30 hr";
+    const data = fetchApiData();
+    if (!data || !data.lastResetAt) {
+      return null;
+    }
+    try {
+      const resetTime = new Date(data.lastResetAt).getTime();
+      const now = Date.now();
+      const diffMs = resetTime - now;
+      if (diffMs <= 0)
+        return "0:00 hr";
+      const hours = Math.floor(diffMs / (1000 * 60 * 60));
+      const minutes = Math.floor(diffMs % (1000 * 60 * 60) / (1000 * 60));
+      return `${hours}:${minutes.toString().padStart(2, "0")} hr`;
+    } catch {
+      return null;
+    }
+  }
+  supportsRawValue() {
+    return false;
+  }
+  supportsColors() {
+    return true;
+  }
+}
+
+class ContextBarWidget {
+  getDefaultColor() {
+    return "blue";
+  }
+  getDescription() {
+    return "Shows context usage as a progress bar";
+  }
+  getDisplayName() {
+    return "Context Bar";
+  }
+  getEditorDisplay() {
+    return { displayText: this.getDisplayName() };
+  }
+  render(item, context) {
+    if (context.isPreview)
+      return "Context: [████░░░░░░░░░░░] 50k/200k (25%)";
+    const cw = context.data?.context_window;
+    if (!cw)
+      return null;
+    const total = cw.context_window_size ?? 200000;
+    const used = cw.current_usage ?? 0;
+    const percent = total > 0 ? used / total * 100 : 0;
+    const usedK = Math.round(used / 1000);
+    const totalK = Math.round(total / 1000);
+    return `Context: ${makeProgressBar(percent)} ${usedK}k/${totalK}k (${Math.round(percent)}%)`;
+  }
+  supportsRawValue() {
+    return false;
+  }
+  supportsColors() {
+    return true;
+  }
+}
 // src/utils/widgets.ts
 var widgetRegistry = new Map([
   ["model", new ModelWidget],
@@ -54481,7 +54722,11 @@ var widgetRegistry = new Map([
   ["version", new VersionWidget],
   ["custom-text", new CustomTextWidget],
   ["custom-command", new CustomCommandWidget],
-  ["claude-session-id", new ClaudeSessionIdWidget]
+  ["claude-session-id", new ClaudeSessionIdWidget],
+  ["session-usage", new SessionUsageWidget],
+  ["weekly-usage", new WeeklyUsageWidget],
+  ["reset-timer", new ResetTimerWidget],
+  ["context-bar", new ContextBarWidget]
 ]);
 function getWidget(type) {
   return widgetRegistry.get(type) ?? null;
@@ -58300,42 +58545,42 @@ var StatusJSONSchema = exports_external.looseObject({
 });
 
 // src/utils/jsonl.ts
-import * as fs7 from "fs";
-import path7 from "node:path";
+import * as fs8 from "fs";
+import path8 from "node:path";
 
 // node_modules/tinyglobby/dist/index.mjs
-import path6, { posix } from "path";
+import path7, { posix } from "path";
 
 // node_modules/fdir/dist/index.mjs
 import { createRequire as createRequire2 } from "module";
-import { basename as basename2, dirname as dirname3, normalize, relative, resolve as resolve2, sep } from "path";
+import { basename as basename2, dirname as dirname4, normalize, relative, resolve as resolve2, sep } from "path";
 import * as nativeFs from "fs";
 var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
-function cleanPath(path6) {
-  let normalized = normalize(path6);
+function cleanPath(path7) {
+  let normalized = normalize(path7);
   if (normalized.length > 1 && normalized[normalized.length - 1] === sep)
     normalized = normalized.substring(0, normalized.length - 1);
   return normalized;
 }
 var SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path6, separator) {
-  return path6.replace(SLASHES_REGEX, separator);
+function convertSlashes(path7, separator) {
+  return path7.replace(SLASHES_REGEX, separator);
 }
 var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path6) {
-  return path6 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path6);
+function isRootDirectory(path7) {
+  return path7 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path7);
 }
-function normalizePath(path6, options) {
+function normalizePath(path7, options) {
   const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-  const pathNeedsCleaning = process.platform === "win32" && path6.includes("/") || path6.startsWith(".");
+  const pathNeedsCleaning = process.platform === "win32" && path7.includes("/") || path7.startsWith(".");
   if (resolvePaths)
-    path6 = resolve2(path6);
+    path7 = resolve2(path7);
   if (normalizePath$1 || pathNeedsCleaning)
-    path6 = cleanPath(path6);
-  if (path6 === ".")
+    path7 = cleanPath(path7);
+  if (path7 === ".")
     return "";
-  const needsSeperator = path6[path6.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path6 + pathSeparator : path6, pathSeparator);
+  const needsSeperator = path7[path7.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path7 + pathSeparator : path7, pathSeparator);
 }
 function joinPathWithBasePath(filename, directoryPath) {
   return directoryPath + filename;
@@ -58375,9 +58620,9 @@ var pushDirectory = (directoryPath, paths) => {
   paths.push(directoryPath || ".");
 };
 var pushDirectoryFilter = (directoryPath, paths, filters) => {
-  const path6 = directoryPath || ".";
-  if (filters.every((filter) => filter(path6, true)))
-    paths.push(path6);
+  const path7 = directoryPath || ".";
+  if (filters.every((filter) => filter(path7, true)))
+    paths.push(path7);
 };
 var empty$2 = () => {};
 function build$6(root, options) {
@@ -58434,29 +58679,29 @@ var empty = () => {};
 function build$3(options) {
   return options.group ? groupFiles : empty;
 }
-var resolveSymlinksAsync = function(path6, state, callback$1) {
-  const { queue, fs: fs7, options: { suppressErrors } } = state;
+var resolveSymlinksAsync = function(path7, state, callback$1) {
+  const { queue, fs: fs8, options: { suppressErrors } } = state;
   queue.enqueue();
-  fs7.realpath(path6, (error43, resolvedPath) => {
+  fs8.realpath(path7, (error43, resolvedPath) => {
     if (error43)
       return queue.dequeue(suppressErrors ? null : error43, state);
-    fs7.stat(resolvedPath, (error$1, stat) => {
+    fs8.stat(resolvedPath, (error$1, stat) => {
       if (error$1)
         return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat.isDirectory() && isRecursive(path6, resolvedPath, state))
+      if (stat.isDirectory() && isRecursive(path7, resolvedPath, state))
         return queue.dequeue(null, state);
       callback$1(stat, resolvedPath);
       queue.dequeue(null, state);
     });
   });
 };
-var resolveSymlinks = function(path6, state, callback$1) {
-  const { queue, fs: fs7, options: { suppressErrors } } = state;
+var resolveSymlinks = function(path7, state, callback$1) {
+  const { queue, fs: fs8, options: { suppressErrors } } = state;
   queue.enqueue();
   try {
-    const resolvedPath = fs7.realpathSync(path6);
-    const stat = fs7.statSync(resolvedPath);
-    if (stat.isDirectory() && isRecursive(path6, resolvedPath, state))
+    const resolvedPath = fs8.realpathSync(path7);
+    const stat = fs8.statSync(resolvedPath);
+    if (stat.isDirectory() && isRecursive(path7, resolvedPath, state))
       return;
     callback$1(stat, resolvedPath);
   } catch (e) {
@@ -58469,10 +58714,10 @@ function build$2(options, isSynchronous) {
     return null;
   return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path6, resolved, state) {
+function isRecursive(path7, resolved, state) {
   if (state.options.useRealPaths)
     return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname3(path6);
+  let parent = dirname4(path7);
   let depth = 1;
   while (parent !== state.root && depth < 2) {
     const resolvedPath = state.symlinks.get(parent);
@@ -58480,9 +58725,9 @@ function isRecursive(path6, resolved, state) {
     if (isSameRoot)
       depth++;
     else
-      parent = dirname3(parent);
+      parent = dirname4(parent);
   }
-  state.symlinks.set(path6, resolved);
+  state.symlinks.set(path7, resolved);
   return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
@@ -58538,23 +58783,23 @@ var walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
   state.queue.enqueue();
   if (currentDepth < 0)
     return state.queue.dequeue(null, state);
-  const { fs: fs7 } = state;
+  const { fs: fs8 } = state;
   state.visited.push(crawlPath);
   state.counts.directories++;
-  fs7.readdir(crawlPath || ".", readdirOpts, (error43, entries = []) => {
+  fs8.readdir(crawlPath || ".", readdirOpts, (error43, entries = []) => {
     callback$1(entries, directoryPath, currentDepth);
     state.queue.dequeue(state.options.suppressErrors ? null : error43, state);
   });
 };
 var walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  const { fs: fs7 } = state;
+  const { fs: fs8 } = state;
   if (currentDepth < 0)
     return;
   state.visited.push(crawlPath);
   state.counts.directories++;
   let entries = [];
   try {
-    entries = fs7.readdirSync(crawlPath || ".", readdirOpts);
+    entries = fs8.readdirSync(crawlPath || ".", readdirOpts);
   } catch (e) {
     if (!state.options.suppressErrors)
       throw e;
@@ -58660,23 +58905,23 @@ var Walker = class {
         const filename = this.joinPath(entry.name, directoryPath);
         this.pushFile(filename, files, this.state.counts, filters);
       } else if (entry.isDirectory()) {
-        let path6 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path6))
+        let path7 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path7))
           continue;
-        this.pushDirectory(path6, paths, filters);
-        this.walkDirectory(this.state, path6, path6, depth - 1, this.walk);
+        this.pushDirectory(path7, paths, filters);
+        this.walkDirectory(this.state, path7, path7, depth - 1, this.walk);
       } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-        let path6 = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path6, this.state, (stat, resolvedPath) => {
+        let path7 = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path7, this.state, (stat, resolvedPath) => {
           if (stat.isDirectory()) {
             resolvedPath = normalizePath(resolvedPath, this.state.options);
-            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path6 + pathSeparator))
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path7 + pathSeparator))
               return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path6 + pathSeparator, depth - 1, this.walk);
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path7 + pathSeparator, depth - 1, this.walk);
           } else {
-            resolvedPath = useRealPaths ? resolvedPath : path6;
+            resolvedPath = useRealPaths ? resolvedPath : path7;
             const filename = basename2(resolvedPath);
-            const directoryPath$1 = normalizePath(dirname3(resolvedPath), this.state.options);
+            const directoryPath$1 = normalizePath(dirname4(resolvedPath), this.state.options);
             resolvedPath = this.joinPath(filename, directoryPath$1);
             this.pushFile(resolvedPath, files, this.state.counts, filters);
           }
@@ -58834,7 +59079,7 @@ var Builder = class {
       isMatch = globFn(patterns, ...options);
       this.globCache[patterns.join("\x00")] = isMatch;
     }
-    this.options.filters.push((path6) => isMatch(path6));
+    this.options.filters.push((path7) => isMatch(path7));
     return this;
   }
 };
@@ -58913,7 +59158,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
   if (!result.endsWith("*") && expandDirectories)
     result += "/**";
   const escapedCwd = escapePath(cwd2);
-  if (path6.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")))
+  if (path7.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")))
     result = posix.relative(escapedCwd, result);
   else
     result = posix.normalize(result);
@@ -58950,7 +59195,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
     }
     props.depthOffset = newCommonPath.length;
     props.commonPath = newCommonPath;
-    props.root = newCommonPath.length > 0 ? path6.posix.join(cwd2, ...newCommonPath) : cwd2;
+    props.root = newCommonPath.length > 0 ? path7.posix.join(cwd2, ...newCommonPath) : cwd2;
   }
   return result;
 }
@@ -59083,18 +59328,18 @@ function globSync(patternsOrOptions, options) {
     ...options,
     patterns: patternsOrOptions
   } : patternsOrOptions;
-  const cwd2 = opts.cwd ? path6.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+  const cwd2 = opts.cwd ? path7.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
   return crawl(opts, cwd2, true);
 }
 
 // src/utils/jsonl.ts
 import { promisify } from "util";
-var readFile4 = promisify(fs7.readFile);
-var readFileSync5 = fs7.readFileSync;
-var statSync4 = fs7.statSync;
+var readFile4 = promisify(fs8.readFile);
+var readFileSync6 = fs8.readFileSync;
+var statSync5 = fs8.statSync;
 async function getSessionDuration(transcriptPath) {
   try {
-    if (!fs7.existsSync(transcriptPath)) {
+    if (!fs8.existsSync(transcriptPath)) {
       return null;
     }
     const content = await readFile4(transcriptPath, "utf-8");
@@ -59146,7 +59391,7 @@ async function getSessionDuration(transcriptPath) {
 }
 async function getTokenMetrics(transcriptPath) {
   try {
-    if (!fs7.existsSync(transcriptPath)) {
+    if (!fs8.existsSync(transcriptPath)) {
       return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
     }
     const content = await readFile4(transcriptPath, "utf-8");
@@ -59199,7 +59444,7 @@ function getBlockMetrics() {
 function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
   const sessionDurationMs = sessionDurationHours * 60 * 60 * 1000;
   const now = new Date;
-  const pattern = path7.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
+  const pattern = path8.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
   const files = globSync([pattern], {
     absolute: true,
     cwd: rootDir
@@ -59207,7 +59452,7 @@ function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
   if (files.length === 0)
     return null;
   const filesWithStats = files.map((file2) => {
-    const stats = statSync4(file2);
+    const stats = statSync5(file2);
     return { file: file2, mtime: stats.mtime };
   });
   filesWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
@@ -59293,7 +59538,7 @@ function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
 function getAllTimestampsFromFile(filePath) {
   const timestamps = [];
   try {
-    const content = readFileSync5(filePath, "utf-8");
+    const content = readFileSync6(filePath, "utf-8");
     const lines = content.trim().split(`
 `).filter((line) => line.length > 0);
     for (const line of lines) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccstatusline-usage",
-  "version": "2.0.30",
+  "version": "2.0.32",
   "description": "A customizable status line formatter for Claude Code CLI",
   "module": "src/ccstatusline.ts",
   "type": "module",