@femtomc/mu-server 26.2.38 → 26.2.40

package/README.md

@@ -1,6 +1,6 @@
 # @femtomc/mu-server
 
-HTTP JSON API server for mu issue and forum stores. Provides the backend for the mu web UI and can also be used standalone for programmatic access.
+HTTP API server for mu. Powers `mu serve`, the web UI, and programmatic status/control endpoints.
 
 ## Installation
 
@@ -115,11 +115,11 @@ Bun.serve(server);
 
 ### With Web UI (Recommended)
 
-The easiest way to run the server with the bundled web interface (and default terminal meta-agent chat):
+The easiest way to run the server with the bundled web interface (and default terminal operator chat):
 
 ```bash
 # From any mu repository
-mu serve              # API + web UI + terminal meta-agent session
+mu serve              # API + web UI + terminal operator session
 mu serve --no-open    # Skip browser auto-open (headless/SSH)
 mu serve --port 8080  # Custom shared API/web UI port
 ```

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/config.d.ts

@@ -21,7 +21,7 @@ export type MuConfig = {
                 refresh_token: string | null;
             };
         };
-        meta_agent: {
+        operator: {
             enabled: boolean;
             run_triggers_enabled: boolean;
             provider: string | null;
@@ -51,7 +51,7 @@ export type MuConfigPatch = {
                 refresh_token?: string | null;
             };
         };
-        meta_agent?: {
+        operator?: {
             enabled?: boolean;
             run_triggers_enabled?: boolean;
             provider?: string | null;
@@ -81,7 +81,7 @@ export type MuConfigPresence = {
                 refresh_token: boolean;
             };
         };
-        meta_agent: {
+        operator: {
             enabled: boolean;
             run_triggers_enabled: boolean;
             provider: boolean;

package/dist/config.js

@@ -23,7 +23,7 @@ export const DEFAULT_MU_CONFIG = {
                 refresh_token: null,
             },
         },
-        meta_agent: {
+        operator: {
             enabled: true,
             run_triggers_enabled: true,
             provider: null,
@@ -109,19 +109,19 @@ export function normalizeMuConfig(input) {
             }
         }
     }
-    const metaAgent = asRecord(controlPlane.meta_agent);
-    if (metaAgent) {
-        if ("enabled" in metaAgent) {
-            next.control_plane.meta_agent.enabled = normalizeBoolean(metaAgent.enabled, next.control_plane.meta_agent.enabled);
+    const operator = asRecord(controlPlane.operator);
+    if (operator) {
+        if ("enabled" in operator) {
+            next.control_plane.operator.enabled = normalizeBoolean(operator.enabled, next.control_plane.operator.enabled);
         }
-        if ("run_triggers_enabled" in metaAgent) {
-            next.control_plane.meta_agent.run_triggers_enabled = normalizeBoolean(metaAgent.run_triggers_enabled, next.control_plane.meta_agent.run_triggers_enabled);
+        if ("run_triggers_enabled" in operator) {
+            next.control_plane.operator.run_triggers_enabled = normalizeBoolean(operator.run_triggers_enabled, next.control_plane.operator.run_triggers_enabled);
         }
-        if ("provider" in metaAgent) {
-            next.control_plane.meta_agent.provider = normalizeNullableString(metaAgent.provider);
+        if ("provider" in operator) {
+            next.control_plane.operator.provider = normalizeNullableString(operator.provider);
         }
-        if ("model" in metaAgent) {
-            next.control_plane.meta_agent.model = normalizeNullableString(metaAgent.model);
+        if ("model" in operator) {
+            next.control_plane.operator.model = normalizeNullableString(operator.model);
         }
     }
     return next;
@@ -189,23 +189,23 @@ function normalizeMuConfigPatch(input) {
             }
         }
     }
-    const metaAgent = asRecord(controlPlane.meta_agent);
-    if (metaAgent) {
-        patch.control_plane.meta_agent = {};
-        if ("enabled" in metaAgent) {
-            patch.control_plane.meta_agent.enabled = normalizeBoolean(metaAgent.enabled, DEFAULT_MU_CONFIG.control_plane.meta_agent.enabled);
+    const operator = asRecord(controlPlane.operator);
+    if (operator) {
+        patch.control_plane.operator = {};
+        if ("enabled" in operator) {
+            patch.control_plane.operator.enabled = normalizeBoolean(operator.enabled, DEFAULT_MU_CONFIG.control_plane.operator.enabled);
         }
-        if ("run_triggers_enabled" in metaAgent) {
-            patch.control_plane.meta_agent.run_triggers_enabled = normalizeBoolean(metaAgent.run_triggers_enabled, DEFAULT_MU_CONFIG.control_plane.meta_agent.run_triggers_enabled);
+        if ("run_triggers_enabled" in operator) {
+            patch.control_plane.operator.run_triggers_enabled = normalizeBoolean(operator.run_triggers_enabled, DEFAULT_MU_CONFIG.control_plane.operator.run_triggers_enabled);
         }
-        if ("provider" in metaAgent) {
-            patch.control_plane.meta_agent.provider = normalizeNullableString(metaAgent.provider);
+        if ("provider" in operator) {
+            patch.control_plane.operator.provider = normalizeNullableString(operator.provider);
         }
-        if ("model" in metaAgent) {
-            patch.control_plane.meta_agent.model = normalizeNullableString(metaAgent.model);
+        if ("model" in operator) {
+            patch.control_plane.operator.model = normalizeNullableString(operator.model);
         }
-        if (Object.keys(patch.control_plane.meta_agent).length === 0) {
-            delete patch.control_plane.meta_agent;
+        if (Object.keys(patch.control_plane.operator).length === 0) {
+            delete patch.control_plane.operator;
         }
     }
     if (patch.control_plane.adapters && Object.keys(patch.control_plane.adapters).length === 0) {
@@ -259,19 +259,19 @@ export function applyMuConfigPatch(base, patchInput) {
             }
         }
     }
-    const metaAgent = patch.control_plane.meta_agent;
-    if (metaAgent) {
-        if ("enabled" in metaAgent && typeof metaAgent.enabled === "boolean") {
-            next.control_plane.meta_agent.enabled = metaAgent.enabled;
+    const operator = patch.control_plane.operator;
+    if (operator) {
+        if ("enabled" in operator && typeof operator.enabled === "boolean") {
+            next.control_plane.operator.enabled = operator.enabled;
         }
-        if ("run_triggers_enabled" in metaAgent && typeof metaAgent.run_triggers_enabled === "boolean") {
-            next.control_plane.meta_agent.run_triggers_enabled = metaAgent.run_triggers_enabled;
+        if ("run_triggers_enabled" in operator && typeof operator.run_triggers_enabled === "boolean") {
+            next.control_plane.operator.run_triggers_enabled = operator.run_triggers_enabled;
         }
-        if ("provider" in metaAgent) {
-            next.control_plane.meta_agent.provider = metaAgent.provider ?? null;
+        if ("provider" in operator) {
+            next.control_plane.operator.provider = operator.provider ?? null;
         }
-        if ("model" in metaAgent) {
-            next.control_plane.meta_agent.model = metaAgent.model ?? null;
+        if ("model" in operator) {
+            next.control_plane.operator.model = operator.model ?? null;
         }
     }
     return next;
@@ -349,11 +349,11 @@ export function muConfigPresence(config) {
                     refresh_token: isPresent(config.control_plane.adapters.gmail.refresh_token),
                 },
             },
-            meta_agent: {
-                enabled: config.control_plane.meta_agent.enabled,
-                run_triggers_enabled: config.control_plane.meta_agent.run_triggers_enabled,
-                provider: isPresent(config.control_plane.meta_agent.provider),
-                model: isPresent(config.control_plane.meta_agent.model),
+            operator: {
+                enabled: config.control_plane.operator.enabled,
+                run_triggers_enabled: config.control_plane.operator.run_triggers_enabled,
+                provider: isPresent(config.control_plane.operator.provider),
+                model: isPresent(config.control_plane.operator.model),
             },
         },
     };

package/dist/control_plane.d.ts

@@ -1,4 +1,4 @@
-import { type MessagingMetaAgentBackend, MessagingMetaAgentRuntime } from "@femtomc/mu-agent";
+import { type MessagingOperatorBackend, MessagingOperatorRuntime } from "@femtomc/mu-agent";
 import { type Channel } from "@femtomc/mu-control-plane";
 import { type MuConfig } from "./config.js";
 export type ActiveAdapter = {
@@ -27,8 +27,8 @@ export declare function detectAdapters(config: ControlPlaneConfig): DetectedAdap
 export type BootstrapControlPlaneOpts = {
     repoRoot: string;
     config?: ControlPlaneConfig;
-    metaAgentRuntime?: MessagingMetaAgentRuntime | null;
-    metaAgentBackend?: MessagingMetaAgentBackend;
+    operatorRuntime?: MessagingOperatorRuntime | null;
+    operatorBackend?: MessagingOperatorBackend;
 };
 export declare function bootstrapControlPlane(opts: BootstrapControlPlaneOpts): Promise<ControlPlaneHandle | null>;
 export {};

package/dist/control_plane.js

@@ -1,4 +1,4 @@
-import { ApprovedCommandBroker, CommandContextResolver, MessagingMetaAgentRuntime, PiMessagingMetaAgentBackend, serveExtensionPaths, } from "@femtomc/mu-agent";
+import { ApprovedCommandBroker, CommandContextResolver, MessagingOperatorRuntime, PiMessagingOperatorBackend, serveExtensionPaths, } from "@femtomc/mu-agent";
 import { ControlPlaneCommandPipeline, ControlPlaneOutbox, ControlPlaneOutboxDispatcher, ControlPlaneRuntime, DiscordControlPlaneAdapter, getControlPlanePaths, SlackControlPlaneAdapter, TelegramControlPlaneAdapter, } from "@femtomc/mu-control-plane";
 import { DEFAULT_MU_CONFIG } from "./config.js";
 export function detectAdapters(config) {
@@ -22,20 +22,20 @@ export function detectAdapters(config) {
     }
     return adapters;
 }
-function buildMessagingMetaAgentRuntime(opts) {
-    if (!opts.config.meta_agent.enabled) {
+function buildMessagingOperatorRuntime(opts) {
+    if (!opts.config.operator.enabled) {
         return null;
     }
     const backend = opts.backend ??
-        new PiMessagingMetaAgentBackend({
-            provider: opts.config.meta_agent.provider ?? undefined,
-            model: opts.config.meta_agent.model ?? undefined,
+        new PiMessagingOperatorBackend({
+            provider: opts.config.operator.provider ?? undefined,
+            model: opts.config.operator.model ?? undefined,
             extensionPaths: serveExtensionPaths,
         });
-    return new MessagingMetaAgentRuntime({
+    return new MessagingOperatorRuntime({
         backend,
         broker: new ApprovedCommandBroker({
-            runTriggersEnabled: opts.config.meta_agent.run_triggers_enabled,
+            runTriggersEnabled: opts.config.operator.run_triggers_enabled,
             contextResolver: new CommandContextResolver({ allowedRepoRoots: [opts.repoRoot] }),
         }),
         enabled: true,
@@ -49,115 +49,146 @@ export async function bootstrapControlPlane(opts) {
     }
     const paths = getControlPlanePaths(opts.repoRoot);
     const runtime = new ControlPlaneRuntime({ repoRoot: opts.repoRoot });
-    await runtime.start();
-    const metaAgent = opts.metaAgentRuntime !== undefined
-        ? opts.metaAgentRuntime
-        : buildMessagingMetaAgentRuntime({
-            repoRoot: opts.repoRoot,
-            config: controlPlaneConfig,
-            backend: opts.metaAgentBackend,
-        });
-    const pipeline = new ControlPlaneCommandPipeline({ runtime, metaAgent });
-    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 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,
+                    }),
+                });
+                if (res.ok) {
+                    return { kind: "delivered" };
+                }
+                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}: ${await res.text().catch(() => "")}`,
+                        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,
                 };
             }
-            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,6 +1,14 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.38",
+  "version": "26.2.40",
+  "description": "HTTP API server for mu status, work items, messaging setup, and web UI.",
+  "keywords": [
+    "mu",
+    "server",
+    "api",
+    "web",
+    "automation"
+  ],
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,10 +31,10 @@
     "start": "bun run dist/cli.js"
   },
   "dependencies": {
-    "@femtomc/mu-agent": "26.2.38",
-    "@femtomc/mu-control-plane": "26.2.38",
-    "@femtomc/mu-core": "26.2.38",
-    "@femtomc/mu-forum": "26.2.38",
-    "@femtomc/mu-issue": "26.2.38"
+    "@femtomc/mu-agent": "26.2.40",
+    "@femtomc/mu-control-plane": "26.2.40",
+    "@femtomc/mu-core": "26.2.40",
+    "@femtomc/mu-forum": "26.2.40",
+    "@femtomc/mu-issue": "26.2.40"
   }
 }