@botcord/daemon 0.2.40 → 0.2.42

package/dist/gateway/channels/telegram.js

@@ -72,17 +72,18 @@ export function createTelegramChannel(opts) {
         }
         return botToken;
     }
-    async function callApi(method, params, timeoutMs) {
+    async function callApi(method, params, timeoutMs, abortSignal) {
         if (!botToken)
             throw new Error("telegram bot token not loaded");
         const url = `${baseUrl}/bot${botToken}/${method}`;
+        const signalLease = createTimeoutSignal(timeoutMs, abortSignal);
         let resp;
         try {
             resp = await fetchImpl(url, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify(params),
-                signal: AbortSignal.timeout(timeoutMs),
+                signal: signalLease.signal,
             });
         }
         catch (err) {
@@ -94,6 +95,9 @@ export function createTelegramChannel(opts) {
             next.name = e.name ?? "Error";
             throw next;
         }
+        finally {
+            signalLease.cleanup();
+        }
         const json = (await resp.json());
         return json;
     }
@@ -156,7 +160,7 @@ export function createTelegramChannel(opts) {
             replyTo: null,
             mentioned: false,
             receivedAt: Date.now(),
-            trace: { id: messageId, streamable: false },
+            trace: { id: messageId, streamable: true },
         };
     }
     async function pollLoop(ctx) {
@@ -194,20 +198,20 @@ export function createTelegramChannel(opts) {
         });
         log.info("telegram poll loop starting", { gatewayId: opts.id, offset });
         let stopped = false;
+        const stopController = new AbortController();
         const onAbort = () => {
             stopped = true;
+            stopController.abort();
         };
         abortSignal.addEventListener("abort", onAbort, { once: true });
-        stopCallback = () => {
-            stopped = true;
-        };
+        stopCallback = onAbort;
         while (!stopped && !abortSignal.aborted) {
             try {
                 const resp = await callApi("getUpdates", {
                     offset,
                     timeout: POLL_TIMEOUT_S,
                     allowed_updates: ["message"],
-                }, (POLL_TIMEOUT_S + 15) * 1000);
+                }, (POLL_TIMEOUT_S + 15) * 1000, stopController.signal);
                 markStatus({ lastPollAt: Date.now() });
                 if (!resp.ok) {
                     log.warn("telegram getUpdates non-ok", {
@@ -369,3 +373,38 @@ function sleep(ms, signal) {
         signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
+function createTimeoutSignal(timeoutMs, parent) {
+    const controller = new AbortController();
+    let settled = false;
+    const abort = (reason) => {
+        if (settled)
+            return;
+        settled = true;
+        try {
+            controller.abort(reason);
+        }
+        catch {
+            controller.abort();
+        }
+    };
+    const timer = setTimeout(() => {
+        abort(new DOMException("Timeout", "TimeoutError"));
+    }, timeoutMs);
+    const onParentAbort = () => abort(parent?.reason);
+    if (parent) {
+        if (parent.aborted) {
+            onParentAbort();
+        }
+        else {
+            parent.addEventListener("abort", onParentAbort, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            clearTimeout(timer);
+            if (parent)
+                parent.removeEventListener("abort", onParentAbort);
+        },
+    };
+}

package/dist/gateway/dispatcher.js

@@ -591,6 +591,7 @@ export class Dispatcher {
         const trustLevel = route.trustLevel ?? "trusted";
         const streamable = msg.trace?.streamable === true;
         const traceId = msg.trace?.id;
+        const canType = streamable && typeof traceId === "string" && typeof channel.typing === "function";
         const canStream = streamable && typeof traceId === "string" && typeof channel.streamBlock === "function";
         const recordBlock = (block) => {
             const summary = { type: block.kind };
@@ -670,7 +671,7 @@ export class Dispatcher {
             forwardBlockToChannel(synth);
         };
         const fireTypingIfNeeded = () => {
-            if (!canStream || typingFired || typeof channel.typing !== "function")
+            if (!canType || typingFired)
                 return;
             typingFired = true;
             const key = `${msg.accountId}:${msg.conversation.id}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.40",
+  "version": "0.2.42",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/gateway/__tests__/dispatcher.test.ts

@@ -619,7 +619,7 @@ describe("Dispatcher", () => {
   // typing / thinking lifecycle (design: runtime-typing-thinking-status-design.md)
   // ---------------------------------------------------------------------------
 
-  it("typing: fires channel.typing once before runtime.run when canStream", async () => {
+  it("typing: fires channel.typing once before runtime.run when trace is streamable", async () => {
     const observed: Array<{ typings: number; calls: number }> = [];
     const runtime = new FakeRuntime({
       observeRun: () => {
@@ -644,6 +644,21 @@ describe("Dispatcher", () => {
     expect(observed[0]?.typings).toBe(1);
   });
 
+  it("typing: does not require channel streamBlock support", async () => {
+    const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid" });
+    const channel = new FakeChannel({ withStream: false });
+    const { dispatcher } = await scaffold({ channel, runtimeFactory: () => runtime });
+
+    await dispatcher.handle(
+      makeEnvelope({ trace: { id: "trace_t", streamable: true } }),
+    );
+    await new Promise((r) => setTimeout(r, 5));
+
+    expect(channel.typings.length).toBe(1);
+    expect(channel.streams.length).toBe(0);
+    expect(channel.sends.length).toBe(1);
+  });
+
   it("typing: not fired when streamable is false", async () => {
     const channel = new FakeChannel();
     const { dispatcher } = await scaffold({

package/src/gateway/__tests__/telegram-channel.test.ts

@@ -144,6 +144,7 @@ describe("createTelegramChannel — start()", () => {
     expect(msg.text).toBe("hello world");
     expect(msg.accountId).toBe("ag_self");
     expect(msg.channel).toBe("gw_tg_a");
+    expect(msg.trace).toEqual({ id: "telegram:42:7", streamable: true });
   });
 
   it("uses telegram:group:<id> for non-private chats", async () => {
@@ -319,6 +320,55 @@ describe("createTelegramChannel — start()", () => {
     expect(calls).toHaveLength(1);
     expect((calls[0]!.body as Record<string, unknown>).offset).toBe(999);
   });
+
+  it("aborts an in-flight getUpdates request when stopped", async () => {
+    const calls: FetchCall[] = [];
+    let requestSignal: AbortSignal | undefined;
+    let fetchStarted!: () => void;
+    const fetchStartedPromise = new Promise<void>((resolve) => {
+      fetchStarted = resolve;
+    });
+    const fetchImpl = (async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = typeof input === "string" ? input : input.toString();
+      const body = init?.body ? JSON.parse(init.body as string) : undefined;
+      calls.push({ url, body });
+      requestSignal = init?.signal ?? undefined;
+      fetchStarted();
+      return await new Promise<Response>((_resolve, reject) => {
+        requestSignal?.addEventListener(
+          "abort",
+          () => {
+            const err = new Error("aborted");
+            err.name = "AbortError";
+            reject(err);
+          },
+          { once: true },
+        );
+      });
+    }) as typeof fetch;
+
+    const channel = createTelegramChannel({
+      id: "gw_tg_stop",
+      accountId: "ag_self",
+      botToken: "tok",
+      allowedChatIds: ["42"],
+      allowedSenderIds: ["42"],
+      stateFile: path.join(tmp, "state.json"),
+      stateDebounceMs: 0,
+      fetchImpl,
+    });
+    const abort = new AbortController();
+    const { ctx } = makeStartCtx({ abort });
+    const startPromise = channel.start(ctx);
+
+    await fetchStartedPromise;
+    expect(requestSignal?.aborted).toBe(false);
+    await channel.stop!({ reason: "remove_gateway" });
+    await startPromise;
+
+    expect(requestSignal?.aborted).toBe(true);
+    expect(calls[0]!.url).toContain("/getUpdates");
+  });
 });
 
 describe("createTelegramChannel — send()", () => {

package/src/gateway/channels/telegram.ts

@@ -152,16 +152,18 @@ export function createTelegramChannel(opts: TelegramChannelOptions): ChannelAdap
     method: string,
     params: Record<string, unknown>,
     timeoutMs: number,
+    abortSignal?: AbortSignal,
   ): Promise<TelegramApiResult<T>> {
     if (!botToken) throw new Error("telegram bot token not loaded");
     const url = `${baseUrl}/bot${botToken}/${method}`;
+    const signalLease = createTimeoutSignal(timeoutMs, abortSignal);
     let resp: Response;
     try {
       resp = await fetchImpl(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(params),
-        signal: AbortSignal.timeout(timeoutMs),
+        signal: signalLease.signal,
       });
     } catch (err) {
       // C3: fetch errors often stringify the URL (which embeds the token).
@@ -171,6 +173,8 @@ export function createTelegramChannel(opts: TelegramChannelOptions): ChannelAdap
       const next = new Error(redacted);
       next.name = e.name ?? "Error";
       throw next;
+    } finally {
+      signalLease.cleanup();
     }
     const json = (await resp.json()) as TelegramApiResult<T>;
     return json;
@@ -237,7 +241,7 @@ export function createTelegramChannel(opts: TelegramChannelOptions): ChannelAdap
       replyTo: null,
       mentioned: false,
       receivedAt: Date.now(),
-      trace: { id: messageId, streamable: false },
+      trace: { id: messageId, streamable: true },
     };
   }
 
@@ -280,13 +284,13 @@ export function createTelegramChannel(opts: TelegramChannelOptions): ChannelAdap
     log.info("telegram poll loop starting", { gatewayId: opts.id, offset });
 
     let stopped = false;
+    const stopController = new AbortController();
     const onAbort = () => {
       stopped = true;
+      stopController.abort();
     };
     abortSignal.addEventListener("abort", onAbort, { once: true });
-    stopCallback = () => {
-      stopped = true;
-    };
+    stopCallback = onAbort;
 
     while (!stopped && !abortSignal.aborted) {
       try {
@@ -298,6 +302,7 @@ export function createTelegramChannel(opts: TelegramChannelOptions): ChannelAdap
             allowed_updates: ["message"],
           },
           (POLL_TIMEOUT_S + 15) * 1000,
+          stopController.signal,
         );
         markStatus({ lastPollAt: Date.now() });
         if (!resp.ok) {
@@ -467,3 +472,41 @@ function sleep(ms: number, signal?: AbortSignal): Promise<void> {
   });
 }
 
+function createTimeoutSignal(
+  timeoutMs: number,
+  parent?: AbortSignal,
+): { signal: AbortSignal; cleanup: () => void } {
+  const controller = new AbortController();
+  let settled = false;
+
+  const abort = (reason?: unknown) => {
+    if (settled) return;
+    settled = true;
+    try {
+      controller.abort(reason);
+    } catch {
+      controller.abort();
+    }
+  };
+
+  const timer = setTimeout(() => {
+    abort(new DOMException("Timeout", "TimeoutError"));
+  }, timeoutMs);
+
+  const onParentAbort = () => abort(parent?.reason);
+  if (parent) {
+    if (parent.aborted) {
+      onParentAbort();
+    } else {
+      parent.addEventListener("abort", onParentAbort, { once: true });
+    }
+  }
+
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timer);
+      if (parent) parent.removeEventListener("abort", onParentAbort);
+    },
+  };
+}

package/src/gateway/dispatcher.ts

@@ -803,6 +803,8 @@ export class Dispatcher {
 
     const streamable = msg.trace?.streamable === true;
     const traceId = msg.trace?.id;
+    const canType =
+      streamable && typeof traceId === "string" && typeof channel.typing === "function";
     const canStream =
       streamable && typeof traceId === "string" && typeof channel.streamBlock === "function";
     const recordBlock = (block: StreamBlock): void => {
@@ -886,7 +888,7 @@ export class Dispatcher {
     };
 
     const fireTypingIfNeeded = (): void => {
-      if (!canStream || typingFired || typeof channel.typing !== "function") return;
+      if (!canType || typingFired) return;
       typingFired = true;
       const key = `${msg.accountId}:${msg.conversation.id}`;
       const now = Date.now();