@botcord/daemon 0.2.70 → 0.2.71

package/dist/gateway/channels/feishu.js

@@ -8,6 +8,8 @@ import { splitText } from "./text-split.js";
 const FEISHU_PROVIDER = "feishu";
 const DEFAULT_SPLIT_AT = 4000;
 const MAX_SEEN_MESSAGES = 2048;
+const TYPING_EMOJI = "Typing";
+const TYPING_REACTION_TTL_MS = 20_000;
 function sdkDomain(domain) {
     const sdk = Lark;
     return domain === "lark" ? sdk.Domain?.Lark : sdk.Domain?.Feishu;
@@ -63,6 +65,7 @@ export function createFeishuChannel(opts) {
     let botOpenId;
     let botName;
     let liveSetStatus = null;
+    const activeTypingReactions = new Map();
     let statusSnapshot = {
         channel: opts.id,
         accountId: opts.accountId,
@@ -292,6 +295,45 @@ export function createFeishuChannel(opts) {
         return ((typeof res.data?.message_id === "string" ? res.data.message_id : undefined) ??
             (typeof res.message_id === "string" ? res.message_id : undefined));
     }
+    function resultReactionId(res) {
+        return ((typeof res.data?.reaction_id === "string" ? res.data.reaction_id : undefined) ??
+            (typeof res.reaction_id === "string" ? res.reaction_id : undefined) ??
+            null);
+    }
+    function messageIdFromTrace(traceId) {
+        if (!traceId.startsWith("feishu:"))
+            return null;
+        const messageId = traceId.slice("feishu:".length).trim();
+        return messageId.length > 0 ? messageId : null;
+    }
+    async function removeTypingReaction(messageId) {
+        const state = activeTypingReactions.get(messageId);
+        if (!state)
+            return;
+        activeTypingReactions.delete(messageId);
+        if (state.timer)
+            clearTimeout(state.timer);
+        if (!state.reactionId)
+            return;
+        try {
+            await callFeishu({
+                method: "DELETE",
+                url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(state.reactionId)}`,
+            });
+        }
+        catch (err) {
+            statusSnapshot.lastError = err instanceof Error ? err.message : String(err);
+        }
+    }
+    function scheduleTypingCleanup(messageId, state) {
+        if (state.timer)
+            clearTimeout(state.timer);
+        state.timer = setTimeout(() => {
+            void removeTypingReaction(messageId);
+        }, TYPING_REACTION_TTL_MS);
+        if (typeof state.timer.unref === "function")
+            state.timer.unref();
+    }
     function resultResourceKey(res, key) {
         const direct = res[key];
         if (typeof direct === "string")
@@ -422,14 +464,61 @@ export function createFeishuChannel(opts) {
                 replyInThread: Boolean(ctx.message.threadId),
             }) ?? providerMessageId;
         }
+        if (ctx.message.replyTo) {
+            void removeTypingReaction(ctx.message.replyTo);
+        }
+        if (ctx.message.threadId && ctx.message.threadId !== ctx.message.replyTo) {
+            void removeTypingReaction(ctx.message.threadId);
+        }
         markStatus({ lastSendAt: Date.now() });
         return { providerMessageId };
     }
     async function typing(ctx) {
-        ctx.log.debug("feishu typing ignored: no native bot typing API", {
-            channel: opts.id,
-            conversationId: ctx.conversationId,
-        });
+        const messageId = messageIdFromTrace(ctx.traceId);
+        if (!messageId) {
+            ctx.log.debug("feishu typing skipped: trace id has no message id", {
+                channel: opts.id,
+                conversationId: ctx.conversationId,
+                traceId: ctx.traceId,
+            });
+            return;
+        }
+        const existing = activeTypingReactions.get(messageId);
+        if (existing) {
+            scheduleTypingCleanup(messageId, existing);
+            return;
+        }
+        const state = { reactionId: null, timer: null };
+        activeTypingReactions.set(messageId, state);
+        scheduleTypingCleanup(messageId, state);
+        try {
+            const res = await callFeishu({
+                method: "POST",
+                url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions`,
+                data: { reaction_type: { emoji_type: TYPING_EMOJI } },
+            });
+            const reactionId = resultReactionId(res);
+            if (activeTypingReactions.get(messageId) !== state) {
+                if (reactionId) {
+                    await callFeishu({
+                        method: "DELETE",
+                        url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(reactionId)}`,
+                    });
+                }
+                return;
+            }
+            state.reactionId = reactionId;
+        }
+        catch (err) {
+            activeTypingReactions.delete(messageId);
+            if (state.timer)
+                clearTimeout(state.timer);
+            ctx.log.warn("feishu typing reaction failed", {
+                channel: opts.id,
+                conversationId: ctx.conversationId,
+                err: err instanceof Error ? err.message : String(err),
+            });
+        }
     }
     async function stop(_ctx) {
         try {
@@ -439,6 +528,7 @@ export function createFeishuChannel(opts) {
             // best effort
         }
         wsClient = null;
+        await Promise.allSettled(Array.from(activeTypingReactions.keys()).map(removeTypingReaction));
         try {
             stateStore?.close();
         }

package/dist/gateway/dispatcher.d.ts

@@ -149,6 +149,7 @@ export declare class Dispatcher {
     private recomposeUserTurn;
     private runTurn;
     private sendReply;
+    private providerReplyTo;
     private emitInbound;
     private emitOutbound;
 }

package/dist/gateway/dispatcher.js

@@ -1098,7 +1098,7 @@ export class Dispatcher {
                         threadId: msg.conversation.threadId ?? null,
                         type: "error",
                         text: `⚠️ Runtime timeout after ${Math.round(this.turnTimeoutMs / 60000)} minute(s); aborted`,
-                        replyTo: msg.id,
+                        replyTo: this.providerReplyTo(msg),
                         traceId: msg.trace?.id ?? null,
                     }, turnId);
                 }
@@ -1144,7 +1144,7 @@ export class Dispatcher {
                         threadId: msg.conversation.threadId ?? null,
                         type: "error",
                         text: `⚠️ Runtime error: ${truncate(errMsg, 500)}`,
-                        replyTo: msg.id,
+                        replyTo: this.providerReplyTo(msg),
                         traceId: msg.trace?.id ?? null,
                     }, turnId);
                 }
@@ -1252,7 +1252,7 @@ export class Dispatcher {
                             threadId: msg.conversation.threadId ?? null,
                             type: "error",
                             text: `⚠️ Runtime error: ${truncate(result.error, 500)}`,
-                            replyTo: msg.id,
+                            replyTo: this.providerReplyTo(msg),
                             traceId: msg.trace?.id ?? null,
                         }, turnId);
                         this.emitOutbound({
@@ -1323,7 +1323,7 @@ export class Dispatcher {
                 conversationId: msg.conversation.id,
                 threadId: msg.conversation.threadId ?? null,
                 text: replyText,
-                replyTo: msg.id,
+                replyTo: this.providerReplyTo(msg),
                 traceId: msg.trace?.id ?? null,
             }, turnId);
             this.emitOutbound({
@@ -1388,6 +1388,9 @@ export class Dispatcher {
         }
         return { ok: true };
     }
+    providerReplyTo(msg) {
+        return msg.replyTo ?? msg.id;
+    }
     emitInbound(turnId, msg) {
         if (!this.transcript.enabled)
             return;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
-    "botcord-daemon": "./dist/index.js"
+    "botcord-daemon": "dist/index.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

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

@@ -293,6 +293,30 @@ describe("Dispatcher", () => {
     expect(store.all()[0].threadId).toBe("t_1");
   });
 
+  it("sends replies to the provider reply id when it differs from the internal message id", async () => {
+    const runtime = new FakeRuntime({ reply: "ok" });
+    const feishuChannel = new FakeChannel({ id: "gw_feishu_1", type: "feishu" });
+    const { dispatcher, channel } = await scaffold({
+      runtimeFactory: () => runtime,
+      channel: feishuChannel,
+      config: baseConfig({
+        channels: [{ id: "gw_feishu_1", type: "feishu", accountId: "ag_me" }],
+      }),
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({
+        id: "feishu:om_internal_wrapped",
+        replyTo: "om_provider_raw",
+        channel: "gw_feishu_1",
+        conversation: { id: "feishu:user:oc_chat", kind: "direct" },
+      }),
+    );
+
+    expect(channel.sends.length).toBe(1);
+    expect(channel.sends[0].message.replyTo).toBe("om_provider_raw");
+  });
+
   it("reuses session id on second message with same queue key", async () => {
     const seen: Array<string | null> = [];
     const runtime = new FakeRuntime({
@@ -2009,7 +2033,8 @@ describe("Dispatcher", () => {
     });
     await dispatcher.handle(
       makeEnvelope({
-        id: "m_err",
+        id: "feishu:om_internal_err",
+        replyTo: "om_provider_err",
         conversation: { id: "rm_g_other", kind: "group" },
       }),
     );
@@ -2017,7 +2042,7 @@ describe("Dispatcher", () => {
     expect(channel.sends[0].message.type).toBe("error");
     expect(channel.sends[0].message.text).toContain("Runtime error: boom");
     expect(channel.sends[0].message.conversationId).toBe("rm_g_other");
-    expect(channel.sends[0].message.replyTo).toBe("m_err");
+    expect(channel.sends[0].message.replyTo).toBe("om_provider_err");
   });
 
   // ─────────────────────────────────────────────────────────────────────

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

@@ -255,27 +255,80 @@ describe("createFeishuChannel", () => {
     expect(JSON.parse(send.data.content as string)).toEqual({ file_key: "file_v2_uploaded" });
   });
 
-  it("exposes typing as a safe no-op because Feishu has no bot typing API", async () => {
-    const debug = vi.fn();
+  it("adds a Typing reaction for typing and removes it when replying", async () => {
     const adapter = createFeishuChannel({
       id: "gw_fs",
       accountId: "ag_self",
       appId: "cli_a",
       appSecret: "sec",
     });
+    larkMock.responses.push(
+      { code: 0, data: { reaction_id: "react_typing_1" } },
+      { code: 0, data: { message_id: "om_reply" } },
+      { code: 0, data: {} },
+    );
 
     await adapter.typing?.({
       traceId: "feishu:om_1",
       accountId: "ag_self",
       conversationId: "feishu:chat:oc_chat",
-      log: { ...SILENT_LOG, debug },
+      log: SILENT_LOG,
     });
 
-    expect(larkMock.requests).toHaveLength(0);
-    expect(debug).toHaveBeenCalledWith(
-      "feishu typing ignored: no native bot typing API",
-      expect.objectContaining({ channel: "gw_fs" }),
-    );
+    expect(larkMock.requests).toHaveLength(1);
+    expect(larkMock.requests[0]).toEqual({
+      method: "POST",
+      url: "/open-apis/im/v1/messages/om_1/reactions",
+      data: { reaction_type: { emoji_type: "Typing" } },
+    });
+
+    await adapter.send({
+      message: {
+        channel: "gw_fs",
+        accountId: "ag_self",
+        conversationId: "feishu:chat:oc_chat",
+        text: "reply",
+        replyTo: "om_1",
+      },
+      log: SILENT_LOG,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(larkMock.requests).toHaveLength(3);
+    expect(larkMock.requests[2]).toEqual({
+      method: "DELETE",
+      url: "/open-apis/im/v1/messages/om_1/reactions/react_typing_1",
+    });
+  });
+
+  it("refreshes an existing Feishu typing reaction without creating duplicates", async () => {
+    const adapter = createFeishuChannel({
+      id: "gw_fs",
+      accountId: "ag_self",
+      appId: "cli_a",
+      appSecret: "sec",
+    });
+    larkMock.responses.push({ code: 0, data: { reaction_id: "react_typing_1" } });
+
+    await adapter.typing?.({
+      traceId: "feishu:om_1",
+      accountId: "ag_self",
+      conversationId: "feishu:chat:oc_chat",
+      log: SILENT_LOG,
+    });
+    await adapter.typing?.({
+      traceId: "feishu:om_1",
+      accountId: "ag_self",
+      conversationId: "feishu:chat:oc_chat",
+      log: SILENT_LOG,
+    });
+
+    expect(larkMock.requests).toHaveLength(1);
+    expect(larkMock.requests[0]).toEqual({
+      method: "POST",
+      url: "/open-apis/im/v1/messages/om_1/reactions",
+      data: { reaction_type: { emoji_type: "Typing" } },
+    });
   });
 
   it("surfaces websocket start failures in channel status", async () => {

package/src/gateway/channels/feishu.ts

@@ -21,6 +21,8 @@ import type { FeishuDomain } from "./feishu-registration.js";
 const FEISHU_PROVIDER = "feishu" as const;
 const DEFAULT_SPLIT_AT = 4000;
 const MAX_SEEN_MESSAGES = 2048;
+const TYPING_EMOJI = "Typing";
+const TYPING_REACTION_TTL_MS = 20_000;
 
 export interface FeishuChannelOptions {
   id: string;
@@ -80,6 +82,10 @@ interface FeishuApiResponse {
 }
 
 type FeishuClient = { request(args: unknown): Promise<unknown> };
+type TypingReactionState = {
+  reactionId: string | null;
+  timer: ReturnType<typeof setTimeout> | null;
+};
 
 function sdkDomain(domain: FeishuDomain | undefined): unknown {
   const sdk = Lark as unknown as {
@@ -137,6 +143,7 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
   let botOpenId: string | undefined;
   let botName: string | undefined;
   let liveSetStatus: ((patch: Partial<ChannelStatusSnapshot>) => void) | null = null;
+  const activeTypingReactions = new Map<string, TypingReactionState>();
 
   let statusSnapshot: ChannelStatusSnapshot = {
     channel: opts.id,
@@ -387,6 +394,44 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
     );
   }
 
+  function resultReactionId(res: FeishuApiResponse): string | null {
+    return (
+      (typeof res.data?.reaction_id === "string" ? res.data.reaction_id : undefined) ??
+      (typeof res.reaction_id === "string" ? res.reaction_id : undefined) ??
+      null
+    );
+  }
+
+  function messageIdFromTrace(traceId: string): string | null {
+    if (!traceId.startsWith("feishu:")) return null;
+    const messageId = traceId.slice("feishu:".length).trim();
+    return messageId.length > 0 ? messageId : null;
+  }
+
+  async function removeTypingReaction(messageId: string): Promise<void> {
+    const state = activeTypingReactions.get(messageId);
+    if (!state) return;
+    activeTypingReactions.delete(messageId);
+    if (state.timer) clearTimeout(state.timer);
+    if (!state.reactionId) return;
+    try {
+      await callFeishu({
+        method: "DELETE",
+        url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(state.reactionId)}`,
+      });
+    } catch (err) {
+      statusSnapshot.lastError = err instanceof Error ? err.message : String(err);
+    }
+  }
+
+  function scheduleTypingCleanup(messageId: string, state: TypingReactionState): void {
+    if (state.timer) clearTimeout(state.timer);
+    state.timer = setTimeout(() => {
+      void removeTypingReaction(messageId);
+    }, TYPING_REACTION_TTL_MS);
+    if (typeof state.timer.unref === "function") state.timer.unref();
+  }
+
   function resultResourceKey(res: FeishuApiResponse, key: "image_key" | "file_key"): string {
     const direct = res[key];
     if (typeof direct === "string") return direct;
@@ -516,15 +561,61 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
         replyInThread: Boolean(ctx.message.threadId),
       }) ?? providerMessageId;
     }
+    if (ctx.message.replyTo) {
+      void removeTypingReaction(ctx.message.replyTo);
+    }
+    if (ctx.message.threadId && ctx.message.threadId !== ctx.message.replyTo) {
+      void removeTypingReaction(ctx.message.threadId);
+    }
     markStatus({ lastSendAt: Date.now() });
     return { providerMessageId };
   }
 
   async function typing(ctx: ChannelTypingContext): Promise<void> {
-    ctx.log.debug("feishu typing ignored: no native bot typing API", {
-      channel: opts.id,
-      conversationId: ctx.conversationId,
-    });
+    const messageId = messageIdFromTrace(ctx.traceId);
+    if (!messageId) {
+      ctx.log.debug("feishu typing skipped: trace id has no message id", {
+        channel: opts.id,
+        conversationId: ctx.conversationId,
+        traceId: ctx.traceId,
+      });
+      return;
+    }
+    const existing = activeTypingReactions.get(messageId);
+    if (existing) {
+      scheduleTypingCleanup(messageId, existing);
+      return;
+    }
+
+    const state: TypingReactionState = { reactionId: null, timer: null };
+    activeTypingReactions.set(messageId, state);
+    scheduleTypingCleanup(messageId, state);
+    try {
+      const res = await callFeishu({
+        method: "POST",
+        url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions`,
+        data: { reaction_type: { emoji_type: TYPING_EMOJI } },
+      });
+      const reactionId = resultReactionId(res);
+      if (activeTypingReactions.get(messageId) !== state) {
+        if (reactionId) {
+          await callFeishu({
+            method: "DELETE",
+            url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(reactionId)}`,
+          });
+        }
+        return;
+      }
+      state.reactionId = reactionId;
+    } catch (err) {
+      activeTypingReactions.delete(messageId);
+      if (state.timer) clearTimeout(state.timer);
+      ctx.log.warn("feishu typing reaction failed", {
+        channel: opts.id,
+        conversationId: ctx.conversationId,
+        err: err instanceof Error ? err.message : String(err),
+      });
+    }
   }
 
   async function stop(_ctx: ChannelStopContext): Promise<void> {
@@ -534,6 +625,7 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
       // best effort
     }
     wsClient = null;
+    await Promise.allSettled(Array.from(activeTypingReactions.keys()).map(removeTypingReaction));
     try {
       stateStore?.close();
     } catch {

package/src/gateway/dispatcher.ts

@@ -1343,7 +1343,7 @@ export class Dispatcher {
             threadId: msg.conversation.threadId ?? null,
             type: "error",
             text: `⚠️ Runtime timeout after ${Math.round(this.turnTimeoutMs / 60000)} minute(s); aborted`,
-            replyTo: msg.id,
+            replyTo: this.providerReplyTo(msg),
             traceId: msg.trace?.id ?? null,
           }, turnId);
         } else {
@@ -1389,7 +1389,7 @@ export class Dispatcher {
             threadId: msg.conversation.threadId ?? null,
             type: "error",
             text: `⚠️ Runtime error: ${truncate(errMsg, 500)}`,
-            replyTo: msg.id,
+            replyTo: this.providerReplyTo(msg),
             traceId: msg.trace?.id ?? null,
           }, turnId);
         } else {
@@ -1494,7 +1494,7 @@ export class Dispatcher {
               threadId: msg.conversation.threadId ?? null,
               type: "error",
               text: `⚠️ Runtime error: ${truncate(result.error, 500)}`,
-              replyTo: msg.id,
+              replyTo: this.providerReplyTo(msg),
               traceId: msg.trace?.id ?? null,
             }, turnId);
             this.emitOutbound({
@@ -1571,7 +1571,7 @@ export class Dispatcher {
         conversationId: msg.conversation.id,
         threadId: msg.conversation.threadId ?? null,
         text: replyText,
-        replyTo: msg.id,
+        replyTo: this.providerReplyTo(msg),
         traceId: msg.trace?.id ?? null,
       }, turnId);
       this.emitOutbound({
@@ -1638,6 +1638,10 @@ export class Dispatcher {
     return { ok: true };
   }
 
+  private providerReplyTo(msg: GatewayInboundMessage): string {
+    return msg.replyTo ?? msg.id;
+  }
+
   private emitInbound(turnId: string, msg: GatewayInboundEnvelope["message"]): void {
     if (!this.transcript.enabled) return;
     const rawText = typeof msg.text === "string" ? msg.text : "";