@tracemarketplace/cli 0.0.13 → 0.0.15

package/src/config.ts

@@ -1,19 +1,45 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+import { DEFAULT_PROFILE } from "./constants.js";
 
-export interface Config {
+export interface StoredProfileConfig {
   apiKey: string;
   serverUrl: string;
   email: string;
 }
 
-// Tracks which chunks of each session have been submitted.
-// Key: "<source_tool>:<source_session_id>", value: highest chunk_index submitted.
+export interface Config extends StoredProfileConfig {
+  profile: string;
+}
+
+export interface ConfigStore {
+  defaultProfile: string;
+  profiles: Record<string, StoredProfileConfig>;
+}
+
+export type TrackedSessionTool = "claude_code" | "codex_cli" | "cursor";
+
+export interface SessionUploadState {
+  sourceTool: TrackedSessionTool;
+  sourceSessionId: string;
+  locator: string;
+  nextChunkIndex: number;
+  openChunkStartTurn: number;
+  lastSeenTurnCount: number;
+  lastActivityAt: string | null;
+  lastFlushedTurnId: string | null;
+}
+
 export interface SubmitState {
+  version: 2;
   chunks: Record<string, number>;
+  sessions: Record<string, SessionUploadState>;
 }
 
+type JsonRecord = Record<string, unknown>;
+const EMPTY_SUBMIT_STATE: SubmitState = { version: 2, chunks: {}, sessions: {} };
+
 export function getConfigDir(): string {
   return join(homedir(), ".config", "tracemarketplace");
 }
@@ -22,40 +48,216 @@ export function getConfigPath(): string {
   return join(getConfigDir(), "config.json");
 }
 
-export function getStatePath(): string {
-  return join(getConfigDir(), "state.json");
+export function getStatePath(profile?: string): string {
+  return join(getConfigDir(), `state${profileSuffix(profile)}.json`);
 }
 
-export function loadConfig(): Config | null {
-  const p = getConfigPath();
-  if (!existsSync(p)) return null;
+export function getAutoSubmitLogPath(profile?: string): string {
+  return join(getConfigDir(), `auto-submit${profileSuffix(profile)}.log`);
+}
+
+export function getDaemonStatePath(profile?: string): string {
+  return join(getConfigDir(), `daemon-state${profileSuffix(profile)}.json`);
+}
+
+export function resolveProfile(profile?: string): string {
+  if (profile) return normalizeProfile(profile);
+  if (process.env.TRACEMP_PROFILE) return normalizeProfile(process.env.TRACEMP_PROFILE);
+  return normalizeProfile(loadConfigStore().defaultProfile);
+}
+
+export function loadConfigStore(): ConfigStore {
+  const raw = readConfigFile();
+  if (isStoredProfileConfig(raw)) {
+    return {
+      defaultProfile: DEFAULT_PROFILE,
+      profiles: { [DEFAULT_PROFILE]: normalizeStoredProfileConfig(raw) },
+    };
+  }
+
+  if (!isRecord(raw)) {
+    return {
+      defaultProfile: DEFAULT_PROFILE,
+      profiles: {},
+    };
+  }
+
+  const profiles = normalizeProfiles(raw.profiles);
+  const requestedDefault = normalizeProfile(
+    typeof raw.defaultProfile === "string" ? raw.defaultProfile : DEFAULT_PROFILE
+  );
+
+  return {
+    defaultProfile: profiles[requestedDefault]
+      ? requestedDefault
+      : profiles[DEFAULT_PROFILE]
+        ? DEFAULT_PROFILE
+        : requestedDefault,
+    profiles,
+  };
+}
+
+export function loadConfig(profile?: string): Config | null {
+  const store = loadConfigStore();
+  const resolvedProfile = resolveProfileFromStore(store, profile);
+  const selected = store.profiles[resolvedProfile];
+  if (!selected) return null;
+  return { profile: resolvedProfile, ...selected };
+}
+
+export function saveConfig(
+  config: StoredProfileConfig,
+  options: { profile?: string; setDefault?: boolean } = {}
+): Config {
+  const store = loadConfigStore();
+  const profile = normalizeProfile(options.profile);
+
+  store.profiles[profile] = normalizeStoredProfileConfig(config);
+
+  const normalizedDefault = normalizeProfile(store.defaultProfile);
+  if (options.setDefault || !store.profiles[normalizedDefault]) {
+    store.defaultProfile = profile;
+  } else {
+    store.defaultProfile = normalizedDefault;
+  }
+
+  writeConfigStore(store);
+  return { profile, ...store.profiles[profile] };
+}
+
+export function loadState(profile?: string): SubmitState {
+  const p = getStatePath(profile);
+  if (!existsSync(p)) return EMPTY_SUBMIT_STATE;
   try {
-    return JSON.parse(readFileSync(p, "utf-8")) as Config;
+    return normalizeSubmitState(JSON.parse(readFileSync(p, "utf-8")));
   } catch {
-    return null;
+    return EMPTY_SUBMIT_STATE;
   }
 }
 
-export function saveConfig(config: Config): void {
+export function saveState(state: SubmitState, profile?: string): void {
   mkdirSync(getConfigDir(), { recursive: true });
-  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync(getStatePath(profile), JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+
+export function stateKey(sourceTool: string, sessionId: string): string {
+  return `${sourceTool}:${sessionId}`;
 }
 
-export function loadState(): SubmitState {
-  const p = getStatePath();
-  if (!existsSync(p)) return { chunks: {} };
+function readConfigFile(): unknown {
+  const p = getConfigPath();
+  if (!existsSync(p)) return null;
   try {
-    return JSON.parse(readFileSync(p, "utf-8")) as SubmitState;
+    return JSON.parse(readFileSync(p, "utf-8"));
   } catch {
-    return { chunks: {} };
+    return null;
   }
 }
 
-export function saveState(state: SubmitState): void {
+function writeConfigStore(store: ConfigStore): void {
+  const profiles = normalizeProfiles(store.profiles);
+  const requestedDefault = normalizeProfile(store.defaultProfile);
+  const defaultProfile = profiles[requestedDefault]
+    ? requestedDefault
+    : profiles[DEFAULT_PROFILE]
+      ? DEFAULT_PROFILE
+      : requestedDefault;
+
   mkdirSync(getConfigDir(), { recursive: true });
-  writeFileSync(getStatePath(), JSON.stringify(state, null, 2), "utf-8");
+  writeFileSync(
+    getConfigPath(),
+    JSON.stringify({ defaultProfile, profiles }, null, 2) + "\n",
+    "utf-8"
+  );
 }
 
-export function stateKey(sourceTool: string, sessionId: string): string {
-  return `${sourceTool}:${sessionId}`;
+function resolveProfileFromStore(store: ConfigStore, profile?: string): string {
+  if (profile) return normalizeProfile(profile);
+  if (process.env.TRACEMP_PROFILE) return normalizeProfile(process.env.TRACEMP_PROFILE);
+  return normalizeProfile(store.defaultProfile);
+}
+
+function profileSuffix(profile?: string): string {
+  const resolvedProfile = normalizeProfile(profile);
+  return resolvedProfile === DEFAULT_PROFILE ? "" : `.${resolvedProfile}`;
+}
+
+function normalizeProfile(profile?: string | null): string {
+  const trimmed = (profile ?? "").trim().toLowerCase();
+  if (!trimmed) return DEFAULT_PROFILE;
+
+  const normalized = trimmed
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^-+/, "")
+    .replace(/-+$/, "");
+
+  return normalized || DEFAULT_PROFILE;
+}
+
+function normalizeProfiles(value: unknown): Record<string, StoredProfileConfig> {
+  if (!isRecord(value)) return {};
+
+  const profiles: Record<string, StoredProfileConfig> = {};
+  for (const [profile, config] of Object.entries(value)) {
+    if (!isStoredProfileConfig(config)) continue;
+    profiles[normalizeProfile(profile)] = normalizeStoredProfileConfig(config);
+  }
+  return profiles;
+}
+
+function normalizeStoredProfileConfig(config: StoredProfileConfig): StoredProfileConfig {
+  return {
+    apiKey: config.apiKey,
+    serverUrl: config.serverUrl,
+    email: config.email,
+  };
+}
+
+function normalizeSubmitState(value: unknown): SubmitState {
+  if (!isRecord(value)) {
+    return EMPTY_SUBMIT_STATE;
+  }
+
+  const chunks = isRecord(value.chunks)
+    ? Object.fromEntries(
+        Object.entries(value.chunks)
+          .filter((entry): entry is [string, number] => typeof entry[1] === "number")
+      )
+    : {};
+
+  const sessions = isRecord(value.sessions)
+    ? Object.fromEntries(
+        Object.entries(value.sessions)
+          .filter((entry): entry is [string, SessionUploadState] => isSessionUploadState(entry[1]))
+      )
+    : {};
+
+  return {
+    version: 2,
+    chunks,
+    sessions,
+  };
+}
+
+function isRecord(value: unknown): value is JsonRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isStoredProfileConfig(value: unknown): value is StoredProfileConfig {
+  return isRecord(value)
+    && typeof value.apiKey === "string"
+    && typeof value.serverUrl === "string"
+    && typeof value.email === "string";
+}
+
+function isSessionUploadState(value: unknown): value is SessionUploadState {
+  return isRecord(value)
+    && (value.sourceTool === "claude_code" || value.sourceTool === "codex_cli" || value.sourceTool === "cursor")
+    && typeof value.sourceSessionId === "string"
+    && typeof value.locator === "string"
+    && typeof value.nextChunkIndex === "number"
+    && typeof value.openChunkStartTurn === "number"
+    && typeof value.lastSeenTurnCount === "number"
+    && (value.lastActivityAt === null || typeof value.lastActivityAt === "string")
+    && (value.lastFlushedTurnId === null || typeof value.lastFlushedTurnId === "string");
 }

package/src/constants.ts

@@ -0,0 +1,18 @@
+export const CLI_NAME = "tracemp";
+export const DEFAULT_PROFILE = "prod";
+export const PROD_SERVER_URL = "https://trace-marketplace-api.fly.dev";
+export const DEV_SERVER_URL = "http://localhost:3001";
+
+export function defaultServerUrlForProfile(profile: string): string {
+  return profile === "dev" ? DEV_SERVER_URL : PROD_SERVER_URL;
+}
+
+export function inferProfileFromServerUrl(serverUrl: string): string {
+  return serverUrl === PROD_SERVER_URL ? DEFAULT_PROFILE : "dev";
+}
+
+export function loginCommandForProfile(profile: string): string {
+  return profile === DEFAULT_PROFILE
+    ? `${CLI_NAME} login`
+    : `${CLI_NAME} login --profile ${profile}`;
+}

package/src/flush.test.ts

@@ -0,0 +1,214 @@
+import { describe, expect, it } from "vitest";
+import type { NormalizedTrace, Turn } from "@tracemarketplace/shared";
+import type { SessionSource } from "./flush.js";
+import {
+  collectIdleSessionSources,
+  createFreshSessionState,
+  migrateLegacySessionState,
+  planSessionUploads,
+} from "./flush.js";
+
+function makeTurn(
+  turnId: string,
+  role: "user" | "assistant",
+  timestamp: string,
+  outputTokens = 0
+): Turn {
+  return {
+    turn_id: turnId,
+    parent_turn_id: null,
+    role,
+    actor: role === "user" ? "human" : "assistant",
+    timestamp,
+    model: "test-model",
+    usage: {
+      input_tokens: 0,
+      output_tokens: outputTokens,
+      cache_read_input_tokens: null,
+      cache_creation_input_tokens: null,
+      reasoning_tokens: null,
+    },
+    source_metadata: {},
+    content: [
+      {
+        type: "text",
+        text: `${turnId}:${role}`,
+      },
+    ],
+  };
+}
+
+function makeTrace(
+  sessionId: string,
+  turns: Turn[],
+  endedAt = turns[turns.length - 1]?.timestamp ?? "2026-03-21T00:00:00.000Z"
+): NormalizedTrace {
+  const outputTokens = turns.reduce((sum, turn) => sum + (turn.usage?.output_tokens ?? 0), 0);
+
+  return {
+    trace_id: `trace-${sessionId}`,
+    schema_version: "1.0",
+    source_tool: "codex_cli",
+    source_session_id: sessionId,
+    source_version: null,
+    submitted_by: "tester@example.com",
+    submitted_at: "2026-03-21T00:00:00.000Z",
+    extracted_at: endedAt,
+    git_branch: null,
+    cwd_hash: null,
+    working_language: null,
+    started_at: turns[0]?.timestamp ?? endedAt,
+    ended_at: endedAt,
+    turns,
+    turn_count: turns.length,
+    tool_call_count: 0,
+    has_tool_calls: false,
+    has_thinking_blocks: false,
+    has_file_changes: false,
+    has_shell_commands: false,
+    total_input_tokens: 0,
+    total_output_tokens: outputTokens,
+    total_cache_read_tokens: null,
+    content_fidelity: "full",
+    env_state: null,
+    score: null,
+    raw_r2_key: "",
+    normalized_r2_key: "",
+  };
+}
+
+function makeSource(tool: SessionSource["tool"], locator: string): SessionSource {
+  return { tool, locator, label: locator };
+}
+
+describe("planSessionUploads", () => {
+  it("flushes a sealed 100k chunk and keeps the tail pending", () => {
+    const trace = makeTrace("session-100k", [
+      makeTurn("u1", "user", "2026-03-21T00:00:00.000Z"),
+      makeTurn("a1", "assistant", "2026-03-21T00:01:00.000Z", 100_200),
+      makeTurn("u2", "user", "2026-03-21T00:02:00.000Z"),
+      makeTurn("a2", "assistant", "2026-03-21T00:03:00.000Z", 25),
+    ]);
+    const cursor = createFreshSessionState(makeSource("codex_cli", "/tmp/session.jsonl"), trace);
+
+    const plan = planSessionUploads(trace, cursor, new Date("2026-03-21T00:04:00.000Z"));
+
+    expect(plan.uploads).toHaveLength(1);
+    expect(plan.uploads[0]?.trace.chunk_index).toBe(0);
+    expect(plan.uploads[0]?.trace.chunk_start_turn).toBe(0);
+    expect(plan.uploads[0]?.trace.chunk_complete).toBe(true);
+    expect(plan.uploads[0]?.trace.chunk_close_reason).toBe("100k_tokens");
+    expect(plan.pending).toBe(true);
+    expect(plan.uploads[0]?.nextState.openChunkStartTurn).toBe(2);
+    expect(plan.uploads[0]?.nextState.nextChunkIndex).toBe(1);
+  });
+
+  it("flushes an under-100k tail after two days of inactivity", () => {
+    const trace = makeTrace("session-idle", [
+      makeTurn("u1", "user", "2026-03-21T00:00:00.000Z"),
+      makeTurn("a1", "assistant", "2026-03-21T00:05:00.000Z", 40),
+    ], "2026-03-21T00:05:00.000Z");
+    const cursor = createFreshSessionState(makeSource("codex_cli", "/tmp/session.jsonl"), trace);
+
+    const plan = planSessionUploads(trace, cursor, new Date("2026-03-23T00:06:00.000Z"));
+
+    expect(plan.uploads).toHaveLength(1);
+    expect(plan.uploads[0]?.trace.chunk_index).toBe(0);
+    expect(plan.uploads[0]?.trace.chunk_close_reason).toBe("idle_2d");
+    expect(plan.pending).toBe(false);
+    expect(plan.uploads[0]?.nextState.openChunkStartTurn).toBe(trace.turn_count);
+  });
+
+  it("creates a later chunk when a session resumes after an idle-finalized chunk", () => {
+    const initialTrace = makeTrace("session-resume", [
+      makeTurn("u1", "user", "2026-03-21T00:00:00.000Z"),
+      makeTurn("a1", "assistant", "2026-03-21T00:05:00.000Z", 20),
+    ], "2026-03-21T00:05:00.000Z");
+    const source = makeSource("codex_cli", "/tmp/session.jsonl");
+    const initialCursor = createFreshSessionState(source, initialTrace);
+    const initialPlan = planSessionUploads(initialTrace, initialCursor, new Date("2026-03-23T00:06:00.000Z"));
+    const finalizedCursor = initialPlan.uploads[0]?.nextState;
+
+    if (!finalizedCursor) {
+      throw new Error("expected initial chunk upload");
+    }
+
+    const resumedTrace = makeTrace("session-resume", [
+      ...initialTrace.turns,
+      makeTurn("u2", "user", "2026-03-24T00:00:00.000Z"),
+      makeTurn("a2", "assistant", "2026-03-24T00:10:00.000Z", 15),
+    ], "2026-03-24T00:10:00.000Z");
+
+    const resumedPlan = planSessionUploads(resumedTrace, finalizedCursor, new Date("2026-03-26T00:11:00.000Z"));
+
+    expect(resumedPlan.uploads).toHaveLength(1);
+    expect(resumedPlan.uploads[0]?.trace.chunk_index).toBe(1);
+    expect(resumedPlan.uploads[0]?.trace.chunk_start_turn).toBe(2);
+    expect(resumedPlan.uploads[0]?.trace.chunk_close_reason).toBe("idle_2d");
+    expect(resumedPlan.pending).toBe(false);
+  });
+
+  it("does not re-upload a legacy session on first migration", () => {
+    const trace = makeTrace("legacy-session", [
+      makeTurn("u1", "user", "2026-03-21T00:00:00.000Z"),
+      makeTurn("a1", "assistant", "2026-03-21T00:05:00.000Z", 55),
+    ]);
+    const migratedCursor = migrateLegacySessionState(
+      makeSource("codex_cli", "/tmp/legacy.jsonl"),
+      trace,
+      0
+    );
+
+    const plan = planSessionUploads(trace, migratedCursor, new Date("2026-03-23T00:06:00.000Z"));
+
+    expect(plan.uploads).toHaveLength(0);
+    expect(plan.pending).toBe(false);
+    expect(plan.observedState.nextChunkIndex).toBe(1);
+    expect(plan.observedState.openChunkStartTurn).toBe(trace.turn_count);
+  });
+});
+
+describe("collectIdleSessionSources", () => {
+  it("returns only tracked sessions with an open tail older than two days", () => {
+    const sources = collectIdleSessionSources({
+      "codex_cli:idle": {
+        sourceTool: "codex_cli",
+        sourceSessionId: "idle",
+        locator: "/tmp/idle.jsonl",
+        nextChunkIndex: 1,
+        openChunkStartTurn: 2,
+        lastSeenTurnCount: 4,
+        lastActivityAt: "2026-03-21T00:00:00.000Z",
+        lastFlushedTurnId: "a1",
+      },
+      "codex_cli:closed": {
+        sourceTool: "codex_cli",
+        sourceSessionId: "closed",
+        locator: "/tmp/closed.jsonl",
+        nextChunkIndex: 1,
+        openChunkStartTurn: 4,
+        lastSeenTurnCount: 4,
+        lastActivityAt: "2026-03-21T00:00:00.000Z",
+        lastFlushedTurnId: "a2",
+      },
+      "codex_cli:fresh": {
+        sourceTool: "codex_cli",
+        sourceSessionId: "fresh",
+        locator: "/tmp/fresh.jsonl",
+        nextChunkIndex: 0,
+        openChunkStartTurn: 0,
+        lastSeenTurnCount: 2,
+        lastActivityAt: "2026-03-22T23:59:59.000Z",
+        lastFlushedTurnId: null,
+      },
+    }, new Date("2026-03-23T00:01:00.000Z"));
+
+    expect(sources).toEqual([
+      {
+        tool: "codex_cli",
+        locator: "/tmp/idle.jsonl",
+        label: "codex_cli:idle",
+      },
+    ]);
+  });
+});