claude-stats 0.1.0

package/dist/streamer.d.ts

@@ -0,0 +1,35 @@
+import { MonitorData } from '@claude-monitor/shared';
+export interface StreamerOptions {
+    server: string;
+    token: string;
+    name?: string;
+    interval?: number;
+    getAccountId: () => string;
+}
+interface HeartbeatResponse {
+    needsData: boolean;
+    clientCount: number;
+}
+export declare class Streamer {
+    private server;
+    private token;
+    private machineId;
+    private machineName;
+    private interval;
+    private getAccountId;
+    private isRunning;
+    private intervalId;
+    private consecutiveErrors;
+    private maxRetries;
+    private lastClientCount;
+    constructor(options: StreamerOptions);
+    /**
+     * Check with server if any clients are viewing the dashboard
+     */
+    checkHeartbeat(): Promise<HeartbeatResponse>;
+    send(data: MonitorData): Promise<boolean>;
+    streamOnce(collectFn: () => MonitorData): Promise<boolean>;
+    start(collectFn: () => MonitorData): void;
+    stop(): void;
+}
+export {};

package/dist/streamer.js

@@ -0,0 +1,199 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) 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 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Streamer = void 0;
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+// Generate a stable machine ID based on hostname and username
+function getMachineId() {
+    const hostname = os.hostname();
+    const username = os.userInfo().username;
+    const combined = `${hostname}-${username}`;
+    return crypto.createHash('md5').update(combined).digest('hex').slice(0, 12);
+}
+class Streamer {
+    constructor(options) {
+        this.isRunning = false;
+        this.intervalId = null;
+        this.consecutiveErrors = 0;
+        this.maxRetries = 5;
+        this.lastClientCount = 0;
+        this.server = options.server.replace(/\/$/, ''); // Remove trailing slash
+        this.token = options.token;
+        this.machineId = getMachineId();
+        this.machineName = options.name || os.hostname();
+        this.interval = options.interval || 10000;
+        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 }; // Default to sending on error
+            }
+            return (await response.json());
+        }
+        catch {
+            return { needsData: true, clientCount: 0 }; // Default to sending on error
+        }
+    }
+    async send(data) {
+        const payload = {
+            machine_id: this.machineId,
+            machine_name: this.machineName,
+            account_id: this.getAccountId(),
+            timestamp: 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('');
+        // Initial send to register the machine
+        this.streamOnce(collectFn).then((success) => {
+            if (success) {
+                console.log(`✓ Connected to server`);
+            }
+            else {
+                console.log(`✗ Failed to connect to server`);
+            }
+        });
+        // Start interval with smart polling
+        this.intervalId = setInterval(async () => {
+            // Check if anyone is viewing the dashboard
+            const heartbeat = await this.checkHeartbeat();
+            // Log when client count changes
+            if (heartbeat.clientCount !== this.lastClientCount) {
+                if (heartbeat.clientCount > 0) {
+                    console.log(`\n👀 ${heartbeat.clientCount} viewer(s) connected - streaming data`);
+                }
+                else {
+                    console.log(`\n💤 No viewers - pausing data stream`);
+                }
+                this.lastClientCount = heartbeat.clientCount;
+            }
+            if (!heartbeat.needsData) {
+                // No one viewing, just send a lightweight heartbeat indicator
+                process.stdout.write('_');
+                return;
+            }
+            // Someone is viewing, send full data
+            const success = await this.streamOnce(collectFn);
+            if (this.consecutiveErrors >= this.maxRetries) {
+                console.error(`\nToo many consecutive errors (${this.consecutiveErrors}), will keep trying...`);
+                this.consecutiveErrors = 0;
+            }
+            if (success) {
+                process.stdout.write('.');
+            }
+            else {
+                process.stdout.write('x');
+            }
+        }, this.interval);
+        // Handle graceful shutdown
+        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);
+    }
+}
+exports.Streamer = Streamer;

package/dist/usage-limits.d.ts

@@ -0,0 +1,14 @@
+import { UsageLimits } from '@claude-monitor/shared';
+/**
+ * Get cached usage limits synchronously.
+ * Starts a background fetch if cache is stale.
+ */
+export declare function getUsageLimitsSync(): UsageLimits | null;
+/**
+ * Async function to fetch usage limits (for initial load)
+ */
+export declare function fetchUsageLimits(): Promise<UsageLimits | null>;
+/**
+ * Force refresh usage limits (clears cache and fetches fresh data)
+ */
+export declare function forceRefreshUsageLimits(): Promise<UsageLimits | null>;

package/dist/usage-limits.js

@@ -0,0 +1,325 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) 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 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUsageLimitsSync = getUsageLimitsSync;
+exports.fetchUsageLimits = fetchUsageLimits;
+exports.forceRefreshUsageLimits = forceRefreshUsageLimits;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// Cache the usage limits
+let cachedLimits = null;
+let lastFetchTime = 0;
+let isFetching = false;
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes memory cache
+// Cache file for persisting usage data
+const CACHE_FILE = path.join(os.homedir(), '.claude', 'usage-cache.json');
+const FILE_CACHE_DURATION = 30 * 60 * 1000; // 30 minutes file cache
+// OAuth API endpoint (like CodexBar)
+const OAUTH_API_URL = 'https://api.anthropic.com/api/oauth/usage';
+/**
+ * Load cached limits from file
+ */
+function loadCacheFromFile() {
+    try {
+        if (fs.existsSync(CACHE_FILE)) {
+            const data = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
+            // Check if cache is still valid
+            if (data.fetched_at) {
+                const age = Date.now() - new Date(data.fetched_at).getTime();
+                if (age < FILE_CACHE_DURATION) {
+                    return data;
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Save limits to cache file
+ */
+function saveCacheToFile(limits) {
+    try {
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(limits, null, 2));
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Get OAuth credentials from macOS Keychain
+ */
+function getOAuthCredentials() {
+    try {
+        // Try macOS Keychain first
+        const result = (0, child_process_1.execSync)('security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null', { encoding: 'utf-8', timeout: 5000 });
+        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 {
+        // Keychain access failed, try file-based credentials
+    }
+    // Try ~/.claude/.credentials.json
+    try {
+        const credFile = path.join(os.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 {
+        // File access failed
+    }
+    return null;
+}
+/**
+ * Fetch usage via OAuth API (like CodexBar)
+ */
+async function fetchUsageViaOAuthAPI() {
+    const credentials = getOAuthCredentials();
+    if (!credentials) {
+        console.log('[usage-limits] No OAuth credentials found');
+        return null;
+    }
+    // Check if token is expired
+    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;
+    }
+}
+/**
+ * Parse OAuth API response into UsageLimits
+ */
+function parseOAuthResponse(data) {
+    const limits = {
+        session: null,
+        weekly: null,
+        fetched_at: new Date().toISOString(),
+    };
+    // Parse 5-hour session window
+    if (data.five_hour) {
+        const window = data.five_hour;
+        // API returns 'utilization' as the percentage used
+        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,
+        };
+    }
+    // Parse 7-day weekly window
+    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;
+}
+/**
+ * Format reset time as relative description
+ */
+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 / (1000 * 60 * 60));
+        const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 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';
+    }
+}
+/**
+ * Get cached usage limits synchronously.
+ * Starts a background fetch if cache is stale.
+ */
+function getUsageLimitsSync() {
+    // Try memory cache first
+    if (cachedLimits && Date.now() - lastFetchTime < CACHE_DURATION) {
+        return cachedLimits;
+    }
+    // Try file cache
+    const fileCache = loadCacheFromFile();
+    if (fileCache) {
+        cachedLimits = fileCache;
+        lastFetchTime = Date.now();
+        // Trigger background refresh if cache is getting old
+        const age = Date.now() - new Date(fileCache.fetched_at).getTime();
+        if (age > 10 * 60 * 1000 && !isFetching) {
+            fetchUsageLimitsBackground();
+        }
+        return cachedLimits;
+    }
+    // Start background fetch if needed
+    if (!isFetching) {
+        fetchUsageLimitsBackground();
+    }
+    return cachedLimits;
+}
+/**
+ * Fetch usage limits in the background without blocking
+ */
+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 to fetch usage limits (for initial load)
+ */
+async function fetchUsageLimits() {
+    // Try file cache first
+    const fileCache = loadCacheFromFile();
+    if (fileCache) {
+        // Start background refresh if cache is getting old (> 10 min)
+        const age = Date.now() - new Date(fileCache.fetched_at).getTime();
+        if (age > 10 * 60 * 1000 && !isFetching) {
+            fetchUsageLimitsBackground();
+        }
+        return fileCache;
+    }
+    // Try OAuth API
+    return fetchUsageViaOAuthAPI();
+}
+/**
+ * Force refresh usage limits (clears cache and fetches fresh data)
+ */
+async function forceRefreshUsageLimits() {
+    cachedLimits = null;
+    lastFetchTime = 0;
+    // Delete cache file
+    try {
+        if (fs.existsSync(CACHE_FILE)) {
+            fs.unlinkSync(CACHE_FILE);
+        }
+    }
+    catch {
+        // Ignore
+    }
+    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;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "claude-stats",
+  "version": "0.1.0",
+  "description": "Monitor and stream Claude Code usage statistics to a remote dashboard",
+  "keywords": [
+    "claude",
+    "anthropic",
+    "cli",
+    "usage",
+    "monitor",
+    "stats",
+    "tokens"
+  ],
+  "author": "Claude Monitor",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/projectashik/claude-monitor"
+  },
+  "bin": {
+    "claude-stats": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node18 --outfile=dist/index.js --external:commander --banner:js='#!/usr/bin/env node'",
+    "build:tsc": "tsc",
+    "dev": "tsc --watch",
+    "stream": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@claude-monitor/shared": "*",
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.24.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}