@femtomc/mu-server 26.2.39 → 26.2.41

package/dist/cli.js

@@ -13,7 +13,19 @@ catch {
 console.log(`Starting mu-server on port ${port}...`);
 console.log(`Repository root: ${repoRoot}`);
 const { serverConfig, controlPlane } = await createServerAsync({ repoRoot, port });
-const server = Bun.serve(serverConfig);
+let server;
+try {
+    server = Bun.serve(serverConfig);
+}
+catch (err) {
+    try {
+        await controlPlane?.stop();
+    }
+    catch {
+        // Best effort cleanup. Preserve the startup error.
+    }
+    throw err;
+}
 console.log(`Server running at http://localhost:${port}`);
 if (controlPlane && controlPlane.activeAdapters.length > 0) {
     console.log("Control plane: active");

package/dist/control_plane.d.ts

@@ -24,6 +24,23 @@ type DetectedAdapter = {
     botUsername: string | null;
 };
 export declare function detectAdapters(config: ControlPlaneConfig): DetectedAdapter[];
+export type TelegramSendMessagePayload = {
+    chat_id: string;
+    text: string;
+    parse_mode?: "Markdown";
+    disable_web_page_preview?: boolean;
+};
+/**
+ * Telegram supports a markdown dialect that uses single markers for emphasis.
+ * Normalize the most common LLM/GitHub-style markers (`**bold**`, `__italic__`, headings)
+ * while preserving fenced code blocks verbatim.
+ */
+export declare function renderTelegramMarkdown(text: string): string;
+export declare function buildTelegramSendMessagePayload(opts: {
+    chatId: string;
+    text: string;
+    richFormatting: boolean;
+}): TelegramSendMessagePayload;
 export type BootstrapControlPlaneOpts = {
     repoRoot: string;
     config?: ControlPlaneConfig;

package/dist/control_plane.js

@@ -22,6 +22,56 @@ export function detectAdapters(config) {
     }
     return adapters;
 }
+/**
+ * Telegram supports a markdown dialect that uses single markers for emphasis.
+ * Normalize the most common LLM/GitHub-style markers (`**bold**`, `__italic__`, headings)
+ * while preserving fenced code blocks verbatim.
+ */
+export function renderTelegramMarkdown(text) {
+    const normalized = text.replaceAll("\r\n", "\n");
+    const lines = normalized.split("\n");
+    const out = [];
+    let inFence = false;
+    for (const line of lines) {
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith("```")) {
+            inFence = !inFence;
+            out.push(line);
+            continue;
+        }
+        if (inFence) {
+            out.push(line);
+            continue;
+        }
+        let next = line;
+        next = next.replace(/^#{1,6}\s+(.+)$/, "*$1*");
+        next = next.replace(/\*\*(.+?)\*\*/g, "*$1*");
+        next = next.replace(/__(.+?)__/g, "_$1_");
+        out.push(next);
+    }
+    return out.join("\n");
+}
+export function buildTelegramSendMessagePayload(opts) {
+    if (!opts.richFormatting) {
+        return {
+            chat_id: opts.chatId,
+            text: opts.text,
+        };
+    }
+    return {
+        chat_id: opts.chatId,
+        text: renderTelegramMarkdown(opts.text),
+        parse_mode: "Markdown",
+        disable_web_page_preview: true,
+    };
+}
+async function postTelegramMessage(botToken, payload) {
+    return await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+    });
+}
 function buildMessagingOperatorRuntime(opts) {
     if (!opts.config.operator.enabled) {
         return null;
@@ -49,115 +99,154 @@ export async function bootstrapControlPlane(opts) {
     }
     const paths = getControlPlanePaths(opts.repoRoot);
     const runtime = new ControlPlaneRuntime({ repoRoot: opts.repoRoot });
-    await runtime.start();
-    const operator = opts.operatorRuntime !== undefined
-        ? opts.operatorRuntime
-        : buildMessagingOperatorRuntime({
-            repoRoot: opts.repoRoot,
-            config: controlPlaneConfig,
-            backend: opts.operatorBackend,
-        });
-    const pipeline = new ControlPlaneCommandPipeline({ runtime, operator });
-    await pipeline.start();
-    const outbox = new ControlPlaneOutbox(paths.outboxPath);
-    await outbox.load();
-    let telegramBotToken = null;
-    const adapterMap = new Map();
-    for (const d of detected) {
-        let adapter;
-        switch (d.name) {
-            case "slack":
-                adapter = new SlackControlPlaneAdapter({
-                    pipeline,
-                    outbox,
-                    signingSecret: d.signingSecret,
-                });
-                break;
-            case "discord":
-                adapter = new DiscordControlPlaneAdapter({
-                    pipeline,
-                    outbox,
-                    signingSecret: d.signingSecret,
-                });
-                break;
-            case "telegram":
-                adapter = new TelegramControlPlaneAdapter({
-                    pipeline,
-                    outbox,
-                    webhookSecret: d.webhookSecret,
-                    botUsername: d.botUsername ?? undefined,
-                });
-                if (d.botToken) {
-                    telegramBotToken = d.botToken;
-                }
-                break;
-        }
-        const route = adapter.spec.route;
-        if (adapterMap.has(route)) {
-            throw new Error(`duplicate control-plane webhook route: ${route}`);
-        }
-        adapterMap.set(route, {
-            adapter,
-            info: {
-                name: adapter.spec.channel,
-                route,
-            },
-        });
-    }
-    const deliver = async (record) => {
-        const { envelope } = record;
-        if (envelope.channel === "telegram") {
-            if (!telegramBotToken) {
-                return { kind: "retry", error: "telegram bot token not configured in .mu/config.json" };
-            }
-            const res = await fetch(`https://api.telegram.org/bot${telegramBotToken}/sendMessage`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    chat_id: envelope.channel_conversation_id,
-                    text: envelope.body,
-                }),
+    let pipeline = null;
+    let drainInterval = null;
+    try {
+        await runtime.start();
+        const operator = opts.operatorRuntime !== undefined
+            ? opts.operatorRuntime
+            : buildMessagingOperatorRuntime({
+                repoRoot: opts.repoRoot,
+                config: controlPlaneConfig,
+                backend: opts.operatorBackend,
             });
-            if (res.ok) {
-                return { kind: "delivered" };
+        pipeline = new ControlPlaneCommandPipeline({ runtime, operator });
+        await pipeline.start();
+        const outbox = new ControlPlaneOutbox(paths.outboxPath);
+        await outbox.load();
+        let telegramBotToken = null;
+        const adapterMap = new Map();
+        for (const d of detected) {
+            let adapter;
+            switch (d.name) {
+                case "slack":
+                    adapter = new SlackControlPlaneAdapter({
+                        pipeline,
+                        outbox,
+                        signingSecret: d.signingSecret,
+                    });
+                    break;
+                case "discord":
+                    adapter = new DiscordControlPlaneAdapter({
+                        pipeline,
+                        outbox,
+                        signingSecret: d.signingSecret,
+                    });
+                    break;
+                case "telegram":
+                    adapter = new TelegramControlPlaneAdapter({
+                        pipeline,
+                        outbox,
+                        webhookSecret: d.webhookSecret,
+                        botUsername: d.botUsername ?? undefined,
+                    });
+                    if (d.botToken) {
+                        telegramBotToken = d.botToken;
+                    }
+                    break;
             }
-            if (res.status === 429 || res.status >= 500) {
-                const retryAfter = res.headers.get("retry-after");
-                const retryDelayMs = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : undefined;
+            const route = adapter.spec.route;
+            if (adapterMap.has(route)) {
+                throw new Error(`duplicate control-plane webhook route: ${route}`);
+            }
+            adapterMap.set(route, {
+                adapter,
+                info: {
+                    name: adapter.spec.channel,
+                    route,
+                },
+            });
+        }
+        const deliver = async (record) => {
+            const { envelope } = record;
+            if (envelope.channel === "telegram") {
+                if (!telegramBotToken) {
+                    return { kind: "retry", error: "telegram bot token not configured in .mu/config.json" };
+                }
+                const richPayload = buildTelegramSendMessagePayload({
+                    chatId: envelope.channel_conversation_id,
+                    text: envelope.body,
+                    richFormatting: true,
+                });
+                let res = await postTelegramMessage(telegramBotToken, richPayload);
+                // Fallback: if Telegram rejects markdown entities, retry as plain text.
+                if (!res.ok && res.status === 400 && richPayload.parse_mode) {
+                    const plainPayload = buildTelegramSendMessagePayload({
+                        chatId: envelope.channel_conversation_id,
+                        text: envelope.body,
+                        richFormatting: false,
+                    });
+                    res = await postTelegramMessage(telegramBotToken, plainPayload);
+                }
+                if (res.ok) {
+                    return { kind: "delivered" };
+                }
+                const responseBody = await res.text().catch(() => "");
+                if (res.status === 429 || res.status >= 500) {
+                    const retryAfter = res.headers.get("retry-after");
+                    const retryDelayMs = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : undefined;
+                    return {
+                        kind: "retry",
+                        error: `telegram sendMessage ${res.status}: ${responseBody}`,
+                        retryDelayMs: retryDelayMs && Number.isFinite(retryDelayMs) ? retryDelayMs : undefined,
+                    };
+                }
                 return {
                     kind: "retry",
-                    error: `telegram sendMessage ${res.status}: ${await res.text().catch(() => "")}`,
-                    retryDelayMs: retryDelayMs && Number.isFinite(retryDelayMs) ? retryDelayMs : undefined,
+                    error: `telegram sendMessage ${res.status}: ${responseBody}`,
                 };
             }
-            return {
-                kind: "retry",
-                error: `telegram sendMessage ${res.status}: ${await res.text().catch(() => "")}`,
-            };
+            return undefined;
+        };
+        const dispatcher = new ControlPlaneOutboxDispatcher({ outbox, deliver });
+        drainInterval = setInterval(async () => {
+            try {
+                await dispatcher.drainDue();
+            }
+            catch {
+                // Swallow errors — the dispatcher already handles retries internally.
+            }
+        }, 2_000);
+        return {
+            activeAdapters: [...adapterMap.values()].map((v) => v.info),
+            async handleWebhook(path, req) {
+                const entry = adapterMap.get(path);
+                if (!entry)
+                    return null;
+                const result = await entry.adapter.ingest(req);
+                return result.response;
+            },
+            async stop() {
+                if (drainInterval) {
+                    clearInterval(drainInterval);
+                    drainInterval = null;
+                }
+                try {
+                    await pipeline?.stop();
+                }
+                finally {
+                    await runtime.stop();
+                }
+            },
+        };
+    }
+    catch (err) {
+        if (drainInterval) {
+            clearInterval(drainInterval);
+            drainInterval = null;
         }
-        return undefined;
-    };
-    const dispatcher = new ControlPlaneOutboxDispatcher({ outbox, deliver });
-    const drainInterval = setInterval(async () => {
         try {
-            await dispatcher.drainDue();
+            await pipeline?.stop();
         }
         catch {
-            // Swallow errors — the dispatcher already handles retries internally.
+            // Best effort cleanup.
         }
-    }, 2_000);
-    return {
-        activeAdapters: [...adapterMap.values()].map((v) => v.info),
-        async handleWebhook(path, req) {
-            const entry = adapterMap.get(path);
-            if (!entry)
-                return null;
-            const result = await entry.adapter.ingest(req);
-            return result.response;
-        },
-        async stop() {
-            clearInterval(drainInterval);
-            await pipeline.stop();
-        },
-    };
+        try {
+            await runtime.stop();
+        }
+        catch {
+            // Best effort cleanup.
+        }
+        throw err;
+    }
 }

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.39",
+  "version": "26.2.41",
   "description": "HTTP API server for mu status, work items, messaging setup, and web UI.",
-  "keywords": ["mu", "server", "api", "web", "automation"],
+  "keywords": [
+    "mu",
+    "server",
+    "api",
+    "web",
+    "automation"
+  ],
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -25,10 +31,10 @@
     "start": "bun run dist/cli.js"
   },
   "dependencies": {
-    "@femtomc/mu-agent": "26.2.39",
-    "@femtomc/mu-control-plane": "26.2.39",
-    "@femtomc/mu-core": "26.2.39",
-    "@femtomc/mu-forum": "26.2.39",
-    "@femtomc/mu-issue": "26.2.39"
+    "@femtomc/mu-agent": "26.2.41",
+    "@femtomc/mu-control-plane": "26.2.41",
+    "@femtomc/mu-core": "26.2.41",
+    "@femtomc/mu-forum": "26.2.41",
+    "@femtomc/mu-issue": "26.2.41"
   }
 }