@tokscale/cli 1.0.24 → 1.1.1

package/src/cli.ts

@@ -16,9 +16,16 @@ import { submit } from "./submit.js";
 import { generateWrapped } from "./wrapped.js";
 
 import {
+  ensureCursorMigration,
   loadCursorCredentials,
   saveCursorCredentials,
   clearCursorCredentials,
+  clearCursorCredentialsAndCache,
+  isCursorLoggedIn,
+  hasCursorUsageCache,
+  listCursorAccounts,
+  setActiveCursorAccount,
+  removeCursorAccount,
   validateCursorSession,
   readCursorUsage,
   getCursorCredentialsPath,
@@ -44,7 +51,11 @@ import {
   type ParsedMessages,
 } 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 type { SourceType } from "./graph-types.js";
 import type { TUIOptions, TabType } from "./tui/types/index.js";
@@ -186,6 +197,217 @@ function getDateRangeLabel(options: DateFilterOptions): string | null {
   return null;
 }
 
+function getHeadlessRoots(homeDir: string): string[] {
+  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: string): string {
+  return fs.existsSync(targetPath) ? targetPath : `${targetPath} (missing)`;
+}
+
+type HeadlessFormat = "json" | "jsonl";
+type HeadlessSource = "codex";
+
+const HEADLESS_SOURCES: HeadlessSource[] = ["codex"];
+
+function normalizeHeadlessSource(source: string): HeadlessSource | null {
+  const normalized = source.toLowerCase();
+  return HEADLESS_SOURCES.includes(normalized as HeadlessSource)
+    ? (normalized as HeadlessSource)
+    : null;
+}
+
+function resolveHeadlessFormat(
+  source: HeadlessSource,
+  args: string[],
+  override?: string
+): HeadlessFormat {
+  if (override === "json" || override === "jsonl") {
+    return override;
+  }
+
+  return "jsonl";
+}
+
+function applyHeadlessDefaults(
+  source: HeadlessSource,
+  args: string[],
+  format: HeadlessFormat,
+  autoFlags: boolean
+): string[] {
+  if (!autoFlags) return args;
+
+  const updated = [...args];
+
+  if (source === "codex" && !updated.includes("--json")) {
+    updated.push("--json");
+  }
+
+  return updated;
+}
+
+function buildHeadlessOutputPath(
+  headlessRoots: string[],
+  source: HeadlessSource,
+  format: HeadlessFormat,
+  outputPath?: string
+): string {
+  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(): void {
+  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: string[]): Promise<void> {
+  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: string | undefined;
+  let formatOverride: HeadlessFormat | undefined;
+  let autoFlags = true;
+  const cmdArgs: string[] = [];
+
+  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 as HeadlessFormat;
+      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<void>((resolve, reject) => {
+    outputStream.on("finish", () => resolve());
+    outputStream.on("error", reject);
+  });
+  proc.stdout.pipe(outputStream);
+  let exitCode: number;
+  try {
+    exitCode = await new Promise<number>((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: FilterOptions & DateFilterOptions,
   initialTab?: TabType
@@ -282,6 +504,142 @@ 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: ParsedMessages | null = null;
+      try {
+        localMessages = await parseLocalSourcesAsync({
+          homeDir,
+          sources: ["claude", "codex", "gemini"],
+        });
+      } catch (e) {
+        console.error(`Error: ${(e as Error).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: Array<{
+        source: "claude" | "codex" | "gemini";
+        label: string;
+        sessionsPath: string;
+        messageCount: number;
+        headlessSupported: boolean;
+        headlessPaths: string[];
+        headlessMessageCount: number;
+      }> = [
+        {
+          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")
@@ -428,31 +786,82 @@ 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: { name?: string }) => {
+      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: { name?: string; all?: boolean; purgeCache?: boolean }) => {
+      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: { name?: string }) => {
+      ensureCursorMigration();
+      await cursorStatus(options);
+    });
+
+  cursorCommand
+    .command("accounts")
+    .description("List saved Cursor accounts")
+    .option("--json", "Output as JSON")
+    .action(async (options: { json?: boolean }) => {
+      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: string) => {
+      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) {
@@ -521,8 +930,7 @@ function getEnabledSources(options: FilterOptions): SourceType[] | undefined {
  * Only attempts sync if user is authenticated with Cursor.
  */
 async function syncCursorData(): Promise<CursorSyncResult> {
-  const credentials = loadCursorCredentials();
-  if (!credentials) {
+  if (!isCursorLoggedIn()) {
     return { attempted: false, synced: false, rows: 0 };
   }
 
@@ -578,8 +986,7 @@ async function showModelReport(options: FilterOptions & DateFilterOptions & { be
 
   // 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);
@@ -610,6 +1017,11 @@ async function showModelReport(options: FilterOptions & DateFilterOptions & { be
     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) {
@@ -628,7 +1040,7 @@ async function showModelReport(options: FilterOptions & DateFilterOptions & { be
     const emptyMessages: ParsedMessages = { 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,
@@ -760,7 +1172,7 @@ async function showMonthlyReport(options: FilterOptions & DateFilterOptions & {
   try {
     report = await finalizeMonthlyReportAsync({
       localMessages,
-      includeCursor: includeCursor && cursorSync.synced,
+      includeCursor: includeCursor && (cursorSync.synced || hasCursorUsageCache()),
       since: dateFilters.since,
       until: dateFilters.until,
       year: dateFilters.year,
@@ -859,7 +1271,7 @@ async function outputJsonReport(
   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,
@@ -868,7 +1280,7 @@ async function outputJsonReport(
   } 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,
@@ -911,7 +1323,7 @@ async function handleGraphCommand(options: GraphCommandOptions) {
 
   const data = await finalizeGraphAsync({
     localMessages,
-    includeCursor: includeCursor && cursorSync.synced,
+    includeCursor: includeCursor && (cursorSync.synced || hasCursorUsageCache()),
     since: dateFilters.since,
     until: dateFilters.until,
     year: dateFilters.year,
@@ -1124,14 +1536,7 @@ function getSourceLabel(source: string): string {
 // Cursor IDE Authentication
 // =============================================================================
 
-async function cursorLogin(): Promise<void> {
-  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: { name?: string } = {}): Promise<void> {
   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"));
@@ -1169,47 +1574,97 @@ async function cursorLogin(): Promise<void> {
     return;
   }
 
-  // Save credentials
-  saveCursorCredentials({
-    sessionToken: token,
-    createdAt: new Date().toISOString(),
-  });
+  // Save credentials (multi-account)
+  let savedAccountId: string;
+  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 as Error).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(): Promise<void> {
-  const credentials = loadCursorCredentials();
-
-  if (!credentials) {
+async function cursorLogout(options: { name?: string; all?: boolean; purgeCache?: boolean } = {}): Promise<void> {
+  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);
   }
-}
 
-async function cursorStatus(): Promise<void> {
-  const credentials = loadCursorCredentials();
+  const target = options.name || listCursorAccounts().find((a) => a.isActive)?.id;
+  if (!target) {
+    console.log(pc.yellow("\n  No saved Cursor accounts.\n"));
+    return;
+  }
 
-  if (!credentials) {
+  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(options: { name?: string } = {}): Promise<void> {
+  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);
@@ -1223,7 +1678,7 @@ async function cursorStatus(): Promise<void> {
 
     // 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}`));