@tracemarketplace/cli 0.0.13 → 0.0.15

package/src/commands/login.ts

@@ -1,16 +1,28 @@
 import chalk from "chalk";
 import ora from "ora";
 import open from "open";
-import { loadConfig, saveConfig } from "../config.js";
+import { loadConfig, resolveProfile, saveConfig } from "../config.js";
 import { ApiClient } from "../api-client.js";
+import {
+  DEFAULT_PROFILE,
+  defaultServerUrlForProfile,
+  inferProfileFromServerUrl,
+  loginCommandForProfile,
+} from "../constants.js";
 
 const POLL_INTERVAL = 2000;
 const POLL_TIMEOUT = 10 * 60 * 1000; // 10 min
 
-export async function loginCommand() {
-  const config = loadConfig();
-  const serverUrl = config?.serverUrl ?? "https://trace-marketplace-api.fly.dev";
-  const client = new ApiClient(serverUrl, config?.apiKey ?? "");
+export interface LoginOptions {
+  profile?: string;
+  serverUrl?: string;
+}
+
+export async function loginCommand(opts: LoginOptions = {}) {
+  const profile = resolveLoginProfile(opts);
+  const config = loadConfig(profile);
+  const serverUrl = opts.serverUrl ?? config?.serverUrl ?? defaultServerUrlForProfile(profile);
+  const client = new ApiClient(serverUrl);
 
   // Step 1: init CLI session
   const spinner = ora("Initializing...").start();
@@ -53,23 +65,39 @@ export async function loginCommand() {
         const infoClient = new ApiClient(serverUrl, res.apiKey);
         const me = await infoClient.get("/api/v1/me") as { email: string };
 
-        saveConfig({ apiKey: res.apiKey, serverUrl, email: me.email });
-        console.log(chalk.green(`\n✓ Logged in as ${me.email}\n`));
+        const saved = saveConfig(
+          { apiKey: res.apiKey, serverUrl, email: me.email },
+          {
+            profile,
+            setDefault: profile === DEFAULT_PROFILE && !opts.profile && !process.env.TRACEMP_PROFILE,
+          }
+        );
+
+        console.log(chalk.green(`\n✓ Logged in as ${me.email}`));
+        console.log(chalk.gray(`  Profile: ${saved.profile}`));
+        console.log(chalk.gray(`  Server:  ${saved.serverUrl}\n`));
         return;
       }
     } catch (e: any) {
       if (e.message?.includes("Expired")) {
-        pollSpinner.fail("Login timed out. Run trace login again.");
+        pollSpinner.fail(`Login timed out. Run ${loginCommandForProfile(profile)} again.`);
         process.exit(1);
       }
       // Transient error — keep polling
     }
   }
 
-  pollSpinner.fail("Timed out. Run trace login again.");
+  pollSpinner.fail(`Timed out. Run ${loginCommandForProfile(profile)} again.`);
   process.exit(1);
 }
 
 function sleep(ms: number) {
   return new Promise((r) => setTimeout(r, ms));
 }
+
+function resolveLoginProfile(opts: LoginOptions): string {
+  if (opts.profile) return resolveProfile(opts.profile);
+  if (process.env.TRACEMP_PROFILE) return resolveProfile();
+  if (opts.serverUrl) return inferProfileFromServerUrl(opts.serverUrl);
+  return resolveProfile();
+}

package/src/commands/register.ts

@@ -1,52 +1,8 @@
-import inquirer from "inquirer";
 import chalk from "chalk";
-import { saveConfig } from "../config.js";
+import { CLI_NAME } from "../constants.js";
+import { loginCommand } from "./login.js";
 
-export async function registerCommand(opts: { serverUrl?: string }): Promise<void> {
-  const { email } = await inquirer.prompt([
-    {
-      type: "input",
-      name: "email",
-      message: "Your email address:",
-      validate: (v: string) => v.includes("@") || "Enter a valid email",
-    },
-  ]);
-
-  const serverUrl =
-    opts.serverUrl ??
-    (
-      await inquirer.prompt([
-        {
-          type: "input",
-          name: "url",
-          message: "Server URL:",
-          default: "https://trace-marketplace-api.fly.dev",
-        },
-      ])
-    ).url;
-
-  const res = await fetch(`${serverUrl}/api/v1/register`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ email }),
-  });
-
-  const data = (await res.json()) as { api_key?: string; error?: string };
-
-  if (!res.ok) {
-    if (res.status === 409 && data.api_key) {
-      console.log(chalk.yellow("Email already registered."));
-      console.log(chalk.cyan("Your API key:"), chalk.bold(data.api_key));
-      saveConfig({ apiKey: data.api_key, serverUrl, email });
-      return;
-    }
-    throw new Error(data.error ?? `HTTP ${res.status}`);
-  }
-
-  const apiKey = data.api_key!;
-  saveConfig({ apiKey, serverUrl, email });
-
-  console.log(chalk.green("Registered successfully!"));
-  console.log(chalk.cyan("Your API key:"), chalk.bold(apiKey));
-  console.log(chalk.gray("Config saved to ~/.config/tracemarketplace/config.json"));
+export async function registerCommand(opts: { profile?: string; serverUrl?: string }): Promise<void> {
+  console.log(chalk.yellow(`\`${CLI_NAME} register\` is now an alias for \`${CLI_NAME} login\`.`));
+  await loginCommand({ profile: opts.profile, serverUrl: opts.serverUrl });
 }

package/src/commands/remove-hook.ts

@@ -0,0 +1,194 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import chalk from "chalk";
+import { CODEX_HOOK_MARKER } from "./setup-hook.js";
+
+interface RemoveHookOptions {
+  tool?: string;
+}
+
+const LEGACY_CODEX_HOOK_MARKER = "# trace-marketplace-hook";
+
+export async function removeHookCommand(opts: RemoveHookOptions): Promise<void> {
+  const tools = opts.tool ? [opts.tool] : ["claude-code", "cursor", "codex"];
+  let removedAny = false;
+
+  for (const tool of tools) {
+    try {
+      let removed = false;
+      switch (tool) {
+        case "claude-code":
+          removed = removeClaudeCode();
+          break;
+        case "cursor":
+          removed = removeCursor();
+          break;
+        case "codex":
+          removed = removeCodex();
+          break;
+        default:
+          console.log(chalk.yellow(`Unknown tool: ${tool}. Supported: claude-code, cursor, codex`));
+          continue;
+      }
+
+      removedAny = removedAny || removed;
+    } catch (err) {
+      console.error(chalk.red(`Failed to remove hook for ${tool}: ${err}`));
+    }
+  }
+
+  if (!removedAny) {
+    console.log(chalk.gray("No tracemp hooks found."));
+  }
+}
+
+function removeClaudeCode(): boolean {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  if (!existsSync(settingsPath)) {
+    console.log(chalk.gray(`Claude Code — no settings file at ${settingsPath}`));
+    return false;
+  }
+
+  let settings: Record<string, unknown>;
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+  } catch {
+    console.log(chalk.yellow(`Claude Code — could not parse ${settingsPath}`));
+    return false;
+  }
+
+  const hooks = (settings.hooks as Record<string, unknown> | undefined) ?? {};
+  const stopHooks = (hooks["Stop"] as unknown[] | undefined) ?? [];
+  let removed = false;
+
+  const nextStopHooks = stopHooks
+    .map((h) => {
+      const entry = { ...(h as Record<string, unknown>) };
+      const innerHooks = Array.isArray(entry.hooks) ? entry.hooks as Array<Record<string, unknown>> : [];
+      const nextInnerHooks = innerHooks.filter((ih) => !String(ih.command ?? "").includes("auto-submit"));
+      if (nextInnerHooks.length !== innerHooks.length) removed = true;
+      entry.hooks = nextInnerHooks;
+      return entry;
+    })
+    .filter((entry) => Array.isArray(entry.hooks) && entry.hooks.length > 0);
+
+  if (!removed) {
+    console.log(chalk.gray("Claude Code — no tracemp hook found"));
+    return false;
+  }
+
+  if (nextStopHooks.length > 0) {
+    hooks["Stop"] = nextStopHooks;
+    settings.hooks = hooks;
+  } else {
+    delete hooks["Stop"];
+    if (Object.keys(hooks).length > 0) {
+      settings.hooks = hooks;
+    } else {
+      delete settings.hooks;
+    }
+  }
+
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  console.log(chalk.green("✓ Claude Code") + chalk.gray(` — tracemp hook removed from ${settingsPath}`));
+  return true;
+}
+
+function removeCursor(): boolean {
+  const hooksPath = join(homedir(), ".cursor", "hooks.json");
+  if (!existsSync(hooksPath)) {
+    console.log(chalk.gray(`Cursor — no hooks file at ${hooksPath}`));
+    return false;
+  }
+
+  let hooks: unknown[] = [];
+  try {
+    const parsed = JSON.parse(readFileSync(hooksPath, "utf-8"));
+    hooks = Array.isArray(parsed) ? parsed : (parsed.hooks ?? []);
+  } catch {
+    console.log(chalk.yellow(`Cursor — could not parse ${hooksPath}`));
+    return false;
+  }
+
+  const nextHooks = hooks.filter((h) => !String((h as Record<string, unknown>).command ?? "").includes("auto-submit"));
+  if (nextHooks.length === hooks.length) {
+    console.log(chalk.gray("Cursor — no tracemp hook found"));
+    return false;
+  }
+
+  writeFileSync(hooksPath, JSON.stringify(nextHooks, null, 2) + "\n", "utf-8");
+  console.log(chalk.green("✓ Cursor") + chalk.gray(` — tracemp hook removed from ${hooksPath}`));
+  return true;
+}
+
+function removeCodex(): boolean {
+  const configPath = join(homedir(), ".codex", "config.toml");
+  if (!existsSync(configPath)) {
+    console.log(chalk.gray(`Codex — no config file at ${configPath}`));
+    return false;
+  }
+
+  let existing = "";
+  try {
+    existing = readFileSync(configPath, "utf-8");
+  } catch {
+    console.log(chalk.yellow(`Codex — could not read ${configPath}`));
+    return false;
+  }
+
+  const next = removeCodexHookBlocks(existing);
+  if (next === existing) {
+    console.log(chalk.gray("Codex — no tracemp hook found"));
+    return false;
+  }
+
+  writeFileSync(configPath, next, "utf-8");
+  console.log(chalk.green("✓ Codex") + chalk.gray(` — tracemp hook removed from ${configPath}`));
+  return true;
+}
+
+function removeCodexHookBlocks(content: string): string {
+  const markers = new Set([CODEX_HOOK_MARKER, LEGACY_CODEX_HOOK_MARKER]);
+  const lines = content.split("\n");
+  const out: string[] = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    if (markers.has(trimmed)) {
+      i++;
+      while (i < lines.length && lines[i].trim() === "") i++;
+      if (i < lines.length && lines[i].trim() === "[[hooks]]") {
+        i = skipHookBlock(lines, i);
+        while (i < lines.length && lines[i].trim() === "") i++;
+      }
+      continue;
+    }
+
+    if (trimmed === "[[hooks]]") {
+      const blockEnd = skipHookBlock(lines, i);
+      const blockText = lines.slice(i, blockEnd).join("\n");
+      if (blockText.includes("auto-submit")) {
+        i = blockEnd;
+        while (i < lines.length && lines[i].trim() === "") i++;
+        continue;
+      }
+    }
+
+    out.push(line);
+    i++;
+  }
+
+  return out.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+function skipHookBlock(lines: string[], start: number): number {
+  let i = start + 1;
+  while (i < lines.length && !lines[i].trim().startsWith("[")) {
+    i++;
+  }
+  return i;
+}

package/src/commands/setup-hook.ts

@@ -1,5 +1,5 @@
 /**
- * setup-hook — installs trace auto-submit as a per-turn hook for AI coding tools.
+ * setup-hook — installs tracemp auto-submit as a per-turn hook for AI coding tools.
  * Run once; sessions are then captured automatically with no user action.
  *
  * Supported tools:
@@ -12,21 +12,22 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import chalk from "chalk";
+import { getAutoSubmitLogPath, resolveProfile } from "../config.js";
 
 interface SetupHookOptions {
+  profile?: string;
   tool?: string;
 }
 
-// The command that hooks invoke — must be on PATH after `npm install -g`
-const HOOK_COMMAND = "tracemp auto-submit";
-
 export async function setupHookCommand(opts: SetupHookOptions): Promise<void> {
+  const profile = resolveProfile(opts.profile);
   const tools = opts.tool ? [opts.tool] : detectInstalledTools();
+  const hookCommand = buildHookCommand(profile);
 
   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"));
+    console.log(chalk.gray("Or specify: tracemp setup-hook --tool claude-code"));
     return;
   }
 
@@ -34,31 +35,32 @@ export async function setupHookCommand(opts: SetupHookOptions): Promise<void> {
     try {
       switch (tool) {
         case "claude-code":
-          setupClaudeCode();
+          setupClaudeCode(hookCommand);
           break;
         case "cursor":
-          setupCursor();
+          setupCursor(hookCommand);
           break;
         case "codex":
-          setupCodex();
+          setupCodex(hookCommand);
           break;
         default:
-          console.log(chalk.yellow(`Unknown tool: ${tool}. Supported: claude-code, cursor`));
+          console.log(chalk.yellow(`Unknown tool: ${tool}. Supported: claude-code, cursor, codex`));
       }
     } 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`));
+  console.log(chalk.gray(`\nProfile: ${profile}`));
+  console.log(chalk.gray(`Hook logs: ${getAutoSubmitLogPath(profile)}`));
+  console.log(chalk.gray("Remove hooks: tracemp remove-hook"));
 }
 
 // ─── Claude Code ────────────────────────────────────────────────────────────
 // Hook config: ~/.claude/settings.json
 // Stop hook fires at session end with stdin: { session_id, transcript_path }
 
-function setupClaudeCode() {
+function setupClaudeCode(hookCommand: string) {
   const settingsPath = join(homedir(), ".claude", "settings.json");
   mkdirSync(join(homedir(), ".claude"), { recursive: true });
 
@@ -70,22 +72,23 @@ function setupClaudeCode() {
   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("auto-submit"));
+  const nextStopHooks = stopHooks
+    .map((h: unknown) => {
+      const entry = { ...(h as Record<string, unknown>) };
+      const innerHooks = Array.isArray(entry.hooks) ? entry.hooks as Array<Record<string, unknown>> : [];
+      entry.hooks = innerHooks.filter((ih) => !String(ih.command ?? "").includes("auto-submit"));
+      return entry;
+    })
+    .filter((entry) => Array.isArray(entry.hooks) && entry.hooks.length > 0);
+
+  nextStopHooks.push({
+    matcher: "",
+    hooks: [{ type: "command", command: hookCommand, async: true }],
   });
 
-  if (!alreadyInstalled) {
-    stopHooks.push({
-      matcher: "",
-      hooks: [{ type: "command", command: HOOK_COMMAND, async: true }],
-    });
-    hooks["Stop"] = stopHooks;
-    settings.hooks = hooks;
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
-  }
+  hooks["Stop"] = nextStopHooks;
+  settings.hooks = hooks;
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
 
   console.log(chalk.green("✓ Claude Code") + chalk.gray(` — Stop hook installed in ${settingsPath}`));
 }
@@ -94,7 +97,7 @@ function setupClaudeCode() {
 // Hook config: ~/.cursor/hooks.json
 // stop fires after each assistant turn with stdin: { sessionId, terminationReason, duration }
 
-function setupCursor() {
+function setupCursor(hookCommand: string) {
   const hooksPath = join(homedir(), ".cursor", "hooks.json");
   mkdirSync(join(homedir(), ".cursor"), { recursive: true });
 
@@ -106,21 +109,19 @@ function setupCursor() {
     } catch {}
   }
 
-  // Remove any old sessionEnd entry for trace auto-submit (migration)
+  // Remove any old sessionEnd entry for tracemp auto-submit (migration)
   hooks = hooks.filter((h: unknown) => {
     const entry = h as Record<string, unknown>;
     return !(entry.event === "sessionEnd" && String(entry.command ?? "").includes("auto-submit"));
   });
 
-  const alreadyInstalled = hooks.some((h: unknown) => {
+  hooks = hooks.filter((h: unknown) => {
     const entry = h as Record<string, unknown>;
-    return entry.event === "stop" && String(entry.command ?? "").includes("auto-submit");
+    return !(entry.event === "stop" && String(entry.command ?? "").includes("auto-submit"));
   });
 
-  if (!alreadyInstalled) {
-    hooks.push({ event: "stop", command: HOOK_COMMAND, timeout: 30 });
-    writeFileSync(hooksPath, JSON.stringify(hooks, null, 2), "utf-8");
-  }
+  hooks.push({ event: "stop", command: hookCommand, timeout: 30 });
+  writeFileSync(hooksPath, JSON.stringify(hooks, null, 2) + "\n", "utf-8");
 
   console.log(chalk.green("✓ Cursor") + chalk.gray(` — stop hook installed in ${hooksPath}`));
 }
@@ -131,9 +132,9 @@ function setupCursor() {
 //   { "thread-id": "...", "turn-id": "...", "cwd": "...", "last-assistant-message": "..." }
 // Uses TOML [[hooks]] array-of-tables format.
 
-const CODEX_HOOK_MARKER = "# trace-marketplace-hook";
+export const CODEX_HOOK_MARKER = "# tracemp-hook";
 
-function setupCodex() {
+function setupCodex(hookCommand: string) {
   const configPath = join(homedir(), ".codex", "config.toml");
   mkdirSync(join(homedir(), ".codex"), { recursive: true });
 
@@ -142,13 +143,8 @@ function setupCodex() {
     try { existing = readFileSync(configPath, "utf-8"); } catch {}
   }
 
-  if (existing.includes("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");
+  const next = appendCodexHook(existing, `${hookCommand} --tool codex`);
+  writeFileSync(configPath, next, "utf-8");
 
   console.log(chalk.green("✓ Codex") + chalk.gray(` — after_agent hook installed in ${configPath}`));
 }
@@ -173,3 +169,57 @@ function detectInstalledTools(): string[] {
 
   return found;
 }
+
+function buildHookCommand(profile: string): string {
+  return `tracemp auto-submit --profile ${profile}`;
+}
+
+function appendCodexHook(content: string, hookCommand: string): string {
+  const base = removeCodexHookBlocks(content).trimEnd();
+  const hookBlock = `${CODEX_HOOK_MARKER}\n[[hooks]]\nevent = "after_agent"\ncommand = "${hookCommand}"`;
+  return base ? `${base}\n\n${hookBlock}\n` : `${hookBlock}\n`;
+}
+
+function removeCodexHookBlocks(content: string): string {
+  const lines = content.split("\n");
+  const out: string[] = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    if (trimmed === CODEX_HOOK_MARKER) {
+      i++;
+      while (i < lines.length && lines[i].trim() === "") i++;
+      if (i < lines.length && lines[i].trim() === "[[hooks]]") {
+        i = skipHookBlock(lines, i);
+        while (i < lines.length && lines[i].trim() === "") i++;
+      }
+      continue;
+    }
+
+    if (trimmed === "[[hooks]]") {
+      const blockEnd = skipHookBlock(lines, i);
+      const blockText = lines.slice(i, blockEnd).join("\n");
+      if (blockText.includes("auto-submit")) {
+        i = blockEnd;
+        while (i < lines.length && lines[i].trim() === "") i++;
+        continue;
+      }
+    }
+
+    out.push(line);
+    i++;
+  }
+
+  return out.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+function skipHookBlock(lines: string[], start: number): number {
+  let i = start + 1;
+  while (i < lines.length && !lines[i].trim().startsWith("[")) {
+    i++;
+  }
+  return i;
+}

package/src/commands/status.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 statusCommand(): Promise<void> {
-  const config = loadConfig();
+export async function statusCommand(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);
   }
 
@@ -16,6 +18,8 @@ export async function statusCommand(): Promise<void> {
   ]);
 
   const balance = ((me as any).balanceCents ?? (me as any).balance_cents ?? 0) / 100;
+  console.log(chalk.gray("Profile:"), config.profile);
+  console.log(chalk.gray("Server:"), config.serverUrl);
   console.log(chalk.bold("Balance:"), chalk.green(`$${balance.toFixed(2)}`));
   console.log(chalk.bold("Submissions:"), (subs as any[]).length);