@botcord/daemon 0.2.90 → 0.2.92

package/src/__tests__/gateway-control.test.ts

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import path from "node:path";
 
 import type { DaemonConfig } from "../config.js";
+import { saveGatewaySecret } from "../gateway/channels/secret-store.js";
 import { LoginSessionStore } from "../gateway/channels/login-session.js";
 import { createGatewayControl } from "../gateway-control.js";
 
@@ -324,6 +325,129 @@ describe("gateway_login_start / status", () => {
     const secretPath = trackSecret(gwId);
     const secret = JSON.parse(readFileSync(secretPath, "utf8")) as { appSecret?: string };
     expect(secret.appSecret).toBe("feishu-secret-1234567890");
+
+    const updateAck = await ctrl.handleUpsert({
+      id: gwId,
+      type: "feishu",
+      accountId: "ag_alice",
+      enabled: true,
+      settings: {
+        allowedSenderIds: ["ou_bob"],
+        allowedChatIds: ["oc_team"],
+        domain: "feishu",
+      },
+    });
+    expect(updateAck.ok).toBe(true);
+    expect(state.cfg.thirdPartyGateways?.[0]).toMatchObject({
+      id: gwId,
+      type: "feishu",
+      appId: "cli_feishu_123",
+      allowedSenderIds: ["ou_bob"],
+      allowedChatIds: ["oc_team"],
+    });
+    expect(gw.addChannel).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        id: gwId,
+        type: "feishu",
+        appId: "cli_feishu_123",
+        allowedChatIds: ["oc_team"],
+      }),
+    );
+  });
+
+  it("rejects changing Feishu domain without a fresh loginId", async () => {
+    const gw = makeFakeGateway();
+    const { io } = makeConfigIO(baseCfg());
+    const sessions = new LoginSessionStore();
+    const ctrl = createGatewayControl({
+      gateway: gw as any,
+      configIO: io,
+      loginSessions: sessions,
+    });
+    const gwId = uniqId("fs-domain");
+    trackSecret(gwId);
+
+    sessions.create({
+      loginId: "fsl_domain_seed",
+      accountId: "ag_alice",
+      provider: "feishu",
+      appId: "cli_domain_seed",
+      appSecret: "feishu-domain-secret-seed",
+      domain: "feishu",
+      userOpenId: "ou_domain_seed",
+    });
+    const installAck = await ctrl.handleUpsert({
+      id: gwId,
+      type: "feishu",
+      accountId: "ag_alice",
+      enabled: true,
+      loginId: "fsl_domain_seed",
+      settings: { domain: "feishu" },
+    });
+    expect(installAck.ok).toBe(true);
+
+    const updateAck = await ctrl.handleUpsert({
+      id: gwId,
+      type: "feishu",
+      accountId: "ag_alice",
+      enabled: true,
+      settings: { domain: "lark" },
+    });
+    expect(updateAck.ok).toBe(false);
+    expect(updateAck.error?.code).toBe("bad_params");
+    expect(updateAck.error?.message).toContain("domain change requires a fresh loginId");
+  });
+
+  it("rejects changing Feishu domain without loginId when saved profile omits domain (implicit feishu)", async () => {
+    const gw = makeFakeGateway();
+    const { state, io } = makeConfigIO(baseCfg());
+    const sessions = new LoginSessionStore();
+    const ctrl = createGatewayControl({
+      gateway: gw as any,
+      configIO: io,
+      loginSessions: sessions,
+    });
+    const gwId = uniqId("fs-domain-implicit");
+    trackSecret(gwId);
+
+    sessions.create({
+      loginId: "fsl_domain_implicit_seed",
+      accountId: "ag_alice",
+      provider: "feishu",
+      appId: "cli_domain_implicit_seed",
+      appSecret: "feishu-domain-implicit-secret-seed",
+      domain: "feishu",
+      userOpenId: "ou_domain_implicit_seed",
+    });
+    const installAck = await ctrl.handleUpsert({
+      id: gwId,
+      type: "feishu",
+      accountId: "ag_alice",
+      enabled: true,
+      loginId: "fsl_domain_implicit_seed",
+      settings: { domain: "feishu" },
+    });
+    expect(installAck.ok).toBe(true);
+
+    // Simulate legacy/missing persisted domain. The daemon should treat this
+    // as implicit "feishu" when validating no-login domain changes.
+    const saved = state.cfg.thirdPartyGateways?.find((g) => g.id === gwId);
+    expect(saved).toBeDefined();
+    if (saved) {
+      delete saved.domain;
+      io.save(state.cfg);
+    }
+
+    const updateAck = await ctrl.handleUpsert({
+      id: gwId,
+      type: "feishu",
+      accountId: "ag_alice",
+      enabled: true,
+      settings: { domain: "lark" },
+    });
+    expect(updateAck.ok).toBe(false);
+    expect(updateAck.error?.code).toBe("bad_params");
+    expect(updateAck.error?.message).toContain("domain change requires a fresh loginId");
   });
 
   it("discovers recent WeChat senders from a confirmed login session", async () => {
@@ -584,6 +708,170 @@ describe("W6: UPDATE rollback on addChannel failure", () => {
       expect(onDisk.botToken).toBe("old-token:123456789012345");
     }
   });
+
+  it("restores previous Feishu secret/config and re-adds old channel when update addChannel fails", async () => {
+    const gw = makeFakeGateway();
+    const { state, io } = makeConfigIO({ ...baseCfg(), agents: ["ag_alice", "ag_bob"] });
+    const sessions = new LoginSessionStore();
+    const ctrl = createGatewayControl({
+      gateway: gw as any,
+      configIO: io,
+      loginSessions: sessions,
+    });
+    const gwId = uniqId("w6fs");
+    trackSecret(gwId);
+
+    sessions.create({
+      loginId: "fsl_w6_old",
+      accountId: "ag_alice",
+      provider: "feishu",
+      appId: "cli_old",
+      appSecret: "old-feishu-secret-12345",
+      userOpenId: "ou_old",
+      domain: "feishu",
+    });
+    const firstAck = await ctrl.handleUpsert({
+      id: gwId,
+      type: "feishu",
+      accountId: "ag_alice",
+      enabled: true,
+      loginId: "fsl_w6_old",
+      settings: { allowedChatIds: ["oc_old"], domain: "feishu" },
+    });
+    expect(firstAck.ok).toBe(true);
+
+    sessions.create({
+      loginId: "fsl_w6_new",
+      accountId: "ag_bob",
+      provider: "feishu",
+      appId: "cli_new",
+      appSecret: "new-feishu-secret-ABCDE",
+      userOpenId: "ou_new",
+      domain: "lark",
+    });
+
+    let addCallCount = 0;
+    gw.addChannel = vi.fn(async (cfg: { id: string; accountId: string }) => {
+      addCallCount += 1;
+      if (addCallCount === 1) throw new Error("simulated feishu update failure");
+      gw.channels.set(cfg.id, {
+        id: cfg.id,
+        status: { channel: cfg.id, accountId: cfg.accountId, running: true, connected: true, authorized: true, lastPollAt: Date.now() },
+      });
+    });
+
+    const updateAck = await ctrl.handleUpsert({
+      id: gwId,
+      type: "feishu",
+      accountId: "ag_bob",
+      enabled: true,
+      loginId: "fsl_w6_new",
+      settings: { allowedChatIds: ["oc_new"], domain: "lark" },
+    });
+    expect(updateAck.ok).toBe(false);
+    expect(updateAck.error?.code).toBe("addChannel_failed");
+    expect(addCallCount).toBe(2);
+
+    const profile = state.cfg.thirdPartyGateways?.find((g) => g.id === gwId);
+    expect(profile).toMatchObject({
+      id: gwId,
+      type: "feishu",
+      appId: "cli_old",
+      domain: "feishu",
+      userOpenId: "ou_old",
+      allowedChatIds: ["oc_old"],
+    });
+
+    const secretPath = trackSecret(gwId);
+    const onDisk = JSON.parse(readFileSync(secretPath, "utf8")) as { appSecret?: string };
+    expect(onDisk.appSecret).toBe("old-feishu-secret-12345");
+    expect(gw.addChannel).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        id: gwId,
+        type: "feishu",
+        accountId: "ag_alice",
+        appId: "cli_old",
+        domain: "feishu",
+        allowedChatIds: ["oc_old"],
+      }),
+    );
+  });
+
+  it("replaces previous Feishu profile on rollback so failed update fields are removed", async () => {
+    const gw = makeFakeGateway();
+    const gwId = uniqId("w6fs-replace");
+    trackSecret(gwId);
+    saveGatewaySecret(gwId, { appSecret: "old-feishu-secret-replace" });
+    const { state, io } = makeConfigIO({
+      ...baseCfg(),
+      agents: ["ag_alice", "ag_bob"],
+      thirdPartyGateways: [
+        {
+          id: gwId,
+          type: "feishu",
+          accountId: "ag_alice",
+          enabled: true,
+          appId: "cli_old_replace",
+        },
+      ],
+    });
+    const sessions = new LoginSessionStore();
+    const ctrl = createGatewayControl({
+      gateway: gw as any,
+      configIO: io,
+      loginSessions: sessions,
+    });
+
+    sessions.create({
+      loginId: "fsl_w6_replace_new",
+      accountId: "ag_bob",
+      provider: "feishu",
+      appId: "cli_new_replace",
+      appSecret: "new-feishu-secret-replace",
+      userOpenId: "ou_new_replace",
+      domain: "lark",
+    });
+
+    let addCallCount = 0;
+    gw.addChannel = vi.fn(async (cfg: { id: string; accountId: string }) => {
+      addCallCount += 1;
+      if (addCallCount === 1) throw new Error("simulated feishu update failure");
+      gw.channels.set(cfg.id, {
+        id: cfg.id,
+        status: { channel: cfg.id, accountId: cfg.accountId, running: true, connected: true, authorized: true, lastPollAt: Date.now() },
+      });
+    });
+
+    const updateAck = await ctrl.handleUpsert({
+      id: gwId,
+      type: "feishu",
+      accountId: "ag_bob",
+      enabled: true,
+      loginId: "fsl_w6_replace_new",
+      settings: {
+        allowedSenderIds: ["ou_new_replace"],
+        allowedChatIds: ["oc_new_replace"],
+        splitAt: 2000,
+        domain: "lark",
+      },
+    });
+
+    expect(updateAck.ok).toBe(false);
+    expect(updateAck.error?.code).toBe("addChannel_failed");
+    expect(addCallCount).toBe(2);
+    expect(state.cfg.thirdPartyGateways).toEqual([
+      {
+        id: gwId,
+        type: "feishu",
+        accountId: "ag_alice",
+        enabled: true,
+        appId: "cli_old_replace",
+      },
+    ]);
+
+    const onDisk = JSON.parse(readFileSync(trackSecret(gwId), "utf8")) as { appSecret?: string };
+    expect(onDisk.appSecret).toBe("old-feishu-secret-replace");
+  });
 });
 
 describe("list_gateways", () => {
@@ -686,6 +974,90 @@ describe("gateway_send", () => {
     expect(ack.error?.code).toBe("conversation_not_allowed");
     expect(gw.sendOutbound).not.toHaveBeenCalled();
   });
+
+  it("allows Feishu outbound when allowedChatIds is empty", async () => {
+    const gw = makeFakeGateway();
+    const gwId = uniqId("send-fs-allow-all");
+    const { io } = makeConfigIO({
+      ...baseCfg(),
+      thirdPartyGateways: [
+        {
+          id: gwId,
+          type: "feishu",
+          accountId: "ag_alice",
+          enabled: true,
+          allowedChatIds: [],
+        },
+      ],
+    });
+    const ctrl = createGatewayControl({ gateway: gw as any, configIO: io });
+
+    const ack = await ctrl.handleSend({
+      agentId: "ag_alice",
+      gatewayId: gwId,
+      conversationId: "feishu:chat:oc_any",
+      text: "hello",
+    });
+
+    expect(ack.ok).toBe(true);
+    expect(gw.sendOutbound).toHaveBeenCalledOnce();
+  });
+
+  it("allows Feishu outbound when allowedChatIds is omitted", async () => {
+    const gw = makeFakeGateway();
+    const gwId = uniqId("send-fs-allow-omitted");
+    const { io } = makeConfigIO({
+      ...baseCfg(),
+      thirdPartyGateways: [
+        {
+          id: gwId,
+          type: "feishu",
+          accountId: "ag_alice",
+          enabled: true,
+        },
+      ],
+    });
+    const ctrl = createGatewayControl({ gateway: gw as any, configIO: io });
+
+    const ack = await ctrl.handleSend({
+      agentId: "ag_alice",
+      gatewayId: gwId,
+      conversationId: "feishu:chat:oc_any",
+      text: "hello",
+    });
+
+    expect(ack.ok).toBe(true);
+    expect(gw.sendOutbound).toHaveBeenCalledOnce();
+  });
+
+  it("denies Telegram outbound when allowedChatIds is empty", async () => {
+    const gw = makeFakeGateway();
+    const gwId = uniqId("send-tg-deny-empty");
+    const { io } = makeConfigIO({
+      ...baseCfg(),
+      thirdPartyGateways: [
+        {
+          id: gwId,
+          type: "telegram",
+          accountId: "ag_alice",
+          enabled: true,
+          allowedChatIds: [],
+        },
+      ],
+    });
+    const ctrl = createGatewayControl({ gateway: gw as any, configIO: io });
+
+    const ack = await ctrl.handleSend({
+      agentId: "ag_alice",
+      gatewayId: gwId,
+      conversationId: "telegram:group:-100123",
+      text: "hello",
+    });
+
+    expect(ack.ok).toBe(false);
+    expect(ack.error?.code).toBe("conversation_not_allowed");
+    expect(gw.sendOutbound).not.toHaveBeenCalled();
+  });
 });
 
 describe("W4: handleLoginStatus accountId ownership check", () => {

package/src/__tests__/provision.test.ts

@@ -336,6 +336,29 @@ describe("wake_agent handler", () => {
     });
   });
 
+  it("acks wake_agent after queueing instead of waiting for the turn to finish", async () => {
+    const gw = makeFakeGateway(["ag_wake"]);
+    gw.injectInbound.mockImplementation(() => new Promise(() => undefined));
+    const handler = createProvisioner({ gateway: gw as any });
+
+    const res = await Promise.race([
+      handler({
+        id: "req_wake_pending",
+        type: "wake_agent",
+        params: {
+          agent_id: "ag_wake",
+          message: "tick",
+          run_id: "sr_pending",
+        },
+      }),
+      new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 20)),
+    ]);
+
+    expect(res).not.toBe("timeout");
+    expect(res).toMatchObject({ ok: true, result: { agent_id: "ag_wake", queued: true } });
+    expect(gw.injectInbound).toHaveBeenCalledTimes(1);
+  });
+
   it("rejects wake_agent for an unloaded agent", async () => {
     const gw = makeFakeGateway(["ag_loaded"]);
     const handler = createProvisioner({ gateway: gw as any });

package/src/__tests__/self-restart.test.ts

@@ -0,0 +1,57 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { findDaemonInstallPrefix } from "../self-restart.js";
+
+describe("self restart install prefix detection", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(path.join(os.tmpdir(), "botcord-self-restart-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("finds the npm install prefix for a managed @botcord/daemon entrypoint", () => {
+    const prefix = path.join(tmpDir, ".botcord", "daemon");
+    const packageRoot = path.join(prefix, "node_modules", "@botcord", "daemon");
+    const entrypoint = path.join(packageRoot, "dist", "index.js");
+    mkdirSync(path.dirname(entrypoint), { recursive: true });
+    writeFileSync(path.join(packageRoot, "package.json"), '{"name":"@botcord/daemon"}');
+    writeFileSync(entrypoint, "");
+
+    expect(findDaemonInstallPrefix(entrypoint)).toBe(prefix);
+  });
+
+  it("resolves npm .bin symlinks before looking for the package root", () => {
+    const prefix = path.join(tmpDir, ".botcord", "daemon");
+    const packageRoot = path.join(prefix, "node_modules", "@botcord", "daemon");
+    const entrypoint = path.join(packageRoot, "dist", "index.js");
+    const bin = path.join(prefix, "node_modules", ".bin", "botcord-daemon");
+    mkdirSync(path.dirname(entrypoint), { recursive: true });
+    mkdirSync(path.dirname(bin), { recursive: true });
+    writeFileSync(path.join(packageRoot, "package.json"), '{"name":"@botcord/daemon"}');
+    writeFileSync(entrypoint, "");
+    symlinkSync(entrypoint, bin);
+
+    expect(findDaemonInstallPrefix(bin)).toBe(realpathSync(prefix));
+  });
+
+  it("does not treat a monorepo development entrypoint as self-updatable", () => {
+    const entrypoint = path.join(tmpDir, "packages", "daemon", "dist", "index.js");
+    mkdirSync(path.dirname(entrypoint), { recursive: true });
+    writeFileSync(entrypoint, "");
+
+    expect(findDaemonInstallPrefix(entrypoint)).toBeNull();
+  });
+});

package/src/__tests__/skill-index.test.ts

@@ -149,6 +149,47 @@ describe("skill snapshots", () => {
     });
   });
 
+  it("scans Gemini workspace and user skill roots without mixing Claude or Codex dirs", () => {
+    const agentId = "ag_gemini_skills";
+    const workspaceGemini = path.join(agentWorkspaceDir(agentId), ".gemini", "skills");
+    const workspaceAgents = path.join(agentWorkspaceDir(agentId), ".agents", "skills");
+    writeSkill(workspaceGemini, "workspace-gemini", "Workspace Gemini skill");
+    writeSkill(workspaceAgents, "workspace-agent", "Workspace shared-agent skill");
+    writeSkill(path.join(tmpDir, ".gemini", "skills"), "global-gemini", "Global Gemini skill");
+    writeSkill(path.join(tmpDir, ".agents", "skills"), "global-agent", "Global shared-agent skill");
+    writeSkill(path.join(agentWorkspaceDir(agentId), ".claude", "skills"), "claude-only", "Claude only");
+    writeSkill(path.join(agentCodexHomeDir(agentId), "skills"), "codex-only", "Codex only");
+
+    const geminiScanned = scanSoftSkills(agentId, { runtime: "gemini" });
+    expect(geminiScanned.map((s) => s.name)).toEqual([
+      "global-agent",
+      "global-gemini",
+      "workspace-agent",
+      "workspace-gemini",
+    ]);
+    expect(geminiScanned.every((s) => s.runtime === "gemini")).toBe(true);
+
+    const snapshot = collectAgentSkillSnapshot(agentId, { runtime: "gemini" });
+    expect(snapshot.runtime).toBe("gemini");
+    expect(snapshot.skills.find((s) => s.name === "workspace-gemini"))
+      .toMatchObject({
+        source: "workspace",
+        sourceDetail: "agent-gemini",
+        runtime: "gemini",
+        path: path.join(workspaceGemini, "workspace-gemini", "SKILL.md"),
+      });
+    expect(snapshot.skills.find((s) => s.name === "workspace-agent"))
+      .toMatchObject({
+        source: "workspace",
+        sourceDetail: "agent-agents",
+      });
+    expect(snapshot.skills.find((s) => s.name === "global-agent"))
+      .toMatchObject({
+        source: "runtime-global",
+        sourceDetail: "global-agents",
+      });
+  });
+
   it("keeps same-device workspace skills scoped by agent id", () => {
     writeSkill(
       path.join(agentWorkspaceDir("ag_workspace_a"), ".claude", "skills"),

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

@@ -1347,6 +1347,44 @@ describe("createBotCordChannel — typing()", () => {
       globalThis.fetch = realFetch;
     }
   });
+
+  it("refreshes the token and retries once on 401 (stale-token recovery)", async () => {
+    const fetchSpy = vi
+      .fn()
+      .mockResolvedValueOnce(new Response('{"code":"invalid_token"}', { status: 401 }))
+      .mockResolvedValueOnce(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.typing!({
+        traceId: "trace_401",
+        accountId: "ag_self",
+        conversationId: "rm_oc_42",
+        log: silentLog,
+      });
+      expect(client.refreshToken).toHaveBeenCalledTimes(1);
+      expect(fetchSpy).toHaveBeenCalledTimes(2);
+      // First attempt uses the stale token; the retry uses the refreshed one.
+      expect((fetchSpy.mock.calls[0][1].headers as Record<string, string>).Authorization).toBe(
+        "Bearer test-token",
+      );
+      expect((fetchSpy.mock.calls[1][1].headers as Record<string, string>).Authorization).toBe(
+        "Bearer test-token-2",
+      );
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
 });
 
 describe("createBotCordChannel — websocket logging", () => {

package/src/gateway/channels/botcord.ts

@@ -308,6 +308,41 @@ function normalizeInboxBatch(
   };
 }
 
+/**
+ * Fire-and-forget authenticated POST for presence/streaming control requests
+ * (`/hub/typing`, `/hub/stream-block`). Mirrors `BotCordClient.hubFetch`'s 401
+ * handling: a stale-but-unexpired token (e.g. after a Hub JWT secret rotation,
+ * which `ensureToken()` won't refresh because it only refreshes near expiry) is
+ * refreshed once and the request retried. Without this, typing/stream-block
+ * silently 401 in a loop until the next actual message send happens to refresh
+ * the token — leaving the conversation with no typing indicator or live stream.
+ */
+async function postControlWithRefresh(
+  client: BotCordChannelClient,
+  hubUrl: string,
+  path: string,
+  body: unknown,
+): Promise<Response> {
+  let token = await client.ensureToken();
+  for (let attempt = 0; attempt <= 1; attempt++) {
+    const resp = await fetch(`${hubUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (resp.status === 401 && attempt === 0) {
+      token = await client.refreshToken();
+      continue;
+    }
+    return resp;
+  }
+  throw new Error("postControlWithRefresh: exhausted retries");
+}
+
 /**
  * Construct a BotCord channel adapter.
  *
@@ -895,21 +930,12 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
       const client = ensureClient();
       const hubUrl = options.hubBaseUrl ?? client.getHubUrl();
       try {
-        const token = await client.ensureToken();
         const block = ctx.block as { raw?: unknown; kind?: string; seq?: number } | undefined;
         const seq = typeof block?.seq === "number" ? block.seq : 0;
-        const resp = await fetch(`${hubUrl}/hub/stream-block`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`,
-          },
-          body: JSON.stringify({
-            trace_id: ctx.traceId,
-            seq,
-            block: normalizeBlockForHub(block, seq),
-          }),
-          signal: AbortSignal.timeout(10_000),
+        const resp = await postControlWithRefresh(client, hubUrl, "/hub/stream-block", {
+          trace_id: ctx.traceId,
+          seq,
+          block: normalizeBlockForHub(block, seq),
         });
         if (!resp.ok && resp.status !== 204) {
           const body = await resp.text().catch(() => "");
@@ -927,15 +953,8 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
       const client = ensureClient();
       const hubUrl = options.hubBaseUrl ?? client.getHubUrl();
       try {
-        const token = await client.ensureToken();
-        const resp = await fetch(`${hubUrl}/hub/typing`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`,
-          },
-          body: JSON.stringify({ room_id: ctx.conversationId }),
-          signal: AbortSignal.timeout(10_000),
+        const resp = await postControlWithRefresh(client, hubUrl, "/hub/typing", {
+          room_id: ctx.conversationId,
         });
         if (!resp.ok && resp.status !== 204) {
           const body = await resp.text().catch(() => "");