test: add telemetry module and settings resolution unit tests

- src/tests/telemetry.test.ts: 6 tests covering enabled flag, missing
  machineId, correct fetch params, error swallowing, custom timeout
- src/tests/settings-and-notify.test.ts: 3 new tests + extended
  precedence test verifying telemetryEnabled resolution chain

Author: Lellansin

src/tests/settings-and-notify.test.ts

@@ -83,6 +83,36 @@ test("resolveSettings reads THINKING_ENABLED, REASONING_EFFORT, and DEBUG_LOG_EN
   assert.equal(resolved.baseURL, "https://default.example.com");
 });
 
+test("resolveSettings defaults telemetryEnabled to true", () => {
+  const resolved = resolveSettings(
+    {},
+    { model: "default-model", baseURL: "https://default.example.com" },
+    TEST_PROCESS_ENV
+  );
+  assert.equal(resolved.telemetryEnabled, true);
+});
+
+test("resolveSettings reads TELEMETRY_ENABLED from env", () => {
+  const resolved = resolveSettings(
+    { env: { TELEMETRY_ENABLED: "0" } },
+    { model: "default-model", baseURL: "https://default.example.com" },
+    TEST_PROCESS_ENV
+  );
+  assert.equal(resolved.telemetryEnabled, false);
+});
+
+test("resolveSettings gives top-level telemetryEnabled priority over env TELEMETRY_ENABLED", () => {
+  const resolved = resolveSettings(
+    {
+      telemetryEnabled: false,
+      env: { TELEMETRY_ENABLED: "true" },
+    },
+    { model: "default-model", baseURL: "https://default.example.com" },
+    TEST_PROCESS_ENV
+  );
+  assert.equal(resolved.telemetryEnabled, false);
+});
+
 test("resolveSettings ignores removed legacy env.THINKING", () => {
   const resolved = resolveSettings(
     {
@@ -115,6 +145,7 @@ test("resolveSettingsSources applies user, project, and DEEPCODE environment pre
       thinkingEnabled: true,
       reasoningEffort: "max",
       debugLogEnabled: true,
+      telemetryEnabled: false,
     },
     {
       env: {
@@ -125,6 +156,7 @@ test("resolveSettingsSources applies user, project, and DEEPCODE environment pre
       },
       model: "project-top-model",
       thinkingEnabled: true,
+      telemetryEnabled: true,
     },
     {
       model: "default-model",
@@ -135,6 +167,7 @@ test("resolveSettingsSources applies user, project, and DEEPCODE environment pre
       DEEPCODE_THINKING_ENABLED: "false",
       DEEPCODE_REASONING_EFFORT: "high",
       DEEPCODE_DEBUG_LOG_ENABLED: "true",
+      DEEPCODE_TELEMETRY_ENABLED: "false",
       DEEPCODE_WEBHOOK: "system-webhook",
     }
   );
@@ -144,6 +177,7 @@ test("resolveSettingsSources applies user, project, and DEEPCODE environment pre
   assert.equal(resolved.thinkingEnabled, false);
   assert.equal(resolved.reasoningEffort, "high");
   assert.equal(resolved.debugLogEnabled, true);
+  assert.equal(resolved.telemetryEnabled, false);
   assert.equal(resolved.env.WEBHOOK, "system-webhook");
 });
 

src/tests/telemetry.test.ts

@@ -0,0 +1,109 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { reportNewPrompt } from "../common/telemetry";
+
+test("reportNewPrompt does not call fetch when enabled is false", () => {
+  let called = false;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = ((..._args: unknown[]) => {
+    called = true;
+    return Promise.resolve(new Response());
+  }) as typeof globalThis.fetch;
+
+  try {
+    reportNewPrompt({ enabled: false, machineId: "test-machine" });
+    assert.equal(called, false);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("reportNewPrompt does not call fetch when machineId is undefined", () => {
+  let called = false;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = ((..._args: unknown[]) => {
+    called = true;
+    return Promise.resolve(new Response());
+  }) as typeof globalThis.fetch;
+
+  try {
+    reportNewPrompt({ enabled: true });
+    assert.equal(called, false);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("reportNewPrompt does not call fetch when machineId is empty string", () => {
+  let called = false;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = ((..._args: unknown[]) => {
+    called = true;
+    return Promise.resolve(new Response());
+  }) as typeof globalThis.fetch;
+
+  try {
+    reportNewPrompt({ enabled: true, machineId: "" });
+    assert.equal(called, false);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("reportNewPrompt calls fetch with correct URL, method, headers, and body", async () => {
+  const calls: Array<{ url: string; init: RequestInit }> = [];
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = ((url: string | URL | Request, init?: RequestInit) => {
+    calls.push({ url: String(url), init: init ?? {} });
+    return Promise.resolve(new Response());
+  }) as typeof globalThis.fetch;
+
+  try {
+    reportNewPrompt({ enabled: true, machineId: "test-machine" });
+
+    // Wait for the fire-and-forget fetch to settle.
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].url, "https://deepcode.vegamo.cn/api/plugin/new");
+    assert.equal(calls[0].init.method, "POST");
+    assert.equal((calls[0].init.headers as Record<string, string>)["Content-Type"], "application/json");
+    assert.equal((calls[0].init.headers as Record<string, string>)["Token"], "test-machine");
+    assert.equal(calls[0].init.body, JSON.stringify({}));
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("reportNewPrompt swallows fetch errors without throwing", async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (() => {
+    return Promise.reject(new Error("Network error"));
+  }) as typeof globalThis.fetch;
+
+  try {
+    // Should not throw.
+    reportNewPrompt({ enabled: true, machineId: "test-machine" });
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("reportNewPrompt respects custom timeoutMs", async () => {
+  const calls: Array<{ signal: AbortSignal }> = [];
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = ((_url: string | URL | Request, init?: RequestInit) => {
+    calls.push({ signal: init?.signal as AbortSignal });
+    return Promise.resolve(new Response());
+  }) as typeof globalThis.fetch;
+
+  try {
+    reportNewPrompt({ enabled: true, machineId: "test-machine", timeoutMs: 100 });
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].signal.aborted, false);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});