@tracemarketplace/cli 0.0.13 → 0.0.15

package/src/commands/submit.ts

@@ -1,22 +1,54 @@
 import { existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+import { readFile } from "fs/promises";
 import chalk from "chalk";
 import ora from "ora";
 import inquirer from "inquirer";
-import { extractClaudeCode, extractCodex, extractCursor, redactTrace } from "@tracemarketplace/shared";
-import { loadConfig } from "../config.js";
-import { ApiClient } from "../api-client.js";
-import { findFiles, CURSOR_DB_PATH } from "../sessions.js";
-import type { NormalizedTrace } from "@tracemarketplace/shared";
+import { extractClaudeCode, extractCodex, extractCursor, type NormalizedTrace } from "@tracemarketplace/shared";
+import { loadConfig, loadState, resolveProfile, stateKey } from "../config.js";
+import { loginCommandForProfile } from "../constants.js";
+import {
+  buildCursorSessionSource,
+  buildFileSessionSource,
+  createFreshSessionState,
+  flushTrackedSessions,
+  migrateLegacySessionState,
+  planSessionUploads,
+  type SessionSource,
+} from "../flush.js";
+import { CURSOR_DB_PATH, findFiles } from "../sessions.js";
 
 interface SubmitOptions {
+  profile?: string;
   tool?: string;
   session?: string;
   dryRun?: boolean;
   since?: string;
 }
 
+interface DiscoveredSession {
+  source: SessionSource;
+  trace: NormalizedTrace;
+}
+
+interface PlannedSession extends DiscoveredSession {
+  readyChunks: number;
+  pending: boolean;
+}
+
+function pushSessionIfNonEmpty(
+  sessions: DiscoveredSession[],
+  source: SessionSource,
+  trace: NormalizedTrace,
+  emptyLabel: string,
+  skippedEmpty: string[],
+): void {
+  if (trace.turn_count > 0) {
+    sessions.push({ source, trace });
+  } else {
+    skippedEmpty.push(emptyLabel);
+  }
+}
+
 function parseSinceMs(since: string): number {
   const m = since.match(/^(\d+)(m|h|d)$/);
   if (!m) return 30 * 24 * 60 * 60 * 1000;
@@ -27,9 +59,10 @@ function parseSinceMs(since: string): number {
 }
 
 export async function submitCommand(opts: SubmitOptions): Promise<void> {
-  const config = loadConfig();
+  const profile = resolveProfile(opts.profile);
+  const config = loadConfig(profile);
   if (!config) {
-    console.error(chalk.red("Not registered. Run: trace register"));
+    console.error(chalk.red(`Not authenticated for profile '${profile}'. Run: ${loginCommandForProfile(profile)}`));
     process.exit(1);
   }
 
@@ -37,8 +70,9 @@ export async function submitCommand(opts: SubmitOptions): Promise<void> {
   const sinceDays = sinceMs / (24 * 60 * 60 * 1000);
   const spinner = ora("Discovering sessions...").start();
 
-  const traces: NormalizedTrace[] = [];
+  const discovered: DiscoveredSession[] = [];
   const errors: string[] = [];
+  const skippedEmpty: string[] = [];
 
   const toolAlias: Record<string, string> = {
     "claude-code": "claude_code",
@@ -50,11 +84,17 @@ export async function submitCommand(opts: SubmitOptions): Promise<void> {
   if (tools.includes("claude_code")) {
     const files = findFiles("claude_code", sinceDays);
     spinner.text = `Found ${files.length} Claude Code sessions`;
-    for (const f of files) {
+    for (const filePath of files) {
       try {
-        traces.push(await extractClaudeCode(f, config.email));
+        pushSessionIfNonEmpty(
+          discovered,
+          buildFileSessionSource("claude_code", filePath),
+          await extractClaudeCode(filePath, config.email),
+          `Claude Code ${filePath}`,
+          skippedEmpty,
+        );
       } catch (e) {
-        errors.push(`Claude Code ${f}: ${e}`);
+        errors.push(`Claude Code ${filePath}: ${e}`);
       }
     }
   }
@@ -62,105 +102,163 @@ export async function submitCommand(opts: SubmitOptions): Promise<void> {
   if (tools.includes("codex_cli")) {
     const files = findFiles("codex_cli", sinceDays);
     spinner.text = `Found ${files.length} Codex sessions`;
-    for (const f of files) {
+    for (const filePath of files) {
       try {
-        const { readFile } = await import("fs/promises");
-        const trace = await extractCodex(await readFile(f), config.email);
-        if (trace.turn_count > 0) traces.push(trace);
+        pushSessionIfNonEmpty(
+          discovered,
+          buildFileSessionSource("codex_cli", filePath),
+          await extractCodex(await readFile(filePath), config.email),
+          `Codex ${filePath}`,
+          skippedEmpty,
+        );
       } catch (e) {
-        errors.push(`Codex ${f}: ${e}`);
+        errors.push(`Codex ${filePath}: ${e}`);
       }
     }
   }
 
-  if (tools.includes("cursor")) {
-    if (existsSync(CURSOR_DB_PATH)) {
-      try {
-        const { default: Database } = await import("better-sqlite3");
-        const db = new Database(CURSOR_DB_PATH, { readonly: true });
-        const cutoff = Date.now() - sinceMs;
-        const allRows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'").all() as Array<{ key: string; value: string }>;
-        const rows = allRows.filter(r => {
-          try { const d = JSON.parse(r.value); return (d.createdAt ?? 0) >= cutoff; } catch { return false; }
-        });
-        db.close();
-        spinner.text = `Found ${rows.length} Cursor sessions`;
-        for (const { key } of rows) {
-          const sessionId = key.replace("composerData:", "");
-          try {
-            traces.push(await extractCursor(CURSOR_DB_PATH, sessionId, config.email));
-          } catch (e) {
-            errors.push(`Cursor ${sessionId}: ${e}`);
-          }
+  if (tools.includes("cursor") && existsSync(CURSOR_DB_PATH)) {
+    try {
+      const { default: Database } = await import("better-sqlite3");
+      const db = new Database(CURSOR_DB_PATH, { readonly: true });
+      const cutoff = Date.now() - sinceMs;
+      const allRows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'").all() as Array<{ key: string; value: string }>;
+      const rows = allRows.filter((row) => {
+        try {
+          const data = JSON.parse(row.value);
+          return (data.createdAt ?? 0) >= cutoff;
+        } catch {
+          return false;
+        }
+      });
+      db.close();
+      spinner.text = `Found ${rows.length} Cursor sessions`;
+      for (const { key } of rows) {
+        const sessionId = key.replace("composerData:", "");
+        try {
+          pushSessionIfNonEmpty(
+            discovered,
+            buildCursorSessionSource(sessionId),
+            await extractCursor(CURSOR_DB_PATH, sessionId, config.email),
+            `Cursor ${sessionId}`,
+            skippedEmpty,
+          );
+        } catch (e) {
+          errors.push(`Cursor ${sessionId}: ${e}`);
         }
-      } catch (e) {
-        errors.push(`Cursor DB: ${e}`);
       }
+    } catch (e) {
+      errors.push(`Cursor DB: ${e}`);
     }
   }
 
   spinner.stop();
 
-  // Filter to specific session if requested
-  const filteredTraces = opts.session
-    ? traces.filter((t) => t.source_session_id.startsWith(opts.session!))
-    : traces;
+  const filtered = opts.session
+    ? discovered.filter((session) => session.trace.source_session_id.startsWith(opts.session!))
+    : discovered;
 
-  if (opts.session && filteredTraces.length === 0) {
+  if (opts.session && filtered.length === 0) {
     console.log(chalk.yellow(`No session found matching ID: ${opts.session}`));
     return;
   }
 
   if (errors.length > 0) {
     console.log(chalk.yellow(`\n${errors.length} extraction error(s):`));
-    errors.slice(0, 3).forEach((e) => console.log(chalk.gray(`  ${e}`)));
+    errors.slice(0, 3).forEach((error) => console.log(chalk.gray(`  ${error}`)));
     if (errors.length > 3) console.log(chalk.gray(`  ...and ${errors.length - 3} more`));
   }
 
-  if (filteredTraces.length === 0) {
-    console.log(chalk.yellow("No sessions found in the last " + sinceDays + " days."));
+  if (skippedEmpty.length > 0) {
+    console.log(chalk.gray(`\nSkipped ${skippedEmpty.length} empty/in-progress session(s).`));
+    skippedEmpty.slice(0, 3).forEach((label) => console.log(chalk.gray(`  ${label}`)));
+    if (skippedEmpty.length > 3) {
+      console.log(chalk.gray(`  ...and ${skippedEmpty.length - 3} more`));
+    }
+  }
+
+  if (filtered.length === 0) {
+    console.log(chalk.yellow(`No sessions found in the last ${sinceDays} days.`));
     return;
   }
 
-  // Preview table
-  console.log(`\n${chalk.bold("Sessions to submit:")} (${filteredTraces.length} total)\n`);
+  const state = loadState(config.profile);
+  const now = new Date();
+  const plannedSessions = filtered.map((session) => {
+    const key = stateKey(session.trace.source_tool, session.trace.source_session_id);
+    const existing = state.sessions[key];
+    const legacyChunkIndex = state.chunks[key];
+    const cursor = existing
+      ? {
+          ...existing,
+          locator: session.source.locator,
+          sourceTool: session.trace.source_tool,
+          sourceSessionId: session.trace.source_session_id,
+        }
+      : typeof legacyChunkIndex === "number"
+        ? migrateLegacySessionState(session.source, session.trace, legacyChunkIndex)
+        : createFreshSessionState(session.source, session.trace);
+    const plan = planSessionUploads(session.trace, cursor, now);
+
+    return {
+      ...session,
+      readyChunks: plan.uploads.length,
+      pending: plan.pending,
+    } satisfies PlannedSession;
+  });
+
+  const readyChunkCount = plannedSessions.reduce((sum, session) => sum + session.readyChunks, 0);
+  const readySessionCount = plannedSessions.filter((session) => session.readyChunks > 0).length;
+  const pendingSessionCount = plannedSessions.filter((session) => session.pending).length;
+
+  console.log(chalk.gray(`Target: ${config.profile} (${config.serverUrl})`));
+  console.log(`\n${chalk.bold("Sessions scanned:")} (${plannedSessions.length} total)\n`);
   console.log(
     chalk.gray(
       "  Tool".padEnd(16) +
         "Session ID".padEnd(20) +
         "Turns".padEnd(8) +
-        "Tokens".padEnd(12) +
-        "Est. payout"
+        "Ready".padEnd(8) +
+        "Status"
     )
   );
-  console.log(chalk.gray("  " + "─".repeat(60)));
+  console.log(chalk.gray("  " + "─".repeat(62)));
 
-  for (const t of filteredTraces.slice(0, 20)) {
-    const tokens = (t.total_input_tokens ?? 0) + (t.total_output_tokens ?? 0);
-    const estPayout = t.content_fidelity === "full" ? "$0.04" : "$0.02";
+  for (const session of plannedSessions.slice(0, 20)) {
     console.log(
       "  " +
-        t.source_tool.padEnd(16) +
-        t.source_session_id.slice(0, 18).padEnd(20) +
-        String(t.turn_count).padEnd(8) +
-        String(tokens || "—").padEnd(12) +
-        estPayout
+        session.trace.source_tool.padEnd(16) +
+        session.trace.source_session_id.slice(0, 18).padEnd(20) +
+        String(session.trace.turn_count).padEnd(8) +
+        String(session.readyChunks).padEnd(8) +
+        describeSessionStatus(session)
     );
   }
-  if (filteredTraces.length > 20) {
-    console.log(chalk.gray(`  ... and ${filteredTraces.length - 20} more`));
+  if (plannedSessions.length > 20) {
+    console.log(chalk.gray(`  ... and ${plannedSessions.length - 20} more`));
   }
 
+  console.log(
+    chalk.gray(
+      `\nReady chunks: ${readyChunkCount} across ${readySessionCount} session(s); pending sessions: ${pendingSessionCount}`
+    )
+  );
+
   if (opts.dryRun) {
     console.log(chalk.cyan("\nDry run — nothing submitted."));
     return;
   }
 
+  if (readyChunkCount === 0) {
+    console.log(chalk.yellow("\nNo finalized chunks are ready to submit yet."));
+    return;
+  }
+
   const { confirm } = await inquirer.prompt([
     {
       type: "confirm",
       name: "confirm",
-      message: `Submit ${filteredTraces.length} traces to ${config.serverUrl}?`,
+      message: `Submit ${readyChunkCount} finalized chunk(s) from ${readySessionCount} session(s) to ${config.profile} (${config.serverUrl})?`,
       default: true,
     },
   ]);
@@ -170,36 +268,44 @@ export async function submitCommand(opts: SubmitOptions): Promise<void> {
     return;
   }
 
-  const uploadSpinner = ora(`Submitting ${traces.length} traces...`).start();
-  const client = new ApiClient(config.serverUrl, config.apiKey);
+  const uploadSpinner = ora(`Submitting ${readyChunkCount} finalized chunk(s) to ${config.profile}...`).start();
 
   try {
-    const home = homedir();
-    const result = (await client.post("/api/v1/traces/batch", {
-      traces: filteredTraces.map((t) => redactTrace(t, { homeDir: home })),
-      source_tool: tools[0] ?? "mixed",
-    })) as {
-      submission_id: string;
-      accepted: number;
-      duplicate: number;
-      total: number;
-      traces: Array<{ payout_cents?: number }>;
-    };
+    const result = await flushTrackedSessions(
+      config,
+      plannedSessions.map((session) => session.source),
+      { includeIdleTracked: false }
+    );
 
     uploadSpinner.stop();
 
-    const totalPayout =
-      result.traces?.reduce((s, t) => s + (t.payout_cents ?? 0), 0) ?? 0;
+    const failedSessions = result.results.filter((session) => session.error && session.error !== "Empty session");
 
     console.log(chalk.green("\nSubmission complete!"));
-    console.log(`  Accepted:   ${chalk.bold(result.accepted)}`);
-    console.log(`  Duplicates: ${chalk.gray(result.duplicate)}`);
-    console.log(`  Total:      ${result.total}`);
-    console.log(`  Payout:     ${chalk.green("$" + (totalPayout / 100).toFixed(2))}`);
-    console.log(chalk.gray(`\nSubmission ID: ${result.submission_id}`));
+    console.log(`  Uploaded chunks:   ${chalk.bold(result.uploadedChunks)}`);
+    console.log(`  Duplicate chunks:  ${chalk.gray(result.duplicateChunks)}`);
+    console.log(`  Pending sessions:  ${result.pendingSessions}`);
+    console.log(`  Payout:            ${chalk.green("$" + (result.payoutCents / 100).toFixed(2))}`);
+
+    if (failedSessions.length > 0) {
+      console.log(chalk.yellow(`\n${failedSessions.length} session(s) failed during submit:`));
+      failedSessions.slice(0, 3).forEach((session) => {
+        console.log(chalk.gray(`  ${session.source.label}: ${session.error}`));
+      });
+      if (failedSessions.length > 3) {
+        console.log(chalk.gray(`  ...and ${failedSessions.length - 3} more`));
+      }
+    }
   } catch (e) {
     uploadSpinner.fail("Submission failed");
     console.error(chalk.red(String(e)));
     process.exit(1);
   }
 }
+
+function describeSessionStatus(session: PlannedSession): string {
+  if (session.readyChunks > 0 && session.pending) return "ready + pending";
+  if (session.readyChunks > 0) return "ready";
+  if (session.pending) return "pending";
+  return "up-to-date";
+}

package/src/commands/whoami.ts

@@ -1,11 +1,13 @@
 import chalk from "chalk";
-import { loadConfig } from "../config.js";
+import { loadConfig, resolveProfile } from "../config.js";
 import { ApiClient } from "../api-client.js";
+import { loginCommandForProfile } from "../constants.js";
 
-export async function whoamiCommand(): Promise<void> {
-  const config = loadConfig();
+export async function whoamiCommand(opts: { profile?: string } = {}): Promise<void> {
+  const profile = resolveProfile(opts.profile);
+  const config = loadConfig(profile);
   if (!config) {
-    console.error(chalk.red("Not registered. Run: trace register"));
+    console.error(chalk.red(`Not authenticated for profile '${profile}'. Run: ${loginCommandForProfile(profile)}`));
     process.exit(1);
   }
 
@@ -18,5 +20,7 @@ export async function whoamiCommand(): Promise<void> {
 
   const balance = (user.balance_cents ?? user.balanceCents ?? 0) / 100;
   console.log(chalk.bold(user.email));
+  console.log(chalk.gray("Profile:"), config.profile);
+  console.log(chalk.gray("Server:"), config.serverUrl);
   console.log(chalk.gray("Balance:"), chalk.green(`$${balance.toFixed(2)}`));
 }