fix(portals): add a 15s request timeout to every board fetch (#197)

None of the board CLIs set a fetch timeout, and the retry loops react only to HTTP status codes, not to a connection that is accepted then never responds (black-holed TCP, hung TLS, stalled proxy) - so await fetch(...) never settles and the command hangs with no output and no exit. freehire's helper even documented a fast-degrade contract its try/catch didn't deliver on a mid-flight stall. Adds signal: AbortSignal.timeout(15000) to every fetch across all six CLIs, with network-free tests asserting the signal is present on each request wrapper.

By @thejesh23. Verified: 8 timeout tests pass locally with fetch stubbed (no network), and would fail on the pre-fix code.

Closes #196

.agents/skills/freehire-search/cli/src/helpers.ts

@@ -42,6 +42,7 @@ export async function apiGet<T>(path: string): Promise<Envelope<T> | null> {
       response = await fetch(url, {
         headers: { "User-Agent": UA, Accept: "application/json" },
         redirect: "follow",
+        signal: AbortSignal.timeout(15000),
       })
     } catch (e) {
       // Connection refused / DNS failure / timeout: the API is unreachable.

.agents/skills/freehire-search/cli/tests/request-timeout.test.ts

@@ -0,0 +1,26 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { apiGet } from "../src/helpers";
+
+// A stalled upstream connection (accepted socket, no response) would otherwise
+// hang the CLI forever - fetch has no default timeout. Assert the request
+// wrapper carries an AbortSignal timeout. Fails on the pre-fix code (no signal).
+const originalFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("apiGet request timeout", () => {
+  test("passes an AbortSignal timeout to fetch", async () => {
+    let init: RequestInit | undefined;
+    globalThis.fetch = (async (_url: string | URL | Request, i?: RequestInit) => {
+      init = i;
+      return new Response(JSON.stringify({ data: [] }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as unknown as typeof fetch;
+
+    await apiGet("/jobs");
+    expect(init?.signal).toBeInstanceOf(AbortSignal);
+  });
+});

.agents/skills/jobbank-search/cli/src/helpers.ts

@@ -15,6 +15,7 @@ export async function fetchWithUA(url: string): Promise<Response> {
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     const response = await fetch(url, {
       headers: { "User-Agent": USER_AGENT },
+      signal: AbortSignal.timeout(15000),
     })
     if (response.status === 429 || response.status >= 500) {
       if (attempt === maxRetries) {

.agents/skills/jobbank-search/cli/tests/request-timeout.test.ts

@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { fetchWithUA } from "../src/helpers";
+
+// A stalled upstream connection (accepted socket, no response) would otherwise
+// hang the CLI forever - fetch has no default timeout. Assert the request
+// wrapper carries an AbortSignal timeout. Fails on the pre-fix code (no signal).
+const originalFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("fetchWithUA request timeout", () => {
+  test("passes an AbortSignal timeout to fetch", async () => {
+    let init: RequestInit | undefined;
+    globalThis.fetch = (async (_url: string | URL | Request, i?: RequestInit) => {
+      init = i;
+      return new Response("<rss></rss>", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    await fetchWithUA("https://jobbank.dk/job/rss");
+    expect(init?.signal).toBeInstanceOf(AbortSignal);
+  });
+});

.agents/skills/jobdanmark-search/cli/src/commands/detail.ts

@@ -217,6 +217,7 @@ export const detail = defineCommand({
           "Accept": "text/html,application/xhtml+xml",
           "User-Agent": "Mozilla/5.0",
         },
+        signal: AbortSignal.timeout(15000),
       })
 
       if (response.status === 404) {

.agents/skills/jobdanmark-search/cli/src/helpers.ts

@@ -10,7 +10,7 @@ export async function apiFetch<T>(path: string, params?: Record<string, string>)
   const maxRetries = 6
   let delay = 500
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const response = await fetch(url)
+    const response = await fetch(url, { signal: AbortSignal.timeout(15000) })
     if (response.status === 429 || response.status >= 500) {
       if (attempt === maxRetries) {
         throw new Error(`API request failed: ${response.status} ${response.statusText}`)
@@ -40,6 +40,7 @@ export async function apiPost<T>(path: string, body: unknown): Promise<T> {
         "Content-Type": "application/json",
       },
       body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15000),
     })
     if (response.status === 429 || response.status >= 500) {
       if (attempt === maxRetries) {

.agents/skills/jobdanmark-search/cli/tests/request-timeout.test.ts

@@ -0,0 +1,34 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { apiFetch, apiPost } from "../src/helpers";
+
+// A stalled upstream connection (accepted socket, no response) would otherwise
+// hang the CLI forever - fetch has no default timeout. Assert both request
+// wrappers carry an AbortSignal timeout. Fails on the pre-fix code (no signal).
+const originalFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("request timeout", () => {
+  test("apiFetch passes an AbortSignal timeout to fetch", async () => {
+    let init: RequestInit | undefined;
+    globalThis.fetch = (async (_url: string | URL | Request, i?: RequestInit) => {
+      init = i;
+      return new Response("{}", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    await apiFetch("/search");
+    expect(init?.signal).toBeInstanceOf(AbortSignal);
+  });
+
+  test("apiPost passes an AbortSignal timeout to fetch", async () => {
+    let init: RequestInit | undefined;
+    globalThis.fetch = (async (_url: string | URL | Request, i?: RequestInit) => {
+      init = i;
+      return new Response("{}", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    await apiPost("/search", { q: "x" });
+    expect(init?.signal).toBeInstanceOf(AbortSignal);
+  });
+});

.agents/skills/jobindex-search/cli/src/helpers.ts

@@ -14,7 +14,7 @@ export async function apiFetch<T>(path: string, params?: Record<string, string>)
   const maxRetries = 6
   let delay = 500
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const response = await fetch(url)
+    const response = await fetch(url, { signal: AbortSignal.timeout(15000) })
     if (response.status === 429 || response.status >= 500) {
       if (attempt === maxRetries) {
         throw new Error(`API request failed: ${response.status} ${response.statusText}`)
@@ -43,6 +43,7 @@ export async function htmlFetch(url: string): Promise<string> {
         "Accept-Language": "da,en;q=0.9",
       },
       redirect: "follow",
+      signal: AbortSignal.timeout(15000),
     })
     if (response.status === 429 || response.status >= 500) {
       if (attempt === maxRetries) {

.agents/skills/jobindex-search/cli/tests/request-timeout.test.ts

@@ -0,0 +1,34 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { apiFetch, htmlFetch } from "../src/helpers";
+
+// A stalled upstream connection (accepted socket, no response) would otherwise
+// hang the CLI forever - fetch has no default timeout. Assert both request
+// wrappers carry an AbortSignal timeout. Fails on the pre-fix code (no signal).
+const originalFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("request timeout", () => {
+  test("apiFetch passes an AbortSignal timeout to fetch", async () => {
+    let init: RequestInit | undefined;
+    globalThis.fetch = (async (_url: string | URL | Request, i?: RequestInit) => {
+      init = i;
+      return new Response("{}", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    await apiFetch("/search");
+    expect(init?.signal).toBeInstanceOf(AbortSignal);
+  });
+
+  test("htmlFetch passes an AbortSignal timeout to fetch", async () => {
+    let init: RequestInit | undefined;
+    globalThis.fetch = (async (_url: string | URL | Request, i?: RequestInit) => {
+      init = i;
+      return new Response("<html></html>", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    await htmlFetch("https://www.jobindex.dk/x");
+    expect(init?.signal).toBeInstanceOf(AbortSignal);
+  });
+});

.agents/skills/jobnet-search/cli/src/helpers.ts

@@ -14,6 +14,7 @@ export async function apiFetch<T>(path: string, params?: Record<string, string>)
       headers: {
         "x-csrf": "1",
       },
+      signal: AbortSignal.timeout(15000),
     })
 
     if (response.status === 429 || response.status >= 500) {

.agents/skills/jobnet-search/cli/tests/request-timeout.test.ts

@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { apiFetch } from "../src/helpers";
+
+// A stalled upstream connection (accepted socket, no response) would otherwise
+// hang the CLI forever - fetch has no default timeout. Assert every request
+// carries an AbortSignal timeout. This fails on the pre-fix code (no signal).
+const originalFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("apiFetch request timeout", () => {
+  test("passes an AbortSignal timeout to fetch", async () => {
+    let init: RequestInit | undefined;
+    globalThis.fetch = (async (_url: string | URL | Request, i?: RequestInit) => {
+      init = i;
+      return new Response("{}", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    await apiFetch("/search");
+    expect(init?.signal).toBeInstanceOf(AbortSignal);
+  });
+});

.agents/skills/linkedin-search/cli/src/helpers.ts

@@ -29,6 +29,7 @@ export async function htmlFetch(url: string): Promise<string> {
         "X-Requested-With": "XMLHttpRequest",
       },
       redirect: "follow",
+      signal: AbortSignal.timeout(15000),
     })
     if (response.status === 429 || response.status >= 500) {
       if (attempt === maxRetries) {

.agents/skills/linkedin-search/cli/tests/request-timeout.test.ts

@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { htmlFetch } from "../src/helpers";
+
+// A stalled upstream connection (accepted socket, no response) would otherwise
+// hang the CLI forever - fetch has no default timeout. Assert the request
+// wrapper carries an AbortSignal timeout. Fails on the pre-fix code (no signal).
+const originalFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("htmlFetch request timeout", () => {
+  test("passes an AbortSignal timeout to fetch", async () => {
+    let init: RequestInit | undefined;
+    globalThis.fetch = (async (_url: string | URL | Request, i?: RequestInit) => {
+      init = i;
+      return new Response("<html></html>", { status: 200 });
+    }) as unknown as typeof fetch;
+
+    await htmlFetch("https://www.linkedin.com/jobs-guest/jobs/api/x");
+    expect(init?.signal).toBeInstanceOf(AbortSignal);
+  });
+});