@tokscale/cli 1.0.24 → 1.1.1

package/dist/cli.js

@@ -13,11 +13,15 @@ import pc from "picocolors";
 import { login, logout, whoami } from "./auth.js";
 import { submit } from "./submit.js";
 import { generateWrapped } from "./wrapped.js";
-import { loadCursorCredentials, saveCursorCredentials, clearCursorCredentials, validateCursorSession, readCursorUsage, getCursorCredentialsPath, syncCursorCache, } from "./cursor.js";
+import { ensureCursorMigration, loadCursorCredentials, saveCursorCredentials, clearCursorCredentialsAndCache, isCursorLoggedIn, hasCursorUsageCache, listCursorAccounts, setActiveCursorAccount, removeCursorAccount, validateCursorSession, readCursorUsage, getCursorCredentialsPath, syncCursorCache, } from "./cursor.js";
 import { createUsageTable, formatUsageRow, formatTotalsRow, formatNumber, formatCurrency, formatModelName, } from "./table.js";
 import { getNativeVersion, parseLocalSourcesAsync, finalizeReportAsync, finalizeMonthlyReportAsync, finalizeGraphAsync, } from "./native.js";
 import { createSpinner } from "./spinner.js";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { performance } from "node:perf_hooks";
 import { loadSettings } from "./tui/config/settings.js";
 let cachedTUILoader = null;
@@ -116,6 +120,174 @@ function getDateRangeLabel(options) {
     }
     return null;
 }
+function getHeadlessRoots(homeDir) {
+    const override = process.env.TOKSCALE_HEADLESS_DIR;
+    if (override && override.trim()) {
+        return [override];
+    }
+    const roots = [
+        path.join(homeDir, ".config", "tokscale", "headless"),
+        path.join(homeDir, "Library", "Application Support", "tokscale", "headless"),
+    ];
+    return Array.from(new Set(roots));
+}
+function describePath(targetPath) {
+    return fs.existsSync(targetPath) ? targetPath : `${targetPath} (missing)`;
+}
+const HEADLESS_SOURCES = ["codex"];
+function normalizeHeadlessSource(source) {
+    const normalized = source.toLowerCase();
+    return HEADLESS_SOURCES.includes(normalized)
+        ? normalized
+        : null;
+}
+function resolveHeadlessFormat(source, args, override) {
+    if (override === "json" || override === "jsonl") {
+        return override;
+    }
+    return "jsonl";
+}
+function applyHeadlessDefaults(source, args, format, autoFlags) {
+    if (!autoFlags)
+        return args;
+    const updated = [...args];
+    if (source === "codex" && !updated.includes("--json")) {
+        updated.push("--json");
+    }
+    return updated;
+}
+function buildHeadlessOutputPath(headlessRoots, source, format, outputPath) {
+    if (outputPath) {
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        return outputPath;
+    }
+    const root = headlessRoots[0] || path.join(os.homedir(), ".config", "tokscale", "headless");
+    const dir = path.join(root, source);
+    fs.mkdirSync(dir, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const id = randomUUID().replace(/-/g, "").slice(0, 8);
+    const filename = `${source}-${stamp}-${id}.${format}`;
+    return path.join(dir, filename);
+}
+function printHeadlessHelp() {
+    console.log("\n  Usage: tokscale headless codex [args...]");
+    console.log("  Options:");
+    console.log("    --format <json|jsonl>   Override output format");
+    console.log("    --output <file>         Write captured output to file");
+    console.log("    --no-auto-flags         Do not auto-add JSON output flags");
+    console.log("\n  Examples:");
+    console.log("    tokscale headless codex exec -m gpt-5");
+    console.log();
+}
+async function runHeadlessCapture(argv) {
+    const sourceArg = argv[1];
+    if (!sourceArg || sourceArg === "--help" || sourceArg === "-h") {
+        printHeadlessHelp();
+        return;
+    }
+    const source = normalizeHeadlessSource(sourceArg);
+    if (!source) {
+        console.error(`\n  Error: Unknown headless source '${sourceArg}'.`);
+        printHeadlessHelp();
+        process.exit(1);
+    }
+    const rawArgs = argv.slice(2);
+    let outputPath;
+    let formatOverride;
+    let autoFlags = true;
+    const cmdArgs = [];
+    for (let i = 0; i < rawArgs.length; i += 1) {
+        const arg = rawArgs[i];
+        if (arg === "--")
+            continue;
+        if ((arg === "--help" || arg === "-h") && cmdArgs.length === 0) {
+            printHeadlessHelp();
+            return;
+        }
+        if (arg === "--output") {
+            const value = rawArgs[i + 1];
+            if (!value) {
+                console.error("\n  Error: --output requires a file path.");
+                process.exit(1);
+            }
+            outputPath = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--format") {
+            const format = rawArgs[i + 1];
+            if (!format) {
+                console.error("\n  Error: --format requires a value (json or jsonl).");
+                process.exit(1);
+            }
+            if (format !== "json" && format !== "jsonl") {
+                console.error(`\n  Error: Invalid format '${format}'. Use json or jsonl.`);
+                process.exit(1);
+            }
+            formatOverride = format;
+            i += 1;
+            continue;
+        }
+        if (arg === "--no-auto-flags") {
+            autoFlags = false;
+            continue;
+        }
+        cmdArgs.push(arg);
+    }
+    if (cmdArgs.length === 0) {
+        console.error("\n  Error: Missing CLI arguments to execute.");
+        printHeadlessHelp();
+        process.exit(1);
+    }
+    const format = resolveHeadlessFormat(source, cmdArgs, formatOverride);
+    const finalArgs = applyHeadlessDefaults(source, cmdArgs, format, autoFlags);
+    const headlessRoots = getHeadlessRoots(os.homedir());
+    const output = buildHeadlessOutputPath(headlessRoots, source, format, outputPath);
+    console.log(pc.cyan("\n  Headless capture"));
+    console.log(pc.gray(`  source: ${source}`));
+    console.log(pc.gray(`  output: ${output}`));
+    console.log();
+    const proc = spawn(source, finalArgs, {
+        stdio: ["inherit", "pipe", "inherit"],
+    });
+    if (!proc.stdout) {
+        console.error("\n  Error: Failed to capture stdout from command.");
+        process.exit(1);
+    }
+    const outputStream = fs.createWriteStream(output, { encoding: "utf-8" });
+    const outputFinished = new Promise((resolve, reject) => {
+        outputStream.on("finish", () => resolve());
+        outputStream.on("error", reject);
+    });
+    proc.stdout.pipe(outputStream);
+    let exitCode;
+    try {
+        exitCode = await new Promise((resolve, reject) => {
+            proc.on("error", reject);
+            proc.on("close", (code) => resolve(code ?? 1));
+        });
+    }
+    catch (err) {
+        outputStream.destroy();
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`\n  Error: Failed to run '${source}': ${message}`);
+        process.exit(1);
+    }
+    outputStream.end();
+    try {
+        await outputFinished;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`\n  Error: Failed to write headless output: ${message}`);
+        process.exit(1);
+    }
+    if (exitCode !== 0) {
+        process.exit(exitCode);
+    }
+    console.log(pc.green(`  Saved headless output to ${output}`));
+    console.log();
+}
 function buildTUIOptions(options, initialTab) {
     const dateFilters = getDateFilters(options);
     const enabledSources = getEnabledSources(options);
@@ -209,6 +381,111 @@ async function main() {
             }
         }
     });
+    program
+        .command("sources")
+        .description("Show local scan locations and Codex headless paths")
+        .option("--json", "Output as JSON (for scripting)")
+        .action(async (options) => {
+        const homeDir = os.homedir();
+        const headlessRoots = getHeadlessRoots(homeDir);
+        const claudeSessions = path.join(homeDir, ".claude", "projects");
+        const codexHome = process.env.CODEX_HOME || path.join(homeDir, ".codex");
+        const codexSessions = path.join(codexHome, "sessions");
+        const geminiSessions = path.join(homeDir, ".gemini", "tmp");
+        let localMessages = null;
+        try {
+            localMessages = await parseLocalSourcesAsync({
+                homeDir,
+                sources: ["claude", "codex", "gemini"],
+            });
+        }
+        catch (e) {
+            console.error(`Error: ${e.message}`);
+            process.exit(1);
+        }
+        const headlessCounts = {
+            codex: 0,
+        };
+        for (const message of localMessages.messages) {
+            if (message.agent === "headless" && message.source === "codex") {
+                headlessCounts.codex += 1;
+            }
+        }
+        const sourceRows = [
+            {
+                source: "claude",
+                label: "Claude Code",
+                sessionsPath: claudeSessions,
+                messageCount: localMessages.claudeCount,
+                headlessSupported: false,
+                headlessPaths: [],
+                headlessMessageCount: 0,
+            },
+            {
+                source: "codex",
+                label: "Codex CLI",
+                sessionsPath: codexSessions,
+                headlessPaths: headlessRoots.map((root) => path.join(root, "codex")),
+                messageCount: localMessages.codexCount,
+                headlessMessageCount: headlessCounts.codex,
+                headlessSupported: true,
+            },
+            {
+                source: "gemini",
+                label: "Gemini CLI",
+                sessionsPath: geminiSessions,
+                messageCount: localMessages.geminiCount,
+                headlessSupported: false,
+                headlessPaths: [],
+                headlessMessageCount: 0,
+            },
+        ];
+        if (options.json) {
+            const payload = {
+                headlessRoots,
+                sources: sourceRows.map((row) => ({
+                    source: row.source,
+                    label: row.label,
+                    sessionsPath: row.sessionsPath,
+                    sessionsPathExists: fs.existsSync(row.sessionsPath),
+                    messageCount: row.messageCount,
+                    headlessSupported: row.headlessSupported,
+                    headlessPaths: row.headlessSupported
+                        ? row.headlessPaths.map((headlessPath) => ({
+                            path: headlessPath,
+                            exists: fs.existsSync(headlessPath),
+                        }))
+                        : [],
+                    headlessMessageCount: row.headlessSupported ? row.headlessMessageCount : 0,
+                })),
+                note: "Headless capture is supported for Codex CLI only.",
+            };
+            console.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        console.log(pc.cyan("\n  Local sources & Codex headless capture"));
+        console.log(pc.gray(`  Headless roots: ${headlessRoots.join(", ")}`));
+        console.log();
+        for (const row of sourceRows) {
+            console.log(pc.white(`  ${row.label}`));
+            console.log(pc.gray(`  sessions: ${describePath(row.sessionsPath)}`));
+            if (row.headlessSupported) {
+                console.log(pc.gray(`  headless: ${row.headlessPaths.map(describePath).join(", ")}`));
+                console.log(pc.gray(`  messages: ${formatNumber(row.messageCount)} (headless: ${formatNumber(row.headlessMessageCount)})`));
+            }
+            else {
+                console.log(pc.gray(`  messages: ${formatNumber(row.messageCount)}`));
+            }
+            console.log();
+        }
+        console.log(pc.gray("  Note: Headless capture is supported for Codex CLI only."));
+        console.log();
+    });
+    program
+        .command("headless")
+        .description("Run a CLI in headless mode and capture stdout")
+        .argument("<source>", "Source CLI to capture (currently only 'codex' is supported)")
+        .argument("[args...]", "Arguments passed to the CLI");
     program
         .command("graph")
         .description("Export contribution graph data as JSON")
@@ -345,28 +622,75 @@ async function main() {
     cursorCommand
         .command("login")
         .description("Login to Cursor (paste your session token)")
-        .action(async () => {
-        await cursorLogin();
+        .option("--name <name>", "Label for this Cursor account (e.g., work, personal)")
+        .action(async (options) => {
+        ensureCursorMigration();
+        await cursorLogin(options);
     });
     cursorCommand
         .command("logout")
-        .description("Logout from Cursor")
-        .action(async () => {
-        await cursorLogout();
+        .description("Logout from a Cursor account")
+        .option("--name <name>", "Account label or id")
+        .option("--all", "Logout from all Cursor accounts")
+        .option("--purge-cache", "Also delete cached Cursor usage for the logged-out account(s)")
+        .action(async (options) => {
+        ensureCursorMigration();
+        await cursorLogout(options);
     });
     cursorCommand
         .command("status")
         .description("Check Cursor authentication status")
-        .action(async () => {
-        await cursorStatus();
+        .option("--name <name>", "Account label or id")
+        .action(async (options) => {
+        ensureCursorMigration();
+        await cursorStatus(options);
+    });
+    cursorCommand
+        .command("accounts")
+        .description("List saved Cursor accounts")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        ensureCursorMigration();
+        const accounts = listCursorAccounts();
+        if (options.json) {
+            console.log(JSON.stringify({ accounts }, null, 2));
+            return;
+        }
+        if (accounts.length === 0) {
+            console.log(pc.yellow("\n  No saved Cursor accounts.\n"));
+            return;
+        }
+        console.log(pc.cyan("\n  Cursor IDE - Accounts\n"));
+        for (const acct of accounts) {
+            const name = acct.label ? `${acct.label} ${pc.gray(`(${acct.id})`)}` : acct.id;
+            console.log(`  ${acct.isActive ? pc.green("*") : pc.gray("-")} ${name}`);
+        }
+        console.log();
+    });
+    cursorCommand
+        .command("switch")
+        .description("Switch active Cursor account")
+        .argument("<name>", "Account label or id")
+        .action(async (name) => {
+        ensureCursorMigration();
+        const result = setActiveCursorAccount(name);
+        if (!result.ok) {
+            console.log(pc.red(`\n  Error: ${result.error}\n`));
+            process.exit(1);
+        }
+        console.log(pc.green(`\n  Active Cursor account set to ${pc.bold(name)}\n`));
     });
     // Check if a subcommand was provided
     const args = process.argv.slice(2);
+    if (args[0] === "headless") {
+        await runHeadlessCapture(args);
+        return;
+    }
     const firstArg = args[0] || '';
     // Global flags should go to main program
     const isGlobalFlag = ['--help', '-h', '--version', '-V'].includes(firstArg);
     const hasSubcommand = args.length > 0 && !firstArg.startsWith('-');
-    const knownCommands = ['monthly', 'models', 'graph', 'wrapped', 'login', 'logout', 'whoami', 'submit', 'cursor', 'tui', 'pricing', 'help'];
+    const knownCommands = ['monthly', 'models', 'sources', 'headless', 'graph', 'wrapped', 'login', 'logout', 'whoami', 'submit', 'cursor', 'tui', 'pricing', 'help'];
     const isKnownCommand = hasSubcommand && knownCommands.includes(firstArg);
     if (isKnownCommand || isGlobalFlag) {
         // Run the specified subcommand or show full help/version
@@ -438,8 +762,7 @@ function getEnabledSources(options) {
  * Only attempts sync if user is authenticated with Cursor.
  */
 async function syncCursorData() {
-    const credentials = loadCursorCredentials();
-    if (!credentials) {
+    if (!isCursorLoggedIn()) {
         return { attempted: false, synced: false, rows: 0 };
     }
     const result = await syncCursorCache();
@@ -478,8 +801,7 @@ async function showModelReport(options, extraOptions) {
     const includeCursor = !enabledSources || enabledSources.includes('cursor');
     // Check cursor auth early if cursor-only mode
     if (onlyCursor) {
-        const credentials = loadCursorCredentials();
-        if (!credentials) {
+        if (!isCursorLoggedIn() && !hasCursorUsageCache()) {
             console.log(pc.red("\n  Error: Cursor authentication required."));
             console.log(pc.gray("  Run 'tokscale cursor login' to authenticate with Cursor.\n"));
             process.exit(1);
@@ -500,6 +822,10 @@ async function showModelReport(options, extraOptions) {
         .filter(s => s !== 'cursor');
     spinner?.start(pc.gray("Scanning session data..."));
     const { cursorSync, localMessages } = await loadDataSourcesParallel(onlyCursor ? [] : localSources, dateFilters, (phase) => spinner?.update(phase));
+    if (includeCursor && cursorSync.attempted && cursorSync.error) {
+        // Don't block report generation; just warn about partial Cursor sync.
+        console.log(pc.yellow(`  Cursor sync warning: ${cursorSync.error}`));
+    }
     if (!localMessages && !onlyCursor) {
         if (spinner) {
             spinner.error('Failed to parse local session files');
@@ -516,7 +842,7 @@ async function showModelReport(options, extraOptions) {
         const emptyMessages = { messages: [], opencodeCount: 0, claudeCount: 0, codexCount: 0, geminiCount: 0, ampCount: 0, droidCount: 0, processingTimeMs: 0 };
         report = await finalizeReportAsync({
             localMessages: localMessages || emptyMessages,
-            includeCursor: includeCursor && cursorSync.synced,
+            includeCursor: includeCursor && (cursorSync.synced || hasCursorUsageCache()),
             since: dateFilters.since,
             until: dateFilters.until,
             year: dateFilters.year,
@@ -608,7 +934,7 @@ async function showMonthlyReport(options, extraOptions) {
     try {
         report = await finalizeMonthlyReportAsync({
             localMessages,
-            includeCursor: includeCursor && cursorSync.synced,
+            includeCursor: includeCursor && (cursorSync.synced || hasCursorUsageCache()),
             since: dateFilters.since,
             until: dateFilters.until,
             year: dateFilters.year,
@@ -675,7 +1001,7 @@ async function outputJsonReport(reportType, options) {
     if (reportType === "models") {
         const report = await finalizeReportAsync({
             localMessages: localMessages || emptyMessages,
-            includeCursor: includeCursor && cursorSync.synced,
+            includeCursor: includeCursor && (cursorSync.synced || hasCursorUsageCache()),
             since: dateFilters.since,
             until: dateFilters.until,
             year: dateFilters.year,
@@ -685,7 +1011,7 @@ async function outputJsonReport(reportType, options) {
     else {
         const report = await finalizeMonthlyReportAsync({
             localMessages: localMessages || emptyMessages,
-            includeCursor: includeCursor && cursorSync.synced,
+            includeCursor: includeCursor && (cursorSync.synced || hasCursorUsageCache()),
             since: dateFilters.since,
             until: dateFilters.until,
             year: dateFilters.year,
@@ -711,7 +1037,7 @@ async function handleGraphCommand(options) {
     const startTime = performance.now();
     const data = await finalizeGraphAsync({
         localMessages,
-        includeCursor: includeCursor && cursorSync.synced,
+        includeCursor: includeCursor && (cursorSync.synced || hasCursorUsageCache()),
         since: dateFilters.since,
         until: dateFilters.until,
         year: dateFilters.year,
@@ -902,13 +1228,7 @@ function getSourceLabel(source) {
 // =============================================================================
 // Cursor IDE Authentication
 // =============================================================================
-async function cursorLogin() {
-    const credentials = loadCursorCredentials();
-    if (credentials) {
-        console.log(pc.yellow("\n  Already logged in to Cursor."));
-        console.log(pc.gray("  Run 'tokscale cursor logout' to sign out first.\n"));
-        return;
-    }
+async function cursorLogin(options = {}) {
     console.log(pc.cyan("\n  Cursor IDE - Login\n"));
     console.log(pc.white("  To get your session token:"));
     console.log(pc.gray("  1. Open https://www.cursor.com/settings in your browser"));
@@ -940,40 +1260,87 @@ async function cursorLogin() {
         console.log(pc.gray("  Please try again with a valid session token.\n"));
         return;
     }
-    // Save credentials
-    saveCursorCredentials({
-        sessionToken: token,
-        createdAt: new Date().toISOString(),
-    });
+    // Save credentials (multi-account)
+    let savedAccountId;
+    try {
+        const saved = saveCursorCredentials({
+            sessionToken: token,
+            createdAt: new Date().toISOString(),
+        }, { label: options.name });
+        savedAccountId = saved.accountId;
+    }
+    catch (e) {
+        console.log(pc.red(`\n  Failed to save credentials: ${e.message}\n`));
+        return;
+    }
     console.log(pc.green("\n  Success! Logged in to Cursor."));
+    if (options.name) {
+        console.log(pc.gray(`  Account: ${options.name} (${savedAccountId})`));
+    }
+    else {
+        console.log(pc.gray(`  Account ID: ${savedAccountId}`));
+    }
     if (validation.membershipType) {
         console.log(pc.gray(`  Membership: ${validation.membershipType}`));
     }
     console.log(pc.gray("  Your usage data will now be included in reports.\n"));
 }
-async function cursorLogout() {
-    const credentials = loadCursorCredentials();
-    if (!credentials) {
+async function cursorLogout(options = {}) {
+    if (!isCursorLoggedIn()) {
         console.log(pc.yellow("\n  Not logged in to Cursor.\n"));
         return;
     }
-    const cleared = clearCursorCredentials();
-    if (cleared) {
-        console.log(pc.green("\n  Logged out from Cursor.\n"));
-    }
-    else {
+    if (options.all) {
+        const cleared = options.purgeCache ? clearCursorCredentialsAndCache({ purgeCache: true }) : clearCursorCredentialsAndCache();
+        if (cleared) {
+            console.log(pc.green("\n  Logged out from all Cursor accounts.\n"));
+            return;
+        }
         console.error(pc.red("\n  Failed to clear Cursor credentials.\n"));
         process.exit(1);
     }
+    const target = options.name || listCursorAccounts().find((a) => a.isActive)?.id;
+    if (!target) {
+        console.log(pc.yellow("\n  No saved Cursor accounts.\n"));
+        return;
+    }
+    const removed = removeCursorAccount(target, { purgeCache: options.purgeCache });
+    if (!removed.removed) {
+        console.error(pc.red(`\n  Failed to log out: ${removed.error}\n`));
+        process.exit(1);
+    }
+    if (options.purgeCache) {
+        console.log(pc.green(`\n  Logged out from Cursor account (cache purged): ${pc.bold(target)}\n`));
+    }
+    else {
+        console.log(pc.green(`\n  Logged out from Cursor account (history archived): ${pc.bold(target)}\n`));
+    }
 }
-async function cursorStatus() {
-    const credentials = loadCursorCredentials();
-    if (!credentials) {
+async function cursorStatus(options = {}) {
+    if (!isCursorLoggedIn()) {
         console.log(pc.yellow("\n  Not logged in to Cursor."));
         console.log(pc.gray("  Run 'tokscale cursor login' to authenticate.\n"));
         return;
     }
+    const accounts = listCursorAccounts();
+    const target = options.name
+        ? options.name
+        : accounts.find((a) => a.isActive)?.id;
+    const credentials = target ? loadCursorCredentials(target) : null;
+    if (!credentials) {
+        console.log(pc.red("\n  Error: Cursor account not found."));
+        console.log(pc.gray("  Run 'tokscale cursor accounts' to list saved accounts.\n"));
+        process.exit(1);
+    }
     console.log(pc.cyan("\n  Cursor IDE - Status\n"));
+    if (accounts.length > 0) {
+        console.log(pc.white("  Accounts:"));
+        for (const acct of accounts) {
+            const name = acct.label ? `${acct.label} ${pc.gray(`(${acct.id})`)}` : acct.id;
+            console.log(`  ${acct.isActive ? pc.green("*") : pc.gray("-")} ${name}`);
+        }
+        console.log();
+    }
     console.log(pc.gray("  Checking session validity..."));
     const validation = await validateCursorSession(credentials.sessionToken);
     if (validation.valid) {
@@ -984,7 +1351,7 @@ async function cursorStatus() {
         console.log(pc.gray(`  Logged in: ${new Date(credentials.createdAt).toLocaleDateString()}`));
         // Try to fetch usage to show summary
         try {
-            const usage = await readCursorUsage();
+            const usage = await readCursorUsage(target);
             const totalCost = usage.byModel.reduce((sum, m) => sum + m.cost, 0);
             console.log(pc.gray(`  Models used: ${usage.byModel.length}`));
             console.log(pc.gray(`  Total usage events: ${usage.rows.length}`));