costhawk 1.2.2 → 1.3.1

package/dist/index.js

@@ -3,17 +3,20 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 // Claude Code local transcript parsing
-import { claudeCodeDirectoryExists, discoverTranscripts, parseAllTranscripts, aggregateUsage, } from "./transcript-parser.js";
+import { claudeCodeDirectoryExists, discoverTranscripts, parseAllTranscriptsDetailed, } from "./transcript-parser.js";
+import { codexDirectoryExists, discoverCodexSessions, parseAllCodexSessionsDetailed, } from "./codex-parser.js";
 import { calculateCost, formatCost, formatTokens, calculateSavings, CLAUDE_SUBSCRIPTIONS, } from "./pricing-constants.js";
 // Constants
 const CHARACTER_LIMIT = 25000;
 const REQUEST_TIMEOUT_MS = 30000; // 30 seconds
 const API_BASE_URL = process.env.COSTHAWK_API_URL || "https://costhawk.ai";
 const DEFAULT_API_KEY = process.env.COSTHAWK_API_KEY;
+const CLIENT_VERSION = "1.3.1";
 // Auto-sync configuration
 const AUTO_SYNC_INTERVAL_MS = 15 * 60 * 1000; // 15 minutes
 const AUTO_SYNC_MAX_AGE_HOURS = 24; // Sync sessions from last 24 hours
 let autoSyncIntervalId = null;
+const CODEX_AUTO_SYNC_ENABLED = process.env.COSTHAWK_CODEX_AUTO_SYNC === "true";
 // AlertType enum values from backend
 const ALERT_TYPE_VALUES = [
     "BUDGET_EXCEEDED",
@@ -352,6 +355,12 @@ function formatClaudeCodeSyncResultMarkdown(data) {
     output += `| Metric | Value |\n|--------|-------|\n`;
     output += `| New Sessions | ${data.sessionsNew} |\n`;
     output += `| Updated Sessions | ${data.sessionsUpdated} |\n`;
+    if (data.sessionsWithDailyUsage !== undefined) {
+        output += `| Sessions w/ Daily Usage | ${data.sessionsWithDailyUsage} |\n`;
+    }
+    if (data.dailyUsageRowsUpserted !== undefined) {
+        output += `| Daily Usage Rows Upserted | ${data.dailyUsageRowsUpserted} |\n`;
+    }
     output += `| Total Tokens | ${formatTokens(data.totalTokens)} |\n`;
     output += `| Estimated Cost | ${formatCost(data.estimatedCost)} |\n`;
     return truncateResponse(output);
@@ -372,10 +381,67 @@ function formatClaudeCodeSessionsMarkdown(sessions) {
     }
     return truncateResponse(output);
 }
+function formatCodexLocalUsageMarkdown(data) {
+    let output = `# Codex Local Usage\n\n`;
+    output += `## Summary\n`;
+    output += `| Metric | Value |\n|--------|-------|\n`;
+    output += `| Sessions | ${data.sessions} |\n`;
+    output += `| Total Tokens | ${formatTokens(data.tokens.total)} |\n`;
+    output += `| Input Tokens | ${formatTokens(data.tokens.input)} |\n`;
+    output += `| Output Tokens | ${formatTokens(data.tokens.output)} |\n`;
+    output += `| Cache Write Tokens | ${formatTokens(data.tokens.cacheCreation)} |\n`;
+    output += `| Cache Read Tokens | ${formatTokens(data.tokens.cacheRead)} |\n\n`;
+    if (data.sessionDetails.length > 0) {
+        output += `## Recent Sessions\n`;
+        output += `| Session | Model | Tokens |\n|---------|-------|--------|\n`;
+        for (const session of data.sessionDetails.slice(0, 10)) {
+            const shortId = session.sessionId.slice(0, 8);
+            output += `| ${shortId}... | ${session.model} | ${formatTokens(session.tokens)} |\n`;
+        }
+        if (data.sessionDetails.length > 10) {
+            output += `\n*...and ${data.sessionDetails.length - 10} more sessions*\n`;
+        }
+    }
+    return truncateResponse(output);
+}
+function formatCodexSyncResultMarkdown(data) {
+    const statusEmoji = data.success ? "✅" : "❌";
+    let output = `# Codex Sync Result\n\n`;
+    output += `${statusEmoji} ${data.message}\n\n`;
+    output += `| Metric | Value |\n|--------|-------|\n`;
+    output += `| New Sessions | ${data.sessionsNew} |\n`;
+    output += `| Updated Sessions | ${data.sessionsUpdated} |\n`;
+    if (data.sessionsWithDailyUsage !== undefined) {
+        output += `| Sessions w/ Daily Usage | ${data.sessionsWithDailyUsage} |\n`;
+    }
+    if (data.dailyUsageRowsUpserted !== undefined) {
+        output += `| Daily Usage Rows Upserted | ${data.dailyUsageRowsUpserted} |\n`;
+    }
+    output += `| Total Tokens | ${formatTokens(data.totalTokens)} |\n`;
+    if (data.estimatedCost !== undefined) {
+        output += `| Estimated Cost | ${formatCost(data.estimatedCost)} |\n`;
+    }
+    return truncateResponse(output);
+}
+function formatCodexSessionsMarkdown(sessions) {
+    if (sessions.length === 0) {
+        return "# Codex Sessions\n\nNo sessions found. Make sure you have used Codex recently.";
+    }
+    let output = `# Codex Sessions\n\n`;
+    output += `Found ${sessions.length} session(s)\n\n`;
+    output += `| Session ID | Last Modified | Size |\n|------------|---------------|------|\n`;
+    for (const session of sessions) {
+        const shortId = session.sessionId.slice(0, 12);
+        const date = session.lastModified.toISOString().split("T")[0];
+        const sizeKB = (session.size / 1024).toFixed(1);
+        output += `| ${shortId}... | ${date} | ${sizeKB} KB |\n`;
+    }
+    return truncateResponse(output);
+}
 // Create MCP server
 const server = new McpServer({
     name: "costhawk-mcp-server",
-    version: "1.2.2",
+    version: "1.3.1",
 });
 // Tool annotations for MCP best practices
 const READ_ONLY_ANNOTATIONS = {
@@ -560,6 +626,41 @@ const ListClaudeCodeSessionsSchema = {
     limit: z.number().min(1).max(100).optional().default(20).describe("Maximum number of sessions to show"),
     format: z.enum(["markdown", "json"]).optional().default("markdown").describe("Response format"),
 };
+const SyncCodexUsageSchema = {
+    apiKey: z
+        .string()
+        .optional()
+        .describe("Your CostHawk API key. If not provided, uses COSTHAWK_API_KEY environment variable."),
+    maxAgeHours: z
+        .number()
+        .min(1)
+        .max(720)
+        .optional()
+        .default(24)
+        .describe("Only sync sessions modified within this many hours (1-720, default 24)"),
+    format: z.enum(["markdown", "json"]).optional().default("markdown").describe("Response format"),
+};
+const GetLocalCodexUsageSchema = {
+    maxAgeHours: z
+        .number()
+        .min(1)
+        .max(720)
+        .optional()
+        .default(24)
+        .describe("Only include sessions modified within this many hours (1-720, default 24)"),
+    format: z.enum(["markdown", "json"]).optional().default("markdown").describe("Response format"),
+};
+const ListCodexSessionsSchema = {
+    maxAgeHours: z
+        .number()
+        .min(1)
+        .max(720)
+        .optional()
+        .default(168)
+        .describe("Only include sessions modified within this many hours (1-720, default 168 = 7 days)"),
+    limit: z.number().min(1).max(100).optional().default(20).describe("Maximum number of sessions to show"),
+    format: z.enum(["markdown", "json"]).optional().default("markdown").describe("Response format"),
+};
 // Register tools using registerTool (recommended API)
 server.registerTool("costhawk_get_usage_summary", {
     description: `Get a summary of your AI API usage and costs over a time period. Returns total costs, API calls, and token usage broken down by provider and model. Supports preset periods (last_24h, today, yesterday, last_7d, last_30d) or custom date ranges.`,
@@ -985,7 +1086,7 @@ server.registerTool("costhawk_sync_claude_code_usage", {
     try {
         // Parse all transcripts within age limit
         const maxAgeHours = args.maxAgeHours ?? 24;
-        const sessions = parseAllTranscripts(maxAgeHours);
+        const sessions = parseAllTranscriptsDetailed(maxAgeHours);
         if (sessions.length === 0) {
             return {
                 content: [
@@ -997,18 +1098,28 @@ server.registerTool("costhawk_sync_claude_code_usage", {
             };
         }
         // Transform sessions to API payload format
-        const allSessions = sessions.map((session) => ({
-            sessionId: session.sessionId,
-            projectHash: session.projectHash,
-            model: session.model,
-            inputTokens: session.tokens.inputTokens,
-            outputTokens: session.tokens.outputTokens,
-            cacheCreationTokens: session.tokens.cacheCreationTokens,
-            cacheReadTokens: session.tokens.cacheReadTokens,
-            messageCount: session.messageCount,
-            startTime: session.startTime,
-            endTime: session.endTime,
-        }));
+        const allSessions = sessions.map((session) => {
+            const dailyUsage = Object.entries(session.dailyUsage).map(([date, tokens]) => ({
+                date,
+                inputTokens: tokens.inputTokens,
+                outputTokens: tokens.outputTokens,
+                cacheCreationTokens: tokens.cacheCreationTokens,
+                cacheReadTokens: tokens.cacheReadTokens,
+            }));
+            return {
+                sessionId: session.sessionId,
+                projectHash: session.projectHash,
+                model: session.model,
+                inputTokens: session.tokens.inputTokens,
+                outputTokens: session.tokens.outputTokens,
+                cacheCreationTokens: session.tokens.cacheCreationTokens,
+                cacheReadTokens: session.tokens.cacheReadTokens,
+                messageCount: session.messageCount,
+                startTime: session.startTime,
+                endTime: session.endTime,
+                dailyUsage: dailyUsage.length > 0 ? dailyUsage : undefined,
+            };
+        });
         // Batch sessions in chunks of 100 (API limit)
         const BATCH_SIZE = 100;
         const batches = [];
@@ -1023,7 +1134,7 @@ server.registerTool("costhawk_sync_claude_code_usage", {
         for (const batch of batches) {
             const payload = {
                 sessions: batch,
-                clientVersion: "1.2.2",
+                clientVersion: CLIENT_VERSION,
                 syncedAt: new Date().toISOString(),
             };
             const result = await apiRequest("/api/mcp/usage/claude-code", {
@@ -1076,8 +1187,29 @@ server.registerTool("costhawk_get_local_claude_code_usage", {
     }
     try {
         const maxAgeHours = args.maxAgeHours ?? 24;
-        const sessions = parseAllTranscripts(maxAgeHours);
-        if (sessions.length === 0) {
+        const rangeEnd = new Date();
+        const rangeStart = new Date(rangeEnd.getTime() - maxAgeHours * 60 * 60 * 1000);
+        const sessions = parseAllTranscriptsDetailed(maxAgeHours, { rangeStart, rangeEnd });
+        const sessionsInRange = sessions
+            .map((session) => {
+            const rangeTokens = session.rangeUsage || {
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheCreationTokens: 0,
+                cacheReadTokens: 0,
+            };
+            const totalTokens = rangeTokens.inputTokens +
+                rangeTokens.outputTokens +
+                rangeTokens.cacheCreationTokens +
+                rangeTokens.cacheReadTokens;
+            return {
+                session,
+                rangeTokens,
+                totalTokens,
+            };
+        })
+            .filter((entry) => entry.totalTokens > 0);
+        if (sessionsInRange.length === 0) {
             return {
                 content: [
                     {
@@ -1087,23 +1219,33 @@ server.registerTool("costhawk_get_local_claude_code_usage", {
                 ],
             };
         }
-        // Aggregate usage
-        const aggregated = aggregateUsage(sessions);
+        // Aggregate usage for the requested window
+        const aggregatedTokens = sessionsInRange.reduce((acc, entry) => ({
+            inputTokens: acc.inputTokens + entry.rangeTokens.inputTokens,
+            outputTokens: acc.outputTokens + entry.rangeTokens.outputTokens,
+            cacheCreationTokens: acc.cacheCreationTokens + entry.rangeTokens.cacheCreationTokens,
+            cacheReadTokens: acc.cacheReadTokens + entry.rangeTokens.cacheReadTokens,
+        }), {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+        });
+        const modelCounts = {};
+        for (const entry of sessionsInRange) {
+            modelCounts[entry.session.model] = (modelCounts[entry.session.model] || 0) + 1;
+        }
         // Calculate total cost using dominant model pricing
-        const dominantModel = Object.entries(aggregated.models).sort((a, b) => b[1] - a[1])[0]?.[0] || "unknown";
+        const dominantModel = Object.entries(modelCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || "unknown";
         const cost = calculateCost({
-            inputTokens: aggregated.tokens.inputTokens,
-            outputTokens: aggregated.tokens.outputTokens,
-            cacheCreationTokens: aggregated.tokens.cacheCreationTokens,
-            cacheReadTokens: aggregated.tokens.cacheReadTokens,
+            inputTokens: aggregatedTokens.inputTokens,
+            outputTokens: aggregatedTokens.outputTokens,
+            cacheCreationTokens: aggregatedTokens.cacheCreationTokens,
+            cacheReadTokens: aggregatedTokens.cacheReadTokens,
         }, dominantModel);
         // Build session details
-        const sessionDetails = sessions.map((session) => {
-            const sessionCost = calculateCost(session.tokens, session.model);
-            const totalTokens = session.tokens.inputTokens +
-                session.tokens.outputTokens +
-                session.tokens.cacheCreationTokens +
-                session.tokens.cacheReadTokens;
+        const sessionDetails = sessionsInRange.map(({ session, rangeTokens, totalTokens }) => {
+            const sessionCost = calculateCost(rangeTokens, session.model);
             return {
                 sessionId: session.sessionId,
                 projectHash: session.projectHash,
@@ -1116,13 +1258,16 @@ server.registerTool("costhawk_get_local_claude_code_usage", {
         });
         // Build response
         const response = {
-            sessions: aggregated.totalSessions,
+            sessions: sessionsInRange.length,
             tokens: {
-                input: aggregated.tokens.inputTokens,
-                output: aggregated.tokens.outputTokens,
-                cacheCreation: aggregated.tokens.cacheCreationTokens,
-                cacheRead: aggregated.tokens.cacheReadTokens,
-                total: aggregated.totalTokens,
+                input: aggregatedTokens.inputTokens,
+                output: aggregatedTokens.outputTokens,
+                cacheCreation: aggregatedTokens.cacheCreationTokens,
+                cacheRead: aggregatedTokens.cacheReadTokens,
+                total: aggregatedTokens.inputTokens +
+                    aggregatedTokens.outputTokens +
+                    aggregatedTokens.cacheCreationTokens +
+                    aggregatedTokens.cacheReadTokens,
             },
             cost,
             sessionDetails,
@@ -1192,6 +1337,254 @@ server.registerTool("costhawk_list_claude_code_sessions", {
         };
     }
 });
+server.registerTool("costhawk_sync_codex_usage", {
+    description: `Sync your local Codex usage to CostHawk. Parses session logs from ~/.codex/sessions/ and uploads token counts to your CostHawk dashboard. Requires API key.`,
+    inputSchema: SyncCodexUsageSchema,
+    annotations: WRITE_ANNOTATIONS,
+}, async (args, _extra) => {
+    const apiKey = getApiKey(args.apiKey);
+    if (!apiKey) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: No API key provided. You must first sign up at https://costhawk.ai to get an API key. Once approved, go to Settings > Developer > Create Token, then set COSTHAWK_API_KEY in your MCP configuration.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    if (!codexDirectoryExists()) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: Codex sessions directory not found at ~/.codex/sessions/. Make sure you have used Codex at least once.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        const maxAgeHours = args.maxAgeHours ?? 24;
+        const sessions = parseAllCodexSessionsDetailed(maxAgeHours);
+        if (sessions.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No Codex sessions found within the last ${maxAgeHours} hours. Try increasing maxAgeHours or use Codex first.`,
+                    },
+                ],
+            };
+        }
+        const allSessions = sessions.map((session) => {
+            const dailyUsage = Object.entries(session.dailyUsage).map(([date, tokens]) => ({
+                date,
+                inputTokens: tokens.inputTokens,
+                outputTokens: tokens.outputTokens,
+                cacheCreationTokens: tokens.cacheCreationTokens,
+                cacheReadTokens: tokens.cacheReadTokens,
+            }));
+            return {
+                sessionId: session.sessionId,
+                projectHash: session.projectHash,
+                model: session.model,
+                inputTokens: session.tokens.inputTokens,
+                outputTokens: session.tokens.outputTokens,
+                cacheCreationTokens: session.tokens.cacheCreationTokens,
+                cacheReadTokens: session.tokens.cacheReadTokens,
+                messageCount: session.messageCount,
+                startTime: session.startTime,
+                endTime: session.endTime,
+                dailyUsage: dailyUsage.length > 0 ? dailyUsage : undefined,
+                source: "codex",
+            };
+        });
+        const BATCH_SIZE = 100;
+        const batches = [];
+        for (let i = 0; i < allSessions.length; i += BATCH_SIZE) {
+            batches.push(allSessions.slice(i, i + BATCH_SIZE));
+        }
+        let totalNew = 0;
+        let totalUpdated = 0;
+        let totalTokens = 0;
+        let totalCost = 0;
+        let sessionsWithDailyUsage = 0;
+        let dailyUsageRowsUpserted = 0;
+        for (const batch of batches) {
+            const payload = {
+                sessions: batch,
+                clientVersion: CLIENT_VERSION,
+                syncedAt: new Date().toISOString(),
+            };
+            const result = await apiRequest("/api/mcp/usage/codex", {
+                method: "POST",
+                apiKey,
+                body: payload,
+            });
+            totalNew += result.sessionsNew;
+            totalUpdated += result.sessionsUpdated;
+            totalTokens += result.totalTokens;
+            totalCost += result.estimatedCost || 0;
+            sessionsWithDailyUsage += result.sessionsWithDailyUsage || 0;
+            dailyUsageRowsUpserted += result.dailyUsageRowsUpserted || 0;
+        }
+        const result = {
+            success: true,
+            sessionsNew: totalNew,
+            sessionsUpdated: totalUpdated,
+            totalTokens,
+            estimatedCost: totalCost > 0 ? totalCost : undefined,
+            sessionsWithDailyUsage: sessionsWithDailyUsage || undefined,
+            dailyUsageRowsUpserted: dailyUsageRowsUpserted || undefined,
+            message: `Synced ${totalNew} new and ${totalUpdated} updated sessions`,
+        };
+        const text = args.format === "json" ? JSON.stringify(result, null, 2) : formatCodexSyncResultMarkdown(result);
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true,
+        };
+    }
+});
+server.registerTool("costhawk_get_local_codex_usage", {
+    description: `Get Codex usage from local sessions WITHOUT uploading to CostHawk. Works offline. Shows token counts by type.`,
+    inputSchema: GetLocalCodexUsageSchema,
+    annotations: READ_ONLY_ANNOTATIONS,
+}, async (args, _extra) => {
+    if (!codexDirectoryExists()) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: Codex sessions directory not found at ~/.codex/sessions/. Make sure you have used Codex at least once.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        const maxAgeHours = args.maxAgeHours ?? 24;
+        const rangeEnd = new Date();
+        const rangeStart = new Date(rangeEnd.getTime() - maxAgeHours * 60 * 60 * 1000);
+        const sessions = parseAllCodexSessionsDetailed(maxAgeHours, { rangeStart, rangeEnd });
+        const sessionsInRange = sessions
+            .map((session) => {
+            const rangeTokens = session.rangeUsage || {
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheCreationTokens: 0,
+                cacheReadTokens: 0,
+            };
+            const totalTokens = rangeTokens.inputTokens +
+                rangeTokens.outputTokens +
+                rangeTokens.cacheCreationTokens +
+                rangeTokens.cacheReadTokens;
+            return {
+                session,
+                rangeTokens,
+                totalTokens,
+            };
+        })
+            .filter((entry) => entry.totalTokens > 0);
+        if (sessionsInRange.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No Codex sessions found within the last ${maxAgeHours} hours. Try increasing maxAgeHours or use Codex first.`,
+                    },
+                ],
+            };
+        }
+        const aggregatedTokens = sessionsInRange.reduce((acc, entry) => ({
+            inputTokens: acc.inputTokens + entry.rangeTokens.inputTokens,
+            outputTokens: acc.outputTokens + entry.rangeTokens.outputTokens,
+            cacheCreationTokens: acc.cacheCreationTokens + entry.rangeTokens.cacheCreationTokens,
+            cacheReadTokens: acc.cacheReadTokens + entry.rangeTokens.cacheReadTokens,
+        }), {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+        });
+        const sessionDetails = sessionsInRange.map(({ session, totalTokens }) => ({
+            sessionId: session.sessionId,
+            model: session.model,
+            tokens: totalTokens,
+            startTime: session.startTime,
+            endTime: session.endTime,
+        }));
+        const response = {
+            sessions: sessionsInRange.length,
+            tokens: {
+                input: aggregatedTokens.inputTokens,
+                output: aggregatedTokens.outputTokens,
+                cacheCreation: aggregatedTokens.cacheCreationTokens,
+                cacheRead: aggregatedTokens.cacheReadTokens,
+                total: aggregatedTokens.inputTokens +
+                    aggregatedTokens.outputTokens +
+                    aggregatedTokens.cacheCreationTokens +
+                    aggregatedTokens.cacheReadTokens,
+            },
+            sessionDetails,
+        };
+        const text = args.format === "json" ? JSON.stringify(response, null, 2) : formatCodexLocalUsageMarkdown(response);
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true,
+        };
+    }
+});
+server.registerTool("costhawk_list_codex_sessions", {
+    description: `List available Codex sessions from local logs. Shows session IDs, modification dates, and file sizes.`,
+    inputSchema: ListCodexSessionsSchema,
+    annotations: READ_ONLY_ANNOTATIONS,
+}, async (args, _extra) => {
+    if (!codexDirectoryExists()) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: Codex sessions directory not found at ~/.codex/sessions/. Make sure you have used Codex at least once.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        const maxAgeHours = args.maxAgeHours ?? 168;
+        const limit = args.limit ?? 20;
+        const sessions = discoverCodexSessions(maxAgeHours).slice(0, limit);
+        const text = args.format === "json"
+            ? JSON.stringify(sessions.map((s) => ({
+                sessionId: s.sessionId,
+                lastModified: s.lastModified.toISOString(),
+                size: s.size,
+                path: s.path,
+            })), null, 2)
+            : formatCodexSessionsMarkdown(sessions);
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true,
+        };
+    }
+});
 // Auto-sync function for Claude Code usage
 async function performAutoSync() {
     const apiKey = DEFAULT_API_KEY;
@@ -1204,24 +1597,34 @@ async function performAutoSync() {
         return;
     }
     try {
-        const sessions = parseAllTranscripts(AUTO_SYNC_MAX_AGE_HOURS);
+        const sessions = parseAllTranscriptsDetailed(AUTO_SYNC_MAX_AGE_HOURS);
         if (sessions.length === 0) {
             console.error("[Auto-sync] No sessions to sync");
             return;
         }
         // Transform sessions to API payload format
-        const allSessions = sessions.map((session) => ({
-            sessionId: session.sessionId,
-            projectHash: session.projectHash,
-            model: session.model,
-            inputTokens: session.tokens.inputTokens,
-            outputTokens: session.tokens.outputTokens,
-            cacheCreationTokens: session.tokens.cacheCreationTokens,
-            cacheReadTokens: session.tokens.cacheReadTokens,
-            messageCount: session.messageCount,
-            startTime: session.startTime,
-            endTime: session.endTime,
-        }));
+        const allSessions = sessions.map((session) => {
+            const dailyUsage = Object.entries(session.dailyUsage).map(([date, tokens]) => ({
+                date,
+                inputTokens: tokens.inputTokens,
+                outputTokens: tokens.outputTokens,
+                cacheCreationTokens: tokens.cacheCreationTokens,
+                cacheReadTokens: tokens.cacheReadTokens,
+            }));
+            return {
+                sessionId: session.sessionId,
+                projectHash: session.projectHash,
+                model: session.model,
+                inputTokens: session.tokens.inputTokens,
+                outputTokens: session.tokens.outputTokens,
+                cacheCreationTokens: session.tokens.cacheCreationTokens,
+                cacheReadTokens: session.tokens.cacheReadTokens,
+                messageCount: session.messageCount,
+                startTime: session.startTime,
+                endTime: session.endTime,
+                dailyUsage: dailyUsage.length > 0 ? dailyUsage : undefined,
+            };
+        });
         // Batch sessions in chunks of 100 (API limit)
         const BATCH_SIZE = 100;
         const batches = [];
@@ -1235,7 +1638,7 @@ async function performAutoSync() {
         for (const batch of batches) {
             const payload = {
                 sessions: batch,
-                clientVersion: "1.2.2",
+                clientVersion: CLIENT_VERSION,
                 syncedAt: new Date().toISOString(),
                 autoSync: true,
             };
@@ -1254,6 +1657,79 @@ async function performAutoSync() {
         console.error(`[Auto-sync] Error: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
 }
+// Auto-sync function for Codex usage (optional)
+async function performCodexAutoSync() {
+    if (!CODEX_AUTO_SYNC_ENABLED) {
+        return;
+    }
+    const apiKey = DEFAULT_API_KEY;
+    if (!apiKey) {
+        console.error("[Codex Auto-sync] Skipped: No COSTHAWK_API_KEY configured");
+        return;
+    }
+    if (!codexDirectoryExists()) {
+        console.error("[Codex Auto-sync] Skipped: Codex sessions directory not found");
+        return;
+    }
+    try {
+        const sessions = parseAllCodexSessionsDetailed(AUTO_SYNC_MAX_AGE_HOURS);
+        if (sessions.length === 0) {
+            console.error("[Codex Auto-sync] No sessions to sync");
+            return;
+        }
+        const allSessions = sessions.map((session) => {
+            const dailyUsage = Object.entries(session.dailyUsage).map(([date, tokens]) => ({
+                date,
+                inputTokens: tokens.inputTokens,
+                outputTokens: tokens.outputTokens,
+                cacheCreationTokens: tokens.cacheCreationTokens,
+                cacheReadTokens: tokens.cacheReadTokens,
+            }));
+            return {
+                sessionId: session.sessionId,
+                projectHash: session.projectHash,
+                model: session.model,
+                inputTokens: session.tokens.inputTokens,
+                outputTokens: session.tokens.outputTokens,
+                cacheCreationTokens: session.tokens.cacheCreationTokens,
+                cacheReadTokens: session.tokens.cacheReadTokens,
+                messageCount: session.messageCount,
+                startTime: session.startTime,
+                endTime: session.endTime,
+                dailyUsage: dailyUsage.length > 0 ? dailyUsage : undefined,
+                source: "codex",
+            };
+        });
+        const BATCH_SIZE = 100;
+        const batches = [];
+        for (let i = 0; i < allSessions.length; i += BATCH_SIZE) {
+            batches.push(allSessions.slice(i, i + BATCH_SIZE));
+        }
+        let totalNew = 0;
+        let totalUpdated = 0;
+        let totalTokens = 0;
+        for (const batch of batches) {
+            const payload = {
+                sessions: batch,
+                clientVersion: CLIENT_VERSION,
+                syncedAt: new Date().toISOString(),
+                autoSync: true,
+            };
+            const result = await apiRequest("/api/mcp/usage/codex", {
+                method: "POST",
+                apiKey,
+                body: payload,
+            });
+            totalNew += result.sessionsNew;
+            totalUpdated += result.sessionsUpdated;
+            totalTokens += result.totalTokens;
+        }
+        console.error(`[Codex Auto-sync] Success: ${totalNew} new, ${totalUpdated} updated, ${formatTokens(totalTokens)} tokens (${batches.length} batch${batches.length > 1 ? "es" : ""})`);
+    }
+    catch (error) {
+        console.error(`[Codex Auto-sync] Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+}
 // Start auto-sync interval
 function startAutoSync() {
     if (!DEFAULT_API_KEY) {
@@ -1263,10 +1739,12 @@ function startAutoSync() {
     // Perform initial sync after 30 seconds (give server time to fully start)
     setTimeout(() => {
         performAutoSync();
+        performCodexAutoSync();
     }, 30 * 1000);
     // Then sync every 15 minutes
     autoSyncIntervalId = setInterval(() => {
         performAutoSync();
+        performCodexAutoSync();
     }, AUTO_SYNC_INTERVAL_MS);
     console.error(`[Auto-sync] Enabled: syncing every ${AUTO_SYNC_INTERVAL_MS / 60000} minutes`);
 }