@mulmobridge/discord 1.3.0 → 1.4.0

package/README.md

@@ -4,6 +4,10 @@
 
 Discord bridge for [MulmoClaude](https://github.com/receptron/mulmoclaude). The bot responds to messages in channels it has access to.
 
+## Typing indicator
+
+From the moment a message arrives until the reply is posted, the bot shows "typing…" in the channel, refreshed before Discord lets it lapse, so a long agent turn reads as "working" rather than "bridge is down". It needs no extra permission or setting. A failed refresh is only logged.
+
 ## Attachments
 
 Files posted with a message are downloaded from Discord's CDN and forwarded to MulmoClaude, so you can paste a screenshot and ask about it. A post with **only** files and no text is forwarded too, with `Describe / analyze this file.` as the body.

package/dist/index.js

@@ -19,6 +19,7 @@ import { createBridgeClient, installProcessGuards } from "@mulmobridge/client";
 import { parseCsvSet } from "@mulmoclaude/common";
 import { collectAttachments, resolveMessageText } from "./attachments.js";
 import { buildExternalChatId, isChannelAllowed, parseGranularity, readChannelRef } from "./sessionId.js";
+import { replyAfterTyping } from "./typing.js";
 const TRANSPORT_ID = "discord";
 installProcessGuards({ name: TRANSPORT_ID });
 const MAX_DISCORD_LENGTH = 2000;
@@ -90,21 +91,27 @@ async function onMessageCreate(msg) {
     }
 }
 async function relayMessage(msg, externalChatId, text, files) {
+    await replyAfterTyping(() => sendTypingTo(msg), {
+        produce: () => produceReply(externalChatId, text, files),
+        post: (reply) => (reply.chunked ? sendChunked(msg, reply.text) : msg.reply(reply.text)),
+    }, { log: console });
+}
+async function sendTypingTo(msg) {
+    if (msg.channel.isSendable())
+        await msg.channel.sendTyping();
+}
+async function produceReply(externalChatId, text, files) {
     const { attachments, dropped } = await collectAttachments(files, { fetchFn: fetch, log: console });
     // Nothing survived on a file-only post: say so instead of relaying a
     // prompt about a file the agent never receives.
     if (text.length === 0 && attachments.length === 0) {
-        await msg.reply("Sorry, I could not download that attachment. Please try again.");
-        return;
+        return { text: "Sorry, I could not download that attachment. Please try again.", chunked: false };
     }
     const ack = await mulmo.send(externalChatId, resolveMessageText(text, dropped), attachments.length > 0 ? attachments : undefined);
-    if (ack.ok) {
-        await sendChunked(msg, ack.reply ?? "");
-    }
-    else {
-        const status = ack.status ? ` (${ack.status})` : "";
-        await msg.reply(`Error${status}: ${ack.error ?? "unknown"}`);
-    }
+    if (ack.ok)
+        return { text: ack.reply ?? "", chunked: true };
+    const status = ack.status ? ` (${ack.status})` : "";
+    return { text: `Error${status}: ${ack.error ?? "unknown"}`, chunked: false };
 }
 async function sendChunked(msg, text) {
     if (text.length === 0) {

package/dist/typing.d.ts

@@ -0,0 +1,29 @@
+export declare const TYPING_REFRESH_MS = 8000;
+export declare const STOP_WAIT_MS = 2000;
+export type SendTyping = () => Promise<unknown>;
+type Cancel = () => void;
+export interface TypingTimers {
+    every: (callback: () => void, delay_ms: number) => Cancel;
+    after: (callback: () => void, delay_ms: number) => Cancel;
+}
+export interface TypingIndicatorOptions {
+    log: {
+        warn: (message: string) => void;
+    };
+    timers?: TypingTimers;
+    refreshMs?: number;
+    stopWaitMs?: number;
+}
+export interface TypingIndicator {
+    /** Resolves once no typing request is in flight, or after the wait cap. */
+    stop: () => Promise<void>;
+}
+export declare function startTypingIndicator(sendTyping: SendTyping, options: TypingIndicatorOptions): TypingIndicator;
+/** Runs `work` with the indicator up; it is fully down by the time this resolves or rejects. */
+export declare function runWhileTyping<T>(sendTyping: SendTyping, work: () => Promise<T>, options: TypingIndicatorOptions): Promise<T>;
+/** Posts only once the indicator is fully down: a typing request that crosses the post lands after it and leaves "typing…" up on an answered message. */
+export declare function replyAfterTyping<T>(sendTyping: SendTyping, steps: {
+    produce: () => Promise<T>;
+    post: (reply: T) => Promise<unknown>;
+}, options: TypingIndicatorOptions): Promise<void>;
+export {};

package/dist/typing.js

@@ -0,0 +1,67 @@
+// Keeps Discord's "typing…" indicator up while the bridge waits for a reply.
+// Discord drops the indicator about 10 s after each send.
+export const TYPING_REFRESH_MS = 8_000;
+// A hung typing request must never hold the reply back.
+export const STOP_WAIT_MS = 2_000;
+const nodeTimers = {
+    every: (callback, delay_ms) => {
+        const handle = setInterval(callback, delay_ms);
+        return () => clearInterval(handle);
+    },
+    after: (callback, delay_ms) => {
+        const handle = setTimeout(callback, delay_ms);
+        return () => clearTimeout(handle);
+    },
+};
+export function startTypingIndicator(sendTyping, options) {
+    const timers = options.timers ?? nodeTimers;
+    let inFlight = null;
+    let stopped = false;
+    const tick = () => {
+        if (stopped || inFlight)
+            return;
+        inFlight = sendTypingSafely(sendTyping, options.log).finally(() => {
+            inFlight = null;
+        });
+    };
+    tick();
+    const cancelRefresh = timers.every(tick, options.refreshMs ?? TYPING_REFRESH_MS);
+    const stop = async () => {
+        stopped = true;
+        cancelRefresh();
+        if (inFlight)
+            await waitAtMost(inFlight, options.stopWaitMs ?? STOP_WAIT_MS, timers);
+    };
+    return { stop };
+}
+/** Runs `work` with the indicator up; it is fully down by the time this resolves or rejects. */
+export async function runWhileTyping(sendTyping, work, options) {
+    const typing = startTypingIndicator(sendTyping, options);
+    try {
+        return await work();
+    }
+    finally {
+        await typing.stop();
+    }
+}
+/** Posts only once the indicator is fully down: a typing request that crosses the post lands after it and leaves "typing…" up on an answered message. */
+export async function replyAfterTyping(sendTyping, steps, options) {
+    const reply = await runWhileTyping(sendTyping, steps.produce, options);
+    await steps.post(reply);
+}
+async function sendTypingSafely(sendTyping, log) {
+    try {
+        await sendTyping();
+    }
+    catch (err) {
+        log.warn(`[discord] sendTyping failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function waitAtMost(pending, limit_ms, timers) {
+    let cancelGiveUp = () => { };
+    const giveUp = new Promise((resolve) => {
+        cancelGiveUp = timers.after(resolve, limit_ms);
+    });
+    await Promise.race([pending, giveUp]);
+    cancelGiveUp();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mulmobridge/discord",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Discord bridge for MulmoBridge — connect a Discord bot to MulmoClaude",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,22 +15,22 @@
   "scripts": {
     "build": "tsc",
     "prepack": "yarn build",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
     "test": "tsx --test test/test_*.ts",
     "lint": "eslint src test"
   },
   "license": "MIT",
   "author": "Receptron Team",
   "dependencies": {
-    "@mulmobridge/client": "^1.3.0",
-    "@mulmobridge/protocol": "^1.0.1",
-    "@mulmoclaude/common": "^1.3.0",
+    "@mulmobridge/client": "^1.4.2",
+    "@mulmobridge/protocol": "^1.1.0",
+    "@mulmoclaude/common": "^1.5.0",
     "discord.js": "^14.27.0",
-    "dotenv": "^17.0.0"
+    "dotenv": "^18.0.8"
   },
   "devDependencies": {
-    "@types/node": "^26.6.2",
-    "tsx": "^4.23.13",
+    "@types/node": "^26.6.5",
+    "tsx": "^4.23.15",
     "typescript": "^6.0.3"
   },
   "homepage": "https://github.com/receptron/mulmoclaude/tree/main/packages/bridges/discord#readme",