@indigoai-us/hq-cloud 6.14.29 → 6.14.31

package/src/telemetry.test.ts

@@ -81,6 +81,7 @@ function makeClient(opts: {
 interface TestEnv {
   root: string;
   claudeProjects: string;
+  codexRoot: string;
   cursorPath: string;
   menubarPath: string;
 }
@@ -88,11 +89,15 @@ interface TestEnv {
 function setupEnv(): TestEnv {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-telemetry-test-"));
   const claudeProjects = path.join(root, ".claude", "projects");
+  const codexRoot = path.join(root, ".codex");
   fs.mkdirSync(claudeProjects, { recursive: true });
+  fs.mkdirSync(path.join(codexRoot, "sessions"), { recursive: true });
+  fs.mkdirSync(path.join(codexRoot, "archived_sessions"), { recursive: true });
   fs.mkdirSync(path.join(root, ".hq"), { recursive: true });
   return {
     root,
     claudeProjects,
+    codexRoot,
     cursorPath: path.join(root, ".hq", "telemetry-cursor.json"),
     menubarPath: path.join(root, ".hq", "menubar.json"),
   };
@@ -120,6 +125,9 @@ function makeOpts(env: TestEnv, client: TelemetryClientSurface): CollectTelemetr
     machineId: "test-machine",
     installerVersion: "test-version",
     claudeProjectsRoot: env.claudeProjects,
+    codexRoot: env.codexRoot,
+    maxScanBytesPerSource: Number.MAX_SAFE_INTEGER,
+    maxBatchesPerRun: Number.MAX_SAFE_INTEGER,
     cursorPath: env.cursorPath,
     menubarPath: env.menubarPath,
   };
@@ -634,6 +642,284 @@ describe("collectAndSendTelemetry", () => {
   });
 });
 
+// ── Codex rollout collection ────────────────────────────────────────────────
+
+function codexLine(value: Record<string, unknown>): string {
+  return JSON.stringify(value);
+}
+
+function writeCodexRollout(
+  env: TestEnv,
+  location: "sessions" | "archived_sessions",
+  name: string,
+  lines: Array<Record<string, unknown>>,
+): string {
+  const dir =
+    location === "sessions"
+      ? path.join(env.codexRoot, location, "2026", "07", "30")
+      : path.join(env.codexRoot, location);
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, name);
+  fs.writeFileSync(file, lines.map(codexLine).join("\n") + "\n", "utf-8");
+  return file;
+}
+
+function codexToken(
+  timestamp: string,
+  uuid: string,
+  input: number,
+  output: number,
+  reasoning = 0,
+  cached = 0,
+): Record<string, unknown> {
+  return {
+    timestamp,
+    uuid,
+    type: "event_msg",
+    payload: {
+      type: "token_count",
+      info: {
+        last_token_usage: {
+          input_tokens: input,
+          output_tokens: output,
+          reasoning_output_tokens: reasoning,
+          cached_input_tokens: cached,
+        },
+        total_token_usage: {
+          input_tokens: 999_999,
+          output_tokens: 999_999,
+        },
+      },
+      raw_content: "must never leave the machine",
+    },
+  };
+}
+
+describe("collectAndSendTelemetry — Codex rollouts", () => {
+  let env: TestEnv;
+  beforeEach(() => {
+    env = setupEnv();
+  });
+  afterEach(() => teardownEnv(env));
+
+  it("collects token deltas from live and archived Linux rollouts", async () => {
+    writeCodexRollout(env, "sessions", "rollout-live.jsonl", [
+      {
+        timestamp: "2026-07-30T10:00:00Z",
+        type: "session_meta",
+        payload: {
+          id: "codex-live",
+          cwd: "/home/yousuf/hq/repos/private/hq-cloud",
+          git: { branch: "feature/live" },
+          model: "session-model",
+          instructions: "private prompt",
+        },
+      },
+      {
+        timestamp: "2026-07-30T10:00:01Z",
+        type: "turn_context",
+        payload: { model: "codex-auto-review" },
+      },
+      codexToken("2026-07-30T10:00:02Z", "codex-event-live", 11, 7, 5, 3),
+    ]);
+    writeCodexRollout(env, "archived_sessions", "rollout-archived.jsonl", [
+      {
+        timestamp: "2026-07-29T10:00:00Z",
+        type: "session_meta",
+        payload: { id: "codex-archived", cwd: "/repo", model: "gpt-5-codex" },
+      },
+      codexToken("2026-07-29T10:00:01Z", "codex-event-archived", 2, 3, 1, 1),
+    ]);
+
+    const client = makeClient();
+    const result = await collectAndSendTelemetry(makeOpts(env, client));
+    const events = client.posts.flatMap((post) => post.events);
+
+    expect(result.filesScanned).toBe(2);
+    expect(result.eventsSent).toBe(2);
+    expect(events).toEqual(
+      expect.arrayContaining([
+        {
+          sessionId: "codex-live",
+          timestamp: "2026-07-30T10:00:02Z",
+          uuid: "codex-event-live",
+          cwd: "/home/yousuf/hq/repos/private/hq-cloud",
+          gitBranch: "feature/live",
+          model: "codex-auto-review",
+          inputTokens: 11,
+          outputTokens: 12,
+          cacheReadInputTokens: 3,
+        },
+        expect.objectContaining({
+          sessionId: "codex-archived",
+          model: "gpt-5-codex",
+          inputTokens: 2,
+          outputTokens: 4,
+          cacheReadInputTokens: 1,
+        }),
+      ]),
+    );
+    expect(JSON.stringify(events)).not.toContain("private prompt");
+    expect(JSON.stringify(events)).not.toContain("raw_content");
+    expect(JSON.stringify(events)).not.toContain("999999");
+
+    await collectAndSendTelemetry(makeOpts(env, client));
+    expect(client.posts.flatMap((post) => post.events)).toHaveLength(2);
+  });
+
+  it("persists model context for incremental rollouts and generates stable IDs", async () => {
+    const file = writeCodexRollout(env, "sessions", "rollout-incremental.jsonl", [
+      {
+        type: "session_meta",
+        payload: { id: "incremental", cwd: "/repo", model: "session-model" },
+      },
+      { type: "turn_context", payload: { model: "model-a" } },
+      codexToken("2026-07-30T13:00:00Z", "first-event", 1, 2),
+    ]);
+    fs.writeFileSync(
+      env.cursorPath,
+      JSON.stringify({ version: "1", files: {}, codex_next_rollout: file }),
+    );
+    const client = makeClient();
+
+    await collectAndSendTelemetry(makeOpts(env, client));
+    fs.appendFileSync(
+      file,
+      [
+        codexLine({ type: "turn_context", payload: { model: "model-b" } }),
+        codexLine({
+          ...codexToken("2026-07-30T13:01:00Z", "temporary", 3, 4),
+          uuid: undefined,
+        }),
+      ].join("\n") + "\n",
+    );
+    await collectAndSendTelemetry(makeOpts(env, client));
+
+    const events = client.posts.flatMap((post) => post.events);
+    expect(events).toHaveLength(2);
+    expect(events[1]).toMatchObject({
+      sessionId: "incremental",
+      cwd: "/repo",
+      model: "model-b",
+      inputTokens: 3,
+      outputTokens: 4,
+    });
+    expect(events[1].uuid).toMatch(/^codex-[a-f0-9]{64}$/);
+    const cursor = JSON.parse(fs.readFileSync(env.cursorPath, "utf-8"));
+    expect(cursor.files[file].context).toMatchObject({
+      session_id: "incremental",
+      cwd: "/repo",
+      session_model: "session-model",
+      turn_model: "model-b",
+    });
+    expect(cursor.codex_next_rollout).toBe(file);
+  });
+
+  it("bounds a quiet first backfill and resumes until the token event", async () => {
+    const file = writeCodexRollout(env, "sessions", "rollout-bounded.jsonl", [
+      { type: "session_meta", payload: { id: "bounded", model: "gpt-5-codex" } },
+      ...Array.from({ length: 8 }, (_, index) => ({
+        type: "response_item",
+        payload: { type: "message", content: "x".repeat(140), index },
+      })),
+      codexToken("2026-07-30T14:00:00Z", "bounded-event", 5, 7),
+    ]);
+    const client = makeClient();
+    const opts = {
+      ...makeOpts(env, client),
+      maxScanBytesPerSource: 350,
+    };
+
+    const first = await collectAndSendTelemetry(opts);
+
+    expect(first.eventsSent).toBe(0);
+    const firstOffset = readCursor(env).files[file]?.offset ?? 0;
+    expect(firstOffset).toBeGreaterThan(0);
+    expect(firstOffset).toBeLessThan(fs.statSync(file).size);
+
+    for (let run = 0; run < 10 && client.posts.length === 0; run++) {
+      await collectAndSendTelemetry(opts);
+    }
+    expect(client.posts.flatMap((post) => post.events)).toEqual([
+      expect.objectContaining({
+        sessionId: "bounded",
+        uuid: "bounded-event",
+        model: "gpt-5-codex",
+      }),
+    ]);
+  });
+
+  it("discards an oversized UTF-8 row without corrupting resume offsets", async () => {
+    const file = writeCodexRollout(env, "sessions", "rollout-utf8.jsonl", [
+      { type: "session_meta", payload: { id: "utf8", model: "gpt-5-codex" } },
+      {
+        type: "response_item",
+        payload: { type: "message", content: "😀".repeat(20_000) },
+      },
+      codexToken("2026-07-30T14:00:01Z", "utf8-event", 2, 3),
+    ]);
+    const client = makeClient();
+    const opts = {
+      ...makeOpts(env, client),
+      maxScanBytesPerSource: 64 * 1024,
+    };
+
+    for (let run = 0; run < 5 && client.posts.length === 0; run++) {
+      await collectAndSendTelemetry(opts);
+    }
+
+    const events = client.posts.flatMap((post) => post.events);
+    expect(events).toEqual([
+      expect.objectContaining({ uuid: "utf8-event", sessionId: "utf8" }),
+    ]);
+    expect(readCursor(env).files[file].offset).toBeLessThanOrEqual(
+      fs.statSync(file).size,
+    );
+  });
+
+  it("caps upload batches and resumes remaining token events", async () => {
+    writeCodexRollout(env, "sessions", "rollout-batch-cap.jsonl", [
+      { type: "session_meta", payload: { id: "batch-cap", model: "gpt-5-codex" } },
+      ...Array.from({ length: 201 }, (_, index) =>
+        codexToken(
+          "2026-07-30T14:01:" + String(index % 60).padStart(2, "0") + "Z",
+          "batch-cap-" + index,
+          1,
+          1,
+        ),
+      ),
+    ]);
+    const client = makeClient();
+    const opts = {
+      ...makeOpts(env, client),
+      maxScanBytesPerSource: 1_000_000,
+      maxBatchesPerRun: 2,
+    };
+
+    const first = await collectAndSendTelemetry(opts);
+    expect(first.batchesSent).toBe(2);
+    expect(first.eventsSent).toBe(200);
+
+    const second = await collectAndSendTelemetry(opts);
+    expect(second.eventsSent).toBe(1);
+    expect(client.posts.flatMap((post) => post.events)).toHaveLength(201);
+  });
+
+  it("does not advance a Codex rollout cursor when upload fails", async () => {
+    const file = writeCodexRollout(env, "sessions", "rollout-retry.jsonl", [
+      { type: "session_meta", payload: { id: "retry", model: "gpt-5-codex" } },
+      codexToken("2026-07-30T12:00:00Z", "retry-event", 1, 2),
+    ]);
+    const client = makeClient({ postResponse: new Error("server 500") });
+
+    const result = await collectAndSendTelemetry(makeOpts(env, client));
+
+    expect(result.eventsSent).toBe(0);
+    const cursor = readCursor(env);
+    expect(cursor.files[file]?.offset ?? 0).toBe(0);
+  });
+});
+
 // ── companyUid edge attribution (US-002) ────────────────────────────────────────
 
 describe("collectAndSendTelemetry — companyUid attribution", () => {