opencode-tokenwatch 0.1.0 → 0.3.0

package/dist/i18n.d.ts

@@ -0,0 +1,5 @@
+export type SupportedLanguage = "zh" | "en";
+export declare function detectLanguage(): SupportedLanguage;
+export declare function setLanguage(lang: SupportedLanguage | "auto"): void;
+export declare function getCurrentLanguage(): SupportedLanguage;
+export declare function t(key: string): string;

package/dist/i18n.js

@@ -0,0 +1,171 @@
+const zh = {
+    panelTitle: "TokenWatch",
+    collapse: "折叠",
+    expand: "展开",
+    sessionSummary: "会话累计",
+    input: "输入",
+    output: "输出",
+    cacheRead: "缓存",
+    cacheWrite: "缓存写",
+    cacheMiss: "未命中",
+    hitRate: "命中率",
+    requests: "请求",
+    cost: "成本",
+    trendUp: "↑",
+    trendDown: "↓",
+    cache: "缓存",
+    performance: "性能",
+    pricing: "Pricing",
+    tokenDistribution: "Token分布",
+    modelLabel: "模型",
+    provider: "提供商",
+    ttft: "TTFT",
+    tps: "TPS",
+    latency: "延迟",
+    avg: "平均",
+    max: "最大",
+    min: "最小",
+    read: "读",
+    write: "写",
+    sessionAccumulated: "Session累计",
+    saving: "节省",
+    priceInput: "输入",
+    priceCacheRead: "缓存读",
+    priceCacheWrite: "缓存写",
+    priceOutput: "输出",
+    total: "总计",
+    system: "系统提示",
+    user: "用户",
+    agent: "Agent指令",
+    toolCall: "Tool调用",
+    toolResult: "Tool结果",
+    outputTokens: "输出",
+    showPerformance: "显示性能指标",
+    showPricing: "显示模型定价",
+    showTokenDistribution: "显示Token分布",
+    showTrend: "显示趋势指示器",
+    language: "语言",
+    auto: "自动",
+    cmdTitleHtml: "HTML报告",
+    cmdDescHtml: "生成交互式HTML仪表盘，展示Token用量、缓存和性能图表",
+    cmdTitleJson: "JSON导出",
+    cmdDescJson: "导出原始用量数据为JSON文件",
+    cmdTitleText: "文本报告",
+    cmdDescText: "生成纯文本报告文件",
+    cmdTitleSettings: "设置",
+    cmdDescSettings: "配置侧边栏显示选项",
+    descShowPerformance: "在侧边栏显示TPS、TTFT、延迟等指标",
+    descShowPricing: "在侧边栏显示成本估算",
+    descShowTokenDistribution: "在侧边栏显示输入/输出/推理Token细分",
+    descShowTrend: "在侧边栏显示Token用量趋势",
+    settingsLanguage: "语言",
+    descSettingsLanguage: "切换显示语言",
+    settingsTitle: "TokenWatch设置",
+    settingsPlaceholder: "切换设置项...",
+    langAuto: "自动",
+    done: "完成",
+    closeSettings: "关闭设置",
+    menuToday: "今天",
+    menu7d: "最近 7 天",
+    menu30d: "最近 30 天",
+    menuAll: "全部时间",
+};
+const en = {
+    panelTitle: "TokenWatch",
+    collapse: "Collapse",
+    expand: "Expand",
+    sessionSummary: "Session",
+    input: "Input",
+    output: "Output",
+    cacheRead: "Cache",
+    cacheWrite: "C.Write",
+    cacheMiss: "Cache Miss",
+    hitRate: "Hit Rate",
+    requests: "Req",
+    cost: "Cost",
+    trendUp: "↑",
+    trendDown: "↓",
+    cache: "Cache",
+    performance: "Performance",
+    pricing: "Pricing",
+    tokenDistribution: "Token Distribution",
+    modelLabel: "Model",
+    provider: "Provider",
+    ttft: "TTFT",
+    tps: "TPS",
+    latency: "Latency",
+    avg: "Avg",
+    max: "Max",
+    min: "Min",
+    read: "Read",
+    write: "Write",
+    sessionAccumulated: "Session Accumulated",
+    saving: "Saving",
+    priceInput: "Input",
+    priceCacheRead: "Cache Read",
+    priceCacheWrite: "Cache Write",
+    priceOutput: "Output",
+    total: "Total",
+    system: "System",
+    user: "User",
+    agent: "Agent",
+    toolCall: "Tool Call",
+    toolResult: "Tool Result",
+    outputTokens: "Output",
+    showPerformance: "Show Performance",
+    showPricing: "Show Pricing",
+    showTokenDistribution: "Show Token Distribution",
+    showTrend: "Show Trend",
+    language: "Language",
+    auto: "Auto",
+    cmdTitleHtml: "HTML Report",
+    cmdDescHtml: "Generate interactive HTML dashboard with token usage, cache, and performance charts",
+    cmdTitleJson: "JSON Export",
+    cmdDescJson: "Export raw usage data as JSON file",
+    cmdTitleText: "Text Report",
+    cmdDescText: "Generate plain text report file",
+    cmdTitleSettings: "Settings",
+    cmdDescSettings: "Configure sidebar display options",
+    descShowPerformance: "Display TPS, TTFT, latency metrics in sidebar",
+    descShowPricing: "Display cost estimates in sidebar",
+    descShowTokenDistribution: "Display input/output/reasoning token breakdown in sidebar",
+    descShowTrend: "Display token usage trend in sidebar",
+    settingsLanguage: "Language",
+    descSettingsLanguage: "Switch display language",
+    settingsTitle: "TokenWatch Settings",
+    settingsPlaceholder: "Toggle settings...",
+    langAuto: "Auto",
+    done: "Done",
+    closeSettings: "Close settings",
+    menuToday: "Today",
+    menu7d: "Last 7 Days",
+    menu30d: "Last 30 Days",
+    menuAll: "All Time",
+};
+let currentLang = detectLanguage();
+export function detectLanguage() {
+    try {
+        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+        if (locale.startsWith("zh"))
+            return "zh";
+    }
+    catch {
+        // Intl may not be available in restricted environments
+    }
+    return "en";
+}
+export function setLanguage(lang) {
+    if (lang === "auto") {
+        currentLang = detectLanguage();
+    }
+    else {
+        currentLang = lang;
+    }
+}
+export function getCurrentLanguage() {
+    return currentLang;
+}
+export function t(key) {
+    const table = currentLang === "zh" ? zh : en;
+    return table[key] ?? key;
+}

package/dist/perf-tracker.d.ts

@@ -0,0 +1,60 @@
+import type { LogEntry, SessionPerfStats } from "./formatter.js";
+interface PartEvent {
+    message_id?: string;
+    type?: string;
+    text?: string;
+    time?: {
+        start?: number;
+    };
+}
+interface MessageUpdateEvent {
+    properties: {
+        info: {
+            id?: string;
+            sessionID?: string;
+            role?: string;
+            providerID?: string;
+            modelID?: string;
+            tokens?: {
+                input?: number;
+                output?: number;
+                reasoning?: number;
+                cache?: {
+                    read?: number;
+                    write?: number;
+                };
+            };
+            cost?: number;
+            time?: {
+                created?: number;
+                completed?: number;
+            };
+        };
+    };
+}
+interface MessageRemoveEvent {
+    properties: {
+        sessionID?: string;
+        messageID?: string;
+    };
+}
+declare class PerfTracker {
+    private firstPartTimes;
+    private statsMap;
+    /** 原始样本串，用于分位数计算，不持久化 */
+    private ttftSamples;
+    private latencySamples;
+    handlePartUpdated(event: PartEvent): void;
+    handleMessageUpdated(event: MessageUpdateEvent): void;
+    private appendLog;
+    handleMessageRemoved(event: MessageRemoveEvent): void;
+    private updateStats;
+    /** 计算有序数组的指定百分位数（线性插值法） */
+    private percentile;
+    getSessionStats(): SessionPerfStats;
+    readLogs(last?: number): LogEntry[];
+    reset(): void;
+}
+export declare function createPerfTracker(): PerfTracker;
+export type { PartEvent, PerfTracker };
+export declare function readLogs(last?: number): LogEntry[];

package/dist/perf-tracker.js

@@ -0,0 +1,257 @@
+import { appendFileSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, statSync } from "node:fs";
+const LOG_PATH = join(homedir(), ".opencode", "tokenwatch.jsonl");
+class PerfTracker {
+    firstPartTimes = new Map();
+    statsMap = new Map();
+    /** 原始样本串，用于分位数计算，不持久化 */
+    ttftSamples = new Map();
+    latencySamples = new Map();
+    handlePartUpdated(event) {
+        if (!event.time?.start || !event.message_id)
+            return;
+        // Bug fix: 取最早 part 时间而非最后一个，避免 TTFT 被高估
+        const cur = this.firstPartTimes.get(event.message_id) ?? Number.POSITIVE_INFINITY;
+        if (event.time.start < cur) {
+            this.firstPartTimes.set(event.message_id, event.time.start);
+        }
+    }
+    handleMessageUpdated(event) {
+        const info = event.properties?.info;
+        if (!info || info.role !== "assistant")
+            return;
+        if (!info.time?.completed)
+            return;
+        const messageID = info.id ?? "";
+        const created = info.time.created;
+        const completed = info.time.completed;
+        if (!created || !completed) {
+            this.firstPartTimes.delete(messageID);
+            return;
+        }
+        const sessionID = info.sessionID ?? "";
+        const providerID = info.providerID ?? "unknown";
+        const modelID = info.modelID ?? "unknown";
+        const model = `${providerID}/${modelID}`;
+        const tokens = info.tokens;
+        const inputTokens = tokens?.input ?? 0;
+        const outputTokens = tokens?.output ?? 0;
+        const reasoningTokens = tokens?.reasoning ?? 0;
+        const cacheRead = tokens?.cache?.read ?? 0;
+        const cacheWrite = tokens?.cache?.write ?? 0;
+        const cost = info.cost ?? 0;
+        const firstPart = this.firstPartTimes.get(messageID) ?? null;
+        const latencyMs = completed - created;
+        const ttftMs = firstPart !== null ? firstPart - created : null;
+        const genMs = firstPart !== null ? completed - firstPart : null;
+        const tps = (genMs !== null && genMs > 0 && outputTokens > 0)
+            ? (outputTokens / genMs) * 1000
+            : null;
+        // Bug fix: 移除 TPS fallback。
+        // 原 fallback 用 latencyMs（completed-created，含排队+TTFT）计算 TPS，
+        // 会使结果严重低估（约 40%+）。null 表示"无可靠数据"比虚假数字更好。
+        this.firstPartTimes.delete(messageID);
+        const entry = {
+            ts: new Date().toISOString(),
+            model,
+            providerID,
+            modelID,
+            sessionID,
+            ttft_ms: ttftMs,
+            tps: tps, // 只在有可靠 genMs 时才有值
+            latency_ms: latencyMs,
+            inputTokens,
+            outputTokens,
+            reasoningTokens,
+            cacheReadTokens: cacheRead,
+            cacheWriteTokens: cacheWrite,
+            cost,
+        };
+        this.appendLog(entry);
+        this.updateStats(model, entry);
+    }
+    appendLog(entry) {
+        try {
+            // Risk fix: JSONL 日志轮转保护，防止长期使用后文件无限增长
+            // 超过 5MB 时截断，保留最新 2000 行
+            const MAX_SIZE = 5 * 1024 * 1024; // 5 MB
+            const KEEP_LINES = 2000;
+            if (existsSync(LOG_PATH) && statSync(LOG_PATH).size > MAX_SIZE) {
+                const lines = readFileSync(LOG_PATH, "utf-8").trim().split("\n");
+                writeFileSync(LOG_PATH, lines.slice(-KEEP_LINES).join("\n") + "\n");
+            }
+            appendFileSync(LOG_PATH, JSON.stringify(entry) + "\n");
+        }
+        catch {
+            // Silently fail — logging is non-critical
+        }
+    }
+    handleMessageRemoved(event) {
+        const mid = event.properties?.messageID ?? "";
+        if (mid) {
+            this.firstPartTimes.delete(mid);
+        }
+    }
+    updateStats(model, entry) {
+        let stats = this.statsMap.get(model);
+        if (!stats) {
+            stats = {
+                model,
+                providerID: entry.providerID,
+                requestCount: 0,
+                ttftCount: 0, // Bug fix: 独立维护有效样本计数
+                tpsCount: 0,
+                latencyCount: 0,
+                totalInput: 0,
+                totalOutput: 0,
+                totalCacheRead: 0,
+                totalCacheWrite: 0,
+                totalCost: 0,
+                avgTTFT: null,
+                maxTTFT: null,
+                minTTFT: null,
+                p50TTFT: null,
+                p95TTFT: null,
+                p99TTFT: null,
+                avgTPS: null,
+                maxTPS: null,
+                minTPS: null,
+                avgLatency: null,
+                maxLatency: null,
+                minLatency: null,
+                p50Latency: null,
+                p95Latency: null,
+                p99Latency: null,
+                cacheHitRate: null,
+            };
+            this.statsMap.set(model, stats);
+        }
+        stats.requestCount++;
+        stats.totalInput += entry.inputTokens;
+        stats.totalOutput += entry.outputTokens;
+        stats.totalCacheRead += entry.cacheReadTokens;
+        stats.totalCacheWrite += entry.cacheWriteTokens;
+        stats.totalCost += entry.cost;
+        if (entry.ttft_ms !== null) {
+            // Bug fix: 分母使用 ttftCount（有效样本数），而非 requestCount（总请求数）
+            stats.ttftCount++;
+            const c = stats.ttftCount;
+            const prev = stats.avgTTFT;
+            stats.avgTTFT = prev !== null ? prev + (entry.ttft_ms - prev) / c : entry.ttft_ms;
+            stats.maxTTFT = stats.maxTTFT !== null ? Math.max(stats.maxTTFT, entry.ttft_ms) : entry.ttft_ms;
+            stats.minTTFT = stats.minTTFT !== null ? Math.min(stats.minTTFT, entry.ttft_ms) : entry.ttft_ms;
+            // 收集原始样本用于分位数计算
+            const ttftArr = this.ttftSamples.get(model) ?? [];
+            ttftArr.push(entry.ttft_ms);
+            this.ttftSamples.set(model, ttftArr);
+        }
+        if (entry.tps !== null) {
+            // Bug fix: 分母使用 tpsCount（有效样本数）
+            stats.tpsCount++;
+            const c = stats.tpsCount;
+            const prev = stats.avgTPS;
+            stats.avgTPS = prev !== null ? prev + (entry.tps - prev) / c : entry.tps;
+            stats.maxTPS = stats.maxTPS !== null ? Math.max(stats.maxTPS, entry.tps) : entry.tps;
+            stats.minTPS = stats.minTPS !== null ? Math.min(stats.minTPS, entry.tps) : entry.tps;
+        }
+        if (entry.latency_ms !== null) {
+            // latency 每条消息都有，但保持一致使用专用计数
+            stats.latencyCount++;
+            const c = stats.latencyCount;
+            const prev = stats.avgLatency;
+            stats.avgLatency = prev !== null ? prev + (entry.latency_ms - prev) / c : entry.latency_ms;
+            stats.maxLatency = stats.maxLatency !== null ? Math.max(stats.maxLatency, entry.latency_ms) : entry.latency_ms;
+            stats.minLatency = stats.minLatency !== null ? Math.min(stats.minLatency, entry.latency_ms) : entry.latency_ms;
+            // 收集原始样本用于分位数计算
+            const latArr = this.latencySamples.get(model) ?? [];
+            latArr.push(entry.latency_ms);
+            this.latencySamples.set(model, latArr);
+        }
+    }
+    /** 计算有序数组的指定百分位数（线性插值法） */
+    percentile(sortedArr, p) {
+        if (sortedArr.length === 0)
+            return null;
+        if (sortedArr.length === 1)
+            return sortedArr[0];
+        const idx = (p / 100) * (sortedArr.length - 1);
+        const lo = Math.floor(idx);
+        const hi = Math.ceil(idx);
+        if (lo === hi)
+            return sortedArr[lo];
+        return sortedArr[lo] + (sortedArr[hi] - sortedArr[lo]) * (idx - lo);
+    }
+    getSessionStats() {
+        let totalInput = 0, totalOutput = 0, totalCacheRead = 0, totalCacheWrite = 0;
+        let totalRequests = 0, totalCost = 0;
+        let weightedHitSum = 0, totalReqForHit = 0;
+        for (const [model, s] of this.statsMap) {
+            totalInput += s.totalInput;
+            totalOutput += s.totalOutput;
+            totalCacheRead += s.totalCacheRead;
+            totalCacheWrite += s.totalCacheWrite;
+            totalRequests += s.requestCount;
+            totalCost += s.totalCost;
+            // 计算每个模型的分位数（需先排序）
+            const ttftArr = [...(this.ttftSamples.get(model) ?? [])].sort((a, b) => a - b);
+            s.p50TTFT = this.percentile(ttftArr, 50);
+            s.p95TTFT = this.percentile(ttftArr, 95);
+            s.p99TTFT = this.percentile(ttftArr, 99);
+            const latArr = [...(this.latencySamples.get(model) ?? [])].sort((a, b) => a - b);
+            s.p50Latency = this.percentile(latArr, 50);
+            s.p95Latency = this.percentile(latArr, 95);
+            s.p99Latency = this.percentile(latArr, 99);
+            // 模型级缓存命中率
+            const denom = s.totalInput + s.totalCacheRead;
+            s.cacheHitRate = denom > 0 ? (s.totalCacheRead / denom) * 100 : null;
+            // 累加加权命中率（按请求数加权）
+            if (s.cacheHitRate !== null) {
+                weightedHitSum += s.cacheHitRate * s.requestCount;
+                totalReqForHit += s.requestCount;
+            }
+        }
+        const weightedCacheHitRate = totalReqForHit > 0 ? weightedHitSum / totalReqForHit : null;
+        return {
+            models: Object.fromEntries(this.statsMap),
+            totals: { totalInput, totalOutput, totalCacheRead, totalCacheWrite, totalRequests, totalCost, weightedCacheHitRate },
+        };
+    }
+    readLogs(last = 50) {
+        try {
+            if (!existsSync(LOG_PATH))
+                return [];
+            const content = readFileSync(LOG_PATH, "utf-8").trim();
+            if (!content)
+                return [];
+            const lines = content.split("\n");
+            const entries = [];
+            for (let i = Math.max(0, lines.length - last); i < lines.length; i++) {
+                try {
+                    entries.push(JSON.parse(lines[i]));
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    }
+    reset() {
+        this.firstPartTimes.clear();
+        this.statsMap.clear();
+        this.ttftSamples.clear();
+        this.latencySamples.clear();
+    }
+}
+export function createPerfTracker() {
+    return new PerfTracker();
+}
+export function readLogs(last = 50) {
+    const tracker = new PerfTracker();
+    return tracker.readLogs(last);
+}

package/dist/queries.d.ts

@@ -1,4 +1,4 @@
-import type { DailyBreakdownItem, ModelBreakdownItem, ProviderBreakdownItem, SessionBreakdownItem, SessionTokenData, UsageFilters, UsageReport } from "./formatter.js";
+import type { DailyBreakdownItem, ErrorStats, ModelBreakdownItem, ProviderBreakdownItem, SessionBreakdownItem, SessionTokenData, UsageFilters, UsageReport } from "./formatter.js";
 export declare function getPresetRange(preset: "all" | "7d" | "30d" | "month"): Pick<UsageFilters, "startDate" | "endDate">;
 export declare function getCurrentSessionStats(sessionId?: string): Promise<SessionTokenData>;
 export declare function getSummary(filters?: UsageFilters): Promise<SessionTokenData>;
@@ -8,5 +8,7 @@ export declare function getDailyBreakdown(filters?: UsageFilters): Promise<Daily
 export declare function getSessionBreakdown(filters?: UsageFilters): Promise<SessionBreakdownItem[]>;
 export declare function getAvailableModels(): Promise<string[]>;
 export declare function getAvailableProviders(): Promise<string[]>;
+/** 失败请求计数 SQL。1次运行获取成功数＋失败数＋按模型细分 */
+export declare function getErrorStats(filters?: UsageFilters): Promise<ErrorStats>;
 export declare function getUsageReport(filters?: UsageFilters): Promise<UsageReport>;
 export declare function exportReportAsCsv(report: UsageReport, section: "models" | "providers" | "daily" | "sessions"): string;