@tracemarketplace/cli 0.0.13 → 0.0.17

package/src/flush.test.ts

@@ -0,0 +1,395 @@
+import { describe, expect, it } from "vitest";
+import type { NormalizedTrace, Turn } from "@tracemarketplace/shared";
+import type { SessionSource } from "./flush.js";
+import type { SessionUploadState } from "./config.js";
+import {
+  collectIdleSessionSources,
+  createFreshSessionState,
+  migrateLegacySessionState,
+  planSessionUploads,
+  verifyUnconfirmedChunks,
+} from "./flush.js";
+import { migrateSessionUploadState } from "./config.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 };
+}
+
+function makeSessionState(overrides: Partial<SessionUploadState> & Pick<SessionUploadState, "sourceTool" | "sourceSessionId" | "locator">): SessionUploadState {
+  return {
+    nextChunkIndex: 0,
+    openChunkStartTurn: 0,
+    lastSeenTurnCount: 0,
+    lastActivityAt: null,
+    lastFlushedTurnId: null,
+    confirmedChunkIndex: 0,
+    confirmedOpenChunkStartTurn: 0,
+    unconfirmedSince: null,
+    ...overrides,
+  };
+}
+
+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("migrateSessionUploadState", () => {
+  it("fills in missing confirmation fields from next/openChunk values", () => {
+    const legacy = {
+      sourceTool: "codex_cli" as const,
+      sourceSessionId: "s1",
+      locator: "/tmp/s1.jsonl",
+      nextChunkIndex: 3,
+      openChunkStartTurn: 10,
+      lastSeenTurnCount: 10,
+      lastActivityAt: "2026-03-21T00:00:00.000Z",
+      lastFlushedTurnId: "a3",
+      // missing: confirmedChunkIndex, confirmedOpenChunkStartTurn, unconfirmedSince
+    } as any;
+
+    const migrated = migrateSessionUploadState(legacy);
+
+    expect(migrated.confirmedChunkIndex).toBe(3);
+    expect(migrated.confirmedOpenChunkStartTurn).toBe(10);
+    expect(migrated.unconfirmedSince).toBeNull();
+  });
+
+  it("does not overwrite existing confirmation fields", () => {
+    const state = makeSessionState({
+      sourceTool: "codex_cli",
+      sourceSessionId: "s2",
+      locator: "/tmp/s2.jsonl",
+      nextChunkIndex: 5,
+      openChunkStartTurn: 20,
+      confirmedChunkIndex: 3,
+      confirmedOpenChunkStartTurn: 12,
+      unconfirmedSince: "2026-03-21T01:00:00.000Z",
+    });
+
+    const migrated = migrateSessionUploadState(state);
+
+    expect(migrated.confirmedChunkIndex).toBe(3);
+    expect(migrated.confirmedOpenChunkStartTurn).toBe(12);
+    expect(migrated.unconfirmedSince).toBe("2026-03-21T01:00:00.000Z");
+  });
+});
+
+describe("verifyUnconfirmedChunks", () => {
+  function makeSubmitState(sessions: Record<string, ReturnType<typeof makeSessionState>>) {
+    return { version: 2 as const, chunks: {}, sessions };
+  }
+
+  function makeMockClient(responses: Record<string, { exists: boolean }>) {
+    return {
+      async get(path: string) {
+        const url = new URL(`http://x${path}`);
+        const tool = url.searchParams.get("source_tool")!;
+        const id = url.searchParams.get("source_session_id")!;
+        const idx = url.searchParams.get("chunk_index")!;
+        const key = `${tool}:${id}:${idx}`;
+        const r = responses[key];
+        if (!r) throw new Error(`Unexpected exists check: ${key}`);
+        return r;
+      },
+    } as any;
+  }
+
+  it("advances confirmedChunkIndex when chunks are confirmed", async () => {
+    const state = makeSubmitState({
+      "codex_cli:sess1": makeSessionState({
+        sourceTool: "codex_cli",
+        sourceSessionId: "sess1",
+        locator: "/tmp/sess1.jsonl",
+        nextChunkIndex: 3,
+        openChunkStartTurn: 12,
+        confirmedChunkIndex: 1,
+        confirmedOpenChunkStartTurn: 4,
+        unconfirmedSince: "2026-03-21T00:00:00.000Z",
+      }),
+    });
+
+    const client = makeMockClient({
+      "codex_cli:sess1:1": { exists: true },
+      "codex_cli:sess1:2": { exists: true },
+    });
+
+    await verifyUnconfirmedChunks(state, client, new Date("2026-03-21T01:00:00.000Z"));
+
+    const s = state.sessions["codex_cli:sess1"]!;
+    expect(s.confirmedChunkIndex).toBe(3);
+    // all confirmed → unconfirmedSince cleared
+    expect(s.unconfirmedSince).toBeNull();
+  });
+
+  it("stops advancing at first missing chunk", async () => {
+    const state = makeSubmitState({
+      "codex_cli:sess2": makeSessionState({
+        sourceTool: "codex_cli",
+        sourceSessionId: "sess2",
+        locator: "/tmp/sess2.jsonl",
+        nextChunkIndex: 3,
+        openChunkStartTurn: 12,
+        confirmedChunkIndex: 1,
+        confirmedOpenChunkStartTurn: 4,
+        unconfirmedSince: "2026-03-21T00:00:00.000Z",
+      }),
+    });
+
+    const client = makeMockClient({
+      "codex_cli:sess2:1": { exists: true },
+      "codex_cli:sess2:2": { exists: false },
+    });
+
+    await verifyUnconfirmedChunks(state, client, new Date("2026-03-21T01:00:00.000Z"));
+
+    const s = state.sessions["codex_cli:sess2"]!;
+    expect(s.confirmedChunkIndex).toBe(2);
+    // still one unconfirmed chunk → unconfirmedSince preserved
+    expect(s.unconfirmedSince).toBe("2026-03-21T00:00:00.000Z");
+  });
+
+  it("resets to confirmed state after 2hr timeout", async () => {
+    const state = makeSubmitState({
+      "codex_cli:sess3": makeSessionState({
+        sourceTool: "codex_cli",
+        sourceSessionId: "sess3",
+        locator: "/tmp/sess3.jsonl",
+        nextChunkIndex: 3,
+        openChunkStartTurn: 12,
+        confirmedChunkIndex: 1,
+        confirmedOpenChunkStartTurn: 4,
+        unconfirmedSince: "2026-03-21T00:00:00.000Z",
+      }),
+    });
+
+    const client = makeMockClient({}); // should not be called
+
+    // now = 2h01m after unconfirmedSince
+    await verifyUnconfirmedChunks(state, client, new Date("2026-03-21T02:01:00.000Z"));
+
+    const s = state.sessions["codex_cli:sess3"]!;
+    // reset back to confirmed baseline so chunks get re-submitted
+    expect(s.nextChunkIndex).toBe(1);
+    expect(s.openChunkStartTurn).toBe(4);
+    expect(s.unconfirmedSince).toBeNull();
+  });
+
+  it("skips sessions that are already fully confirmed", async () => {
+    const state = makeSubmitState({
+      "codex_cli:sess4": makeSessionState({
+        sourceTool: "codex_cli",
+        sourceSessionId: "sess4",
+        locator: "/tmp/sess4.jsonl",
+        nextChunkIndex: 2,
+        openChunkStartTurn: 8,
+        confirmedChunkIndex: 2,
+        confirmedOpenChunkStartTurn: 8,
+        unconfirmedSince: null,
+      }),
+    });
+
+    let callCount = 0;
+    const client = { async get() { callCount++; return { exists: true }; } } as any;
+
+    await verifyUnconfirmedChunks(state, client, new Date("2026-03-21T01:00:00.000Z"));
+
+    expect(callCount).toBe(0);
+  });
+});
+
+describe("collectIdleSessionSources", () => {
+  it("returns only tracked sessions with an open tail older than two days", () => {
+    const sources = collectIdleSessionSources({
+      "codex_cli:idle": makeSessionState({
+        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": makeSessionState({
+        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": makeSessionState({
+        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",
+      },
+    ]);
+  });
+});