@femtomc/mu-server 26.2.30 → 26.2.32

package/dist/control_plane.d.ts

@@ -1,4 +1,4 @@
-import { type Channel } from "@femtomc/mu-control-plane";
+import { type Channel, type MessagingMetaAgentBackend, MessagingMetaAgentRuntime } from "@femtomc/mu-control-plane";
 export declare const ENV_VARS: {
     readonly slack: {
         readonly signingSecret: "MU_SLACK_SIGNING_SECRET";
@@ -8,9 +8,21 @@ export declare const ENV_VARS: {
     };
     readonly telegram: {
         readonly webhookSecret: "MU_TELEGRAM_WEBHOOK_SECRET";
+        readonly botToken: "MU_TELEGRAM_BOT_TOKEN";
         readonly botUsername: "MU_TELEGRAM_BOT_USERNAME";
         readonly tenantId: "MU_TELEGRAM_TENANT_ID";
     };
+    readonly metaAgent: {
+        readonly enabled: "MU_META_AGENT_ENABLED";
+        readonly enabledChannels: "MU_META_AGENT_ENABLED_CHANNELS";
+        readonly runTriggersEnabled: "MU_META_AGENT_RUN_TRIGGERS_ENABLED";
+        readonly provider: "MU_META_AGENT_PROVIDER";
+        readonly model: "MU_META_AGENT_MODEL";
+        readonly thinking: "MU_META_AGENT_THINKING";
+        readonly systemPrompt: "MU_META_AGENT_SYSTEM_PROMPT";
+        readonly timeoutMs: "MU_META_AGENT_TIMEOUT_MS";
+        readonly piBinary: "MU_META_AGENT_PI_BINARY";
+    };
 };
 export type ActiveAdapter = {
     name: Channel;
@@ -30,12 +42,16 @@ type DetectedAdapter = {
 } | {
     name: "telegram";
     webhookSecret: string;
+    botToken: string | null;
     botUsername: string | null;
     tenantId: string | null;
 };
 export declare function detectAdapters(env: Record<string, string | undefined>): DetectedAdapter[];
-export declare function bootstrapControlPlane(opts: {
+export type BootstrapControlPlaneOpts = {
     repoRoot: string;
     env?: Record<string, string | undefined>;
-}): Promise<ControlPlaneHandle | null>;
+    metaAgentRuntime?: MessagingMetaAgentRuntime | null;
+    metaAgentBackend?: MessagingMetaAgentBackend;
+};
+export declare function bootstrapControlPlane(opts: BootstrapControlPlaneOpts): Promise<ControlPlaneHandle | null>;
 export {};

package/dist/control_plane.js

@@ -1,12 +1,24 @@
-import { ControlPlaneRuntime, ControlPlaneCommandPipeline, ControlPlaneOutbox, SlackControlPlaneAdapter, DiscordControlPlaneAdapter, TelegramControlPlaneAdapter, getControlPlanePaths, } from "@femtomc/mu-control-plane";
+import { ApprovedCommandBroker, CommandContextResolver, ControlPlaneCommandPipeline, ControlPlaneOutbox, ControlPlaneOutboxDispatcher, ControlPlaneRuntime, DiscordControlPlaneAdapter, getControlPlanePaths, MessagingMetaAgentRuntime, PiMessagingMetaAgentBackend, SlackControlPlaneAdapter, TelegramControlPlaneAdapter, } from "@femtomc/mu-control-plane";
 export const ENV_VARS = {
     slack: { signingSecret: "MU_SLACK_SIGNING_SECRET" },
     discord: { signingSecret: "MU_DISCORD_SIGNING_SECRET" },
     telegram: {
         webhookSecret: "MU_TELEGRAM_WEBHOOK_SECRET",
+        botToken: "MU_TELEGRAM_BOT_TOKEN",
         botUsername: "MU_TELEGRAM_BOT_USERNAME",
         tenantId: "MU_TELEGRAM_TENANT_ID",
     },
+    metaAgent: {
+        enabled: "MU_META_AGENT_ENABLED",
+        enabledChannels: "MU_META_AGENT_ENABLED_CHANNELS",
+        runTriggersEnabled: "MU_META_AGENT_RUN_TRIGGERS_ENABLED",
+        provider: "MU_META_AGENT_PROVIDER",
+        model: "MU_META_AGENT_MODEL",
+        thinking: "MU_META_AGENT_THINKING",
+        systemPrompt: "MU_META_AGENT_SYSTEM_PROMPT",
+        timeoutMs: "MU_META_AGENT_TIMEOUT_MS",
+        piBinary: "MU_META_AGENT_PI_BINARY",
+    },
 };
 const ROUTE_MAP = {
     slack: "/webhooks/slack",
@@ -28,12 +40,73 @@ export function detectAdapters(env) {
         adapters.push({
             name: "telegram",
             webhookSecret: telegramSecret,
+            botToken: env[ENV_VARS.telegram.botToken] ?? null,
             botUsername: env[ENV_VARS.telegram.botUsername] ?? null,
             tenantId: env[ENV_VARS.telegram.tenantId] ?? null,
         });
     }
     return adapters;
 }
+function parseBooleanEnv(value, defaultValue) {
+    if (value == null) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on", "enabled"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off", "disabled"].includes(normalized)) {
+        return false;
+    }
+    return defaultValue;
+}
+function parsePositiveIntEnv(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return undefined;
+    }
+    return parsed;
+}
+function parseCsvEnv(value) {
+    if (!value) {
+        return undefined;
+    }
+    const tokens = value
+        .split(",")
+        .map((token) => token.trim().toLowerCase())
+        .filter((token) => token.length > 0);
+    return tokens.length > 0 ? tokens : undefined;
+}
+function buildMessagingMetaAgentRuntime(opts) {
+    const enabled = parseBooleanEnv(opts.env[ENV_VARS.metaAgent.enabled], true);
+    if (!enabled) {
+        return null;
+    }
+    const runTriggersEnabled = parseBooleanEnv(opts.env[ENV_VARS.metaAgent.runTriggersEnabled], true);
+    const enabledChannels = parseCsvEnv(opts.env[ENV_VARS.metaAgent.enabledChannels]);
+    const timeoutMs = parsePositiveIntEnv(opts.env[ENV_VARS.metaAgent.timeoutMs]);
+    const backend = opts.backend ??
+        new PiMessagingMetaAgentBackend({
+            provider: opts.env[ENV_VARS.metaAgent.provider],
+            model: opts.env[ENV_VARS.metaAgent.model],
+            thinking: opts.env[ENV_VARS.metaAgent.thinking],
+            systemPrompt: opts.env[ENV_VARS.metaAgent.systemPrompt],
+            timeoutMs,
+            piBinary: opts.env[ENV_VARS.metaAgent.piBinary],
+        });
+    return new MessagingMetaAgentRuntime({
+        backend,
+        broker: new ApprovedCommandBroker({
+            runTriggersEnabled,
+            contextResolver: new CommandContextResolver({ allowedRepoRoots: [opts.repoRoot] }),
+        }),
+        enabled,
+        enabledChannels,
+    });
+}
 export async function bootstrapControlPlane(opts) {
     const env = opts.env ?? process.env;
     const detected = detectAdapters(env);
@@ -43,10 +116,19 @@ export async function bootstrapControlPlane(opts) {
     const paths = getControlPlanePaths(opts.repoRoot);
     const runtime = new ControlPlaneRuntime({ repoRoot: opts.repoRoot });
     await runtime.start();
-    const pipeline = new ControlPlaneCommandPipeline({ runtime });
+    const metaAgent = opts.metaAgentRuntime !== undefined
+        ? opts.metaAgentRuntime
+        : buildMessagingMetaAgentRuntime({
+            repoRoot: opts.repoRoot,
+            env,
+            backend: opts.metaAgentBackend,
+        });
+    const pipeline = new ControlPlaneCommandPipeline({ runtime, metaAgent });
     await pipeline.start();
     const outbox = new ControlPlaneOutbox(paths.outboxPath);
     await outbox.load();
+    // Collect bot tokens for delivery.
+    const telegramBotTokens = new Map();
     const adapterMap = new Map();
     for (const d of detected) {
         const route = ROUTE_MAP[d.name];
@@ -74,10 +156,61 @@ export async function bootstrapControlPlane(opts) {
                     botUsername: d.botUsername ?? undefined,
                     tenantId: d.tenantId ?? undefined,
                 });
+                if (d.botToken) {
+                    telegramBotTokens.set(d.tenantId ?? "default", d.botToken);
+                }
                 break;
         }
         adapterMap.set(route, { adapter, info: { name: d.name, route } });
     }
+    // Build delivery handler that routes by channel.
+    const deliver = async (record) => {
+        const { envelope } = record;
+        if (envelope.channel === "telegram") {
+            const tenantId = envelope.channel_tenant_id ?? "default";
+            const botToken = telegramBotTokens.get(tenantId) ?? telegramBotTokens.values().next().value;
+            if (!botToken) {
+                return { kind: "retry", error: "MU_TELEGRAM_BOT_TOKEN not configured" };
+            }
+            const res = await fetch(`https://api.telegram.org/bot${botToken}/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,
+                };
+            }
+            // Permanent error — let it dead-letter after max attempts.
+            return {
+                kind: "retry",
+                error: `telegram sendMessage ${res.status}: ${await res.text().catch(() => "")}`,
+            };
+        }
+        // Other channels: treat as delivered (no-op for now).
+        return undefined;
+    };
+    const dispatcher = new ControlPlaneOutboxDispatcher({ outbox, deliver });
+    // Drain loop: check for pending outbox records every 2 seconds.
+    const 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) {
@@ -88,6 +221,7 @@ export async function bootstrapControlPlane(opts) {
             return result.response;
         },
         async stop() {
+            clearInterval(drainInterval);
             await pipeline.stop();
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.30",
+  "version": "26.2.32",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,9 +23,9 @@
     "start": "bun run dist/cli.js"
   },
   "dependencies": {
-    "@femtomc/mu-core": "26.2.30",
-    "@femtomc/mu-issue": "26.2.30",
-    "@femtomc/mu-forum": "26.2.30",
-    "@femtomc/mu-control-plane": "26.2.30"
+    "@femtomc/mu-core": "26.2.32",
+    "@femtomc/mu-issue": "26.2.32",
+    "@femtomc/mu-forum": "26.2.32",
+    "@femtomc/mu-control-plane": "26.2.32"
   }
 }