ccstatusline-usage 2.0.40 → 2.0.41

package/README.md

@@ -40,7 +40,7 @@ Session: [████░░░░░░░░░░░] 27.0% | Weekly: [██
   Context: [███████░░░░░░░░] 103k/200k (51%)
 ```
 
-To use the enhanced configuration, copy `defaults/settings-enhanced.json` to your config directory.
+These widgets are enabled by default. Just install and run!
 
 ![Status Bar Demo](screenshots/status-bar-demo.png)
 

package/dist/ccstatusline.js

@@ -32383,8 +32383,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path7, { windows } = {}) => {
-    const segs = path7.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path6, { windows } = {}) => {
+    const segs = path6.split(windows ? /[\\/]/ : "/");
     const last = segs[segs.length - 1];
     if (last === "") {
       return segs[segs.length - 2];
@@ -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.40";
+var PACKAGE_VERSION = "2.0.41";
 function getPackageVersion() {
   if (/^\d+\.\d+\.\d+/.test(PACKAGE_VERSION)) {
     return PACKAGE_VERSION;
@@ -53812,83 +53812,8 @@ var CustomTextEditor = ({ widget, onComplete, onCancel }) => {
 };
 // src/widgets/CustomCommand.tsx
 import { execSync as execSync7 } from "child_process";
-import * as fs6 from "fs";
 var import_react30 = __toESM(require_react(), 1);
-import * as path5 from "path";
 var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
-function getPackageDir() {
-  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);
-      for (let i = 0;i < 10; i++) {
-        const pkgJson = path5.join(dir, "package.json");
-        if (fs6.existsSync(pkgJson)) {
-          try {
-            const pkg = JSON.parse(fs6.readFileSync(pkgJson, "utf8"));
-            if (pkg.name === "ccstatusline-usage") {
-              return dir;
-            }
-          } catch {}
-        }
-        const scriptsDir = path5.join(dir, "scripts");
-        if (fs6.existsSync(path5.join(scriptsDir, "usage.sh"))) {
-          return dir;
-        }
-        dir = path5.dirname(dir);
-      }
-    } catch {}
-  }
-  const home = process.env.HOME ?? "";
-  const npxPaths = [
-    path5.join(home, ".npm", "_npx"),
-    path5.join(home, ".cache", "npm", "_npx"),
-    path5.join(home, ".local", "share", "npm", "_npx")
-  ];
-  for (const npxBase of npxPaths) {
-    if (fs6.existsSync(npxBase)) {
-      try {
-        const entries = fs6.readdirSync(npxBase);
-        for (const entry of entries) {
-          const pkgDir = path5.join(npxBase, entry, "node_modules", "ccstatusline-usage");
-          if (fs6.existsSync(path5.join(pkgDir, "scripts", "usage.sh"))) {
-            return pkgDir;
-          }
-        }
-      } 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();
 
 class CustomCommandWidget {
   getDefaultColor() {
@@ -53901,11 +53826,9 @@ class CustomCommandWidget {
     return "Custom Command";
   }
   getEditorDisplay(item) {
-    const displayText = item.label ? item.label : (() => {
-      const cmd = item.commandPath ?? "No command";
-      const truncatedCmd = cmd.length > 20 ? `${cmd.substring(0, 17)}...` : cmd;
-      return `${this.getDisplayName()} (${truncatedCmd})`;
-    })();
+    const cmd = item.commandPath ?? "No command";
+    const truncatedCmd = cmd.length > 20 ? `${cmd.substring(0, 17)}...` : cmd;
+    const displayText = `${this.getDisplayName()} (${truncatedCmd})`;
     const modifiers = [];
     if (item.maxWidth) {
       modifiers.push(`max:${item.maxWidth}`);
@@ -53927,17 +53850,6 @@ class CustomCommandWidget {
     }
     return null;
   }
-  resolveCommandPath(commandPath) {
-    if (commandPath.startsWith("$PKG/") || commandPath.startsWith("$PACKAGE_DIR/")) {
-      const relativePath = commandPath.replace(/^\$(PKG|PACKAGE_DIR)\//, "");
-      const resolved = path5.join(PKG_DIR, relativePath);
-      return resolved;
-    }
-    if (commandPath.startsWith("$HOME/")) {
-      return commandPath.replace("$HOME", process.env.HOME ?? "~");
-    }
-    return commandPath;
-  }
   render(item, context, settings) {
     if (context.isPreview) {
       return item.commandPath ? `[cmd: ${item.commandPath.substring(0, 20)}${item.commandPath.length > 20 ? "..." : ""}]` : "[No command]";
@@ -53945,8 +53857,7 @@ class CustomCommandWidget {
       try {
         const timeout = item.timeout ?? 1000;
         const jsonInput = JSON.stringify(context.data);
-        const resolvedPath = this.resolveCommandPath(item.commandPath);
-        let output = execSync7(resolvedPath, {
+        let output = execSync7(item.commandPath, {
           encoding: "utf8",
           input: jsonInput,
           timeout,
@@ -54367,13 +54278,13 @@ class CurrentWorkingDirWidget {
   supportsColors(item) {
     return true;
   }
-  abbreviatePath(path6) {
+  abbreviatePath(path5) {
     const homeDir = os5.homedir();
-    const useBackslash = path6.includes("\\") && !path6.includes("/");
+    const useBackslash = path5.includes("\\") && !path5.includes("/");
     const sep = useBackslash ? "\\" : "/";
-    let normalizedPath = path6;
-    if (path6.startsWith(homeDir)) {
-      normalizedPath = "~" + path6.slice(homeDir.length);
+    let normalizedPath = path5;
+    if (path5.startsWith(homeDir)) {
+      normalizedPath = "~" + path5.slice(homeDir.length);
     }
     const parts = normalizedPath.split(/[\\/]+/).filter((part) => part !== "");
     const abbreviated = parts.map((part, index) => {
@@ -54487,14 +54398,11 @@ class ClaudeSessionIdWidget {
   }
 }
 // src/widgets/ApiUsage.tsx
-import {
-  execSync as execSync8,
-  spawnSync
-} 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 LOCK_FILE = path6.join(process.env.HOME ?? "", ".cache", "ccstatusline-api.lock");
+import { execSync as execSync8, spawnSync } from "child_process";
+import * as fs6 from "fs";
+import * as path5 from "path";
+var CACHE_FILE = path5.join(process.env.HOME ?? "", ".cache", "ccstatusline-api.json");
+var LOCK_FILE = path5.join(process.env.HOME ?? "", ".cache", "ccstatusline-api.lock");
 var CACHE_MAX_AGE = 180;
 var LOCK_MAX_AGE = 30;
 var TOKEN_CACHE_MAX_AGE = 3600;
@@ -54519,8 +54427,8 @@ function getToken() {
       }
       return token;
     } else {
-      const credFile = path6.join(process.env.HOME ?? "", ".claude", ".credentials.json");
-      const creds = JSON.parse(fs7.readFileSync(credFile, "utf8"));
+      const credFile = path5.join(process.env.HOME ?? "", ".claude", ".credentials.json");
+      const creds = JSON.parse(fs6.readFileSync(credFile, "utf8"));
       const token = creds?.claudeAiOauth?.accessToken ?? null;
       if (token) {
         cachedToken = token;
@@ -54534,21 +54442,59 @@ function getToken() {
 }
 function readStaleCache() {
   try {
-    return JSON.parse(fs7.readFileSync(CACHE_FILE, "utf8"));
+    return JSON.parse(fs6.readFileSync(CACHE_FILE, "utf8"));
   } catch {
     return null;
   }
 }
+function fetchFromApi(token) {
+  const script = `
+        const https = require('https');
+        const options = {
+            hostname: 'api.anthropic.com',
+            path: '/api/oauth/usage',
+            method: 'GET',
+            headers: {
+                'Authorization': 'Bearer ' + process.env.TOKEN,
+                'anthropic-beta': 'oauth-2025-04-20'
+            },
+            timeout: 5000
+        };
+        const req = https.request(options, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                if (res.statusCode === 200) {
+                    process.stdout.write(data);
+                } else {
+                    process.exit(1);
+                }
+            });
+        });
+        req.on('error', () => process.exit(1));
+        req.on('timeout', () => { req.destroy(); process.exit(1); });
+        req.end();
+    `;
+  const result = spawnSync("node", ["-e", script], {
+    encoding: "utf8",
+    timeout: 6000,
+    env: { ...process.env, TOKEN: token }
+  });
+  if (result.error || result.status !== 0 || !result.stdout) {
+    return null;
+  }
+  return result.stdout;
+}
 function fetchApiData() {
   const now = Math.floor(Date.now() / 1000);
   if (cachedData && !cachedData.error && now - cacheTime < CACHE_MAX_AGE) {
     return cachedData;
   }
   try {
-    const stat = fs7.statSync(CACHE_FILE);
+    const stat = fs6.statSync(CACHE_FILE);
     const fileAge = now - Math.floor(stat.mtimeMs / 1000);
     if (fileAge < CACHE_MAX_AGE) {
-      const fileData = JSON.parse(fs7.readFileSync(CACHE_FILE, "utf8"));
+      const fileData = JSON.parse(fs6.readFileSync(CACHE_FILE, "utf8"));
       if (!fileData.error) {
         cachedData = fileData;
         cacheTime = now;
@@ -54557,7 +54503,7 @@ function fetchApiData() {
     }
   } catch {}
   try {
-    const lockStat = fs7.statSync(LOCK_FILE);
+    const lockStat = fs6.statSync(LOCK_FILE);
     const lockAge = now - Math.floor(lockStat.mtimeMs / 1000);
     if (lockAge < LOCK_MAX_AGE) {
       const stale = readStaleCache();
@@ -54567,11 +54513,11 @@ function fetchApiData() {
     }
   } catch {}
   try {
-    const lockDir = path6.dirname(LOCK_FILE);
-    if (!fs7.existsSync(lockDir)) {
-      fs7.mkdirSync(lockDir, { recursive: true });
+    const lockDir = path5.dirname(LOCK_FILE);
+    if (!fs6.existsSync(lockDir)) {
+      fs6.mkdirSync(lockDir, { recursive: true });
     }
-    fs7.writeFileSync(LOCK_FILE, "");
+    fs6.writeFileSync(LOCK_FILE, "");
   } catch {}
   const token = getToken();
   if (!token) {
@@ -54581,23 +54527,14 @@ function fetchApiData() {
     return { error: "no-credentials" };
   }
   try {
-    const curlResult = spawnSync("curl", [
-      "-s",
-      "--max-time",
-      "5",
-      "https://api.anthropic.com/api/oauth/usage",
-      "-H",
-      `Authorization: Bearer ${token}`,
-      "-H",
-      "anthropic-beta: oauth-2025-04-20"
-    ], { encoding: "utf8", timeout: 6000 });
-    if (curlResult.error || curlResult.status !== 0 || !curlResult.stdout) {
+    const response = fetchFromApi(token);
+    if (!response) {
       const stale = readStaleCache();
       if (stale && !stale.error)
         return stale;
       return { error: "api-error" };
     }
-    const data = JSON.parse(curlResult.stdout);
+    const data = JSON.parse(response);
     const apiData = {};
     if (data.five_hour) {
       apiData.sessionUsage = data.five_hour.utilization;
@@ -54613,11 +54550,11 @@ function fetchApiData() {
       return { error: "parse-error" };
     }
     try {
-      const cacheDir = path6.dirname(CACHE_FILE);
-      if (!fs7.existsSync(cacheDir)) {
-        fs7.mkdirSync(cacheDir, { recursive: true });
+      const cacheDir = path5.dirname(CACHE_FILE);
+      if (!fs6.existsSync(cacheDir)) {
+        fs6.mkdirSync(cacheDir, { recursive: true });
       }
-      fs7.writeFileSync(CACHE_FILE, JSON.stringify(apiData));
+      fs6.writeFileSync(CACHE_FILE, JSON.stringify(apiData));
     } catch {}
     cachedData = apiData;
     cacheTime = now;
@@ -58639,42 +58576,42 @@ var StatusJSONSchema = exports_external.looseObject({
 });
 
 // src/utils/jsonl.ts
-import * as fs8 from "fs";
-import path8 from "node:path";
+import * as fs7 from "fs";
+import path7 from "node:path";
 
 // node_modules/tinyglobby/dist/index.mjs
-import path7, { posix } from "path";
+import path6, { posix } from "path";
 
 // node_modules/fdir/dist/index.mjs
 import { createRequire as createRequire2 } from "module";
-import { basename as basename2, dirname as dirname4, normalize, relative, resolve as resolve2, sep } from "path";
+import { basename as basename2, dirname as dirname3, normalize, relative, resolve as resolve2, sep } from "path";
 import * as nativeFs from "fs";
 var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
-function cleanPath(path7) {
-  let normalized = normalize(path7);
+function cleanPath(path6) {
+  let normalized = normalize(path6);
   if (normalized.length > 1 && normalized[normalized.length - 1] === sep)
     normalized = normalized.substring(0, normalized.length - 1);
   return normalized;
 }
 var SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path7, separator) {
-  return path7.replace(SLASHES_REGEX, separator);
+function convertSlashes(path6, separator) {
+  return path6.replace(SLASHES_REGEX, separator);
 }
 var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path7) {
-  return path7 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path7);
+function isRootDirectory(path6) {
+  return path6 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path6);
 }
-function normalizePath(path7, options) {
+function normalizePath(path6, options) {
   const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-  const pathNeedsCleaning = process.platform === "win32" && path7.includes("/") || path7.startsWith(".");
+  const pathNeedsCleaning = process.platform === "win32" && path6.includes("/") || path6.startsWith(".");
   if (resolvePaths)
-    path7 = resolve2(path7);
+    path6 = resolve2(path6);
   if (normalizePath$1 || pathNeedsCleaning)
-    path7 = cleanPath(path7);
-  if (path7 === ".")
+    path6 = cleanPath(path6);
+  if (path6 === ".")
     return "";
-  const needsSeperator = path7[path7.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path7 + pathSeparator : path7, pathSeparator);
+  const needsSeperator = path6[path6.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path6 + pathSeparator : path6, pathSeparator);
 }
 function joinPathWithBasePath(filename, directoryPath) {
   return directoryPath + filename;
@@ -58714,9 +58651,9 @@ var pushDirectory = (directoryPath, paths) => {
   paths.push(directoryPath || ".");
 };
 var pushDirectoryFilter = (directoryPath, paths, filters) => {
-  const path7 = directoryPath || ".";
-  if (filters.every((filter) => filter(path7, true)))
-    paths.push(path7);
+  const path6 = directoryPath || ".";
+  if (filters.every((filter) => filter(path6, true)))
+    paths.push(path6);
 };
 var empty$2 = () => {};
 function build$6(root, options) {
@@ -58773,29 +58710,29 @@ var empty = () => {};
 function build$3(options) {
   return options.group ? groupFiles : empty;
 }
-var resolveSymlinksAsync = function(path7, state, callback$1) {
-  const { queue, fs: fs8, options: { suppressErrors } } = state;
+var resolveSymlinksAsync = function(path6, state, callback$1) {
+  const { queue, fs: fs7, options: { suppressErrors } } = state;
   queue.enqueue();
-  fs8.realpath(path7, (error43, resolvedPath) => {
+  fs7.realpath(path6, (error43, resolvedPath) => {
     if (error43)
       return queue.dequeue(suppressErrors ? null : error43, state);
-    fs8.stat(resolvedPath, (error$1, stat) => {
+    fs7.stat(resolvedPath, (error$1, stat) => {
       if (error$1)
         return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat.isDirectory() && isRecursive(path7, resolvedPath, state))
+      if (stat.isDirectory() && isRecursive(path6, resolvedPath, state))
         return queue.dequeue(null, state);
       callback$1(stat, resolvedPath);
       queue.dequeue(null, state);
     });
   });
 };
-var resolveSymlinks = function(path7, state, callback$1) {
-  const { queue, fs: fs8, options: { suppressErrors } } = state;
+var resolveSymlinks = function(path6, state, callback$1) {
+  const { queue, fs: fs7, options: { suppressErrors } } = state;
   queue.enqueue();
   try {
-    const resolvedPath = fs8.realpathSync(path7);
-    const stat = fs8.statSync(resolvedPath);
-    if (stat.isDirectory() && isRecursive(path7, resolvedPath, state))
+    const resolvedPath = fs7.realpathSync(path6);
+    const stat = fs7.statSync(resolvedPath);
+    if (stat.isDirectory() && isRecursive(path6, resolvedPath, state))
       return;
     callback$1(stat, resolvedPath);
   } catch (e) {
@@ -58808,10 +58745,10 @@ function build$2(options, isSynchronous) {
     return null;
   return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path7, resolved, state) {
+function isRecursive(path6, resolved, state) {
   if (state.options.useRealPaths)
     return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname4(path7);
+  let parent = dirname3(path6);
   let depth = 1;
   while (parent !== state.root && depth < 2) {
     const resolvedPath = state.symlinks.get(parent);
@@ -58819,9 +58756,9 @@ function isRecursive(path7, resolved, state) {
     if (isSameRoot)
       depth++;
     else
-      parent = dirname4(parent);
+      parent = dirname3(parent);
   }
-  state.symlinks.set(path7, resolved);
+  state.symlinks.set(path6, resolved);
   return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
@@ -58877,23 +58814,23 @@ var walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
   state.queue.enqueue();
   if (currentDepth < 0)
     return state.queue.dequeue(null, state);
-  const { fs: fs8 } = state;
+  const { fs: fs7 } = state;
   state.visited.push(crawlPath);
   state.counts.directories++;
-  fs8.readdir(crawlPath || ".", readdirOpts, (error43, entries = []) => {
+  fs7.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: fs8 } = state;
+  const { fs: fs7 } = state;
   if (currentDepth < 0)
     return;
   state.visited.push(crawlPath);
   state.counts.directories++;
   let entries = [];
   try {
-    entries = fs8.readdirSync(crawlPath || ".", readdirOpts);
+    entries = fs7.readdirSync(crawlPath || ".", readdirOpts);
   } catch (e) {
     if (!state.options.suppressErrors)
       throw e;
@@ -58999,23 +58936,23 @@ var Walker = class {
         const filename = this.joinPath(entry.name, directoryPath);
         this.pushFile(filename, files, this.state.counts, filters);
       } else if (entry.isDirectory()) {
-        let path7 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path7))
+        let path6 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path6))
           continue;
-        this.pushDirectory(path7, paths, filters);
-        this.walkDirectory(this.state, path7, path7, depth - 1, this.walk);
+        this.pushDirectory(path6, paths, filters);
+        this.walkDirectory(this.state, path6, path6, depth - 1, this.walk);
       } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-        let path7 = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path7, this.state, (stat, resolvedPath) => {
+        let path6 = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path6, this.state, (stat, resolvedPath) => {
           if (stat.isDirectory()) {
             resolvedPath = normalizePath(resolvedPath, this.state.options);
-            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path7 + pathSeparator))
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path6 + pathSeparator))
               return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path7 + pathSeparator, depth - 1, this.walk);
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path6 + pathSeparator, depth - 1, this.walk);
           } else {
-            resolvedPath = useRealPaths ? resolvedPath : path7;
+            resolvedPath = useRealPaths ? resolvedPath : path6;
             const filename = basename2(resolvedPath);
-            const directoryPath$1 = normalizePath(dirname4(resolvedPath), this.state.options);
+            const directoryPath$1 = normalizePath(dirname3(resolvedPath), this.state.options);
             resolvedPath = this.joinPath(filename, directoryPath$1);
             this.pushFile(resolvedPath, files, this.state.counts, filters);
           }
@@ -59173,7 +59110,7 @@ var Builder = class {
       isMatch = globFn(patterns, ...options);
       this.globCache[patterns.join("\x00")] = isMatch;
     }
-    this.options.filters.push((path7) => isMatch(path7));
+    this.options.filters.push((path6) => isMatch(path6));
     return this;
   }
 };
@@ -59252,7 +59189,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
   if (!result.endsWith("*") && expandDirectories)
     result += "/**";
   const escapedCwd = escapePath(cwd2);
-  if (path7.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")))
+  if (path6.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")))
     result = posix.relative(escapedCwd, result);
   else
     result = posix.normalize(result);
@@ -59289,7 +59226,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
     }
     props.depthOffset = newCommonPath.length;
     props.commonPath = newCommonPath;
-    props.root = newCommonPath.length > 0 ? path7.posix.join(cwd2, ...newCommonPath) : cwd2;
+    props.root = newCommonPath.length > 0 ? path6.posix.join(cwd2, ...newCommonPath) : cwd2;
   }
   return result;
 }
@@ -59422,18 +59359,18 @@ function globSync(patternsOrOptions, options) {
     ...options,
     patterns: patternsOrOptions
   } : patternsOrOptions;
-  const cwd2 = opts.cwd ? path7.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+  const cwd2 = opts.cwd ? path6.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(fs8.readFile);
-var readFileSync6 = fs8.readFileSync;
-var statSync5 = fs8.statSync;
+var readFile4 = promisify(fs7.readFile);
+var readFileSync5 = fs7.readFileSync;
+var statSync5 = fs7.statSync;
 async function getSessionDuration(transcriptPath) {
   try {
-    if (!fs8.existsSync(transcriptPath)) {
+    if (!fs7.existsSync(transcriptPath)) {
       return null;
     }
     const content = await readFile4(transcriptPath, "utf-8");
@@ -59485,7 +59422,7 @@ async function getSessionDuration(transcriptPath) {
 }
 async function getTokenMetrics(transcriptPath) {
   try {
-    if (!fs8.existsSync(transcriptPath)) {
+    if (!fs7.existsSync(transcriptPath)) {
       return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
     }
     const content = await readFile4(transcriptPath, "utf-8");
@@ -59538,7 +59475,7 @@ function getBlockMetrics() {
 function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
   const sessionDurationMs = sessionDurationHours * 60 * 60 * 1000;
   const now = new Date;
-  const pattern = path8.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
+  const pattern = path7.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
   const files = globSync([pattern], {
     absolute: true,
     cwd: rootDir
@@ -59632,7 +59569,7 @@ function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
 function getAllTimestampsFromFile(filePath) {
   const timestamps = [];
   try {
-    const content = readFileSync6(filePath, "utf-8");
+    const content = readFileSync5(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.40",
+  "version": "2.0.41",
   "description": "A customizable status line formatter for Claude Code CLI",
   "module": "src/ccstatusline.ts",
   "type": "module",