claude-stats 0.1.0

package/dist/index.js

@@ -0,0 +1,1169 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../packages/shared/dist/types.js
+var require_types = __commonJS({
+  "../../packages/shared/dist/types.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// ../../packages/shared/dist/pricing.js
+var require_pricing = __commonJS({
+  "../../packages/shared/dist/pricing.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DEFAULT_PRICING = exports2.MODEL_PRICING = void 0;
+    exports2.calculateCost = calculateCost2;
+    exports2.formatModelName = formatModelName;
+    exports2.MODEL_PRICING = {
+      "claude-opus-4-5-20251101": { input: 5, output: 25, cache_read: 0.5, cache_write: 6.25 },
+      "claude-opus-4-5-thinking": { input: 5, output: 25, cache_read: 0.5, cache_write: 6.25 },
+      "claude-sonnet-4-5-20250929": { input: 3, output: 15, cache_read: 0.3, cache_write: 3.75 },
+      "claude-sonnet-4-5-thinking": { input: 3, output: 15, cache_read: 0.3, cache_write: 3.75 },
+      "claude-haiku-4-5": { input: 1, output: 5, cache_read: 0.1, cache_write: 1.25 }
+    };
+    exports2.DEFAULT_PRICING = {
+      input: 3,
+      output: 15,
+      cache_read: 0.3,
+      cache_write: 3.75
+    };
+    function calculateCost2(model, usage) {
+      const pricing = exports2.MODEL_PRICING[model] || exports2.DEFAULT_PRICING;
+      const inputTokens = usage.inputTokens ?? usage.input_tokens ?? 0;
+      const outputTokens = usage.outputTokens ?? usage.output_tokens ?? 0;
+      const cacheRead = usage.cacheReadInputTokens ?? usage.cache_read_input_tokens ?? 0;
+      const cacheWrite = usage.cacheCreationInputTokens ?? usage.cache_creation_input_tokens ?? 0;
+      const cost = inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output + cacheRead / 1e6 * pricing.cache_read + cacheWrite / 1e6 * pricing.cache_write;
+      return Math.round(cost * 1e4) / 1e4;
+    }
+    function formatModelName(model) {
+      return model.replace("claude-", "").replace("-20251101", "").replace("-20250929", "").replace("-thinking", " (think)").replace("gemini-", "").replace("-high", "");
+    }
+  }
+});
+
+// ../../packages/shared/dist/index.js
+var require_dist = __commonJS({
+  "../../packages/shared/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_types(), exports2);
+    __exportStar(require_pricing(), exports2);
+  }
+});
+
+// src/index.ts
+var import_commander = require("commander");
+var readline = __toESM(require("readline"));
+
+// src/streamer.ts
+var os = __toESM(require("os"));
+var crypto = __toESM(require("crypto"));
+function getMachineId() {
+  const hostname2 = os.hostname();
+  const username = os.userInfo().username;
+  const combined = `${hostname2}-${username}`;
+  return crypto.createHash("md5").update(combined).digest("hex").slice(0, 12);
+}
+var Streamer = class {
+  constructor(options) {
+    this.isRunning = false;
+    this.intervalId = null;
+    this.consecutiveErrors = 0;
+    this.maxRetries = 5;
+    this.lastClientCount = 0;
+    this.server = options.server.replace(/\/$/, "");
+    this.token = options.token;
+    this.machineId = getMachineId();
+    this.machineName = options.name || os.hostname();
+    this.interval = options.interval || 1e4;
+    this.getAccountId = options.getAccountId;
+  }
+  /**
+   * Check with server if any clients are viewing the dashboard
+   */
+  async checkHeartbeat() {
+    try {
+      const response = await fetch(`${this.server}/api/heartbeat`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.token}`
+        }
+      });
+      if (!response.ok) {
+        return { needsData: true, clientCount: 0 };
+      }
+      return await response.json();
+    } catch {
+      return { needsData: true, clientCount: 0 };
+    }
+  }
+  async send(data) {
+    const payload = {
+      machine_id: this.machineId,
+      machine_name: this.machineName,
+      account_id: this.getAccountId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+    try {
+      const response = await fetch(`${this.server}/api/stream`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        console.error(`Server error: ${response.status} - ${text}`);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error(`Network error: ${error instanceof Error ? error.message : error}`);
+      return false;
+    }
+  }
+  async streamOnce(collectFn) {
+    try {
+      const data = collectFn();
+      const success = await this.send(data);
+      if (success) {
+        this.consecutiveErrors = 0;
+      } else {
+        this.consecutiveErrors++;
+      }
+      return success;
+    } catch (error) {
+      console.error(`Collection error: ${error instanceof Error ? error.message : error}`);
+      this.consecutiveErrors++;
+      return false;
+    }
+  }
+  start(collectFn) {
+    if (this.isRunning) {
+      console.log("Streamer is already running");
+      return;
+    }
+    this.isRunning = true;
+    console.log(`Starting streamer (smart polling)...`);
+    console.log(`  Machine ID: ${this.machineId}`);
+    console.log(`  Machine Name: ${this.machineName}`);
+    console.log(`  Account ID: ${this.getAccountId()}`);
+    console.log(`  Server: ${this.server}`);
+    console.log(`  Interval: ${this.interval}ms`);
+    console.log("");
+    console.log("Data will only be sent when someone is viewing the dashboard.");
+    console.log("");
+    this.streamOnce(collectFn).then((success) => {
+      if (success) {
+        console.log(`\u2713 Connected to server`);
+      } else {
+        console.log(`\u2717 Failed to connect to server`);
+      }
+    });
+    this.intervalId = setInterval(async () => {
+      const heartbeat = await this.checkHeartbeat();
+      if (heartbeat.clientCount !== this.lastClientCount) {
+        if (heartbeat.clientCount > 0) {
+          console.log(`
+\u{1F440} ${heartbeat.clientCount} viewer(s) connected - streaming data`);
+        } else {
+          console.log(`
+\u{1F4A4} No viewers - pausing data stream`);
+        }
+        this.lastClientCount = heartbeat.clientCount;
+      }
+      if (!heartbeat.needsData) {
+        process.stdout.write("_");
+        return;
+      }
+      const success = await this.streamOnce(collectFn);
+      if (this.consecutiveErrors >= this.maxRetries) {
+        console.error(`
+Too many consecutive errors (${this.consecutiveErrors}), will keep trying...`);
+        this.consecutiveErrors = 0;
+      }
+      if (success) {
+        process.stdout.write(".");
+      } else {
+        process.stdout.write("x");
+      }
+    }, this.interval);
+    process.on("SIGINT", () => this.stop());
+    process.on("SIGTERM", () => this.stop());
+  }
+  stop() {
+    if (!this.isRunning) return;
+    console.log("\nStopping streamer...");
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    process.exit(0);
+  }
+};
+
+// src/collector.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+var crypto2 = __toESM(require("crypto"));
+var import_child_process2 = require("child_process");
+var import_shared = __toESM(require_dist());
+
+// src/usage-limits.ts
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+var cachedLimits = null;
+var lastFetchTime = 0;
+var isFetching = false;
+var CACHE_DURATION = 5 * 60 * 1e3;
+var CACHE_FILE = path.join(os2.homedir(), ".claude", "usage-cache.json");
+var FILE_CACHE_DURATION = 30 * 60 * 1e3;
+var OAUTH_API_URL = "https://api.anthropic.com/api/oauth/usage";
+function loadCacheFromFile() {
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      const data = JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+      if (data.fetched_at) {
+        const age = Date.now() - new Date(data.fetched_at).getTime();
+        if (age < FILE_CACHE_DURATION) {
+          return data;
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function saveCacheToFile(limits) {
+  try {
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(limits, null, 2));
+  } catch {
+  }
+}
+function getOAuthCredentials() {
+  try {
+    const result = (0, import_child_process.execSync)(
+      'security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null',
+      { encoding: "utf-8", timeout: 5e3 }
+    );
+    const credentials = JSON.parse(result.trim());
+    if (credentials.claudeAiOauth?.accessToken) {
+      return {
+        accessToken: credentials.claudeAiOauth.accessToken,
+        refreshToken: credentials.claudeAiOauth.refreshToken,
+        expiresAt: credentials.claudeAiOauth.expiresAt,
+        scopes: credentials.claudeAiOauth.scopes
+      };
+    }
+  } catch {
+  }
+  try {
+    const credFile = path.join(os2.homedir(), ".claude", ".credentials.json");
+    if (fs.existsSync(credFile)) {
+      const data = JSON.parse(fs.readFileSync(credFile, "utf-8"));
+      if (data.claudeAiOauth?.accessToken) {
+        return {
+          accessToken: data.claudeAiOauth.accessToken,
+          refreshToken: data.claudeAiOauth.refreshToken,
+          expiresAt: data.claudeAiOauth.expiresAt,
+          scopes: data.claudeAiOauth.scopes
+        };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function fetchUsageViaOAuthAPI() {
+  const credentials = getOAuthCredentials();
+  if (!credentials) {
+    console.log("[usage-limits] No OAuth credentials found");
+    return null;
+  }
+  if (credentials.expiresAt) {
+    const expiresAt = new Date(credentials.expiresAt).getTime();
+    if (Date.now() > expiresAt) {
+      console.log("[usage-limits] OAuth token expired");
+      return null;
+    }
+  }
+  try {
+    const response = await fetch(OAUTH_API_URL, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${credentials.accessToken}`,
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "anthropic-beta": "oauth-2025-04-20",
+        "User-Agent": "claude-monitor-cli"
+      }
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      console.log(`[usage-limits] OAuth API error: ${response.status} - ${text}`);
+      return null;
+    }
+    const data = await response.json();
+    return parseOAuthResponse(data);
+  } catch (error) {
+    console.log(`[usage-limits] OAuth API fetch error: ${error instanceof Error ? error.message : error}`);
+    return null;
+  }
+}
+function parseOAuthResponse(data) {
+  const limits = {
+    session: null,
+    weekly: null,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (data.five_hour) {
+    const window = data.five_hour;
+    const percentUsed = window.utilization ?? window.percent_used ?? 100 - (window.percent_remaining ?? 0);
+    const resetTime = window.resets_at || window.reset_at || null;
+    limits.session = {
+      percent_used: Math.round(percentUsed),
+      resets_at: resetTime,
+      reset_description: resetTime ? formatResetTime(resetTime) : null
+    };
+  }
+  if (data.seven_day) {
+    const window = data.seven_day;
+    const percentUsed = window.utilization ?? window.percent_used ?? 100 - (window.percent_remaining ?? 0);
+    const resetTime = window.resets_at || window.reset_at || null;
+    limits.weekly = {
+      percent_used: Math.round(percentUsed),
+      resets_at: resetTime,
+      reset_description: resetTime ? formatResetTime(resetTime) : null
+    };
+  }
+  if (limits.session || limits.weekly) {
+    return limits;
+  }
+  return null;
+}
+function formatResetTime(isoTime) {
+  try {
+    const resetTime = new Date(isoTime).getTime();
+    const now = Date.now();
+    const diffMs = resetTime - now;
+    if (diffMs <= 0) return "Soon";
+    const hours = Math.floor(diffMs / (1e3 * 60 * 60));
+    const minutes = Math.floor(diffMs % (1e3 * 60 * 60) / (1e3 * 60));
+    if (hours > 24) {
+      const days = Math.floor(hours / 24);
+      return `${days}d ${hours % 24}h`;
+    }
+    if (hours > 0) {
+      return `${hours}h ${minutes}m`;
+    }
+    return `${minutes}m`;
+  } catch {
+    return "Unknown";
+  }
+}
+function getUsageLimitsSync() {
+  if (cachedLimits && Date.now() - lastFetchTime < CACHE_DURATION) {
+    return cachedLimits;
+  }
+  const fileCache = loadCacheFromFile();
+  if (fileCache) {
+    cachedLimits = fileCache;
+    lastFetchTime = Date.now();
+    const age = Date.now() - new Date(fileCache.fetched_at).getTime();
+    if (age > 10 * 60 * 1e3 && !isFetching) {
+      fetchUsageLimitsBackground();
+    }
+    return cachedLimits;
+  }
+  if (!isFetching) {
+    fetchUsageLimitsBackground();
+  }
+  return cachedLimits;
+}
+function fetchUsageLimitsBackground() {
+  if (isFetching) return;
+  isFetching = true;
+  fetchUsageViaOAuthAPI().then((limits) => {
+    if (limits) {
+      cachedLimits = limits;
+      lastFetchTime = Date.now();
+      saveCacheToFile(limits);
+      console.log("[usage-limits] Fetched via OAuth API successfully");
+    } else {
+      console.log("[usage-limits] OAuth API failed, no fallback available");
+    }
+  }).catch((err) => {
+    console.log("[usage-limits] Error fetching usage:", err?.message || err);
+  }).finally(() => {
+    isFetching = false;
+  });
+}
+async function fetchUsageLimits() {
+  const fileCache = loadCacheFromFile();
+  if (fileCache) {
+    const age = Date.now() - new Date(fileCache.fetched_at).getTime();
+    if (age > 10 * 60 * 1e3 && !isFetching) {
+      fetchUsageLimitsBackground();
+    }
+    return fileCache;
+  }
+  return fetchUsageViaOAuthAPI();
+}
+async function forceRefreshUsageLimits() {
+  cachedLimits = null;
+  lastFetchTime = 0;
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      fs.unlinkSync(CACHE_FILE);
+    }
+  } catch {
+  }
+  console.log("[usage-limits] Force refreshing via OAuth API...");
+  const limits = await fetchUsageViaOAuthAPI();
+  if (limits) {
+    cachedLimits = limits;
+    lastFetchTime = Date.now();
+    saveCacheToFile(limits);
+    console.log("[usage-limits] Force refresh successful");
+  } else {
+    console.log("[usage-limits] Force refresh failed");
+  }
+  return limits;
+}
+
+// src/collector.ts
+var CLAUDE_DIR = path2.join(os3.homedir(), ".claude");
+var STATS_FILE = path2.join(CLAUDE_DIR, "stats-cache.json");
+var PROJECTS_DIR = path2.join(CLAUDE_DIR, "projects");
+var cachedAccountId = null;
+function getAccountId() {
+  if (cachedAccountId) return cachedAccountId;
+  try {
+    const stats = getStats();
+    const firstSession = stats.firstSessionDate || "";
+    let projectsHash = "";
+    if (fs2.existsSync(PROJECTS_DIR)) {
+      const projects = fs2.readdirSync(PROJECTS_DIR).sort().join(",");
+      projectsHash = projects;
+    }
+    const combined = `${firstSession}:${projectsHash}`;
+    cachedAccountId = crypto2.createHash("md5").update(combined).digest("hex").slice(0, 12);
+    return cachedAccountId;
+  } catch {
+    cachedAccountId = crypto2.randomBytes(6).toString("hex");
+    return cachedAccountId;
+  }
+}
+function getStats() {
+  try {
+    if (fs2.existsSync(STATS_FILE)) {
+      const content = fs2.readFileSync(STATS_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch (e) {
+  }
+  return {};
+}
+function parseSessionTokens(sessionFile) {
+  const result = {
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read: 0,
+    cache_write: 0,
+    model: null,
+    messages: 0
+  };
+  try {
+    const content = fs2.readFileSync(sessionFile, "utf-8");
+    const lines = content.trim().split("\n");
+    for (const line of lines) {
+      try {
+        const msg = JSON.parse(line);
+        if (msg.type === "assistant") {
+          result.messages++;
+          const usage = msg.message?.usage || {};
+          result.input_tokens += usage.input_tokens || 0;
+          result.output_tokens += usage.output_tokens || 0;
+          result.cache_read += usage.cache_read_input_tokens || 0;
+          result.cache_write += usage.cache_creation_input_tokens || 0;
+          if (!result.model) {
+            result.model = msg.message?.model || null;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function parseSessionActivity(sessionFile) {
+  const activity = {
+    status: "idle",
+    current_activity: null,
+    last_tool: null,
+    last_user_message: null,
+    subagent_detail: null,
+    waiting_reason: null
+  };
+  try {
+    const stats = fs2.statSync(sessionFile);
+    const fd = fs2.openSync(sessionFile, "r");
+    const bufferSize = Math.min(8e4, stats.size);
+    const buffer = Buffer.alloc(bufferSize);
+    const startPos = Math.max(0, stats.size - bufferSize);
+    fs2.readSync(fd, buffer, 0, bufferSize, startPos);
+    fs2.closeSync(fd);
+    const content = buffer.toString("utf-8");
+    const lines = content.trim().split("\n");
+    const lastMessages = [];
+    for (const line of lines.slice(-30)) {
+      try {
+        lastMessages.push(JSON.parse(line));
+      } catch {
+        continue;
+      }
+    }
+    if (lastMessages.length === 0) return activity;
+    const lastMsg = lastMessages[lastMessages.length - 1];
+    const lastType = lastMsg.type;
+    if (lastType === "assistant") {
+      const content2 = lastMsg.message?.content || [];
+      let hasToolUse = false;
+      let lastText = "";
+      if (Array.isArray(content2)) {
+        for (const block of content2) {
+          if (block?.type === "tool_use") hasToolUse = true;
+          if (block?.type === "text") lastText = block.text || "";
+        }
+      }
+      if (!hasToolUse && lastText) {
+        activity.status = "waiting_input";
+        const textLines = lastText.trim().split("\n");
+        const lastLine = textLines[textLines.length - 1] || "";
+        if (lastText.slice(-300).includes("?")) {
+          activity.waiting_reason = "Asking a question";
+          for (let i = textLines.length - 1; i >= 0; i--) {
+            if (textLines[i].includes("?")) {
+              const q = textLines[i].slice(0, 80);
+              activity.current_activity = `\u2753 ${q}${textLines[i].length > 80 ? "..." : ""}`;
+              break;
+            }
+          }
+        } else {
+          activity.waiting_reason = "Waiting for your response";
+          activity.current_activity = `\u{1F4AC} ${lastLine.slice(0, 60)}${lastLine.length > 60 ? "..." : ""}`;
+        }
+      }
+    }
+    for (let i = lastMessages.length - 1; i >= 0; i--) {
+      const msg = lastMessages[i];
+      const msgType = msg.type;
+      if (msgType === "user" && !activity.last_user_message) {
+        const content2 = msg.message?.content;
+        if (typeof content2 === "string") {
+          activity.last_user_message = content2.slice(0, 100) + (content2.length > 100 ? "..." : "");
+        } else if (Array.isArray(content2)) {
+          for (const c of content2) {
+            if (c?.type === "text") {
+              const text = (c.text || "").slice(0, 100);
+              activity.last_user_message = text + (text.length >= 100 ? "..." : "");
+              break;
+            }
+          }
+        }
+      }
+      if (msgType === "assistant" && activity.status !== "waiting_input") {
+        const content2 = msg.message?.content || [];
+        if (Array.isArray(content2)) {
+          for (let j = content2.length - 1; j >= 0; j--) {
+            const block = content2[j];
+            if (block?.type === "tool_use") {
+              const toolName = block.name || "unknown";
+              activity.last_tool = toolName;
+              activity.status = "working";
+              const inp = block.input || {};
+              if (toolName === "TodoWrite") {
+                const todos = inp.todos || [];
+                const inProgress = todos.filter((t) => t.status === "in_progress");
+                if (inProgress.length > 0) {
+                  activity.current_activity = `\u{1F4CB} ${(inProgress[0].content || "Working on task").slice(0, 50)}`;
+                } else {
+                  activity.current_activity = "\u{1F4CB} Updating task list";
+                }
+              } else if (toolName === "Read") {
+                const file = (inp.file_path || "").split("/").pop();
+                activity.current_activity = `\u{1F4D6} Reading ${file}`;
+              } else if (toolName === "Write") {
+                const file = (inp.file_path || "").split("/").pop();
+                activity.current_activity = `\u270F\uFE0F Writing ${file}`;
+              } else if (toolName === "Edit") {
+                const file = (inp.file_path || "").split("/").pop();
+                activity.current_activity = `\u270F\uFE0F Editing ${file}`;
+              } else if (toolName === "Bash") {
+                const cmd = inp.command || "";
+                const desc = inp.description || "";
+                if (desc) {
+                  activity.current_activity = `\u26A1 ${desc.slice(0, 50)}`;
+                } else {
+                  activity.current_activity = `\u26A1 $ ${cmd.slice(0, 45)}`;
+                }
+              } else if (toolName === "Task") {
+                const desc = inp.description || "task";
+                const agentType = inp.subagent_type || "";
+                const prompt = inp.prompt || "";
+                if (agentType) {
+                  activity.current_activity = `\u{1F916} ${agentType} agent: ${desc}`;
+                } else {
+                  activity.current_activity = `\u{1F916} Subagent: ${desc}`;
+                }
+                if (prompt) {
+                  activity.subagent_detail = prompt.slice(0, 120) + (prompt.length > 120 ? "..." : "");
+                }
+              } else if (toolName === "Grep") {
+                const pattern = inp.pattern || "";
+                activity.current_activity = `\u{1F50D} Searching: ${pattern.slice(0, 40)}`;
+              } else if (toolName === "Glob") {
+                const pattern = inp.pattern || "";
+                activity.current_activity = `\u{1F4C1} Finding: ${pattern.slice(0, 40)}`;
+              } else if (toolName === "AskUserQuestion") {
+                const questions = inp.questions || [];
+                if (questions.length > 0) {
+                  const q = (questions[0].question || "").slice(0, 60);
+                  activity.current_activity = `\u2753 ${q}`;
+                } else {
+                  activity.current_activity = "\u2753 Asking question";
+                }
+                activity.status = "waiting_input";
+                activity.waiting_reason = "Needs your input";
+              } else if (["WebSearch", "WebFetch", "mcp__web-search-prime__webSearchPrime"].includes(toolName)) {
+                const query = (inp.query || inp.search_query || "").slice(0, 40);
+                activity.current_activity = `\u{1F310} Searching: ${query}`;
+              } else if (toolName.startsWith("mcp__")) {
+                const shortName = toolName.split("__").pop();
+                activity.current_activity = `\u{1F50C} ${shortName}`;
+              } else {
+                activity.current_activity = `\u{1F527} ${toolName}`;
+              }
+              break;
+            }
+          }
+        }
+      }
+      if (activity.current_activity) break;
+    }
+  } catch {
+  }
+  return activity;
+}
+function getCliProcesses() {
+  try {
+    const result = (0, import_child_process2.execSync)("ps aux", { encoding: "utf-8", timeout: 5e3 });
+    const processes = [];
+    for (const line of result.trim().split("\n").slice(1)) {
+      const parts = line.split(/\s+/);
+      if (parts.length < 11) continue;
+      const cmd = parts.slice(10).join(" ");
+      if (cmd.startsWith("claude") && !cmd.includes("Claude.app")) {
+        const pid = parseInt(parts[1], 10);
+        const cpu = parseFloat(parts[2]);
+        const mem = parseFloat(parts[3]);
+        let cwd = null;
+        try {
+          const lsof = (0, import_child_process2.execSync)(`lsof -p ${pid} -Fn`, { encoding: "utf-8", timeout: 2e3 });
+          for (const lline of lsof.split("\n")) {
+            if (lline.startsWith("n") && lline.includes("projects") && lline.includes(".jsonl")) {
+              const filePath = lline.slice(1);
+              const match = filePath.split("/projects/")[1];
+              if (match) {
+                cwd = match.split("/")[0].replace(/-/g, "/");
+              }
+              break;
+            }
+          }
+        } catch {
+        }
+        processes.push({ pid, cpu, mem, cwd });
+      }
+    }
+    return processes;
+  } catch {
+    return [];
+  }
+}
+function getOpenFiles() {
+  const openFiles = /* @__PURE__ */ new Set();
+  try {
+    const result = (0, import_child_process2.execSync)("lsof -c claude", { encoding: "utf-8", timeout: 5e3 });
+    for (const line of result.split("\n")) {
+      if (line.includes(".jsonl") && line.includes("projects")) {
+        const parts = line.split(/\s+/);
+        for (const part of parts) {
+          if (part.includes(".jsonl")) {
+            openFiles.add(part);
+            break;
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return openFiles;
+}
+function getTodayUsageFromSessions() {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const todayStart = /* @__PURE__ */ new Date();
+  todayStart.setHours(0, 0, 0, 0);
+  const todayStartTs = todayStart.getTime();
+  const modelTokens = {};
+  let messages = 0;
+  let sessions = 0;
+  if (!fs2.existsSync(PROJECTS_DIR)) {
+    return {
+      date: today,
+      tokens: 0,
+      cost: 0,
+      messages: 0,
+      sessions: 0,
+      models: [],
+      model_breakdown: {}
+    };
+  }
+  const projectDirs = fs2.readdirSync(PROJECTS_DIR);
+  for (const projectDir of projectDirs) {
+    const projectPath = path2.join(PROJECTS_DIR, projectDir);
+    if (!fs2.statSync(projectPath).isDirectory()) continue;
+    const sessionFiles = fs2.readdirSync(projectPath).filter((f) => f.endsWith(".jsonl"));
+    for (const sessionFile of sessionFiles) {
+      const sessionPath = path2.join(projectPath, sessionFile);
+      const stat = fs2.statSync(sessionPath);
+      if (stat.mtimeMs < todayStartTs) continue;
+      sessions++;
+      try {
+        const content = fs2.readFileSync(sessionPath, "utf-8");
+        for (const line of content.trim().split("\n")) {
+          try {
+            const msg = JSON.parse(line);
+            const ts = msg.timestamp || "";
+            if (!ts.startsWith(today)) continue;
+            if (msg.type === "assistant") {
+              messages++;
+              const usage = msg.message?.usage || {};
+              const model = msg.message?.model || "unknown";
+              if (!modelTokens[model]) {
+                modelTokens[model] = { input: 0, output: 0, cache_read: 0, cache_write: 0 };
+              }
+              modelTokens[model].input += usage.input_tokens || 0;
+              modelTokens[model].output += usage.output_tokens || 0;
+              modelTokens[model].cache_read += usage.cache_read_input_tokens || 0;
+              modelTokens[model].cache_write += usage.cache_creation_input_tokens || 0;
+            }
+          } catch {
+            continue;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  let allTokens = 0;
+  let totalCost = 0;
+  const modelBreakdown = {};
+  for (const [model, tokens] of Object.entries(modelTokens)) {
+    const modelTotal = tokens.input + tokens.output + tokens.cache_read + tokens.cache_write;
+    allTokens += modelTotal;
+    const pricing = import_shared.MODEL_PRICING[model] || import_shared.DEFAULT_PRICING;
+    const cost = tokens.input / 1e6 * pricing.input + tokens.output / 1e6 * pricing.output + tokens.cache_read / 1e6 * pricing.cache_read + tokens.cache_write / 1e6 * pricing.cache_write;
+    totalCost += cost;
+    modelBreakdown[model] = {
+      inputTokens: tokens.input,
+      outputTokens: tokens.output,
+      cacheReadInputTokens: tokens.cache_read,
+      cacheCreationInputTokens: tokens.cache_write,
+      cost: Math.round(cost * 1e4) / 1e4
+    };
+  }
+  return {
+    date: today,
+    tokens: allTokens,
+    cost: Math.round(totalCost * 1e4) / 1e4,
+    messages,
+    sessions,
+    models: Object.keys(modelTokens),
+    model_breakdown: modelBreakdown
+  };
+}
+function getDailyUsage(stats) {
+  const dailyTokens = stats.dailyModelTokens || [];
+  const dailyActivity = {};
+  for (const d of stats.dailyActivity || []) {
+    dailyActivity[d.date] = d;
+  }
+  const result = [];
+  for (const day of dailyTokens.slice(-14)) {
+    const date = day.date;
+    const tokensByModel = day.tokensByModel || {};
+    const totalTokens = Object.values(tokensByModel).reduce((sum, t) => sum + t, 0);
+    let dayCost = 0;
+    for (const [model, tokens] of Object.entries(tokensByModel)) {
+      const pricing = import_shared.MODEL_PRICING[model] || import_shared.DEFAULT_PRICING;
+      dayCost += tokens / 1e6 * pricing.input;
+    }
+    const activity = dailyActivity[date] || { messageCount: 0, sessionCount: 0 };
+    result.push({
+      date,
+      tokens: totalTokens,
+      cost: Math.round(dayCost * 1e4) / 1e4,
+      messages: activity.messageCount,
+      sessions: activity.sessionCount,
+      models: Object.keys(tokensByModel)
+    });
+  }
+  return result;
+}
+function getSessions() {
+  const active = [];
+  const recent = [];
+  if (!fs2.existsSync(PROJECTS_DIR)) {
+    return { active, recent };
+  }
+  const openFiles = getOpenFiles();
+  const now = Date.now();
+  const projectDirs = fs2.readdirSync(PROJECTS_DIR);
+  for (const projectDir of projectDirs) {
+    const projectPath = path2.join(PROJECTS_DIR, projectDir);
+    if (!fs2.statSync(projectPath).isDirectory()) continue;
+    const sessionFiles = fs2.readdirSync(projectPath).filter((f) => f.endsWith(".jsonl"));
+    for (const sessionFile of sessionFiles) {
+      const sessionPath = path2.join(projectPath, sessionFile);
+      const stat = fs2.statSync(sessionPath);
+      const isActive = openFiles.has(sessionPath) || now - stat.mtimeMs < 3e4;
+      const projectName = projectDir.replace(/-/g, "/");
+      const projectShort = projectName.includes("/") ? projectName.split("/").pop() : projectName;
+      let activity = {
+        status: "idle",
+        current_activity: null,
+        last_tool: null,
+        last_user_message: null,
+        subagent_detail: null,
+        waiting_reason: null
+      };
+      let tokenData = null;
+      let sessionCost = null;
+      if (isActive) {
+        activity = parseSessionActivity(sessionPath);
+        tokenData = parseSessionTokens(sessionPath);
+        sessionCost = (0, import_shared.calculateCost)(tokenData.model || "claude-opus-4-5-20251101", {
+          input_tokens: tokenData.input_tokens,
+          output_tokens: tokenData.output_tokens,
+          cache_read_input_tokens: tokenData.cache_read,
+          cache_creation_input_tokens: tokenData.cache_write
+        });
+      }
+      const session = {
+        session_id: path2.basename(sessionFile, ".jsonl"),
+        project: projectName,
+        project_short: projectShort,
+        last_modified: new Date(stat.mtimeMs).toLocaleTimeString("en-US", { hour12: false }),
+        size_kb: Math.round(stat.size / 1024 * 10) / 10,
+        is_active: isActive,
+        tokens: tokenData,
+        cost: sessionCost,
+        model: tokenData?.model || null,
+        ...activity
+      };
+      if (isActive) {
+        active.push(session);
+      } else if (now - stat.mtimeMs < 864e5) {
+        recent.push(session);
+      }
+    }
+  }
+  active.sort((a, b) => b.last_modified.localeCompare(a.last_modified));
+  recent.sort((a, b) => b.last_modified.localeCompare(a.last_modified));
+  return { active, recent: recent.slice(0, 10) };
+}
+function collectData() {
+  const stats = getStats();
+  const processes = getCliProcesses();
+  const { active: activeSessions, recent: recentSessions } = getSessions();
+  const todayUsage = getTodayUsageFromSessions();
+  const modelUsage = { ...stats.modelUsage };
+  const todayBreakdown = todayUsage.model_breakdown;
+  for (const [model, todayData] of Object.entries(todayBreakdown)) {
+    if (modelUsage[model]) {
+      modelUsage[model] = {
+        inputTokens: (modelUsage[model].inputTokens || 0) + (todayData.inputTokens || 0),
+        outputTokens: (modelUsage[model].outputTokens || 0) + (todayData.outputTokens || 0),
+        cacheReadInputTokens: (modelUsage[model].cacheReadInputTokens || 0) + (todayData.cacheReadInputTokens || 0),
+        cacheCreationInputTokens: (modelUsage[model].cacheCreationInputTokens || 0) + (todayData.cacheCreationInputTokens || 0)
+      };
+    } else {
+      modelUsage[model] = {
+        inputTokens: todayData.inputTokens,
+        outputTokens: todayData.outputTokens,
+        cacheReadInputTokens: todayData.cacheReadInputTokens,
+        cacheCreationInputTokens: todayData.cacheCreationInputTokens
+      };
+    }
+  }
+  const modelCosts = {};
+  let totalCost = 0;
+  let totalTokens = 0;
+  for (const [model, usage] of Object.entries(modelUsage)) {
+    const cost = (0, import_shared.calculateCost)(model, usage);
+    modelCosts[model] = cost;
+    totalCost += cost;
+    totalTokens += (usage.inputTokens || 0) + (usage.outputTokens || 0) + (usage.cacheReadInputTokens || 0) + (usage.cacheCreationInputTokens || 0);
+  }
+  const dailyUsage = getDailyUsage(stats);
+  if (todayUsage.tokens > 0) {
+    dailyUsage.push({
+      date: todayUsage.date,
+      tokens: todayUsage.tokens,
+      cost: todayUsage.cost,
+      messages: todayUsage.messages,
+      sessions: todayUsage.sessions,
+      models: todayUsage.models
+    });
+  }
+  const activeSessionsCost = activeSessions.reduce((sum, s) => sum + (s.cost || 0), 0);
+  const activeSessionsTokens = activeSessions.reduce((sum, s) => {
+    if (!s.tokens) return sum;
+    return sum + s.tokens.input_tokens + s.tokens.output_tokens + s.tokens.cache_read + s.tokens.cache_write;
+  }, 0);
+  const totalSessionsCount = (stats.totalSessions || 0) + todayUsage.sessions;
+  const totalMessagesCount = (stats.totalMessages || 0) + todayUsage.messages;
+  const avgCostPerMessage = totalMessagesCount > 0 ? totalCost / totalMessagesCount : 0;
+  const avgCostPerSession = totalSessionsCount > 0 ? totalCost / totalSessionsCount : 0;
+  let daysActive = dailyUsage.length || 1;
+  const firstSessionDate = stats.firstSessionDate;
+  if (firstSessionDate) {
+    try {
+      const firstDt = new Date(firstSessionDate);
+      daysActive = Math.max(1, Math.floor((Date.now() - firstDt.getTime()) / 864e5) + 1);
+    } catch {
+    }
+  }
+  const dailyAvgCost = daysActive > 0 ? totalCost / daysActive : 0;
+  const last7Days = dailyUsage.slice(-7);
+  let weeklyCost = last7Days.reduce((sum, d) => sum + (d.cost || 0), 0);
+  weeklyCost += todayUsage.cost;
+  const currentHour = (/* @__PURE__ */ new Date()).getHours();
+  const hoursElapsed = Math.max(currentHour, 1);
+  const todayHourlyRate = hoursElapsed > 0 ? todayUsage.cost / hoursElapsed : 0;
+  const hourCounts = stats.hourCounts || {};
+  const summary = {
+    is_running: activeSessions.length > 0,
+    active_count: activeSessions.length,
+    waiting_input: activeSessions.filter((s) => s.status === "waiting_input").length,
+    total_sessions: totalSessionsCount,
+    total_messages: totalMessagesCount,
+    total_cost: Math.round(totalCost * 100) / 100,
+    total_tokens: totalTokens,
+    active_sessions_cost: Math.round(activeSessionsCost * 1e4) / 1e4,
+    active_sessions_tokens: activeSessionsTokens,
+    first_session: firstSessionDate || null,
+    days_active: daysActive,
+    avg_cost_per_message: Math.round(avgCostPerMessage * 1e4) / 1e4,
+    avg_cost_per_session: Math.round(avgCostPerSession * 100) / 100,
+    daily_avg_cost: Math.round(dailyAvgCost * 100) / 100,
+    projected_monthly: Math.round(dailyAvgCost * 30 * 100) / 100,
+    weekly_cost: Math.round(weeklyCost * 100) / 100,
+    today_hourly_rate: Math.round(todayHourlyRate * 1e4) / 1e4,
+    est_weekly: Math.round(dailyAvgCost * 7 * 100) / 100
+  };
+  return {
+    stats,
+    model_usage: modelUsage,
+    processes,
+    active_sessions: activeSessions,
+    recent_sessions: recentSessions,
+    model_costs: modelCosts,
+    daily_usage: dailyUsage,
+    today_usage: todayUsage,
+    hour_counts: hourCounts,
+    summary,
+    usage_limits: getUsageLimitsSync()
+  };
+}
+
+// src/index.ts
+var DEFAULT_SERVER = "https://cm.cban.top";
+var program = new import_commander.Command();
+program.name("claude-stats").description("Monitor and stream Claude Code usage statistics").version("0.1.0");
+function promptForInput(question, hidden = false) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    if (hidden && process.stdin.isTTY) {
+      process.stdout.write(question);
+      const stdin = process.stdin;
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding("utf8");
+      let input = "";
+      const onData = (char) => {
+        if (char === "\n" || char === "\r" || char === "") {
+          stdin.setRawMode(false);
+          stdin.removeListener("data", onData);
+          rl.close();
+          console.log("");
+          resolve(input);
+        } else if (char === "") {
+          process.exit();
+        } else if (char === "\x7F" || char === "\b") {
+          input = input.slice(0, -1);
+        } else {
+          input += char;
+        }
+      };
+      stdin.on("data", onData);
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    }
+  });
+}
+program.command("start", { isDefault: true }).description("Start streaming usage data to the monitor server").option("-s, --server <url>", "Server URL", process.env.MONITOR_SERVER || DEFAULT_SERVER).option("-t, --token <token>", "Authentication token", process.env.MONITOR_TOKEN).option("-n, --name <name>", "Machine name (defaults to hostname)", process.env.MONITOR_NAME).option("-i, --interval <ms>", "Polling interval in milliseconds", "10000").action(async (options) => {
+  let server = options.server;
+  let token = options.token;
+  if (server && !server.startsWith("http://") && !server.startsWith("https://")) {
+    server = `https://${server}`;
+  }
+  if (!token) {
+    console.log("Claude Stats Monitor");
+    console.log("====================");
+    console.log(`Server: ${server}`);
+    console.log("");
+    token = await promptForInput("Enter your monitor token: ", true);
+    if (!token) {
+      console.error("Error: Token is required");
+      process.exit(1);
+    }
+  }
+  console.log("Claude Stats Monitor");
+  console.log("====================");
+  fetchUsageLimits().then((limits) => {
+    if (limits) {
+      console.log(`Usage limits loaded (Session: ${limits.session?.percent_used ?? "?"}% used)`);
+    }
+  });
+  const streamer = new Streamer({
+    server,
+    token,
+    name: options.name,
+    interval: parseInt(options.interval, 10),
+    getAccountId
+  });
+  streamer.start(collectData);
+});
+program.command("test").description("Collect and display current data without streaming").action(() => {
+  console.log("Collecting data...\n");
+  const data = collectData();
+  console.log("Summary:");
+  console.log(`  Active sessions: ${data.summary.active_count}`);
+  console.log(`  Waiting input: ${data.summary.waiting_input}`);
+  console.log(`  Total sessions: ${data.summary.total_sessions}`);
+  console.log(`  Total cost: $${data.summary.total_cost}`);
+  console.log(`  Today's cost: $${data.today_usage.cost}`);
+  console.log("");
+  if (data.active_sessions.length > 0) {
+    console.log("Active Sessions:");
+    for (const session of data.active_sessions) {
+      console.log(`  - ${session.project_short} (${session.status})`);
+      if (session.current_activity) {
+        console.log(`    ${session.current_activity}`);
+      }
+    }
+    console.log("");
+  }
+  console.log("Model Usage:");
+  for (const [model, cost] of Object.entries(data.model_costs)) {
+    const shortModel = model.replace("claude-", "").replace("-20251101", "").replace("-20250929", "");
+    console.log(`  - ${shortModel}: $${cost.toFixed(4)}`);
+  }
+  if (data.usage_limits) {
+    console.log("\nUsage Limits:");
+    if (data.usage_limits.session) {
+      console.log(`  Session: ${data.usage_limits.session.percent_used}% used, resets in ${data.usage_limits.session.reset_description}`);
+    }
+    if (data.usage_limits.weekly) {
+      console.log(`  Weekly: ${data.usage_limits.weekly.percent_used}% used, resets in ${data.usage_limits.weekly.reset_description}`);
+    }
+  }
+});
+program.command("refresh-usage").description("Force refresh usage limits from Claude API").action(async () => {
+  console.log("Refreshing usage limits...");
+  const limits = await forceRefreshUsageLimits();
+  if (limits) {
+    console.log("Usage limits refreshed:");
+    if (limits.session) {
+      console.log(`  Session: ${limits.session.percent_used}% used, resets in ${limits.session.reset_description}`);
+    }
+    if (limits.weekly) {
+      console.log(`  Weekly: ${limits.weekly.percent_used}% used, resets in ${limits.weekly.reset_description}`);
+    }
+  } else {
+    console.log("Failed to refresh usage limits. Make sure you are logged into Claude.");
+  }
+});
+program.parse();