fix(http): clear per-attempt timeout timers (#137)

* fix(http): clear per-attempt timeout timers

* fix(http): preserve timeout race classification

Author: JerryNee

src/lib/http.test.ts

@@ -449,6 +449,52 @@ describe('HttpClient per-request timeout', () => {
     expect(callCount).toBe(1);
   });
 
+  it('clears the per-attempt timeout after a successful response body is read', async () => {
+    let capturedSignal: AbortSignal | undefined;
+    const fetchImpl = vi.fn(async (_input: unknown, init?: RequestInit) => {
+      capturedSignal = init?.signal ?? undefined;
+      return jsonResponse({ ok: true });
+    });
+    const client = new HttpClient({
+      baseUrl: 'https://api.example.com/api/cli/v1',
+      apiKey: 'sk-test',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+      sleep: () => Promise.resolve(),
+      random: () => 0,
+      requestTimeoutMs: 25,
+    });
+
+    await expect(client.get('/me')).resolves.toEqual({ ok: true });
+    expect(capturedSignal?.aborted).toBe(false);
+    await new Promise(resolve => setTimeout(resolve, 50));
+    expect(capturedSignal?.aborted).toBe(false);
+  });
+
+  it('clears a failed attempt timeout before retry backoff sleeps', async () => {
+    const attemptSignals: AbortSignal[] = [];
+    let calls = 0;
+    const fetchImpl = vi.fn(async (_input: unknown, init?: RequestInit) => {
+      if (init?.signal) attemptSignals.push(init.signal);
+      calls += 1;
+      if (calls === 1) return errorEnvelopeResponse(500, 'INTERNAL');
+      return jsonResponse({ ok: true });
+    });
+    const client = new HttpClient({
+      baseUrl: 'https://api.example.com/api/cli/v1',
+      apiKey: 'sk-test',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+      sleep: () => new Promise(resolve => setTimeout(resolve, 50)),
+      random: () => 0,
+      requestTimeoutMs: 25,
+    });
+
+    await expect(client.get('/me')).resolves.toEqual({ ok: true });
+    expect(attemptSignals).toHaveLength(2);
+    expect(attemptSignals.every(signal => signal.aborted === false)).toBe(true);
+    await new Promise(resolve => setTimeout(resolve, 50));
+    expect(attemptSignals.every(signal => signal.aborted === false)).toBe(true);
+  });
+
   it('caller-supplied AbortSignal still propagates as AbortError (not RequestTimeoutError)', async () => {
     const controller = new AbortController();
     // Abort immediately
@@ -475,6 +521,33 @@ describe('HttpClient per-request timeout', () => {
     expect((err as Error).name).toBe('AbortError');
   });
 
+  it('preserves RequestTimeoutError when the caller aborts after the request timeout wins', async () => {
+    const controller = new AbortController();
+    const fetchImpl = vi.fn(async (_input: unknown, init?: { signal?: AbortSignal }) => {
+      return new Promise<Response>((_resolve, reject) => {
+        init?.signal?.addEventListener('abort', () => {
+          const reason = init.signal?.reason;
+          controller.abort(new Error('caller aborted after timeout'));
+          const err = new Error(reason?.message ?? 'timed out');
+          err.name = reason?.name ?? 'TimeoutError';
+          reject(err);
+        });
+      });
+    });
+    const client = new HttpClient({
+      baseUrl: 'https://api.example.com/api/cli/v1',
+      apiKey: 'sk-test',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+      sleep: () => Promise.resolve(),
+      random: () => 0,
+      requestTimeoutMs: 1,
+    });
+    const err = await client.get('/me', { signal: controller.signal }).catch(e => e);
+    expect(err).toBeInstanceOf(RequestTimeoutError);
+    expect((err as RequestTimeoutError).exitCode).toBe(7);
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
   it('defaults to REQUEST_TIMEOUT_DEFAULT_MS when no requestTimeoutMs is supplied', () => {
     // Verify the default is wired without actually waiting 120s.
     // We test via the exported constant rather than exercising the stall.