@tracemarketplace/cli 0.0.15 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tracemarketplace/cli",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "type": "module",
   "bin": {
     "tracemp": "dist/cli.js"
@@ -13,7 +13,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@tracemarketplace/shared": "^0.0.10",
+    "@tracemarketplace/shared": "^0.0.11",
     "better-sqlite3": "^12.8.0",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",

package/src/api-client.test.ts

@@ -0,0 +1,47 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ApiClient, ApiError } from "./api-client.js";
+
+describe("ApiClient", () => {
+  const originalFetch = global.fetch;
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.restoreAllMocks();
+  });
+
+  it("parses retry-after and json error bodies", async () => {
+    global.fetch = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ error: "busy" }), {
+        status: 503,
+        headers: {
+          "content-type": "application/json",
+          "retry-after": "12",
+        },
+      }),
+    ) as typeof fetch;
+
+    const client = new ApiClient("https://example.test", "token");
+
+    await expect(client.post("/api/v1/traces/batch", {})).rejects.toEqual(
+      expect.objectContaining<Partial<ApiError>>({
+        name: "ApiError",
+        status: 503,
+        retryAfterSeconds: 12,
+        body: { error: "busy" },
+      }),
+    );
+  });
+
+  it("returns parsed json bodies on success", async () => {
+    global.fetch = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ ok: true }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }),
+    ) as typeof fetch;
+
+    const client = new ApiClient("https://example.test", "token");
+
+    await expect(client.get("/health")).resolves.toEqual({ ok: true });
+  });
+});

package/src/api-client.ts

@@ -1,3 +1,15 @@
+export class ApiError extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+    readonly body: unknown,
+    readonly retryAfterSeconds: number | null,
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
 export class ApiClient {
   constructor(
     private baseUrl: string,
@@ -5,29 +17,101 @@ export class ApiClient {
   ) {}
 
   async get(path: string): Promise<unknown> {
-    const res = await fetch(`${this.baseUrl}${path}`, {
-      headers: this.apiKey ? { "X-Api-Key": this.apiKey } : {},
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`API error ${res.status}: ${text}`);
-    }
-    return res.json();
+    return this.request("GET", path);
   }
 
   async post(path: string, body: unknown): Promise<unknown> {
+    return this.request("POST", path, body);
+  }
+
+  private async request(method: "GET" | "POST", path: string, body?: unknown): Promise<unknown> {
+    let reqBody: string | Uint8Array | undefined;
+    const extraHeaders: Record<string, string> = {};
+
+    if (method === "POST" && body !== undefined) {
+      const json = JSON.stringify(body);
+      try {
+        const { gzip } = await import("zlib");
+        const buf = await new Promise<Buffer>((resolve, reject) =>
+          gzip(Buffer.from(json), (err, result) => err ? reject(err) : resolve(result))
+        );
+        reqBody = new Uint8Array(buf);
+        extraHeaders["X-Content-Encoding"] = "gzip";
+        const ratio = Math.round((1 - buf.length / json.length) * 100);
+        console.error(`[gzip] ${Math.round(json.length / 1024)}KB → ${Math.round(buf.length / 1024)}KB (${ratio}% reduction)`);
+      } catch (e) {
+        console.error(`[gzip] compression failed, sending uncompressed: ${e}`);
+        reqBody = json;
+      }
+    }
+
     const res = await fetch(`${this.baseUrl}${path}`, {
-      method: "POST",
+      method,
       headers: {
-        "Content-Type": "application/json",
+        ...(method === "POST" ? { "Content-Type": "application/json" } : {}),
         ...(this.apiKey ? { "X-Api-Key": this.apiKey } : {}),
+        ...extraHeaders,
       },
-      body: JSON.stringify(body),
+      body: reqBody as BodyInit | undefined,
     });
+
+    const parsedBody = await parseResponseBody(res);
     if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`API error ${res.status}: ${text}`);
+      throw new ApiError(
+        `API error ${res.status}: ${formatErrorBody(parsedBody)}`,
+        res.status,
+        parsedBody,
+        parseRetryAfterHeader(res.headers.get("retry-after")),
+      );
     }
-    return res.json();
+
+    return parsedBody;
+  }
+}
+
+async function parseResponseBody(res: Response): Promise<unknown> {
+  const text = await res.text();
+  if (!text) {
+    return null;
   }
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function formatErrorBody(body: unknown): string {
+  if (typeof body === "string") {
+    return body;
+  }
+
+  if (body && typeof body === "object") {
+    const error = (body as { error?: unknown }).error;
+    if (typeof error === "string") {
+      return error;
+    }
+  }
+
+  return JSON.stringify(body);
+}
+
+function parseRetryAfterHeader(value: string | null): number | null {
+  if (!value) {
+    return null;
+  }
+
+  const numeric = Number.parseInt(value, 10);
+  if (Number.isFinite(numeric)) {
+    return Math.max(0, numeric);
+  }
+
+  const dateMs = Date.parse(value);
+  if (Number.isNaN(dateMs)) {
+    return null;
+  }
+
+  const seconds = Math.ceil((dateMs - Date.now()) / 1000);
+  return Math.max(0, seconds);
 }

package/src/cli.ts

@@ -4,7 +4,6 @@ import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { program } from "commander";
 import { loginCommand } from "./commands/login.js";
-import { registerCommand } from "./commands/register.js";
 import { whoamiCommand } from "./commands/whoami.js";
 import { submitCommand } from "./commands/submit.js";
 import { statusCommand } from "./commands/status.js";
@@ -13,6 +12,7 @@ import { autoSubmitCommand } from "./commands/auto-submit.js";
 import { setupHookCommand } from "./commands/setup-hook.js";
 import { daemonCommand } from "./commands/daemon.js";
 import { removeHookCommand } from "./commands/remove-hook.js";
+import { removeDaemonCommand } from "./commands/remove-daemon.js";
 import { CLI_NAME, DEFAULT_PROFILE, PROD_SERVER_URL } from "./constants.js";
 
 const profileOptionDescription = `Config profile (default: ${DEFAULT_PROFILE})`;
@@ -32,13 +32,6 @@ program
   .option("--server-url <url>", `Server URL (default prod: ${PROD_SERVER_URL})`)
   .action((opts) => loginCommand({ profile: opts.profile, serverUrl: opts.serverUrl }).catch(handleError));
 
-program
-  .command("register")
-  .description("Alias for login — signs in via browser and saves your API key")
-  .option("--profile <name>", profileOptionDescription)
-  .option("--server-url <url>", `Server URL (default prod: ${PROD_SERVER_URL})`)
-  .action((opts) => registerCommand({ profile: opts.profile, serverUrl: opts.serverUrl }).catch(handleError));
-
 program
   .command("whoami")
   .description("Show your account info and balance")
@@ -76,7 +69,7 @@ program
   .action((opts) => historyCommand({ profile: opts.profile }).catch(handleError));
 
 program
-  .command("auto-submit")
+  .command("auto-submit", { hidden: true })
   .description("Submit the current session (called by tool hooks — do not run manually)")
   .option("--profile <name>", profileOptionDescription)
   .option("--tool <tool>", "Tool that triggered the hook (claude-code|cursor|codex)")
@@ -113,6 +106,12 @@ program
   .option("--tool <tool>", "Only remove hook for specific tool (claude-code|cursor|codex)")
   .action((opts) => removeHookCommand({ tool: opts.tool }).catch(handleError));
 
+program
+  .command("remove-daemon")
+  .description("Stop a running tracemp daemon")
+  .option("--profile <name>", profileOptionDescription)
+  .action((opts) => removeDaemonCommand({ profile: opts.profile }).catch(handleError));
+
 function handleError(e: unknown) {
   console.error((e as Error).message ?? String(e));
   process.exit(1);

package/src/commands/daemon.ts

@@ -6,16 +6,25 @@
  * pass and exits. `--watch` preserves the old live-watch behavior.
  *
  * State: ~/.config/tracemarketplace/daemon-state(.<profile>).json
- *   { [filePath]: { mtime: number, size: number } }
+ *   { [filePath]: { mtime: number; size: number } }
+ *
+ * PID: ~/.config/tracemarketplace/daemon(.<profile>).pid
  */
-import { readFileSync, writeFileSync, mkdirSync, statSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, statSync, existsSync, unlinkSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import chalk from "chalk";
-import { type Config, getConfigDir, getDaemonStatePath, loadConfig, resolveProfile } from "../config.js";
+import {
+  type Config,
+  getConfigDir,
+  getDaemonPidPath,
+  getDaemonStatePath,
+  loadConfig,
+  resolveProfile,
+} from "../config.js";
 import { findFiles, watchDirs } from "../sessions.js";
 import { log } from "./auto-submit.js";
-import { loginCommandForProfile } from "../constants.js";
+import { CLI_NAME, DEFAULT_PROFILE, loginCommandForProfile } from "../constants.js";
 import { buildFileSessionSource, flushTrackedSessions } from "../flush.js";
 
 type DaemonState = Record<string, { mtime: number; size: number }>;
@@ -29,6 +38,68 @@ interface DaemonOptions {
   watch?: boolean;
 }
 
+function readDaemonPid(profile: string): number | null {
+  const pidPath = getDaemonPidPath(profile);
+  if (!existsSync(pidPath)) return null;
+
+  try {
+    const parsed = Number.parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return (err as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+function removeDaemonPidFile(profile: string, expectedPid?: number) {
+  const pidPath = getDaemonPidPath(profile);
+  if (!existsSync(pidPath)) return;
+
+  try {
+    if (expectedPid !== undefined) {
+      const currentPid = Number.parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      if (currentPid !== expectedPid) return;
+    }
+    unlinkSync(pidPath);
+  } catch {}
+}
+
+function reserveDaemonPid(profile: string): () => void {
+  const existingPid = readDaemonPid(profile);
+  if (existingPid !== null) {
+    if (isProcessRunning(existingPid)) {
+      const profileArg = profile === DEFAULT_PROFILE ? "" : ` --profile ${profile}`;
+      throw new Error(
+        `Daemon already running for profile '${profile}' (pid ${existingPid}). Run: ${CLI_NAME} remove-daemon${profileArg}`
+      );
+    }
+    removeDaemonPidFile(profile);
+  } else {
+    removeDaemonPidFile(profile);
+  }
+
+  mkdirSync(getConfigDir(), { recursive: true });
+  writeFileSync(getDaemonPidPath(profile), `${process.pid}\n`, "utf-8");
+
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    removeDaemonPidFile(profile, process.pid);
+  };
+
+  process.once("exit", release);
+  return release;
+}
+
 function loadState(profile: string): DaemonState {
   try { return JSON.parse(readFileSync(getDaemonStatePath(profile), "utf-8")); } catch { return {}; }
 }
@@ -93,6 +164,7 @@ export async function daemonCommand(opts: DaemonOptions = {}): Promise<void> {
 
   const intervalSeconds = parseIntervalSeconds(opts.interval);
   let state = loadState(config.profile);
+  const releasePid = opts.once ? null : reserveDaemonPid(config.profile);
 
   console.log(chalk.bold("tracemp daemon starting"));
   console.log(chalk.gray(`Profile: ${config.profile}`));
@@ -102,7 +174,7 @@ export async function daemonCommand(opts: DaemonOptions = {}): Promise<void> {
   if (opts.watch) {
     console.log(chalk.gray("Mode: live watch"));
     console.log(chalk.gray("Press Ctrl+C to stop\n"));
-    await runWatchLoop(config, tools, state);
+    await runWatchLoop(config, tools, state, releasePid ?? (() => {}));
     return;
   }
 
@@ -115,6 +187,7 @@ export async function daemonCommand(opts: DaemonOptions = {}): Promise<void> {
   const stop = () => {
     if (shuttingDown) return;
     shuttingDown = true;
+    releasePid?.();
     console.log(chalk.gray("\nDaemon stopped."));
     process.exit(0);
   };
@@ -169,7 +242,8 @@ async function runScanPass(
 async function runWatchLoop(
   config: Config,
   tools: Array<"claude_code" | "codex_cli">,
-  state: DaemonState
+  state: DaemonState,
+  releasePid: () => void
 ): Promise<void> {
   let nextState = await runScanPass(config, tools, state, { logWhenEmpty: true });
   const stop = watchDirs(tools, async (tool, filePath) => {
@@ -180,11 +254,13 @@ async function runWatchLoop(
 
   process.on("SIGINT", () => {
     stop();
+    releasePid();
     console.log(chalk.gray("\nDaemon stopped."));
     process.exit(0);
   });
   process.on("SIGTERM", () => {
     stop();
+    releasePid();
     process.exit(0);
   });
 

package/src/commands/remove-daemon.ts

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import chalk from "chalk";
+import { DEFAULT_PROFILE } from "../constants.js";
+import { getDaemonPidPath, resolveProfile } from "../config.js";
+
+interface RemoveDaemonOptions {
+  profile?: string;
+}
+
+function readDaemonPid(profile: string): number | null {
+  const pidPath = getDaemonPidPath(profile);
+  if (!existsSync(pidPath)) return null;
+
+  try {
+    const parsed = Number.parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return (err as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+function removePidFile(profile: string) {
+  const pidPath = getDaemonPidPath(profile);
+  if (!existsSync(pidPath)) return;
+  try {
+    unlinkSync(pidPath);
+  } catch {}
+}
+
+async function waitForExit(pid: number, timeoutMs = 3000): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(pid)) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return !isProcessRunning(pid);
+}
+
+export async function removeDaemonCommand(opts: RemoveDaemonOptions = {}): Promise<void> {
+  const profile = resolveProfile(opts.profile);
+  const pid = readDaemonPid(profile);
+  const profileLabel = profile === DEFAULT_PROFILE ? "default profile" : `profile '${profile}'`;
+
+  if (pid === null) {
+    console.log(chalk.gray(`No tracemp daemon found for ${profileLabel}.`));
+    return;
+  }
+
+  if (!isProcessRunning(pid)) {
+    removePidFile(profile);
+    console.log(chalk.gray(`Removed stale daemon PID file for ${profileLabel}.`));
+    return;
+  }
+
+  process.kill(pid, "SIGTERM");
+
+  if (await waitForExit(pid)) {
+    removePidFile(profile);
+    console.log(chalk.green(`✓ Stopped tracemp daemon for ${profileLabel}`));
+    return;
+  }
+
+  console.log(chalk.yellow(`Sent SIGTERM to tracemp daemon for ${profileLabel} (pid ${pid}), but it is still running.`));
+}

package/src/commands/submit.ts

@@ -271,10 +271,12 @@ export async function submitCommand(opts: SubmitOptions): Promise<void> {
   const uploadSpinner = ora(`Submitting ${readyChunkCount} finalized chunk(s) to ${config.profile}...`).start();
 
   try {
+    const readySessions = plannedSessions.filter((session) => session.readyChunks > 0);
+    const prefetchedTraces = new Map(readySessions.map((s) => [`${s.source.tool}:${s.source.locator}`, s.trace]));
     const result = await flushTrackedSessions(
       config,
-      plannedSessions.map((session) => session.source),
-      { includeIdleTracked: false }
+      readySessions.map((session) => session.source),
+      { includeIdleTracked: false, prefetchedTraces }
     );
 
     uploadSpinner.stop();

package/src/config.ts

@@ -29,6 +29,10 @@ export interface SessionUploadState {
   lastSeenTurnCount: number;
   lastActivityAt: string | null;
   lastFlushedTurnId: string | null;
+  // Async confirmation tracking
+  confirmedChunkIndex: number;         // all chunks below this index are confirmed in DB
+  confirmedOpenChunkStartTurn: number; // openChunkStartTurn to restore if re-submitting
+  unconfirmedSince: string | null;     // ISO timestamp when chunks first went unconfirmed
 }
 
 export interface SubmitState {
@@ -60,6 +64,10 @@ export function getDaemonStatePath(profile?: string): string {
   return join(getConfigDir(), `daemon-state${profileSuffix(profile)}.json`);
 }
 
+export function getDaemonPidPath(profile?: string): string {
+  return join(getConfigDir(), `daemon${profileSuffix(profile)}.pid`);
+}
+
 export function resolveProfile(profile?: string): string {
   if (profile) return normalizeProfile(profile);
   if (process.env.TRACEMP_PROFILE) return normalizeProfile(process.env.TRACEMP_PROFILE);
@@ -261,3 +269,13 @@ function isSessionUploadState(value: unknown): value is SessionUploadState {
     && (value.lastActivityAt === null || typeof value.lastActivityAt === "string")
     && (value.lastFlushedTurnId === null || typeof value.lastFlushedTurnId === "string");
 }
+
+export function migrateSessionUploadState(value: SessionUploadState): SessionUploadState {
+  return {
+    ...value,
+    // Backward compat: existing sessions assume all submitted chunks are confirmed
+    confirmedChunkIndex: value.confirmedChunkIndex ?? value.nextChunkIndex,
+    confirmedOpenChunkStartTurn: value.confirmedOpenChunkStartTurn ?? value.openChunkStartTurn,
+    unconfirmedSince: value.unconfirmedSince ?? null,
+  };
+}