letmecode 0.1.4 → 0.1.6

package/ink-app/dist/providers/claude.js

@@ -1,31 +1,67 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
+import { promisify } from "node:util";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
 import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
+import { resolveUsageRate } from "./pricing.js";
 const RATE_CARD = {
-    "claude-opus-4-8": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
-    "claude-opus-4-7": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
-    "claude-opus-4-6": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
-    "claude-opus-4-5": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
-    "claude-opus-4-1": { input: 15, cacheWrite5m: 18.75, cacheWrite1h: 30, cacheRead: 1.5, output: 75 },
-    "claude-opus-4": { input: 15, cacheWrite5m: 18.75, cacheWrite1h: 30, cacheRead: 1.5, output: 75 },
-    "claude-sonnet-4-6": { input: 3, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3, output: 15 },
-    "claude-sonnet-4-5": { input: 3, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3, output: 15 },
-    "claude-sonnet-4": { input: 3, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3, output: 15 },
-    "claude-haiku-4-5": { input: 1, cacheWrite5m: 1.25, cacheWrite1h: 2, cacheRead: 0.1, output: 5 },
-    "claude-haiku-3-5": { input: 0.8, cacheWrite5m: 1, cacheWrite1h: 1.6, cacheRead: 0.08, output: 4 }
+    "claude-opus-4-8": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
+    "claude-opus-4-7": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
+    "claude-opus-4-6": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
+    "claude-opus-4-5": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, cacheWrite5m: 6.25, cacheWrite1h: 10, output: 25 },
+    "claude-opus-4-1": { input: 15, cacheRead: 1.5, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 30, output: 75 },
+    "claude-opus-4": { input: 15, cacheRead: 1.5, cacheWrite: 18.75, cacheWrite5m: 18.75, cacheWrite1h: 30, output: 75 },
+    "claude-sonnet-4-6": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
+    "claude-sonnet-4-5": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
+    "claude-sonnet-4": { input: 3, cacheRead: 0.3, cacheWrite: 3.75, cacheWrite5m: 3.75, cacheWrite1h: 6, output: 15 },
+    "claude-haiku-4-5": { input: 1, cacheRead: 0.1, cacheWrite: 1.25, cacheWrite5m: 1.25, cacheWrite1h: 2, output: 5 },
+    "claude-haiku-3-5": { input: 0.8, cacheRead: 0.08, cacheWrite: 1, cacheWrite5m: 1, cacheWrite1h: 1.6, output: 4 }
 };
+const execFileAsync = promisify(execFile);
 const USD_TO_CREDITS = 100;
+const VSCODE_CLAUDE_EXTENSION_PREFIX = "anthropic.claude-code-";
+const CLAUDE_SESSION_WINDOW_MINUTES = 5 * 60;
+const CLAUDE_WEEK_WINDOW_MINUTES = 7 * 24 * 60;
+const ANSI_ESCAPE_SEQUENCE = /\u001B\[[0-9;]*[A-Za-z]/g;
+const DEFAULT_CLAUDE_ENTRYPOINTS = ["sdk-cli", "claude"];
+const MONTH_INDEX_BY_LABEL = {
+    jan: 0,
+    feb: 1,
+    mar: 2,
+    apr: 3,
+    may: 4,
+    jun: 5,
+    jul: 6,
+    aug: 7,
+    sep: 8,
+    oct: 9,
+    nov: 10,
+    dec: 11
+};
+const parsedClaudeSessionFilesCache = new Map();
+const claudeBinaryPathCache = new Map();
+const claudeUsageOutputCache = new Map();
+const claudeAuthStatusOutputCache = new Map();
 export class ClaudeUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
-        super("claude", "Claude");
+        super(options.id ?? "claude", options.label ?? "Claude");
         this.root = path.resolve(options.root ?? os.homedir());
+        this.entrypoints = new Set(options.entrypoints ?? DEFAULT_CLAUDE_ENTRYPOINTS);
+        this.usageCommandKind = options.usageCommandKind ?? "cli";
+        this.readUsageCommandOutput = options.readUsageCommandOutput;
+        this.readAuthStatusOutput = options.readAuthStatusOutput;
+        this.now = options.now ?? (() => new Date());
     }
     async getStats(options = {}) {
-        const sessionsRoot = path.join(this.root, ".claude", "projects");
+        const resolvedSessionsRoot = await resolveClaudeSessionsRoot(this.root);
+        const sessionsRoot = resolvedSessionsRoot.rootPath;
+        const agentName = normalizeAnalyticsAgentName(this.label);
+        const userIdHash = await readClaudeUserIdHash(this.root, this.usageCommandKind, this.readAuthStatusOutput, agentName);
         const byModel = new Map();
         const byDay = createDailyUsageAggregates();
         const windows = createLimitWindowAggregates();
@@ -38,11 +74,18 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             tokenEvents: 0,
             malformedLines: 0
         };
-        for await (const file of walkSessionFiles(sessionsRoot)) {
+        const parsedSessionFiles = await loadParsedClaudeSessionFiles(sessionsRoot);
+        for (const file of parsedSessionFiles) {
+            const matchingEvents = file.events.filter((event) => this.entrypoints.has(event.entrypoint));
+            if (matchingEvents.length === 0) {
+                continue;
+            }
             parseTotals.filesScanned += 1;
-            const fileStats = await parseSessionFile(file, parsedEvents);
-            parseTotals.linesRead += fileStats.linesRead;
-            parseTotals.malformedLines += fileStats.malformedLines;
+            parseTotals.linesRead += file.linesRead;
+            parseTotals.malformedLines += file.malformedLines;
+            for (const event of matchingEvents) {
+                recordParsedUsageEvent(parsedEvents, event);
+            }
         }
         const selectedEvents = [
             ...parsedEvents.keyedEvents.values(),
@@ -77,18 +120,26 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         if (unknownPricedModels.length > 0) {
             warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
         }
-        if (parseTotals.filesScanned === 0) {
+        if (parsedSessionFiles.length === 0) {
             warnings.push(`No Claude session files found under ${sessionsRoot}.`);
         }
         const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
         const dayUsage = buildDailyUsageRows(byDay);
-        const [primaryLimitWindows, secondaryLimitWindows] = buildWindowLists(windows);
-        if (parseTotals.filesScanned > 0 &&
-            parseTotals.tokenEvents > 0 &&
-            primaryLimitWindows.length === 0 &&
-            secondaryLimitWindows.length === 0) {
-            warnings.push("Claude transcripts did not expose rate-limit windows in the local logs.");
-        }
+        const [fallbackPrimaryLimitWindows, fallbackSecondaryLimitWindows] = buildWindowLists(windows);
+        const liveLimitWindows = await buildLiveLimitWindows({
+            root: this.root,
+            usageCommandKind: this.usageCommandKind,
+            readUsageCommandOutput: this.readUsageCommandOutput,
+            readAuthStatusOutput: this.readAuthStatusOutput,
+            now: this.now(),
+            selectedEvents
+        });
+        const primaryLimitWindows = liveLimitWindows.primaryLimitWindows.length > 0
+            ? liveLimitWindows.primaryLimitWindows
+            : fallbackPrimaryLimitWindows;
+        const secondaryLimitWindows = liveLimitWindows.secondaryLimitWindows.length > 0
+            ? liveLimitWindows.secondaryLimitWindows
+            : fallbackSecondaryLimitWindows;
         return {
             providerId: this.id,
             providerLabel: this.label,
@@ -99,14 +150,18 @@ export class ClaudeUsageProvider extends UsageProviderBase {
                 totals: summaryTotals,
                 distinctModels: modelUsage.map((row) => row.modelId),
                 distinctPlanTypes: [...planTypes].sort(),
-                rootLabel: "~/.claude/projects",
+                rootLabel: resolvedSessionsRoot.rootLabel,
                 rootPath: sessionsRoot
             },
             modelUsage,
             dayUsage,
             primaryLimitWindows,
             secondaryLimitWindows,
-            warnings
+            warnings,
+            analytics: {
+                agentName,
+                userIdHash
+            }
         };
     }
 }
@@ -127,13 +182,7 @@ function normalizeUsage(value) {
     };
 }
 function resolveRate(modelId) {
-    const candidates = Object.keys(RATE_CARD).sort((left, right) => right.length - left.length);
-    for (const candidate of candidates) {
-        if (modelId === candidate || modelId.startsWith(`${candidate}-`)) {
-            return RATE_CARD[candidate];
-        }
-    }
-    return undefined;
+    return resolveUsageRate(RATE_CARD, modelId, 0, { prefixMatch: true });
 }
 function isInternalClaudeModel(modelId) {
     return modelId === "<synthetic>";
@@ -155,30 +204,27 @@ function creditsFor(modelId, usage) {
 }
 function usageToTotals(modelId, usage) {
     const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
-    const inputTotalTokens = usage.inputTokens +
-        cacheWriteBreakdown.cacheWrite5mInputTokens +
-        cacheWriteBreakdown.cacheWrite1hInputTokens +
-        usage.cacheReadInputTokens;
+    const cacheWriteInputTokens = cacheWriteBreakdown.cacheWrite5mInputTokens +
+        cacheWriteBreakdown.cacheWrite1hInputTokens;
     return {
-        inputTotalTokens,
+        inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
+        cacheReadInputTokens: usage.cacheReadInputTokens,
+        cacheWriteInputTokens,
+        cacheWrite5mInputTokens: cacheWriteBreakdown.cacheWrite5mInputTokens,
+        cacheWrite1hInputTokens: cacheWriteBreakdown.cacheWrite1hInputTokens,
         reasoningOutputTokens: 0,
-        totalTokens: inputTotalTokens + usage.outputTokens,
+        totalTokens: usage.inputTokens +
+            usage.cacheReadInputTokens +
+            cacheWriteInputTokens +
+            usage.outputTokens,
         estimatedCredits: creditsFor(modelId, usage),
-        eventCount: 1,
-        tokenBreakdown: {
-            schema: "anthropic",
-            inputTokens: usage.inputTokens,
-            cacheWrite5mInputTokens: cacheWriteBreakdown.cacheWrite5mInputTokens,
-            cacheWrite1hInputTokens: cacheWriteBreakdown.cacheWrite1hInputTokens,
-            cacheReadInputTokens: usage.cacheReadInputTokens,
-            outputTokens: usage.outputTokens
-        }
+        eventCount: 1
     };
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals("anthropic");
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }
@@ -191,7 +237,87 @@ function resolveClaudeCacheWriteBreakdown(usage) {
     };
 }
 function isSessionFile(filePath) {
-    return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.claude${path.sep}projects${path.sep}`);
+    return filePath.endsWith(".jsonl");
+}
+async function resolveClaudeSessionsRoot(root) {
+    const candidates = buildClaudeSessionsRootCandidates(root);
+    for (const candidate of candidates) {
+        if (await isDirectory(candidate.rootPath)) {
+            return candidate;
+        }
+    }
+    return candidates[0] ?? {
+        rootLabel: "~/.claude/projects",
+        rootPath: path.join(path.resolve(root), ".claude", "projects")
+    };
+}
+function buildClaudeSessionsRootCandidates(root) {
+    const resolvedRoot = path.resolve(root);
+    const baseName = path.basename(resolvedRoot);
+    const parentBaseName = path.basename(path.dirname(resolvedRoot));
+    const candidates = [];
+    if (baseName === "projects") {
+        if (parentBaseName === ".claude") {
+            candidates.push({
+                rootLabel: "~/.claude/projects",
+                rootPath: resolvedRoot
+            });
+        }
+        else if (parentBaseName === "claude" || parentBaseName === "Claude") {
+            candidates.push({
+                rootLabel: `~/.config/${parentBaseName}/projects`,
+                rootPath: resolvedRoot
+            });
+        }
+        else {
+            candidates.push({
+                rootLabel: "projects",
+                rootPath: resolvedRoot
+            });
+        }
+    }
+    if (baseName === ".claude") {
+        candidates.push({
+            rootLabel: "~/.claude/projects",
+            rootPath: path.join(resolvedRoot, "projects")
+        });
+    }
+    if (parentBaseName === ".config" && (baseName === "claude" || baseName === "Claude")) {
+        candidates.push({
+            rootLabel: `~/.config/${baseName}/projects`,
+            rootPath: path.join(resolvedRoot, "projects")
+        });
+    }
+    candidates.push({
+        rootLabel: "~/.claude/projects",
+        rootPath: path.join(resolvedRoot, ".claude", "projects")
+    }, {
+        rootLabel: "~/.config/claude/projects",
+        rootPath: path.join(resolvedRoot, ".config", "claude", "projects")
+    }, {
+        rootLabel: "~/.config/Claude/projects",
+        rootPath: path.join(resolvedRoot, ".config", "Claude", "projects")
+    });
+    const dedupedCandidates = new Map();
+    for (const candidate of candidates) {
+        const normalizedPath = path.resolve(candidate.rootPath);
+        if (!dedupedCandidates.has(normalizedPath)) {
+            dedupedCandidates.set(normalizedPath, {
+                rootLabel: candidate.rootLabel,
+                rootPath: normalizedPath
+            });
+        }
+    }
+    return [...dedupedCandidates.values()];
+}
+async function isDirectory(directoryPath) {
+    try {
+        const stats = await fs.promises.stat(directoryPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
 }
 async function* walkSessionFiles(directory) {
     let entries;
@@ -211,11 +337,28 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function parseSessionFile(filePath, parsedEvents) {
+async function loadParsedClaudeSessionFiles(sessionsRoot) {
+    const cacheKey = path.resolve(sessionsRoot);
+    const cached = parsedClaudeSessionFilesCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const pending = (async () => {
+        const files = [];
+        for await (const filePath of walkSessionFiles(sessionsRoot)) {
+            files.push(await parseSessionFile(filePath));
+        }
+        return files;
+    })();
+    parsedClaudeSessionFilesCache.set(cacheKey, pending);
+    return pending;
+}
+async function parseSessionFile(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let linesRead = 0;
     let malformedLines = 0;
+    const events = [];
     for await (const line of lineReader) {
         linesRead += 1;
         if (!line.trim()) {
@@ -243,17 +386,17 @@ async function parseSessionFile(filePath, parsedEvents) {
         const normalizedUsage = normalizeUsage(usage);
         const usageKey = buildUsageEventKey(payloadObject, message);
         const usageSignature = buildUsageSignature(payloadObject, modelId, normalizedUsage);
-        const parsedEvent = {
+        events.push({
+            entrypoint: typeof payloadObject.entrypoint === "string" ? payloadObject.entrypoint : "",
             usageKey,
             usageSignature,
             timestampMs: eventTimeMs,
             modelId,
             totals: usageToTotals(modelId, normalizedUsage),
             rateLimits
-        };
-        recordParsedUsageEvent(parsedEvents, parsedEvent);
+        });
     }
-    return { linesRead, malformedLines };
+    return { linesRead, malformedLines, events };
 }
 function buildUsageEventKey(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
@@ -327,3 +470,343 @@ function normalizeTimestamp(value) {
 function extractRateLimits(payloadObject, message) {
     return asRecord(payloadObject.rate_limits) ?? asRecord(message?.rate_limits);
 }
+async function buildLiveLimitWindows(options) {
+    const [usageOutput, subscriptionType] = await Promise.all([
+        readClaudeUsageCommandOutput(options.root, options.usageCommandKind, options.readUsageCommandOutput),
+        readClaudeSubscriptionType(options.root, options.usageCommandKind, options.readAuthStatusOutput)
+    ]);
+    const snapshots = parseLiveUsageWindowSnapshots(usageOutput, options.now);
+    const resolvedPlanType = subscriptionType || "live";
+    return {
+        primaryLimitWindows: snapshots
+            .filter((snapshot) => snapshot.scope === "primary")
+            .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now)),
+        secondaryLimitWindows: snapshots
+            .filter((snapshot) => snapshot.scope === "secondary")
+            .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now))
+    };
+}
+async function readClaudeSubscriptionType(root, usageCommandKind, override) {
+    const output = await readClaudeAuthStatusOutput(root, usageCommandKind, override);
+    return parseClaudeSubscriptionType(output);
+}
+async function readClaudeAuthStatusOutput(root, usageCommandKind, override) {
+    if (override) {
+        try {
+            return await override();
+        }
+        catch {
+            return null;
+        }
+    }
+    const cacheKey = `${usageCommandKind}:${path.resolve(root)}`;
+    const cached = claudeAuthStatusOutputCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const pending = (async () => {
+        const binaryPath = await resolveClaudeBinaryPath(root, usageCommandKind);
+        if (!binaryPath) {
+            return null;
+        }
+        try {
+            const { stdout, stderr } = await execFileAsync(binaryPath, ["auth", "status"], {
+                encoding: "utf8",
+                maxBuffer: 1024 * 1024,
+                timeout: 15000,
+                windowsHide: true
+            });
+            const combined = [stdout, stderr].filter(Boolean).join("\n").trim();
+            return combined || null;
+        }
+        catch (error) {
+            const combined = extractExecOutput(error);
+            return combined || null;
+        }
+    })();
+    claudeAuthStatusOutputCache.set(cacheKey, pending);
+    return pending;
+}
+function parseClaudeSubscriptionType(output) {
+    const snapshot = parseClaudeAuthStatusSnapshot(output);
+    return snapshot?.subscriptionType ?? null;
+}
+function parseClaudeAuthStatusSnapshot(output) {
+    if (!output) {
+        return null;
+    }
+    const normalizedOutput = output.replace(ANSI_ESCAPE_SEQUENCE, "").trim();
+    const firstBraceIndex = normalizedOutput.indexOf("{");
+    const lastBraceIndex = normalizedOutput.lastIndexOf("}");
+    if (firstBraceIndex < 0 || lastBraceIndex <= firstBraceIndex) {
+        return null;
+    }
+    try {
+        const payload = JSON.parse(normalizedOutput.slice(firstBraceIndex, lastBraceIndex + 1));
+        const record = asRecord(payload);
+        const email = typeof record?.email === "string" ? record.email.trim() : "";
+        const orgId = typeof record?.orgId === "string" ? record.orgId.trim() : "";
+        const orgName = typeof record?.orgName === "string" ? record.orgName.trim() : "";
+        const subscriptionType = typeof record?.subscriptionType === "string" ? record.subscriptionType.trim() : "";
+        if (!email || !orgId || !orgName || !subscriptionType) {
+            return null;
+        }
+        return { email, orgId, orgName, subscriptionType };
+    }
+    catch {
+        return null;
+    }
+}
+async function readClaudeUserIdHash(root, usageCommandKind, override, agentName) {
+    const authStatusOutput = await readClaudeAuthStatusOutput(root, usageCommandKind, override);
+    const snapshot = parseClaudeAuthStatusSnapshot(authStatusOutput);
+    if (!snapshot) {
+        return null;
+    }
+    return buildUserIdHash([agentName, snapshot.email, snapshot.orgId, snapshot.orgName]);
+}
+async function readClaudeUsageCommandOutput(root, usageCommandKind, override) {
+    if (override) {
+        try {
+            return await override();
+        }
+        catch {
+            return null;
+        }
+    }
+    const cacheKey = `${usageCommandKind}:${path.resolve(root)}`;
+    const cached = claudeUsageOutputCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const pending = (async () => {
+        const binaryPath = await resolveClaudeBinaryPath(root, usageCommandKind);
+        if (!binaryPath) {
+            return null;
+        }
+        try {
+            const { stdout, stderr } = await execFileAsync(binaryPath, ["-p", "/usage"], {
+                encoding: "utf8",
+                maxBuffer: 1024 * 1024,
+                timeout: 15000,
+                windowsHide: true
+            });
+            const combined = [stdout, stderr].filter(Boolean).join("\n").trim();
+            return combined || null;
+        }
+        catch (error) {
+            const combined = extractExecOutput(error);
+            return combined || null;
+        }
+    })();
+    claudeUsageOutputCache.set(cacheKey, pending);
+    return pending;
+}
+function extractExecOutput(error) {
+    if (!error || typeof error !== "object") {
+        return "";
+    }
+    const stdout = typeof error.stdout === "string" ? error.stdout : "";
+    const stderr = typeof error.stderr === "string" ? error.stderr : "";
+    return [stdout, stderr].filter(Boolean).join("\n").trim();
+}
+async function resolveClaudeBinaryPath(root, usageCommandKind) {
+    const cacheKey = `${usageCommandKind}:${path.resolve(root)}`;
+    const cached = claudeBinaryPathCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const pending = usageCommandKind === "vscode"
+        ? resolveVsCodeClaudeBinaryPath(root)
+        : resolveCliClaudeBinaryPath(root);
+    claudeBinaryPathCache.set(cacheKey, pending);
+    return pending;
+}
+async function resolveVsCodeClaudeBinaryPath(root) {
+    const boosterDirectories = [
+        path.join(root, ".vscode", "extensions"),
+        path.join(root, ".vscode-server", "extensions"),
+        path.join(root, ".vscode-server-insiders", "extensions")
+    ];
+    for (const directory of boosterDirectories) {
+        const binaryPath = await resolveClaudeBinaryFromExtensionDirectory(directory);
+        if (binaryPath) {
+            return binaryPath;
+        }
+    }
+    return null;
+}
+async function resolveClaudeBinaryFromExtensionDirectory(directory) {
+    let entries;
+    try {
+        entries = await fs.promises.readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    const candidates = entries
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith(VSCODE_CLAUDE_EXTENSION_PREFIX))
+        .map((entry) => entry.name)
+        .sort(compareClaudeExtensionDirectoryNames);
+    for (const candidate of candidates) {
+        const binaryPath = path.join(directory, candidate, "resources", "native-binary", "claude");
+        if (await isReadableExecutableFile(binaryPath)) {
+            return binaryPath;
+        }
+    }
+    return null;
+}
+function compareClaudeExtensionDirectoryNames(left, right) {
+    const leftVersion = extractClaudeExtensionVersion(left);
+    const rightVersion = extractClaudeExtensionVersion(right);
+    const length = Math.max(leftVersion.length, rightVersion.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (rightVersion[index] ?? 0) - (leftVersion[index] ?? 0);
+        if (difference !== 0) {
+            return difference;
+        }
+    }
+    return right.localeCompare(left);
+}
+function extractClaudeExtensionVersion(directoryName) {
+    if (!directoryName.startsWith(VSCODE_CLAUDE_EXTENSION_PREFIX)) {
+        return [];
+    }
+    const versionLabel = directoryName.slice(VSCODE_CLAUDE_EXTENSION_PREFIX.length).split("-")[0] ?? "";
+    return versionLabel
+        .split(".")
+        .map((part) => Number(part))
+        .filter((part) => Number.isFinite(part));
+}
+async function resolveCliClaudeBinaryPath(root) {
+    const directCandidates = [
+        path.join(root, ".local", "bin", "claude"),
+        path.join(root, "bin", "claude")
+    ];
+    for (const candidate of directCandidates) {
+        if (await isReadableExecutableFile(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function isReadableExecutableFile(filePath) {
+    try {
+        await fs.promises.access(filePath, fs.constants.R_OK | fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseLiveUsageWindowSnapshots(usageOutput, now) {
+    if (!usageOutput) {
+        return [];
+    }
+    const snapshots = new Map();
+    const normalizedOutput = usageOutput.replace(ANSI_ESCAPE_SEQUENCE, "");
+    for (const line of normalizedOutput.split(/\r?\n/)) {
+        const match = line
+            .trim()
+            .match(/^Current\s+(session|week)(?:\s+\([^)]+\))?:\s+(\d+)%\s+used\b.*?\bresets\s+(.+)$/i);
+        if (!match) {
+            continue;
+        }
+        const label = match[1].toLowerCase() === "session" ? "session" : "week";
+        const usedPercent = Number(match[2]);
+        const windowMinutes = label === "session" ? CLAUDE_SESSION_WINDOW_MINUTES : CLAUDE_WEEK_WINDOW_MINUTES;
+        const resetsAtMs = parseResetTimestampUtc(match[3], now.getTime(), windowMinutes);
+        if (!Number.isFinite(usedPercent) || !resetsAtMs) {
+            continue;
+        }
+        snapshots.set(label, {
+            scope: label === "session" ? "primary" : "secondary",
+            label,
+            usedPercent,
+            resetsAtMs,
+            windowMinutes
+        });
+    }
+    return [...snapshots.values()].sort((left, right) => left.windowMinutes - right.windowMinutes);
+}
+function parseResetTimestampUtc(value, nowMs, windowMinutes) {
+    const match = value
+        .trim()
+        .match(/^([A-Za-z]{3})\s+(\d{1,2}),\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s+\(UTC\)$/i);
+    if (!match) {
+        return null;
+    }
+    const monthIndex = MONTH_INDEX_BY_LABEL[match[1].slice(0, 3).toLowerCase()];
+    const day = Number(match[2]);
+    const hour12 = Number(match[3]);
+    const minute = Number(match[4] ?? "0");
+    const meridiem = match[5].toLowerCase();
+    if (monthIndex === undefined ||
+        !Number.isFinite(day) ||
+        !Number.isFinite(hour12) ||
+        !Number.isFinite(minute) ||
+        day < 1 ||
+        day > 31 ||
+        hour12 < 1 ||
+        hour12 > 12 ||
+        minute < 0 ||
+        minute > 59) {
+        return null;
+    }
+    const hour24 = resolveHour24(hour12, meridiem);
+    const currentYear = new Date(nowMs).getUTCFullYear();
+    const candidates = [currentYear - 1, currentYear, currentYear + 1]
+        .map((year) => Date.UTC(year, monthIndex, day, hour24, minute))
+        .filter((candidate) => Number.isFinite(candidate));
+    const maxFutureMs = nowMs + windowMinutes * 60000 + 24 * 60 * 60 * 1000;
+    const plausibleFutureCandidate = candidates
+        .filter((candidate) => candidate >= nowMs - 60000 && candidate <= maxFutureMs)
+        .sort((left, right) => left - right)[0];
+    if (plausibleFutureCandidate !== undefined) {
+        return plausibleFutureCandidate;
+    }
+    const nearestCandidate = candidates.sort((left, right) => Math.abs(left - nowMs) - Math.abs(right - nowMs))[0];
+    return nearestCandidate ?? null;
+}
+function resolveHour24(hour12, meridiem) {
+    if (hour12 === 12) {
+        return meridiem === "am" ? 0 : 12;
+    }
+    return meridiem === "pm" ? hour12 + 12 : hour12;
+}
+function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
+    const startTimeMs = snapshot.resetsAtMs - snapshot.windowMinutes * 60000;
+    const inWindowEvents = selectedEvents.filter((event) => Number.isFinite(event.timestampMs) &&
+        event.timestampMs >= startTimeMs &&
+        event.timestampMs < snapshot.resetsAtMs);
+    const totals = sumUsageTotals(inWindowEvents.map((event) => event.totals));
+    const fallbackLastSeenMs = Math.min(now.getTime(), snapshot.resetsAtMs);
+    const firstSeenMs = inWindowEvents.reduce((minimum, event) => Math.min(minimum, event.timestampMs), Number.POSITIVE_INFINITY);
+    const lastSeenMs = inWindowEvents.reduce((maximum, event) => Math.max(maximum, event.timestampMs), Number.NEGATIVE_INFINITY);
+    return {
+        scope: snapshot.scope,
+        planType,
+        limitId: `current-${snapshot.label}`,
+        windowMinutes: snapshot.windowMinutes,
+        startTimeUtcIso: toUtcIso(startTimeMs),
+        endTimeUtcIso: toUtcIso(snapshot.resetsAtMs),
+        firstSeenUtcIso: toUtcIso(Number.isFinite(firstSeenMs) ? firstSeenMs : startTimeMs),
+        lastSeenUtcIso: toUtcIso(Number.isFinite(lastSeenMs) ? lastSeenMs : fallbackLastSeenMs),
+        minUsedPercent: snapshot.usedPercent,
+        maxUsedPercent: snapshot.usedPercent,
+        totals,
+        eventCount: totals.eventCount
+    };
+}
+function toUtcIso(value) {
+    return new Date(value).toISOString().replace(".000Z", "Z");
+}
+function buildUserIdHash(parts) {
+    if (parts.some((part) => !part)) {
+        return null;
+    }
+    return createHash("md5").update(parts.join("-")).digest("hex");
+}
+function normalizeAnalyticsAgentName(label) {
+    return label.replace(/\s+/g, "");
+}