fix: normalize abort signals for telegram fetch

src/infra/fetch.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { wrapFetchWithAbortSignal } from "./fetch.js";
+
+describe("wrapFetchWithAbortSignal", () => {
+  it("converts foreign abort signals to native controllers", async () => {
+    let seenSignal: AbortSignal | undefined;
+    const fetchImpl = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+      seenSignal = init?.signal as AbortSignal | undefined;
+      return {} as Response;
+    });
+
+    const wrapped = wrapFetchWithAbortSignal(fetchImpl);
+
+    let abortHandler: (() => void) | null = null;
+    const fakeSignal = {
+      aborted: false,
+      addEventListener: (event: string, handler: () => void) => {
+        if (event === "abort") abortHandler = handler;
+      },
+      removeEventListener: (event: string, handler: () => void) => {
+        if (event === "abort" && abortHandler === handler) abortHandler = null;
+      },
+    } as AbortSignal;
+
+    const promise = wrapped("https://example.com", { signal: fakeSignal });
+    expect(fetchImpl).toHaveBeenCalledOnce();
+    expect(seenSignal).toBeInstanceOf(AbortSignal);
+    expect(seenSignal).not.toBe(fakeSignal);
+
+    abortHandler?.();
+    expect(seenSignal?.aborted).toBe(true);
+
+    await promise;
+  });
+});

src/infra/fetch.ts

@@ -0,0 +1,29 @@
+export function wrapFetchWithAbortSignal(fetchImpl: typeof fetch): typeof fetch {
+  return (input: RequestInfo | URL, init?: RequestInit) => {
+    const signal = init?.signal;
+    if (!signal) return fetchImpl(input, init);
+    if (typeof AbortSignal !== "undefined" && signal instanceof AbortSignal) {
+      return fetchImpl(input, init);
+    }
+    if (typeof AbortController === "undefined") {
+      return fetchImpl(input, init);
+    }
+    if (typeof signal.addEventListener !== "function") {
+      return fetchImpl(input, init);
+    }
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    if (signal.aborted) {
+      controller.abort();
+    } else {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const response = fetchImpl(input, { ...init, signal: controller.signal });
+    if (typeof signal.removeEventListener === "function") {
+      void response.finally(() => {
+        signal.removeEventListener("abort", onAbort);
+      });
+    }
+    return response;
+  };
+}

src/telegram/bot.create-telegram-bot.installs-grammy-throttler.test.ts

@@ -157,13 +157,12 @@ describe("createTelegramBot", () => {
       (globalThis as { Bun?: unknown }).Bun = {};
       createTelegramBot({ token: "tok" });
       const fetchImpl = resolveTelegramFetch();
-      expect(fetchImpl).toBe(fetchSpy);
+      expect(fetchImpl).toBeTypeOf("function");
-      expect(botCtorSpy).toHaveBeenCalledWith(
+      expect(fetchImpl).not.toBe(fetchSpy);
-        "tok",
+      const clientFetch = (botCtorSpy.mock.calls[0]?.[1] as { client?: { fetch?: unknown } })
-        expect.objectContaining({
+        ?.client?.fetch;
-          client: expect.objectContaining({ fetch: fetchSpy }),
+      expect(clientFetch).toBeTypeOf("function");
-        }),
+      expect(clientFetch).not.toBe(fetchSpy);
-      );
     } finally {
       globalThis.fetch = originalFetch;
       if (originalBun === undefined) {

src/telegram/bot.test.ts

@@ -284,13 +284,12 @@ describe("createTelegramBot", () => {
       (globalThis as { Bun?: unknown }).Bun = {};
       createTelegramBot({ token: "tok" });
       const fetchImpl = resolveTelegramFetch();
-      expect(fetchImpl).toBe(fetchSpy);
+      expect(fetchImpl).toBeTypeOf("function");
-      expect(botCtorSpy).toHaveBeenCalledWith(
+      expect(fetchImpl).not.toBe(fetchSpy);
-        "tok",
+      const clientFetch = (botCtorSpy.mock.calls[0]?.[1] as { client?: { fetch?: unknown } })
-        expect.objectContaining({
+        ?.client?.fetch;
-          client: expect.objectContaining({ fetch: fetchSpy }),
+      expect(clientFetch).toBeTypeOf("function");
-        }),
+      expect(clientFetch).not.toBe(fetchSpy);
-      );
     } finally {
       globalThis.fetch = originalFetch;
       if (originalBun === undefined) {

src/telegram/fetch.ts

@@ -1,11 +1,13 @@
+import { wrapFetchWithAbortSignal } from "../infra/fetch.js";
+
 // Bun-only: force native fetch to avoid grammY's Node shim under Bun.
 export function resolveTelegramFetch(proxyFetch?: typeof fetch): typeof fetch | undefined {
-  if (proxyFetch) return proxyFetch;
+  if (proxyFetch) return wrapFetchWithAbortSignal(proxyFetch);
   const fetchImpl = globalThis.fetch;
   const isBun = "Bun" in globalThis || Boolean(process?.versions?.bun);
   if (!isBun) return undefined;
   if (!fetchImpl) {
     throw new Error("fetch is not available; set channels.telegram.proxy in config");
   }
-  return fetchImpl;
+  return wrapFetchWithAbortSignal(fetchImpl);
 }

src/telegram/proxy.ts

@@ -1,10 +1,11 @@
 // @ts-nocheck
 import { ProxyAgent } from "undici";
+import { wrapFetchWithAbortSignal } from "../infra/fetch.js";
 
 export function makeProxyFetch(proxyUrl: string): typeof fetch {
   const agent = new ProxyAgent(proxyUrl);
-  return (input: RequestInfo | URL, init?: RequestInit) => {
+  return wrapFetchWithAbortSignal((input: RequestInfo | URL, init?: RequestInit) => {
     const base = init ? { ...init } : {};
     return fetch(input, { ...base, dispatcher: agent });
-  };
+  });
 }

src/telegram/send.returns-undefined-empty-input.test.ts

@@ -164,12 +164,10 @@ describe("sendMessageTelegram", () => {
     });
     try {
       await sendMessageTelegram("123", "hi", { token: "tok" });
-      expect(botCtorSpy).toHaveBeenCalledWith(
+      const clientFetch = (botCtorSpy.mock.calls[0]?.[1] as { client?: { fetch?: unknown } })
-        "tok",
+        ?.client?.fetch;
-        expect.objectContaining({
+      expect(clientFetch).toBeTypeOf("function");
-          client: expect.objectContaining({ fetch: fetchSpy }),
+      expect(clientFetch).not.toBe(fetchSpy);
-        }),
-      );
     } finally {
       globalThis.fetch = originalFetch;
       if (originalBun === undefined) {