@botcord/daemon 0.2.38 → 0.2.41

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/dist/gateway-control.d.ts

@@ -8,13 +8,49 @@
  * gateway, login-session store, fetch impl, and config I/O — `provision.ts`
  * wires the production defaults.
  */
-import type { ControlAck, GatewayLoginStartParams, GatewayLoginStatusParams, RemoveGatewayParams, TestGatewayParams, UpsertGatewayParams } from "@botcord/protocol-core";
+import type { ControlAck } from "@botcord/protocol-core";
 import type { Gateway } from "./gateway/index.js";
 import { type DaemonConfig } from "./config.js";
 import { LoginSessionStore } from "./gateway/channels/login-session.js";
 import { getBotQrcode, getQrcodeStatus } from "./gateway/channels/wechat-login.js";
 import type { FetchLike } from "./gateway/channels/http-types.js";
 type AckBody = Omit<ControlAck, "id">;
+type GatewayProvider = "telegram" | "wechat";
+interface UpsertGatewayParams {
+    id: string;
+    type: GatewayProvider;
+    accountId: string;
+    label?: string;
+    enabled?: boolean;
+    loginId?: string;
+    secret?: {
+        botToken?: string;
+    };
+    settings?: {
+        baseUrl?: string;
+        allowedSenderIds?: string[];
+        allowedChatIds?: string[];
+        splitAt?: number;
+    };
+}
+interface RemoveGatewayParams {
+    id: string;
+    deleteSecret?: boolean;
+}
+interface TestGatewayParams {
+    id: string;
+}
+interface GatewayLoginStartParams {
+    provider: GatewayProvider;
+    accountId: string;
+    gatewayId?: string;
+    baseUrl?: string;
+}
+interface GatewayLoginStatusParams {
+    provider: GatewayProvider;
+    loginId: string;
+    accountId: string;
+}
 export type { FetchLike };
 export interface GatewayControlContext {
     gateway: Gateway;

package/dist/provision.js

@@ -201,9 +201,9 @@ export function createProvisioner(opts) {
                 daemonLog.debug("list_runtimes", { count: snapshot.runtimes.length });
                 return { ok: true, result: snapshot };
             }
-            case CONTROL_FRAME_TYPES.LIST_GATEWAYS:
+            case "list_gateways":
                 return gatewayControl.handleList();
-            case CONTROL_FRAME_TYPES.UPSERT_GATEWAY: {
+            case "upsert_gateway": {
                 const v = validateGatewayParams(frame.params, {
                     required: ["id", "type", "accountId"],
                 });
@@ -211,19 +211,19 @@ export function createProvisioner(opts) {
                     return v.ack;
                 return gatewayControl.handleUpsert(v.params);
             }
-            case CONTROL_FRAME_TYPES.REMOVE_GATEWAY: {
+            case "remove_gateway": {
                 const v = validateGatewayParams(frame.params, { required: ["id"] });
                 if (!v.ok)
                     return v.ack;
                 return gatewayControl.handleRemove(v.params);
             }
-            case CONTROL_FRAME_TYPES.TEST_GATEWAY: {
+            case "test_gateway": {
                 const v = validateGatewayParams(frame.params, { required: ["id"] });
                 if (!v.ok)
                     return v.ack;
                 return gatewayControl.handleTest(v.params);
             }
-            case CONTROL_FRAME_TYPES.GATEWAY_LOGIN_START: {
+            case "gateway_login_start": {
                 const v = validateGatewayParams(frame.params, {
                     required: ["provider", "accountId"],
                 });
@@ -231,7 +231,7 @@ export function createProvisioner(opts) {
                     return v.ack;
                 return gatewayControl.handleLoginStart(v.params);
             }
-            case CONTROL_FRAME_TYPES.GATEWAY_LOGIN_STATUS: {
+            case "gateway_login_status": {
                 const v = validateGatewayParams(frame.params, {
                     required: ["provider", "loginId"],
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.38",
+  "version": "0.2.41",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@botcord/cli": "^0.1.7",
-    "@botcord/protocol-core": "^0.2.2",
+    "@botcord/protocol-core": "^0.2.4",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/src/__tests__/provision.test.ts

@@ -1698,7 +1698,7 @@ describe("W8: gateway frame param validation in provision dispatch", () => {
     });
     const ack = await provisioner({
       id: "req_w8a",
-      type: CONTROL_FRAME_TYPES.UPSERT_GATEWAY,
+      type: "upsert_gateway",
       params: { id: "gw_x", type: "telegram" } as unknown as Record<string, unknown>,
     });
     expect(ack.ok).toBe(false);
@@ -1714,7 +1714,7 @@ describe("W8: gateway frame param validation in provision dispatch", () => {
     });
     const ack = await provisioner({
       id: "req_w8b",
-      type: CONTROL_FRAME_TYPES.REMOVE_GATEWAY,
+      type: "remove_gateway",
       // @ts-expect-error — exercising the runtime guard
       params: "not-an-object",
     });
@@ -1729,7 +1729,7 @@ describe("W8: gateway frame param validation in provision dispatch", () => {
     });
     const ack = await provisioner({
       id: "req_w8c",
-      type: CONTROL_FRAME_TYPES.TEST_GATEWAY,
+      type: "test_gateway",
       params: {},
     });
     expect(ack.ok).toBe(false);
@@ -1743,7 +1743,7 @@ describe("W8: gateway frame param validation in provision dispatch", () => {
     });
     const ack = await provisioner({
       id: "req_w8d",
-      type: CONTROL_FRAME_TYPES.GATEWAY_LOGIN_START,
+      type: "gateway_login_start",
       params: { accountId: "ag_a" },
     });
     expect(ack.ok).toBe(false);
@@ -1757,7 +1757,7 @@ describe("W8: gateway frame param validation in provision dispatch", () => {
     });
     const ack = await provisioner({
       id: "req_w8e",
-      type: CONTROL_FRAME_TYPES.GATEWAY_LOGIN_STATUS,
+      type: "gateway_login_status",
       params: { provider: "wechat" },
     });
     expect(ack.ok).toBe(false);

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();

package/src/gateway-control.ts

@@ -9,22 +9,7 @@
  * wires the production defaults.
  */
 
-import type {
-  ControlAck,
-  GatewayLoginStartParams,
-  GatewayLoginStartResult,
-  GatewayLoginStatusParams,
-  GatewayLoginStatusResult,
-  GatewayProfileSummary,
-  GatewayProvider,
-  ListGatewaysResult,
-  RemoveGatewayParams,
-  RemoveGatewayResult,
-  TestGatewayParams,
-  TestGatewayResult,
-  UpsertGatewayParams,
-  UpsertGatewayResult,
-} from "@botcord/protocol-core";
+import type { ControlAck } from "@botcord/protocol-core";
 import type { Gateway, GatewayChannelConfig } from "./gateway/index.js";
 import {
   loadConfig,
@@ -56,6 +41,108 @@ import type { FetchLike } from "./gateway/channels/http-types.js";
 
 type AckBody = Omit<ControlAck, "id">;
 
+type GatewayProvider = "telegram" | "wechat";
+
+interface GatewayProfileSummary {
+  id: string;
+  type: GatewayProvider;
+  accountId: string;
+  label?: string;
+  enabled: boolean;
+  baseUrl?: string;
+  allowedSenderIds?: string[];
+  allowedChatIds?: string[];
+  splitAt?: number;
+  status?: {
+    running: boolean;
+    connected?: boolean;
+    authorized?: boolean;
+    lastPollAt?: number;
+    lastInboundAt?: number;
+    lastSendAt?: number;
+    lastError?: string | null;
+  };
+}
+
+interface ListGatewaysResult {
+  gateways: GatewayProfileSummary[];
+}
+
+interface UpsertGatewayParams {
+  id: string;
+  type: GatewayProvider;
+  accountId: string;
+  label?: string;
+  enabled?: boolean;
+  loginId?: string;
+  secret?: {
+    botToken?: string;
+  };
+  settings?: {
+    baseUrl?: string;
+    allowedSenderIds?: string[];
+    allowedChatIds?: string[];
+    splitAt?: number;
+  };
+}
+
+interface UpsertGatewayResult {
+  id: string;
+  type: GatewayProvider;
+  accountId: string;
+  enabled: boolean;
+  tokenPreview?: string;
+  status?: GatewayProfileSummary["status"];
+}
+
+interface RemoveGatewayParams {
+  id: string;
+  deleteSecret?: boolean;
+}
+
+interface RemoveGatewayResult {
+  id: string;
+  removed: boolean;
+  secretDeleted: boolean;
+}
+
+interface TestGatewayParams {
+  id: string;
+}
+
+interface TestGatewayResult {
+  id: string;
+  ok: boolean;
+  info?: Record<string, unknown>;
+  error?: string;
+}
+
+interface GatewayLoginStartParams {
+  provider: GatewayProvider;
+  accountId: string;
+  gatewayId?: string;
+  baseUrl?: string;
+}
+
+interface GatewayLoginStartResult {
+  loginId: string;
+  qrcode?: string;
+  qrcodeUrl?: string;
+  expiresAt: number;
+}
+
+interface GatewayLoginStatusParams {
+  provider: GatewayProvider;
+  loginId: string;
+  accountId: string;
+}
+
+interface GatewayLoginStatusResult {
+  status: "pending" | "scanned" | "confirmed" | "expired" | "failed";
+  baseUrl?: string;
+  tokenPreview?: string;
+}
+
 export type { FetchLike };
 
 export interface GatewayControlContext {

package/src/provision.ts

@@ -322,10 +322,10 @@ export function createProvisioner(opts: ProvisionerOptions): (
         return { ok: true, result: snapshot };
       }
 
-      case CONTROL_FRAME_TYPES.LIST_GATEWAYS:
+      case "list_gateways":
         return gatewayControl.handleList();
 
-      case CONTROL_FRAME_TYPES.UPSERT_GATEWAY: {
+      case "upsert_gateway": {
         const v = validateGatewayParams(frame.params, {
           required: ["id", "type", "accountId"],
         });
@@ -335,7 +335,7 @@ export function createProvisioner(opts: ProvisionerOptions): (
         );
       }
 
-      case CONTROL_FRAME_TYPES.REMOVE_GATEWAY: {
+      case "remove_gateway": {
         const v = validateGatewayParams(frame.params, { required: ["id"] });
         if (!v.ok) return v.ack;
         return gatewayControl.handleRemove(
@@ -343,7 +343,7 @@ export function createProvisioner(opts: ProvisionerOptions): (
         );
       }
 
-      case CONTROL_FRAME_TYPES.TEST_GATEWAY: {
+      case "test_gateway": {
         const v = validateGatewayParams(frame.params, { required: ["id"] });
         if (!v.ok) return v.ack;
         return gatewayControl.handleTest(
@@ -351,7 +351,7 @@ export function createProvisioner(opts: ProvisionerOptions): (
         );
       }
 
-      case CONTROL_FRAME_TYPES.GATEWAY_LOGIN_START: {
+      case "gateway_login_start": {
         const v = validateGatewayParams(frame.params, {
           required: ["provider", "accountId"],
         });
@@ -361,7 +361,7 @@ export function createProvisioner(opts: ProvisionerOptions): (
         );
       }
 
-      case CONTROL_FRAME_TYPES.GATEWAY_LOGIN_STATUS: {
+      case "gateway_login_status": {
         const v = validateGatewayParams(frame.params, {
           required: ["provider", "loginId"],
         });