@georgedong32/ccs 7.67.0 → 8.0.0

package/dist/web-server/usage/handlers.js

@@ -5,10 +5,40 @@
  * Contains all route handler logic for usage analytics endpoints.
  * Separated from routes for better testability and organization.
  */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleInsights = exports.handleStatus = exports.handleRefresh = exports.handleMonthly = exports.handleSessions = exports.handleModels = exports.handleHourly = exports.handleDaily = exports.handleSummary = exports.summarizeAnomalies = exports.detectAnomalies = exports.fillHourlyGaps = exports.calculateTokenBreakdownCosts = exports.errorResponse = exports.filterByDateRange = exports.validateOffset = exports.validateLimit = exports.validateDate = void 0;
+exports.handleCursorDataClear = exports.handleCursorStatus = exports.handleCursorImport = exports.handleInsights = exports.handleStatus = exports.handleRefresh = exports.handleMonthly = exports.handleSessions = exports.handleModels = exports.handleHourly = exports.handleDaily = exports.handleSummary = exports.summarizeAnomalies = exports.detectAnomalies = exports.fillHourlyGaps = exports.calculateTokenBreakdownCosts = exports.computeEffectiveIoRatio = exports.errorResponse = exports.filterByDateRange = exports.validateDateRangeOrder = exports.validateOffset = exports.validateLimit = exports.validateDate = void 0;
 const model_pricing_1 = require("../model-pricing");
 const aggregator_1 = require("./aggregator");
+const model_identity_1 = require("./model-identity");
+const cursor_data_store_1 = require("./cursor-data-store");
+const cursor_csv_parser_1 = require("./cursor-csv-parser");
+const profile_filter_1 = require("./profile-filter");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
 // ============================================================================
 // Constants
 // ============================================================================
@@ -65,6 +95,14 @@ function validateOffset(offset) {
     return num;
 }
 exports.validateOffset = validateOffset;
+function validateDateRangeOrder(since, until) {
+    if (!since || !until)
+        return;
+    if (since > until) {
+        throw new Error('The "since" date must be earlier than or equal to "until"');
+    }
+}
+exports.validateDateRangeOrder = validateDateRangeOrder;
 function filterByDateRange(data, since, until) {
     if (!data || !Array.isArray(data))
         return [];
@@ -96,6 +134,55 @@ function errorResponse(res, error, defaultMessage) {
     });
 }
 exports.errorResponse = errorResponse;
+/**
+ * Compute effective I/O ratio including cache tokens.
+ * Cache Read and Cache Creation are both input-side operations.
+ */
+function computeEffectiveIoRatio(inputTokens, cacheCreationTokens, cacheReadTokens, outputTokens) {
+    if (outputTokens <= 0)
+        return 0;
+    return (inputTokens + cacheCreationTokens + cacheReadTokens) / outputTokens;
+}
+exports.computeEffectiveIoRatio = computeEffectiveIoRatio;
+function roundToCurrency(value) {
+    return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+function calculateUsageTotalTokens(input, output, cacheCreation, cacheRead) {
+    return input + output + cacheCreation + cacheRead;
+}
+function parseDateKey(dateString) {
+    return new Date(Date.UTC(Number(dateString.slice(0, 4)), Number(dateString.slice(4, 6)) - 1, Number(dateString.slice(6, 8))));
+}
+function getInclusiveDayCount(start, end) {
+    const dayMs = 24 * 60 * 60 * 1000;
+    return Math.floor((end.getTime() - start.getTime()) / dayMs) + 1;
+}
+function countCalendarDays(data, since, until) {
+    const sortedDates = [...data]
+        .map((item) => item.date.replace(/-/g, ''))
+        .sort((a, b) => a.localeCompare(b));
+    const earliestDate = sortedDates[0];
+    const latestDate = sortedDates[sortedDates.length - 1];
+    if (since && until) {
+        return getInclusiveDayCount(parseDateKey(since), parseDateKey(until));
+    }
+    if (since) {
+        const end = until
+            ? parseDateKey(until)
+            : latestDate
+                ? parseDateKey(latestDate)
+                : parseDateKey(since);
+        return getInclusiveDayCount(parseDateKey(since), end);
+    }
+    if (until) {
+        const start = earliestDate ? parseDateKey(earliestDate) : parseDateKey(until);
+        return getInclusiveDayCount(start, parseDateKey(until));
+    }
+    if (data.length === 0) {
+        return 0;
+    }
+    return getInclusiveDayCount(parseDateKey(earliestDate), parseDateKey(latestDate));
+}
 // ============================================================================
 // Cost Calculation Helpers
 // ============================================================================
@@ -104,7 +191,7 @@ function calculateTokenBreakdownCosts(dailyData) {
     let inputCost = 0, outputCost = 0, cacheCreationCost = 0, cacheReadCost = 0;
     for (const day of dailyData) {
         for (const breakdown of day.modelBreakdowns) {
-            const pricing = (0, model_pricing_1.getModelPricing)(breakdown.modelName);
+            const pricing = (0, model_pricing_1.getModelPricing)(breakdown.modelName, { provider: breakdown.provider });
             inputTokens += breakdown.inputTokens;
             outputTokens += breakdown.outputTokens;
             cacheCreationTokens += breakdown.cacheCreationTokens;
@@ -117,10 +204,10 @@ function calculateTokenBreakdownCosts(dailyData) {
         }
     }
     return {
-        input: { tokens: inputTokens, cost: Math.round(inputCost * 100) / 100 },
-        output: { tokens: outputTokens, cost: Math.round(outputCost * 100) / 100 },
-        cacheCreation: { tokens: cacheCreationTokens, cost: Math.round(cacheCreationCost * 100) / 100 },
-        cacheRead: { tokens: cacheReadTokens, cost: Math.round(cacheReadCost * 100) / 100 },
+        input: { tokens: inputTokens, cost: roundToCurrency(inputCost) },
+        output: { tokens: outputTokens, cost: roundToCurrency(outputCost) },
+        cacheCreation: { tokens: cacheCreationTokens, cost: roundToCurrency(cacheCreationCost) },
+        cacheRead: { tokens: cacheReadTokens, cost: roundToCurrency(cacheReadCost) },
     };
 }
 exports.calculateTokenBreakdownCosts = calculateTokenBreakdownCosts;
@@ -203,19 +290,17 @@ function detectAnomalies(dailyData) {
                     message: `Input tokens ${multiplier}x above threshold (${formatTokenCount(breakdown.inputTokens)})`,
                 });
             }
-            if (breakdown.outputTokens > 0) {
-                const ioRatio = breakdown.inputTokens / breakdown.outputTokens;
-                if (ioRatio > ANOMALY_THRESHOLDS.HIGH_IO_RATIO) {
-                    const multiplier = Math.round((ioRatio / ANOMALY_THRESHOLDS.HIGH_IO_RATIO) * 10) / 10;
-                    anomalies.push({
-                        date: day.date,
-                        type: 'high_io_ratio',
-                        model: breakdown.modelName,
-                        value: ioRatio,
-                        threshold: ANOMALY_THRESHOLDS.HIGH_IO_RATIO,
-                        message: `I/O ratio ${multiplier}x above threshold (${Math.round(ioRatio)}:1)`,
-                    });
-                }
+            const ioRatio = computeEffectiveIoRatio(breakdown.inputTokens, breakdown.cacheCreationTokens, breakdown.cacheReadTokens, breakdown.outputTokens);
+            if (ioRatio > 0 && ioRatio > ANOMALY_THRESHOLDS.HIGH_IO_RATIO) {
+                const multiplier = Math.round((ioRatio / ANOMALY_THRESHOLDS.HIGH_IO_RATIO) * 10) / 10;
+                anomalies.push({
+                    date: day.date,
+                    type: 'high_io_ratio',
+                    model: breakdown.modelName,
+                    value: ioRatio,
+                    threshold: ANOMALY_THRESHOLDS.HIGH_IO_RATIO,
+                    message: `I/O ratio ${multiplier}x above threshold (${Math.round(ioRatio)}:1)`,
+                });
             }
             if (breakdown.cacheReadTokens > ANOMALY_THRESHOLDS.HIGH_CACHE_READ_TOKENS) {
                 const multiplier = Math.round((breakdown.cacheReadTokens / ANOMALY_THRESHOLDS.HIGH_CACHE_READ_TOKENS) * 10) /
@@ -271,7 +356,9 @@ async function handleSummary(req, res) {
     try {
         const since = validateDate(req.query.since);
         const until = validateDate(req.query.until);
-        const dailyData = await (0, aggregator_1.getCachedDailyData)();
+        const profile = (0, profile_filter_1.normalizeProfileQuery)(req.query.profile);
+        validateDateRangeOrder(since, until);
+        const dailyData = await (0, aggregator_1.getCachedDailyData)(profile);
         const filtered = filterByDateRange(dailyData, since, until);
         let totalInputTokens = 0, totalOutputTokens = 0;
         let totalCacheCreationTokens = 0, totalCacheReadTokens = 0, totalCost = 0;
@@ -282,8 +369,10 @@ async function handleSummary(req, res) {
             totalCacheReadTokens += day.cacheReadTokens;
             totalCost += day.totalCost;
         }
-        const totalTokens = totalInputTokens + totalOutputTokens;
+        const totalTokens = calculateUsageTotalTokens(totalInputTokens, totalOutputTokens, totalCacheCreationTokens, totalCacheReadTokens);
         const tokenBreakdown = calculateTokenBreakdownCosts(filtered);
+        const totalDays = countCalendarDays(filtered, since, until);
+        const activeDays = filtered.length;
         res.json({
             success: true,
             data: {
@@ -293,11 +382,14 @@ async function handleSummary(req, res) {
                 totalCacheTokens: totalCacheCreationTokens + totalCacheReadTokens,
                 totalCacheCreationTokens,
                 totalCacheReadTokens,
-                totalCost: Math.round(totalCost * 100) / 100,
+                totalCost: roundToCurrency(totalCost),
                 tokenBreakdown,
-                totalDays: filtered.length,
-                averageTokensPerDay: filtered.length > 0 ? Math.round(totalTokens / filtered.length) : 0,
-                averageCostPerDay: filtered.length > 0 ? Math.round((totalCost / filtered.length) * 100) / 100 : 0,
+                totalDays,
+                activeDays,
+                averageTokensPerDay: totalDays > 0 ? Math.round(totalTokens / totalDays) : 0,
+                averageTokensPerActiveDay: activeDays > 0 ? Math.round(totalTokens / activeDays) : 0,
+                averageCostPerDay: totalDays > 0 ? roundToCurrency(totalCost / totalDays) : 0,
+                averageCostPerActiveDay: activeDays > 0 ? roundToCurrency(totalCost / activeDays) : 0,
             },
         });
     }
@@ -310,15 +402,17 @@ async function handleDaily(req, res) {
     try {
         const since = validateDate(req.query.since);
         const until = validateDate(req.query.until);
-        const dailyData = await (0, aggregator_1.getCachedDailyData)();
+        const profile = (0, profile_filter_1.normalizeProfileQuery)(req.query.profile);
+        validateDateRangeOrder(since, until);
+        const dailyData = await (0, aggregator_1.getCachedDailyData)(profile);
         const filtered = filterByDateRange(dailyData, since, until);
         const trends = filtered.map((day) => ({
             date: day.date,
-            tokens: day.inputTokens + day.outputTokens,
+            tokens: calculateUsageTotalTokens(day.inputTokens, day.outputTokens, day.cacheCreationTokens, day.cacheReadTokens),
             inputTokens: day.inputTokens,
             outputTokens: day.outputTokens,
             cacheTokens: day.cacheCreationTokens + day.cacheReadTokens,
-            cost: Math.round(day.totalCost * 100) / 100,
+            cost: roundToCurrency(day.totalCost),
             modelsUsed: day.modelsUsed.length,
         }));
         res.json({ success: true, data: trends });
@@ -332,7 +426,9 @@ async function handleHourly(req, res) {
     try {
         const since = validateDate(req.query.since);
         const until = validateDate(req.query.until);
-        const hourlyData = await (0, aggregator_1.getCachedHourlyData)();
+        const profile = (0, profile_filter_1.normalizeProfileQuery)(req.query.profile);
+        validateDateRangeOrder(since, until);
+        const hourlyData = await (0, aggregator_1.getCachedHourlyData)(profile);
         const filtered = (hourlyData || []).filter((h) => {
             const hourDate = h.hour.slice(0, 10).replace(/-/g, '');
             if (since && hourDate < since)
@@ -343,13 +439,13 @@ async function handleHourly(req, res) {
         });
         const trends = filtered.map((hour) => ({
             hour: hour.hour,
-            tokens: hour.inputTokens + hour.outputTokens,
+            tokens: calculateUsageTotalTokens(hour.inputTokens, hour.outputTokens, hour.cacheCreationTokens, hour.cacheReadTokens),
             inputTokens: hour.inputTokens,
             outputTokens: hour.outputTokens,
             cacheTokens: hour.cacheCreationTokens + hour.cacheReadTokens,
-            cost: Math.round(hour.totalCost * 100) / 100,
+            cost: roundToCurrency(hour.totalCost),
             modelsUsed: hour.modelsUsed.length,
-            requests: hour.modelBreakdowns.length,
+            requests: hour.requestCount ?? hour.modelBreakdowns.length,
         }));
         const filledTrends = fillHourlyGaps(trends, since, until);
         res.json({ success: true, data: filledTrends });
@@ -363,13 +459,17 @@ async function handleModels(req, res) {
     try {
         const since = validateDate(req.query.since);
         const until = validateDate(req.query.until);
-        const dailyData = await (0, aggregator_1.getCachedDailyData)();
+        const profile = (0, profile_filter_1.normalizeProfileQuery)(req.query.profile);
+        validateDateRangeOrder(since, until);
+        const dailyData = await (0, aggregator_1.getCachedDailyData)(profile);
         const filtered = filterByDateRange(dailyData, since, until);
         const modelMap = new Map();
         for (const day of filtered) {
             for (const breakdown of day.modelBreakdowns) {
-                const existing = modelMap.get(breakdown.modelName) || {
+                const modelKey = (0, model_identity_1.getProviderModelKey)(breakdown);
+                const existing = modelMap.get(modelKey) || {
                     model: breakdown.modelName,
+                    provider: breakdown.provider,
                     inputTokens: 0,
                     outputTokens: 0,
                     cacheCreationTokens: 0,
@@ -381,39 +481,40 @@ async function handleModels(req, res) {
                 existing.cacheCreationTokens += breakdown.cacheCreationTokens;
                 existing.cacheReadTokens += breakdown.cacheReadTokens;
                 existing.cost += breakdown.cost;
-                modelMap.set(breakdown.modelName, existing);
+                modelMap.set(modelKey, existing);
             }
         }
         const models = Array.from(modelMap.values());
-        const totalTokens = models.reduce((sum, m) => sum + m.inputTokens + m.outputTokens, 0);
+        const totalTokens = models.reduce((sum, model) => sum +
+            calculateUsageTotalTokens(model.inputTokens, model.outputTokens, model.cacheCreationTokens, model.cacheReadTokens), 0);
         const result = models
             .map((m) => {
-            const pricing = (0, model_pricing_1.getModelPricing)(m.model);
+            const pricing = (0, model_pricing_1.getModelPricing)(m.model, { provider: m.provider });
             const inputCost = (m.inputTokens / 1000000) * pricing.inputPerMillion;
             const outputCost = (m.outputTokens / 1000000) * pricing.outputPerMillion;
             const cacheCreationCost = (m.cacheCreationTokens / 1000000) * pricing.cacheCreationPerMillion;
             const cacheReadCost = (m.cacheReadTokens / 1000000) * pricing.cacheReadPerMillion;
             const ioRatio = m.outputTokens > 0 ? m.inputTokens / m.outputTokens : 0;
+            const totalModelTokens = calculateUsageTotalTokens(m.inputTokens, m.outputTokens, m.cacheCreationTokens, m.cacheReadTokens);
             return {
                 model: m.model,
-                tokens: m.inputTokens + m.outputTokens,
+                provider: m.provider,
+                tokens: totalModelTokens,
                 inputTokens: m.inputTokens,
                 outputTokens: m.outputTokens,
                 cacheCreationTokens: m.cacheCreationTokens,
                 cacheReadTokens: m.cacheReadTokens,
                 cacheTokens: m.cacheCreationTokens + m.cacheReadTokens,
-                cost: Math.round(m.cost * 100) / 100,
-                percentage: totalTokens > 0
-                    ? Math.round(((m.inputTokens + m.outputTokens) / totalTokens) * 1000) / 10
-                    : 0,
+                cost: roundToCurrency(m.cost),
+                percentage: totalTokens > 0 ? Math.round((totalModelTokens / totalTokens) * 1000) / 10 : 0,
                 costBreakdown: {
-                    input: { tokens: m.inputTokens, cost: Math.round(inputCost * 100) / 100 },
-                    output: { tokens: m.outputTokens, cost: Math.round(outputCost * 100) / 100 },
+                    input: { tokens: m.inputTokens, cost: roundToCurrency(inputCost) },
+                    output: { tokens: m.outputTokens, cost: roundToCurrency(outputCost) },
                     cacheCreation: {
                         tokens: m.cacheCreationTokens,
-                        cost: Math.round(cacheCreationCost * 100) / 100,
+                        cost: roundToCurrency(cacheCreationCost),
                     },
-                    cacheRead: { tokens: m.cacheReadTokens, cost: Math.round(cacheReadCost * 100) / 100 },
+                    cacheRead: { tokens: m.cacheReadTokens, cost: roundToCurrency(cacheReadCost) },
                 },
                 ioRatio: Math.round(ioRatio * 10) / 10,
             };
@@ -430,19 +531,21 @@ async function handleSessions(req, res) {
     try {
         const since = validateDate(req.query.since);
         const until = validateDate(req.query.until);
+        const profile = (0, profile_filter_1.normalizeProfileQuery)(req.query.profile);
+        validateDateRangeOrder(since, until);
         const limit = validateLimit(req.query.limit);
         const offset = validateOffset(req.query.offset);
-        const sessionData = await (0, aggregator_1.getCachedSessionData)();
+        const sessionData = await (0, aggregator_1.getCachedSessionData)(profile);
         const filtered = filterByDateRange(sessionData, since, until);
         const sorted = [...filtered].sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
         const paginated = sorted.slice(offset, offset + limit);
         const sessions = paginated.map((s) => ({
             sessionId: s.sessionId,
             projectPath: s.projectPath,
-            tokens: s.inputTokens + s.outputTokens,
+            tokens: calculateUsageTotalTokens(s.inputTokens, s.outputTokens, s.cacheCreationTokens, s.cacheReadTokens),
             inputTokens: s.inputTokens,
             outputTokens: s.outputTokens,
-            cost: Math.round(s.totalCost * 100) / 100,
+            cost: roundToCurrency(s.totalCost),
             lastActivity: s.lastActivity,
             modelsUsed: s.modelsUsed,
             target: s.target || 'claude',
@@ -467,24 +570,74 @@ async function handleMonthly(req, res) {
     try {
         const since = validateDate(req.query.since);
         const until = validateDate(req.query.until);
-        const monthlyData = await (0, aggregator_1.getCachedMonthlyData)();
-        const filtered = since || until
-            ? monthlyData.filter((m) => {
-                const monthDate = m.month.replace('-', '') + '01';
-                if (since && monthDate < since)
-                    return false;
-                if (until && monthDate > until)
-                    return false;
-                return true;
+        const profile = (0, profile_filter_1.normalizeProfileQuery)(req.query.profile);
+        validateDateRangeOrder(since, until);
+        let filtered;
+        if (since || until) {
+            const dailyData = filterByDateRange(await (0, aggregator_1.getCachedDailyData)(profile), since, until);
+            const monthMap = new Map();
+            for (const day of dailyData) {
+                const month = day.date.slice(0, 7);
+                const existing = monthMap.get(month) ?? {
+                    month,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheCreationTokens: 0,
+                    cacheReadTokens: 0,
+                    totalCost: 0,
+                    modelBreakdowns: new Map(),
+                };
+                existing.inputTokens += day.inputTokens;
+                existing.outputTokens += day.outputTokens;
+                existing.cacheCreationTokens += day.cacheCreationTokens;
+                existing.cacheReadTokens += day.cacheReadTokens;
+                existing.totalCost += day.totalCost;
+                for (const breakdown of day.modelBreakdowns) {
+                    const breakdownKey = (0, model_identity_1.getProviderModelKey)(breakdown);
+                    const existingBreakdown = existing.modelBreakdowns.get(breakdownKey) ?? {
+                        modelName: breakdown.modelName,
+                        provider: breakdown.provider,
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        cacheCreationTokens: 0,
+                        cacheReadTokens: 0,
+                        cost: 0,
+                    };
+                    existingBreakdown.inputTokens += breakdown.inputTokens;
+                    existingBreakdown.outputTokens += breakdown.outputTokens;
+                    existingBreakdown.cacheCreationTokens += breakdown.cacheCreationTokens;
+                    existingBreakdown.cacheReadTokens += breakdown.cacheReadTokens;
+                    existingBreakdown.cost += breakdown.cost;
+                    existing.modelBreakdowns.set(breakdownKey, existingBreakdown);
+                }
+                monthMap.set(month, existing);
+            }
+            filtered = Array.from(monthMap.values())
+                .map((month) => {
+                const modelBreakdowns = (0, model_identity_1.coalesceLegacyProviderlessBreakdowns)(Array.from(month.modelBreakdowns.values()));
+                return {
+                    month: month.month,
+                    inputTokens: month.inputTokens,
+                    outputTokens: month.outputTokens,
+                    cacheCreationTokens: month.cacheCreationTokens,
+                    cacheReadTokens: month.cacheReadTokens,
+                    totalCost: month.totalCost,
+                    modelBreakdowns,
+                    modelsUsed: (0, model_identity_1.getModelsUsed)(modelBreakdowns),
+                };
             })
-            : monthlyData;
+                .sort((a, b) => a.month.localeCompare(b.month));
+        }
+        else {
+            filtered = await (0, aggregator_1.getCachedMonthlyData)(profile);
+        }
         const result = filtered.map((m) => ({
             month: m.month,
-            tokens: m.inputTokens + m.outputTokens,
+            tokens: calculateUsageTotalTokens(m.inputTokens, m.outputTokens, m.cacheCreationTokens, m.cacheReadTokens),
             inputTokens: m.inputTokens,
             outputTokens: m.outputTokens,
             cacheTokens: m.cacheCreationTokens + m.cacheReadTokens,
-            cost: Math.round(m.totalCost * 100) / 100,
+            cost: roundToCurrency(m.totalCost),
             modelsUsed: m.modelsUsed.length,
         }));
         res.json({ success: true, data: result.sort((a, b) => a.month.localeCompare(b.month)) });
@@ -505,10 +658,9 @@ async function handleRefresh(_req, res) {
 }
 exports.handleRefresh = handleRefresh;
 function handleStatus(_req, res) {
-    const cache = new Map(); // Note: this is a placeholder, actual cache is in aggregator
     res.json({
         success: true,
-        data: { lastFetch: (0, aggregator_1.getLastFetchTimestamp)(), cacheSize: cache.size },
+        data: { lastFetch: (0, aggregator_1.getLastFetchTimestamp)(), cacheSize: (0, aggregator_1.getUsageCacheSize)() },
     });
 }
 exports.handleStatus = handleStatus;
@@ -516,7 +668,9 @@ async function handleInsights(req, res) {
     try {
         const since = validateDate(req.query.since);
         const until = validateDate(req.query.until);
-        const dailyData = await (0, aggregator_1.getCachedDailyData)();
+        const profile = (0, profile_filter_1.normalizeProfileQuery)(req.query.profile);
+        validateDateRangeOrder(since, until);
+        const dailyData = await (0, aggregator_1.getCachedDailyData)(profile);
         const filtered = filterByDateRange(dailyData, since, until);
         const anomalies = detectAnomalies(filtered);
         const summary = summarizeAnomalies(anomalies);
@@ -527,4 +681,77 @@ async function handleInsights(req, res) {
     }
 }
 exports.handleInsights = handleInsights;
+// ============================================================================
+// Cursor Usage Handlers (fork extension)
+// ============================================================================
+/**
+ * Handle CSV file upload from Cursor usage export.
+ * Writes uploaded file to temp, parses, imports, then cleans up.
+ */
+async function handleCursorImport(req, res) {
+    let tempFilePath = null;
+    try {
+        if (!req.file) {
+            res.status(400).json({
+                success: false,
+                error: 'No file uploaded',
+                details: "Expected multipart form data with 'file' field",
+            });
+            return;
+        }
+        // Write buffer to temp file for streaming parser
+        tempFilePath = path.join(os.tmpdir(), `cursor-usage-${Date.now()}.csv`);
+        const uploadedFile = req.file;
+        fs.writeFileSync(tempFilePath, uploadedFile.buffer);
+        const result = await (0, cursor_data_store_1.importCsvFile)(tempFilePath);
+        // Trigger cache refresh so aggregator picks up new Cursor data
+        (0, aggregator_1.refreshUsageCache)().catch(() => {
+            // Non-blocking refresh — data available next request
+        });
+        res.json({ success: true, data: result });
+    }
+    catch (error) {
+        if (error instanceof cursor_csv_parser_1.CursorCsvError) {
+            res.status(422).json({
+                success: false,
+                error: error.message,
+                details: error.details,
+            });
+            return;
+        }
+        errorResponse(res, error, 'Failed to import Cursor usage data');
+    }
+    finally {
+        // Clean up temp file
+        if (tempFilePath) {
+            try {
+                fs.unlinkSync(tempFilePath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+exports.handleCursorImport = handleCursorImport;
+/** Return current Cursor usage data status */
+function handleCursorStatus(_req, res) {
+    const status = (0, cursor_data_store_1.getCursorStatus)();
+    res.json({ success: true, data: status });
+}
+exports.handleCursorStatus = handleCursorStatus;
+/** Clear all stored Cursor usage data */
+function handleCursorDataClear(_req, res) {
+    const eventsRemoved = (0, cursor_data_store_1.clearCursorData)();
+    // Trigger cache refresh
+    (0, aggregator_1.refreshUsageCache)().catch(() => { });
+    res.json({
+        success: true,
+        data: {
+            message: 'Cursor usage data cleared',
+            eventsRemoved,
+        },
+    });
+}
+exports.handleCursorDataClear = handleCursorDataClear;
 //# sourceMappingURL=handlers.js.map