@indigoai-us/hq-cloud 6.15.17 → 6.15.19

package/dist/telemetry.test.js

@@ -50,14 +50,17 @@ function setupEnv() {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-telemetry-test-"));
     const claudeProjects = path.join(root, ".claude", "projects");
     const codexRoot = path.join(root, ".codex");
+    const grokRoot = path.join(root, ".grok");
     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(grokRoot, "sessions"), { recursive: true });
     fs.mkdirSync(path.join(root, ".hq"), { recursive: true });
     return {
         root,
         claudeProjects,
         codexRoot,
+        grokRoot,
         cursorPath: path.join(root, ".hq", "telemetry-cursor.json"),
         menubarPath: path.join(root, ".hq", "menubar.json"),
     };
@@ -82,6 +85,7 @@ function makeOpts(env, client) {
         installerVersion: "test-version",
         claudeProjectsRoot: env.claudeProjects,
         codexRoot: env.codexRoot,
+        grokRoot: env.grokRoot,
         maxScanBytesPerSource: Number.MAX_SAFE_INTEGER,
         maxBatchesPerRun: Number.MAX_SAFE_INTEGER,
         cursorPath: env.cursorPath,
@@ -745,6 +749,393 @@ describe("collectAndSendTelemetry — Codex rollouts", () => {
         expect(cursor.files[file]?.offset ?? 0).toBe(0);
     });
 });
+// ── Grok session collection ──────────────────────────────────────────────────
+function writeGrokSession(env, opts) {
+    const encodedCwd = opts.encodedCwd ?? encodeURIComponent("/Users/x/proj");
+    const dir = path.join(env.grokRoot, "sessions", encodedCwd, opts.sessionId);
+    fs.mkdirSync(dir, { recursive: true });
+    if (opts.summary) {
+        fs.writeFileSync(path.join(dir, "summary.json"), JSON.stringify(opts.summary), "utf-8");
+    }
+    const file = path.join(dir, "updates.jsonl");
+    fs.writeFileSync(file, opts.lines.map((line) => JSON.stringify(line)).join("\n") + "\n", "utf-8");
+    return file;
+}
+function grokTurnCompleted(opts) {
+    const update = {
+        sessionUpdate: "turn_completed",
+        prompt_id: opts.promptId,
+        stop_reason: "end_turn",
+        usage: opts.usage,
+        ...opts.extraUpdate,
+    };
+    const params = {
+        sessionId: opts.sessionId,
+        update,
+    };
+    if (opts.eventId) {
+        params._meta = { eventId: opts.eventId };
+    }
+    return {
+        timestamp: opts.timestamp ?? 1_786_507_623,
+        method: opts.method ?? "_x.ai/session/update",
+        params,
+    };
+}
+describe("collectAndSendTelemetry — Grok sessions", () => {
+    let env;
+    beforeEach(() => {
+        env = setupEnv();
+    });
+    afterEach(() => teardownEnv(env));
+    it("collects turn_completed usage with reasoning folded into outputTokens", async () => {
+        const sessionId = "grok-session-1";
+        writeGrokSession(env, {
+            sessionId,
+            summary: {
+                info: { id: sessionId, cwd: "/Users/x/proj" },
+                current_model_id: "grok-4.5-build",
+                head_branch: "feat/grok-usage",
+            },
+            lines: [
+                {
+                    timestamp: 1_786_507_620,
+                    method: "session/update",
+                    params: {
+                        sessionId,
+                        update: {
+                            sessionUpdate: "agent_message_chunk",
+                            content: { type: "text", text: "secret prompt body" },
+                            _meta: { totalTokens: 999_999 },
+                        },
+                    },
+                },
+                grokTurnCompleted({
+                    sessionId,
+                    promptId: "prompt-1",
+                    eventId: "evt-turn-1",
+                    usage: {
+                        inputTokens: 2552850,
+                        outputTokens: 29428,
+                        cachedReadTokens: 2414208,
+                        cacheCreationTokens: 0,
+                        reasoningTokens: 14654,
+                        modelUsage: {
+                            "grok-4.5-build": {
+                                inputTokens: 2552850,
+                                outputTokens: 29428,
+                                cachedReadTokens: 2414208,
+                                cacheCreationTokens: 0,
+                                reasoningTokens: 14654,
+                            },
+                        },
+                    },
+                }),
+            ],
+        });
+        const client = makeClient();
+        const result = await collectAndSendTelemetry(makeOpts(env, client));
+        const events = client.posts.flatMap((post) => post.events);
+        expect(result.filesScanned).toBe(1);
+        expect(result.eventsSent).toBe(1);
+        expect(events).toEqual([
+            {
+                sessionId,
+                timestamp: new Date(1_786_507_623 * 1000).toISOString(),
+                uuid: "evt-turn-1",
+                cwd: "/Users/x/proj",
+                gitBranch: "feat/grok-usage",
+                model: "grok-4.5-build",
+                inputTokens: 2552850,
+                outputTokens: 29428 + 14654,
+                cacheReadInputTokens: 2414208,
+                cacheCreationInputTokens: 0,
+            },
+        ]);
+        expect(JSON.stringify(events)).not.toContain("secret prompt body");
+        expect(JSON.stringify(events)).not.toContain("999999");
+    });
+    it("advances the cursor incrementally and only posts new turn_completed rows", async () => {
+        const sessionId = "grok-incremental";
+        const file = writeGrokSession(env, {
+            sessionId,
+            summary: {
+                info: { cwd: "/repo" },
+                current_model_id: "grok-4.5-build",
+            },
+            lines: [
+                grokTurnCompleted({
+                    sessionId,
+                    promptId: "p1",
+                    eventId: "evt-1",
+                    usage: {
+                        inputTokens: 10,
+                        outputTokens: 2,
+                        reasoningTokens: 1,
+                        cachedReadTokens: 0,
+                        cacheCreationTokens: 0,
+                        modelUsage: {
+                            "grok-4.5-build": {
+                                inputTokens: 10,
+                                outputTokens: 2,
+                                reasoningTokens: 1,
+                                cachedReadTokens: 0,
+                                cacheCreationTokens: 0,
+                            },
+                        },
+                    },
+                }),
+            ],
+        });
+        const client = makeClient();
+        await collectAndSendTelemetry(makeOpts(env, client));
+        expect(client.posts.flatMap((post) => post.events)).toHaveLength(1);
+        const offsetAfterFirst = readCursor(env).files[file].offset;
+        await collectAndSendTelemetry(makeOpts(env, client));
+        expect(client.posts.flatMap((post) => post.events)).toHaveLength(1);
+        expect(readCursor(env).files[file].offset).toBe(offsetAfterFirst);
+        fs.appendFileSync(file, JSON.stringify(grokTurnCompleted({
+            timestamp: 1_786_507_700,
+            sessionId,
+            promptId: "p2",
+            eventId: "evt-2",
+            usage: {
+                inputTokens: 20,
+                outputTokens: 4,
+                reasoningTokens: 0,
+                cachedReadTokens: 5,
+                cacheCreationTokens: 1,
+                modelUsage: {
+                    "grok-4.5-build": {
+                        inputTokens: 20,
+                        outputTokens: 4,
+                        reasoningTokens: 0,
+                        cachedReadTokens: 5,
+                        cacheCreationTokens: 1,
+                    },
+                },
+            },
+        })) + "\n");
+        await collectAndSendTelemetry(makeOpts(env, client));
+        const events = client.posts.flatMap((post) => post.events);
+        expect(events).toHaveLength(2);
+        expect(events[1]).toMatchObject({
+            uuid: "evt-2",
+            inputTokens: 20,
+            outputTokens: 4,
+            cacheReadInputTokens: 5,
+            cacheCreationInputTokens: 1,
+        });
+    });
+    it("opt-out with no company skips the grok scan entirely", async () => {
+        writeGrokSession(env, {
+            sessionId: "grok-optout",
+            summary: { info: { cwd: "/repo" }, current_model_id: "grok-4.5-build" },
+            lines: [
+                grokTurnCompleted({
+                    sessionId: "grok-optout",
+                    promptId: "p1",
+                    eventId: "evt-optout",
+                    usage: {
+                        inputTokens: 1,
+                        outputTokens: 1,
+                        reasoningTokens: 0,
+                        modelUsage: {
+                            "grok-4.5-build": {
+                                inputTokens: 1,
+                                outputTokens: 1,
+                                reasoningTokens: 0,
+                            },
+                        },
+                    },
+                }),
+            ],
+        });
+        const client = makeClient({
+            optInResponse: { enabled: false, updatedAt: null },
+        });
+        const result = await collectAndSendTelemetry(makeOpts(env, client));
+        expect(result.enabled).toBe(false);
+        expect(result.filesScanned).toBe(0);
+        expect(client.posts).toHaveLength(0);
+        expect(fs.existsSync(env.cursorPath)).toBe(false);
+    });
+    it("ignores streaming _meta.totalTokens chunks but still advances the cursor", async () => {
+        const sessionId = "grok-stream-only";
+        const file = writeGrokSession(env, {
+            sessionId,
+            summary: { info: { cwd: "/repo" }, current_model_id: "grok-4.5-build" },
+            lines: [
+                {
+                    timestamp: 1_786_507_600,
+                    method: "session/update",
+                    params: {
+                        sessionId,
+                        update: {
+                            sessionUpdate: "agent_thought_chunk",
+                            content: { type: "text", text: "thinking" },
+                            _meta: { totalTokens: 20447, eventId: "chunk-1" },
+                        },
+                    },
+                },
+                {
+                    timestamp: 1_786_507_601,
+                    method: "_x.ai/session/update",
+                    params: {
+                        sessionId,
+                        update: {
+                            sessionUpdate: "tool_call",
+                            title: "read_file",
+                            _meta: { totalTokens: 31430 },
+                        },
+                    },
+                },
+            ],
+        });
+        const client = makeClient();
+        const result = await collectAndSendTelemetry(makeOpts(env, client));
+        expect(result.eventsSent).toBe(0);
+        expect(client.posts).toHaveLength(0);
+        expect(readCursor(env).files[file].offset).toBe(fs.statSync(file).size);
+    });
+    it("missing ~/.grok is a silent success", async () => {
+        fs.rmSync(env.grokRoot, { recursive: true, force: true });
+        const client = makeClient();
+        const result = await collectAndSendTelemetry(makeOpts(env, client));
+        expect(result.filesScanned).toBe(0);
+        expect(result.eventsSent).toBe(0);
+        expect(client.posts).toHaveLength(0);
+    });
+    it("emits one event per model in modelUsage", async () => {
+        const sessionId = "grok-multi";
+        writeGrokSession(env, {
+            sessionId,
+            summary: { info: { cwd: "/repo" }, current_model_id: "grok-4.5-build" },
+            lines: [
+                grokTurnCompleted({
+                    sessionId,
+                    promptId: "multi-prompt",
+                    eventId: "evt-multi",
+                    usage: {
+                        inputTokens: 100,
+                        outputTokens: 10,
+                        reasoningTokens: 5,
+                        cachedReadTokens: 20,
+                        cacheCreationTokens: 0,
+                        modelUsage: {
+                            "grok-4.5-build": {
+                                inputTokens: 60,
+                                outputTokens: 6,
+                                reasoningTokens: 3,
+                                cachedReadTokens: 10,
+                                cacheCreationTokens: 0,
+                            },
+                            "grok-code-fast-1": {
+                                inputTokens: 40,
+                                outputTokens: 4,
+                                reasoningTokens: 2,
+                                cachedReadTokens: 10,
+                                cacheCreationTokens: 0,
+                            },
+                        },
+                    },
+                }),
+            ],
+        });
+        const client = makeClient();
+        await collectAndSendTelemetry(makeOpts(env, client));
+        const events = client.posts.flatMap((post) => post.events);
+        expect(events).toHaveLength(2);
+        expect(events).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                model: "grok-4.5-build",
+                inputTokens: 60,
+                outputTokens: 9,
+                cacheReadInputTokens: 10,
+            }),
+            expect.objectContaining({
+                model: "grok-code-fast-1",
+                inputTokens: 40,
+                outputTokens: 6,
+                cacheReadInputTokens: 10,
+            }),
+        ]));
+        // Multi-model rows must not share a single eventId (would collapse on ingest).
+        expect(events[0].uuid).not.toBe(events[1].uuid);
+        expect(String(events[0].uuid)).toMatch(/^grok-[a-f0-9]{64}$/);
+        expect(String(events[1].uuid)).toMatch(/^grok-[a-f0-9]{64}$/);
+    });
+    it("never POSTs raw prompt or tool text from grok updates", async () => {
+        const sessionId = "grok-redact";
+        writeGrokSession(env, {
+            sessionId,
+            summary: {
+                info: { cwd: "/repo" },
+                current_model_id: "grok-4.5-build",
+                session_summary: "private summary text",
+            },
+            lines: [
+                {
+                    timestamp: 1_786_507_610,
+                    method: "session/update",
+                    params: {
+                        sessionId,
+                        update: {
+                            sessionUpdate: "user_message_chunk",
+                            content: {
+                                type: "text",
+                                text: "SUPER_SECRET_USER_PROMPT_XYZ",
+                            },
+                        },
+                    },
+                },
+                {
+                    timestamp: 1_786_507_611,
+                    method: "session/update",
+                    params: {
+                        sessionId,
+                        update: {
+                            sessionUpdate: "tool_call",
+                            title: "read_file",
+                            rawInput: { target_file: "/secret/path.ts" },
+                        },
+                    },
+                },
+                grokTurnCompleted({
+                    method: "session/update",
+                    sessionId,
+                    promptId: "redact-prompt",
+                    eventId: "evt-redact",
+                    usage: {
+                        inputTokens: 3,
+                        outputTokens: 1,
+                        reasoningTokens: 1,
+                        cachedReadTokens: 0,
+                        cacheCreationTokens: 0,
+                        modelUsage: {
+                            "grok-4.5-build": {
+                                inputTokens: 3,
+                                outputTokens: 1,
+                                reasoningTokens: 1,
+                                cachedReadTokens: 0,
+                                cacheCreationTokens: 0,
+                            },
+                        },
+                    },
+                }),
+            ],
+        });
+        const client = makeClient();
+        await collectAndSendTelemetry(makeOpts(env, client));
+        const wire = JSON.stringify(client.posts);
+        expect(client.posts.flatMap((post) => post.events)).toHaveLength(1);
+        expect(wire).not.toContain("SUPER_SECRET_USER_PROMPT_XYZ");
+        expect(wire).not.toContain("/secret/path.ts");
+        expect(wire).not.toContain("private summary text");
+        expect(wire).not.toContain("rawInput");
+        expect(wire).not.toContain("user_message_chunk");
+    });
+});
 // ── companyUid edge attribution (US-002) ────────────────────────────────────────
 describe("collectAndSendTelemetry — companyUid attribution", () => {
     const COMPANY_UID = "cmp_01INDIGOTEST";