Add 30s request timeout to CoderClient.request()

Without a timeout, a hanging server (accepts TCP, never responds)
blocks every API call indefinitely. The GitHub Action then burns CI
minutes until the job-level timeout kills it.

Uses AbortSignal.timeout(30_000) as default, respects caller signal.

Author: mafredri

dist/index.js

@@ -3,25 +3,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -3447,7 +3465,7 @@ var require_constants2 = __commonJS((exports2, module2) => {
     }
   })();
   var channel;
-  var structuredClone = globalThis.structuredClone ?? function structuredClone(value, options = undefined) {
+  var structuredClone = globalThis.structuredClone ?? function structuredClone2(value, options = undefined) {
     if (arguments.length === 0) {
       throw new TypeError("missing argument");
     }
@@ -16372,7 +16390,7 @@ var require_undici = __commonJS((exports2, module2) => {
   module2.exports.getGlobalDispatcher = getGlobalDispatcher;
   if (util.nodeMajor > 16 || util.nodeMajor === 16 && util.nodeMinor >= 8) {
     let fetchImpl = null;
-    module2.exports.fetch = async function fetch(resource) {
+    module2.exports.fetch = async function fetch2(resource) {
       if (!fetchImpl) {
         fetchImpl = require_fetch().fetch;
       }
@@ -22708,11 +22726,11 @@ var require_github = __commonJS((exports2) => {
 });
 
 // src/index.ts
-var core2 = __toESM(require_core());
-var github = __toESM(require_github());
+var core2 = __toESM(require_core(), 1);
+var github = __toESM(require_github(), 1);
 
 // src/action.ts
-var core = __toESM(require_core());
+var core = __toESM(require_core(), 1);
 
 class CoderAgentChatAction {
   coder;
@@ -26818,7 +26836,8 @@ class RealCoderClient {
     const url = `${this.serverURL}${endpoint}`;
     const response = await fetch(url, {
       ...options,
-      headers: { ...this.headers, ...options?.headers }
+      headers: { ...this.headers, ...options?.headers },
+      signal: options?.signal ?? AbortSignal.timeout(30000)
     });
     if (!response.ok) {
       const body = await response.text().catch(() => "");

src/coder-client.test.ts

@@ -156,4 +156,41 @@ describe("CoderClient", () => {
 			);
 		});
 	});
+
+	describe("request timeout", () => {
+		test("aborts when server never responds", async () => {
+			const original = AbortSignal.timeout;
+			try {
+				// Use a 10ms timeout so the test doesn't wait 30s.
+				AbortSignal.timeout = () => original.call(AbortSignal, 10);
+				mockFetch.mockImplementation(
+					(_url: string, init?: RequestInit) =>
+						new Promise((_resolve, reject) => {
+							// Keep event loop alive so the abort timer fires.
+							const keepalive = setTimeout(() => {}, 5000);
+							if (init?.signal?.aborted) {
+								clearTimeout(keepalive);
+								reject(init.signal.reason);
+								return;
+							}
+							init?.signal?.addEventListener("abort", () => {
+								clearTimeout(keepalive);
+								reject(init.signal?.reason);
+							});
+						}),
+				);
+				await expect(client.getChat(mockChat.id)).rejects.toThrow();
+			} finally {
+				AbortSignal.timeout = original;
+			}
+		});
+
+		test("passes signal to fetch", async () => {
+			mockFetch.mockResolvedValue(createMockResponse(mockChat));
+			await client.getChat(mockChat.id);
+			const call = mockFetch.mock.calls[0];
+			const init = call[1] as RequestInit;
+			expect(init.signal).toBeInstanceOf(AbortSignal);
+		});
+	});
 });

src/coder-client.ts

@@ -38,6 +38,7 @@ export class RealCoderClient implements CoderClient {
 		const response = await fetch(url, {
 			...options,
 			headers: { ...this.headers, ...options?.headers },
+			signal: options?.signal ?? AbortSignal.timeout(30_000),
 		});
 
 		if (!response.ok) {