@tracemarketplace/cli 0.0.1

package/src/commands/setup-hook.ts

@@ -0,0 +1,175 @@
+/**
+ * setup-hook — installs trace auto-submit as a per-turn hook for AI coding tools.
+ * Run once; sessions are then captured automatically with no user action.
+ *
+ * Supported tools:
+ *   --tool claude-code  → writes ~/.claude/settings.json Stop hook (per-turn)
+ *   --tool cursor       → writes ~/.cursor/hooks.json stop hook (per-turn)
+ *   --tool codex        → writes ~/.codex/config.toml [[hooks]] after_agent (per-turn)
+ *   (no flag)           → installs for all detected tools
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import chalk from "chalk";
+
+interface SetupHookOptions {
+  tool?: string;
+}
+
+// The command that hooks invoke — must be on PATH after `npm install -g`
+const HOOK_COMMAND = "trace auto-submit";
+
+export async function setupHookCommand(opts: SetupHookOptions): Promise<void> {
+  const tools = opts.tool ? [opts.tool] : detectInstalledTools();
+
+  if (tools.length === 0) {
+    console.log(chalk.yellow("No supported AI coding tools detected."));
+    console.log(chalk.gray("Install Claude Code, Cursor, or Codex CLI, then run setup-hook again."));
+    console.log(chalk.gray("Or specify: trace setup-hook --tool claude-code"));
+    return;
+  }
+
+  for (const tool of tools) {
+    try {
+      switch (tool) {
+        case "claude-code":
+          setupClaudeCode();
+          break;
+        case "cursor":
+          setupCursor();
+          break;
+        case "codex":
+          setupCodex();
+          break;
+        default:
+          console.log(chalk.yellow(`Unknown tool: ${tool}. Supported: claude-code, cursor`));
+      }
+    } catch (err) {
+      console.error(chalk.red(`Failed to set up hook for ${tool}: ${err}`));
+    }
+  }
+
+  console.log(chalk.gray(`\nHook logs: ~/.config/tracemarketplace/auto-submit.log`));
+  console.log(chalk.gray(`Remove hooks: trace remove-hook`));
+}
+
+// ─── Claude Code ────────────────────────────────────────────────────────────
+// Hook config: ~/.claude/settings.json
+// Stop hook fires at session end with stdin: { session_id, transcript_path }
+
+function setupClaudeCode() {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  mkdirSync(join(homedir(), ".claude"), { recursive: true });
+
+  let settings: Record<string, unknown> = {};
+  if (existsSync(settingsPath)) {
+    try { settings = JSON.parse(readFileSync(settingsPath, "utf-8")); } catch {}
+  }
+
+  const hooks = (settings.hooks as Record<string, unknown> | undefined) ?? {};
+  const stopHooks = (hooks["Stop"] as unknown[] | undefined) ?? [];
+
+  // Don't add if already present
+  const alreadyInstalled = stopHooks.some((h: unknown) => {
+    const entry = h as Record<string, unknown>;
+    const innerHooks = entry.hooks as Array<Record<string, unknown>> | undefined;
+    return innerHooks?.some((ih) => String(ih.command ?? "").includes("trace auto-submit"));
+  });
+
+  if (!alreadyInstalled) {
+    stopHooks.push({
+      matcher: "",
+      hooks: [{ type: "command", command: HOOK_COMMAND }],
+    });
+    hooks["Stop"] = stopHooks;
+    settings.hooks = hooks;
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  }
+
+  console.log(chalk.green("✓ Claude Code") + chalk.gray(` — Stop hook installed in ${settingsPath}`));
+}
+
+// ─── Cursor ─────────────────────────────────────────────────────────────────
+// Hook config: ~/.cursor/hooks.json
+// stop fires after each assistant turn with stdin: { sessionId, terminationReason, duration }
+
+function setupCursor() {
+  const hooksPath = join(homedir(), ".cursor", "hooks.json");
+  mkdirSync(join(homedir(), ".cursor"), { recursive: true });
+
+  let hooks: unknown[] = [];
+  if (existsSync(hooksPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(hooksPath, "utf-8"));
+      hooks = Array.isArray(parsed) ? parsed : (parsed.hooks ?? []);
+    } catch {}
+  }
+
+  // Remove any old sessionEnd entry for trace auto-submit (migration)
+  hooks = hooks.filter((h: unknown) => {
+    const entry = h as Record<string, unknown>;
+    return !(entry.event === "sessionEnd" && String(entry.command ?? "").includes("trace auto-submit"));
+  });
+
+  const alreadyInstalled = hooks.some((h: unknown) => {
+    const entry = h as Record<string, unknown>;
+    return entry.event === "stop" && String(entry.command ?? "").includes("trace auto-submit");
+  });
+
+  if (!alreadyInstalled) {
+    hooks.push({ event: "stop", command: HOOK_COMMAND, timeout: 30 });
+    writeFileSync(hooksPath, JSON.stringify(hooks, null, 2), "utf-8");
+  }
+
+  console.log(chalk.green("✓ Cursor") + chalk.gray(` — stop hook installed in ${hooksPath}`));
+}
+
+// ─── Codex CLI ───────────────────────────────────────────────────────────────
+// Hook config: ~/.codex/config.toml
+// after_agent fires after each agent turn with stdin:
+//   { "thread-id": "...", "turn-id": "...", "cwd": "...", "last-assistant-message": "..." }
+// Uses TOML [[hooks]] array-of-tables format.
+
+const CODEX_HOOK_MARKER = "# trace-marketplace-hook";
+
+function setupCodex() {
+  const configPath = join(homedir(), ".codex", "config.toml");
+  mkdirSync(join(homedir(), ".codex"), { recursive: true });
+
+  let existing = "";
+  if (existsSync(configPath)) {
+    try { existing = readFileSync(configPath, "utf-8"); } catch {}
+  }
+
+  if (existing.includes("trace auto-submit")) {
+    console.log(chalk.green("✓ Codex") + chalk.gray(` — after_agent hook already installed in ${configPath}`));
+    return;
+  }
+
+  const hookEntry = `\n${CODEX_HOOK_MARKER}\n[[hooks]]\nevent = "after_agent"\ncommand = "${HOOK_COMMAND} --tool codex"\n`;
+  writeFileSync(configPath, existing + hookEntry, "utf-8");
+
+  console.log(chalk.green("✓ Codex") + chalk.gray(` — after_agent hook installed in ${configPath}`));
+}
+
+// ─── Tool detection ──────────────────────────────────────────────────────────
+
+function detectInstalledTools(): string[] {
+  const found: string[] = [];
+
+  if (existsSync(join(homedir(), ".claude"))) {
+    found.push("claude-code");
+  }
+  if (
+    existsSync(join(homedir(), "Library", "Application Support", "Cursor")) ||
+    existsSync(join(homedir(), ".cursor"))
+  ) {
+    found.push("cursor");
+  }
+  if (existsSync(join(homedir(), ".codex"))) {
+    found.push("codex");
+  }
+
+  return found;
+}

package/src/commands/status.ts

@@ -0,0 +1,26 @@
+import chalk from "chalk";
+import { loadConfig } from "../config.js";
+import { ApiClient } from "../api-client.js";
+
+export async function statusCommand(): Promise<void> {
+  const config = loadConfig();
+  if (!config) {
+    console.error(chalk.red("Not registered. Run: trace register"));
+    process.exit(1);
+  }
+
+  const client = new ApiClient(config.serverUrl, config.apiKey);
+  const [me, subs] = await Promise.all([
+    client.get("/api/v1/me") as Promise<{ email: string; balanceCents?: number; balance_cents?: number }>,
+    client.get("/api/v1/submissions") as Promise<any[]>,
+  ]);
+
+  const balance = ((me as any).balanceCents ?? (me as any).balance_cents ?? 0) / 100;
+  console.log(chalk.bold("Balance:"), chalk.green(`$${balance.toFixed(2)}`));
+  console.log(chalk.bold("Submissions:"), (subs as any[]).length);
+
+  const pending = (subs as any[]).filter((s) => s.acceptedCount === null);
+  if (pending.length > 0) {
+    console.log(chalk.yellow(`\n${pending.length} pending submission(s)`));
+  }
+}

package/src/commands/submit.ts

@@ -0,0 +1,184 @@
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { extractClaudeCode, extractCodex, extractCursor } 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";
+
+interface SubmitOptions {
+  tool?: string;
+  dryRun?: boolean;
+  since?: string;
+}
+
+function parseSinceDays(since: string): number {
+  const match = since.match(/^(\d+)d$/);
+  return match ? parseInt(match[1], 10) : 30;
+}
+
+export async function submitCommand(opts: SubmitOptions): Promise<void> {
+  const config = loadConfig();
+  if (!config) {
+    console.error(chalk.red("Not registered. Run: trace register"));
+    process.exit(1);
+  }
+
+  const sinceDays = parseSinceDays(opts.since ?? "30d");
+  const spinner = ora("Discovering sessions...").start();
+
+  const traces: NormalizedTrace[] = [];
+  const errors: string[] = [];
+
+  const toolAlias: Record<string, string> = {
+    "claude-code": "claude_code",
+    "codex": "codex_cli",
+  };
+  const normalizedTool = opts.tool ? (toolAlias[opts.tool] ?? opts.tool) : null;
+  const tools = normalizedTool ? [normalizedTool] : ["claude_code", "codex_cli", "cursor"];
+
+  if (tools.includes("claude_code")) {
+    const files = findFiles("claude_code", sinceDays);
+    spinner.text = `Found ${files.length} Claude Code sessions`;
+    for (const f of files) {
+      try {
+        traces.push(await extractClaudeCode(f, config.email));
+      } catch (e) {
+        errors.push(`Claude Code ${f}: ${e}`);
+      }
+    }
+  }
+
+  if (tools.includes("codex_cli")) {
+    const files = findFiles("codex_cli", sinceDays);
+    spinner.text = `Found ${files.length} Codex sessions`;
+    for (const f 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);
+      } catch (e) {
+        errors.push(`Codex ${f}: ${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 rows = db.prepare("SELECT key FROM cursorDiskKV WHERE key LIKE 'composerData:%'").all() as Array<{ key: string }>;
+        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}`);
+          }
+        }
+      } catch (e) {
+        errors.push(`Cursor DB: ${e}`);
+      }
+    }
+  }
+
+  spinner.stop();
+
+  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}`)));
+    if (errors.length > 3) console.log(chalk.gray(`  ...and ${errors.length - 3} more`));
+  }
+
+  if (traces.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:")} (${traces.length} total)\n`);
+  console.log(
+    chalk.gray(
+      "  Tool".padEnd(16) +
+        "Session ID".padEnd(20) +
+        "Turns".padEnd(8) +
+        "Tokens".padEnd(12) +
+        "Est. payout"
+    )
+  );
+  console.log(chalk.gray("  " + "─".repeat(60)));
+
+  for (const t of traces.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";
+    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
+    );
+  }
+  if (traces.length > 20) {
+    console.log(chalk.gray(`  ... and ${traces.length - 20} more`));
+  }
+
+  if (opts.dryRun) {
+    console.log(chalk.cyan("\nDry run — nothing submitted."));
+    return;
+  }
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `Submit ${traces.length} traces to ${config.serverUrl}?`,
+      default: true,
+    },
+  ]);
+
+  if (!confirm) {
+    console.log(chalk.gray("Cancelled."));
+    return;
+  }
+
+  const uploadSpinner = ora(`Submitting ${traces.length} traces...`).start();
+  const client = new ApiClient(config.serverUrl, config.apiKey);
+
+  try {
+    const result = (await client.post("/api/v1/traces/batch", {
+      traces,
+      source_tool: tools[0] ?? "mixed",
+    })) as {
+      submission_id: string;
+      accepted: number;
+      duplicate: number;
+      total: number;
+      traces: Array<{ payout_cents?: number }>;
+    };
+
+    uploadSpinner.stop();
+
+    const totalPayout =
+      result.traces?.reduce((s, t) => s + (t.payout_cents ?? 0), 0) ?? 0;
+
+    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}`));
+  } catch (e) {
+    uploadSpinner.fail("Submission failed");
+    console.error(chalk.red(String(e)));
+    process.exit(1);
+  }
+}

package/src/commands/whoami.ts

@@ -0,0 +1,22 @@
+import chalk from "chalk";
+import { loadConfig } from "../config.js";
+import { ApiClient } from "../api-client.js";
+
+export async function whoamiCommand(): Promise<void> {
+  const config = loadConfig();
+  if (!config) {
+    console.error(chalk.red("Not registered. Run: trace register"));
+    process.exit(1);
+  }
+
+  const client = new ApiClient(config.serverUrl, config.apiKey);
+  const user = (await client.get("/api/v1/me")) as {
+    email: string;
+    balance_cents?: number;
+    balanceCents?: number;
+  };
+
+  const balance = (user.balance_cents ?? user.balanceCents ?? 0) / 100;
+  console.log(chalk.bold(user.email));
+  console.log(chalk.gray("Balance:"), chalk.green(`$${balance.toFixed(2)}`));
+}

package/src/config.ts

@@ -0,0 +1,29 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+export interface Config {
+  apiKey: string;
+  serverUrl: string;
+  email: string;
+}
+
+export function getConfigPath(): string {
+  return join(homedir(), ".config", "tracemarketplace", "config.json");
+}
+
+export function loadConfig(): Config | null {
+  const p = getConfigPath();
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf-8")) as Config;
+  } catch {
+    return null;
+  }
+}
+
+export function saveConfig(config: Config): void {
+  const p = getConfigPath();
+  mkdirSync(join(homedir(), ".config", "tracemarketplace"), { recursive: true });
+  writeFileSync(p, JSON.stringify(config, null, 2), "utf-8");
+}

package/src/sessions.ts

@@ -0,0 +1,105 @@
+/**
+ * sessions.ts — knows where each tool stores session files.
+ * Used by submit (batch discovery), auto-submit (hook path resolution), and daemon (watching).
+ */
+import { readdirSync, statSync, existsSync, watch } from "fs";
+import type { FSWatcher } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+export type ToolName = "claude_code" | "codex_cli" | "cursor";
+
+// Root directories to watch per tool
+export const SESSION_DIRS: Record<ToolName, string> = {
+  claude_code: join(homedir(), ".claude", "projects"),
+  codex_cli:   join(homedir(), ".codex", "sessions"),
+  cursor:      join(homedir(), "Library", "Application Support", "Cursor", "User", "globalStorage"),
+};
+
+export const CURSOR_DB_PATH = join(
+  homedir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb"
+);
+
+/** Walk a directory and return all .jsonl files modified within the cutoff. */
+function walkJsonl(dir: string, cutoff = 0): string[] {
+  const results: string[] = [];
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...walkJsonl(full, cutoff));
+      } else if (entry.name.endsWith(".jsonl")) {
+        try {
+          if (statSync(full).mtimeMs >= cutoff) results.push(full);
+        } catch {}
+      }
+    }
+  } catch {}
+  return results;
+}
+
+/** Find session files for a file-based tool (claude_code, codex_cli) within the last N days. */
+export function findFiles(tool: "claude_code" | "codex_cli", sinceDays = 30): string[] {
+  const dir = SESSION_DIRS[tool];
+  if (!existsSync(dir)) return [];
+  const cutoff = Date.now() - sinceDays * 86400000;
+  return walkJsonl(dir, cutoff);
+}
+
+/** Find the most recently modified .jsonl file for claude_code (used when hook doesn't give path). */
+export function findLatestFile(tool: "claude_code" | "codex_cli"): string | null {
+  const dir = SESSION_DIRS[tool];
+  if (!existsSync(dir)) return null;
+  const all = walkJsonl(dir, 0);
+  if (all.length === 0) return null;
+  return all.reduce((a, b) => {
+    try { return statSync(a).mtimeMs >= statSync(b).mtimeMs ? a : b; } catch { return a; }
+  });
+}
+
+/** Find a specific codex session file by UUID (the UUID appears in the filename). */
+export function findCodexFileById(sessionId: string): string | null {
+  const dir = SESSION_DIRS["codex_cli"];
+  if (!existsSync(dir)) return null;
+  const files = walkJsonl(dir, 0);
+  return files.find(f => f.includes(sessionId)) ?? null;
+}
+
+/**
+ * Watch session directories for new/changed .jsonl files.
+ * Calls onChange(tool, filePath) after a 5s debounce (lets writes settle).
+ * Returns a cleanup function.
+ */
+export function watchDirs(
+  tools: Array<"claude_code" | "codex_cli">,
+  onChange: (tool: "claude_code" | "codex_cli", filePath: string) => void
+): () => void {
+  const watchers: FSWatcher[] = [];
+  const debounce = new Map<string, ReturnType<typeof setTimeout>>();
+
+  for (const tool of tools) {
+    const dir = SESSION_DIRS[tool];
+    if (!existsSync(dir)) continue;
+
+    try {
+      const watcher = watch(dir, { recursive: true }, (_event, filename) => {
+        if (!filename || !filename.endsWith(".jsonl")) return;
+        const full = join(dir, filename);
+
+        // Debounce: wait 5s of no writes before treating the file as settled
+        const existing = debounce.get(full);
+        if (existing) clearTimeout(existing);
+        debounce.set(full, setTimeout(() => {
+          debounce.delete(full);
+          if (existsSync(full)) onChange(tool, full);
+        }, 5000));
+      });
+      watchers.push(watcher);
+    } catch {}
+  }
+
+  return () => {
+    for (const w of watchers) w.close();
+    for (const t of debounce.values()) clearTimeout(t);
+  };
+}

package/src/submitter.ts

@@ -0,0 +1,89 @@
+/**
+ * submitter.ts — extract one session file and submit it to the API.
+ * Shared by auto-submit (hook), submit (batch), and daemon (watch).
+ */
+import { readFile } from "fs/promises";
+import { extractClaudeCode, extractCodex, extractCursor } from "@tracemarketplace/shared";
+import { ApiClient } from "./api-client.js";
+import { CURSOR_DB_PATH } from "./sessions.js";
+import type { Config } from "./config.js";
+
+export interface SubmitResult {
+  accepted: boolean;
+  superseded: boolean;
+  duplicate: boolean;
+  turnCount: number;
+  payoutCents: number;
+  traceId: string | null;
+  error?: string;
+}
+
+/**
+ * Extract a claude_code or codex_cli session from a file path and submit it.
+ */
+export async function submitFile(
+  tool: "claude_code" | "codex_cli",
+  filePath: string,
+  config: Config
+): Promise<SubmitResult> {
+  let trace;
+  try {
+    if (tool === "claude_code") {
+      trace = await extractClaudeCode(filePath, config.email);
+    } else {
+      const buf = await readFile(filePath);
+      trace = await extractCodex(buf, config.email);
+    }
+  } catch (err) {
+    return { accepted: false, superseded: false, duplicate: false, turnCount: 0, payoutCents: 0, traceId: null, error: `Extraction failed: ${err}` };
+  }
+
+  if (trace.turn_count === 0) {
+    return { accepted: false, superseded: false, duplicate: false, turnCount: 0, payoutCents: 0, traceId: null, error: "Empty session" };
+  }
+
+  return submitTrace(trace, config);
+}
+
+/**
+ * Extract a Cursor session by session ID and submit it.
+ */
+export async function submitCursorSession(
+  sessionId: string,
+  config: Config
+): Promise<SubmitResult> {
+  let trace;
+  try {
+    trace = await extractCursor(CURSOR_DB_PATH, sessionId, config.email);
+  } catch (err) {
+    return { accepted: false, superseded: false, duplicate: false, turnCount: 0, payoutCents: 0, traceId: null, error: `Cursor extraction failed: ${err}` };
+  }
+  return submitTrace(trace, config);
+}
+
+async function submitTrace(trace: Awaited<ReturnType<typeof extractClaudeCode>>, config: Config): Promise<SubmitResult> {
+  const client = new ApiClient(config.serverUrl, config.apiKey);
+  try {
+    const result = await client.post("/api/v1/traces/batch", {
+      traces: [trace],
+      source_tool: trace.source_tool,
+    }) as {
+      accepted: number;
+      duplicate: number;
+      superseded: number;
+      traces: Array<{ trace_id?: string; payout_cents?: number }>;
+    };
+
+    const first = result.traces?.[0];
+    return {
+      accepted: result.accepted > 0,
+      superseded: result.superseded > 0,
+      duplicate: result.duplicate > 0,
+      turnCount: trace.turn_count,
+      payoutCents: first?.payout_cents ?? 0,
+      traceId: first?.trace_id ?? null,
+    };
+  } catch (err) {
+    return { accepted: false, superseded: false, duplicate: false, turnCount: trace.turn_count, payoutCents: 0, traceId: null, error: `Submit failed: ${err}` };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}