@femtomc/mu-server 26.2.35 → 26.2.37

package/README.md

@@ -39,10 +39,38 @@ Bun.serve(server);
   {
     "repo_root": "/path/to/repo",
     "open_count": 10,
-    "ready_count": 3
+    "ready_count": 3,
+    "control_plane": {
+      "active": true,
+      "adapters": ["slack"],
+      "routes": [{ "name": "slack", "route": "/webhooks/slack" }]
+    }
   }
   ```
 
+### Config + Control Plane Admin
+
+- `GET /api/config` - Read redacted `.mu/config.json` plus presence booleans
+- `POST /api/config` - Apply a partial patch to `.mu/config.json`
+  - Body:
+  ```json
+  {
+    "patch": {
+      "control_plane": {
+        "adapters": {
+          "slack": { "signing_secret": "..." }
+        }
+      }
+    }
+  }
+  ```
+- `POST /api/control-plane/reload` - Re-bootstrap control-plane adapters in-process
+  - Re-reads current config from `.mu/config.json` and re-mounts adapters without restarting
+  - Body (optional):
+  ```json
+  { "reason": "mu_setup_apply" }
+  ```
+
 ### Issues
 
 - `GET /api/issues` - List issues

package/dist/api/events.d.ts

@@ -0,0 +1,2 @@
+import type { ServerContext } from "../server.js";
+export declare function eventRoutes(request: Request, context: ServerContext): Promise<Response>;

package/dist/api/events.js

@@ -0,0 +1,45 @@
+export async function eventRoutes(request, context) {
+    const url = new URL(request.url);
+    const path = url.pathname.replace("/api/events", "") || "/";
+    const method = request.method;
+    if (method !== "GET") {
+        return new Response("Method Not Allowed", { status: 405 });
+    }
+    try {
+        const allEvents = await context.eventsStore.read();
+        // Tail - GET /api/events/tail?n=50
+        if (path === "/tail") {
+            const n = Math.min(Math.max(1, parseInt(url.searchParams.get("n") ?? "50", 10) || 50), 500);
+            return Response.json(allEvents.slice(-n));
+        }
+        // Query - GET /api/events?type=...&source=...&since=...&limit=50
+        if (path === "/") {
+            const typeFilter = url.searchParams.get("type");
+            const sourceFilter = url.searchParams.get("source");
+            const sinceRaw = url.searchParams.get("since");
+            const limit = Math.min(Math.max(1, parseInt(url.searchParams.get("limit") ?? "50", 10) || 50), 500);
+            let filtered = allEvents;
+            if (typeFilter) {
+                filtered = filtered.filter((e) => e.type === typeFilter);
+            }
+            if (sourceFilter) {
+                filtered = filtered.filter((e) => e.source === sourceFilter);
+            }
+            if (sinceRaw) {
+                const sinceMs = parseInt(sinceRaw, 10);
+                if (!Number.isNaN(sinceMs)) {
+                    filtered = filtered.filter((e) => e.ts_ms >= sinceMs);
+                }
+            }
+            return Response.json(filtered.slice(-limit));
+        }
+        return new Response("Not Found", { status: 404 });
+    }
+    catch (error) {
+        console.error("Events API error:", error);
+        return new Response(JSON.stringify({ error: error instanceof Error ? error.message : "Internal server error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}

package/dist/api/forum.js

@@ -21,7 +21,7 @@ export async function forumRoutes(request, context) {
         }
         // Post message - POST /api/forum/post
         if (path === "/post" && method === "POST") {
-            const body = await request.json();
+            const body = (await request.json());
             const { topic, body: messageBody, author } = body;
             if (!topic || !messageBody) {
                 return new Response("Topic and body are required", { status: 400 });
@@ -35,7 +35,7 @@ export async function forumRoutes(request, context) {
         console.error("Forum API error:", error);
         return new Response(JSON.stringify({ error: error instanceof Error ? error.message : "Internal server error" }), {
             status: 500,
-            headers: { "Content-Type": "application/json" }
+            headers: { "Content-Type": "application/json" },
         });
     }
 }

package/dist/api/issues.js

@@ -9,7 +9,7 @@ export async function issueRoutes(request, context) {
             const tag = url.searchParams.get("tag");
             const issues = await context.issueStore.list({
                 status: status,
-                tag: tag || undefined
+                tag: tag || undefined,
             });
             return Response.json(issues);
         }
@@ -32,7 +32,7 @@ export async function issueRoutes(request, context) {
         }
         // Create issue - POST /api/issues
         if (path === "/" && method === "POST") {
-            const body = await request.json();
+            const body = (await request.json());
             const { title, body: issueBody, tags, priority } = body;
             if (!title) {
                 return new Response("Title is required", { status: 400 });
@@ -48,7 +48,7 @@ export async function issueRoutes(request, context) {
         if (path.startsWith("/") && method === "PATCH") {
             const id = path.slice(1);
             if (id) {
-                const body = await request.json();
+                const body = (await request.json());
                 const issue = await context.issueStore.update(id, body);
                 return Response.json(issue);
             }
@@ -56,7 +56,7 @@ export async function issueRoutes(request, context) {
         // Close issue - POST /api/issues/:id/close
         if (path.endsWith("/close") && method === "POST") {
             const id = path.slice(1, -6); // Remove leading / and trailing /close
-            const body = await request.json();
+            const body = (await request.json());
             const { outcome } = body;
             if (!outcome) {
                 return new Response("Outcome is required", { status: 400 });
@@ -80,7 +80,7 @@ export async function issueRoutes(request, context) {
         console.error("Issue API error:", error);
         return new Response(JSON.stringify({ error: error instanceof Error ? error.message : "Internal server error" }), {
             status: 500,
-            headers: { "Content-Type": "application/json" }
+            headers: { "Content-Type": "application/json" },
         });
     }
 }

package/dist/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env bun
-import { createServerAsync } from "./server.js";
 import { findRepoRoot } from "@femtomc/mu-core/node";
-const port = parseInt(process.env.PORT || "3000", 10);
+import { createServerAsync } from "./server.js";
+const port = parseInt(Bun.env.PORT || "3000", 10);
 let repoRoot;
 try {
     repoRoot = findRepoRoot();
 }
 catch {
-    console.error("Error: Could not find .mu directory. Run 'mu init' first.");
+    console.error("Error: Could not find .mu directory. Run 'mu serve' or 'mu run' once to initialize it.");
     process.exit(1);
 }
 console.log(`Starting mu-server on port ${port}...`);

package/dist/config.d.ts

@@ -0,0 +1,99 @@
+export type MuConfig = {
+    version: 1;
+    control_plane: {
+        adapters: {
+            slack: {
+                signing_secret: string | null;
+            };
+            discord: {
+                signing_secret: string | null;
+            };
+            telegram: {
+                webhook_secret: string | null;
+                bot_token: string | null;
+                bot_username: string | null;
+            };
+            gmail: {
+                enabled: boolean;
+                webhook_secret: string | null;
+                client_id: string | null;
+                client_secret: string | null;
+                refresh_token: string | null;
+            };
+        };
+        meta_agent: {
+            enabled: boolean;
+            run_triggers_enabled: boolean;
+            provider: string | null;
+            model: string | null;
+        };
+    };
+};
+export type MuConfigPatch = {
+    control_plane?: {
+        adapters?: {
+            slack?: {
+                signing_secret?: string | null;
+            };
+            discord?: {
+                signing_secret?: string | null;
+            };
+            telegram?: {
+                webhook_secret?: string | null;
+                bot_token?: string | null;
+                bot_username?: string | null;
+            };
+            gmail?: {
+                enabled?: boolean;
+                webhook_secret?: string | null;
+                client_id?: string | null;
+                client_secret?: string | null;
+                refresh_token?: string | null;
+            };
+        };
+        meta_agent?: {
+            enabled?: boolean;
+            run_triggers_enabled?: boolean;
+            provider?: string | null;
+            model?: string | null;
+        };
+    };
+};
+export type MuConfigPresence = {
+    control_plane: {
+        adapters: {
+            slack: {
+                signing_secret: boolean;
+            };
+            discord: {
+                signing_secret: boolean;
+            };
+            telegram: {
+                webhook_secret: boolean;
+                bot_token: boolean;
+                bot_username: boolean;
+            };
+            gmail: {
+                enabled: boolean;
+                webhook_secret: boolean;
+                client_id: boolean;
+                client_secret: boolean;
+                refresh_token: boolean;
+            };
+        };
+        meta_agent: {
+            enabled: boolean;
+            run_triggers_enabled: boolean;
+            provider: boolean;
+            model: boolean;
+        };
+    };
+};
+export declare const DEFAULT_MU_CONFIG: MuConfig;
+export declare function normalizeMuConfig(input: unknown): MuConfig;
+export declare function applyMuConfigPatch(base: MuConfig, patchInput: unknown): MuConfig;
+export declare function getMuConfigPath(repoRoot: string): string;
+export declare function readMuConfigFile(repoRoot: string): Promise<MuConfig>;
+export declare function writeMuConfigFile(repoRoot: string, config: MuConfig): Promise<string>;
+export declare function redactMuConfigSecrets(config: MuConfig): MuConfig;
+export declare function muConfigPresence(config: MuConfig): MuConfigPresence;

package/dist/config.js

@@ -0,0 +1,360 @@
+import { chmod, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export const DEFAULT_MU_CONFIG = {
+    version: 1,
+    control_plane: {
+        adapters: {
+            slack: {
+                signing_secret: null,
+            },
+            discord: {
+                signing_secret: null,
+            },
+            telegram: {
+                webhook_secret: null,
+                bot_token: null,
+                bot_username: null,
+            },
+            gmail: {
+                enabled: false,
+                webhook_secret: null,
+                client_id: null,
+                client_secret: null,
+                refresh_token: null,
+            },
+        },
+        meta_agent: {
+            enabled: true,
+            run_triggers_enabled: true,
+            provider: null,
+            model: null,
+        },
+    },
+};
+function cloneDefault() {
+    return JSON.parse(JSON.stringify(DEFAULT_MU_CONFIG));
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function normalizeNullableString(value) {
+    if (value == null)
+        return null;
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeBoolean(value, fallback) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        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 fallback;
+}
+export function normalizeMuConfig(input) {
+    const next = cloneDefault();
+    const root = asRecord(input);
+    if (!root)
+        return next;
+    const controlPlane = asRecord(root.control_plane);
+    if (!controlPlane)
+        return next;
+    const adapters = asRecord(controlPlane.adapters);
+    if (adapters) {
+        const slack = asRecord(adapters.slack);
+        if (slack && "signing_secret" in slack) {
+            next.control_plane.adapters.slack.signing_secret = normalizeNullableString(slack.signing_secret);
+        }
+        const discord = asRecord(adapters.discord);
+        if (discord && "signing_secret" in discord) {
+            next.control_plane.adapters.discord.signing_secret = normalizeNullableString(discord.signing_secret);
+        }
+        const telegram = asRecord(adapters.telegram);
+        if (telegram) {
+            if ("webhook_secret" in telegram) {
+                next.control_plane.adapters.telegram.webhook_secret = normalizeNullableString(telegram.webhook_secret);
+            }
+            if ("bot_token" in telegram) {
+                next.control_plane.adapters.telegram.bot_token = normalizeNullableString(telegram.bot_token);
+            }
+            if ("bot_username" in telegram) {
+                next.control_plane.adapters.telegram.bot_username = normalizeNullableString(telegram.bot_username);
+            }
+        }
+        const gmail = asRecord(adapters.gmail);
+        if (gmail) {
+            if ("enabled" in gmail) {
+                next.control_plane.adapters.gmail.enabled = normalizeBoolean(gmail.enabled, next.control_plane.adapters.gmail.enabled);
+            }
+            if ("webhook_secret" in gmail) {
+                next.control_plane.adapters.gmail.webhook_secret = normalizeNullableString(gmail.webhook_secret);
+            }
+            if ("client_id" in gmail) {
+                next.control_plane.adapters.gmail.client_id = normalizeNullableString(gmail.client_id);
+            }
+            if ("client_secret" in gmail) {
+                next.control_plane.adapters.gmail.client_secret = normalizeNullableString(gmail.client_secret);
+            }
+            if ("refresh_token" in gmail) {
+                next.control_plane.adapters.gmail.refresh_token = normalizeNullableString(gmail.refresh_token);
+            }
+        }
+    }
+    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);
+        }
+        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 ("provider" in metaAgent) {
+            next.control_plane.meta_agent.provider = normalizeNullableString(metaAgent.provider);
+        }
+        if ("model" in metaAgent) {
+            next.control_plane.meta_agent.model = normalizeNullableString(metaAgent.model);
+        }
+    }
+    return next;
+}
+function normalizeMuConfigPatch(input) {
+    const root = asRecord(input);
+    if (!root)
+        return {};
+    const patch = {};
+    const controlPlane = asRecord(root.control_plane);
+    if (!controlPlane)
+        return patch;
+    patch.control_plane = {};
+    const adapters = asRecord(controlPlane.adapters);
+    if (adapters) {
+        patch.control_plane.adapters = {};
+        const slack = asRecord(adapters.slack);
+        if (slack && "signing_secret" in slack) {
+            patch.control_plane.adapters.slack = {
+                signing_secret: normalizeNullableString(slack.signing_secret),
+            };
+        }
+        const discord = asRecord(adapters.discord);
+        if (discord && "signing_secret" in discord) {
+            patch.control_plane.adapters.discord = {
+                signing_secret: normalizeNullableString(discord.signing_secret),
+            };
+        }
+        const telegram = asRecord(adapters.telegram);
+        if (telegram) {
+            const telegramPatch = {};
+            if ("webhook_secret" in telegram) {
+                telegramPatch.webhook_secret = normalizeNullableString(telegram.webhook_secret);
+            }
+            if ("bot_token" in telegram) {
+                telegramPatch.bot_token = normalizeNullableString(telegram.bot_token);
+            }
+            if ("bot_username" in telegram) {
+                telegramPatch.bot_username = normalizeNullableString(telegram.bot_username);
+            }
+            if (Object.keys(telegramPatch).length > 0) {
+                patch.control_plane.adapters.telegram = telegramPatch;
+            }
+        }
+        const gmail = asRecord(adapters.gmail);
+        if (gmail) {
+            const gmailPatch = {};
+            if ("enabled" in gmail) {
+                gmailPatch.enabled = normalizeBoolean(gmail.enabled, DEFAULT_MU_CONFIG.control_plane.adapters.gmail.enabled);
+            }
+            if ("webhook_secret" in gmail) {
+                gmailPatch.webhook_secret = normalizeNullableString(gmail.webhook_secret);
+            }
+            if ("client_id" in gmail) {
+                gmailPatch.client_id = normalizeNullableString(gmail.client_id);
+            }
+            if ("client_secret" in gmail) {
+                gmailPatch.client_secret = normalizeNullableString(gmail.client_secret);
+            }
+            if ("refresh_token" in gmail) {
+                gmailPatch.refresh_token = normalizeNullableString(gmail.refresh_token);
+            }
+            if (Object.keys(gmailPatch).length > 0) {
+                patch.control_plane.adapters.gmail = gmailPatch;
+            }
+        }
+    }
+    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);
+        }
+        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 ("provider" in metaAgent) {
+            patch.control_plane.meta_agent.provider = normalizeNullableString(metaAgent.provider);
+        }
+        if ("model" in metaAgent) {
+            patch.control_plane.meta_agent.model = normalizeNullableString(metaAgent.model);
+        }
+        if (Object.keys(patch.control_plane.meta_agent).length === 0) {
+            delete patch.control_plane.meta_agent;
+        }
+    }
+    if (patch.control_plane.adapters && Object.keys(patch.control_plane.adapters).length === 0) {
+        delete patch.control_plane.adapters;
+    }
+    if (Object.keys(patch.control_plane).length === 0) {
+        delete patch.control_plane;
+    }
+    return patch;
+}
+export function applyMuConfigPatch(base, patchInput) {
+    const patch = normalizeMuConfigPatch(patchInput);
+    const next = normalizeMuConfig(base);
+    if (!patch.control_plane) {
+        return next;
+    }
+    const adapters = patch.control_plane.adapters;
+    if (adapters) {
+        if (adapters.slack && "signing_secret" in adapters.slack) {
+            next.control_plane.adapters.slack.signing_secret = adapters.slack.signing_secret ?? null;
+        }
+        if (adapters.discord && "signing_secret" in adapters.discord) {
+            next.control_plane.adapters.discord.signing_secret = adapters.discord.signing_secret ?? null;
+        }
+        if (adapters.telegram) {
+            if ("webhook_secret" in adapters.telegram) {
+                next.control_plane.adapters.telegram.webhook_secret = adapters.telegram.webhook_secret ?? null;
+            }
+            if ("bot_token" in adapters.telegram) {
+                next.control_plane.adapters.telegram.bot_token = adapters.telegram.bot_token ?? null;
+            }
+            if ("bot_username" in adapters.telegram) {
+                next.control_plane.adapters.telegram.bot_username = adapters.telegram.bot_username ?? null;
+            }
+        }
+        if (adapters.gmail) {
+            if ("enabled" in adapters.gmail && typeof adapters.gmail.enabled === "boolean") {
+                next.control_plane.adapters.gmail.enabled = adapters.gmail.enabled;
+            }
+            if ("webhook_secret" in adapters.gmail) {
+                next.control_plane.adapters.gmail.webhook_secret = adapters.gmail.webhook_secret ?? null;
+            }
+            if ("client_id" in adapters.gmail) {
+                next.control_plane.adapters.gmail.client_id = adapters.gmail.client_id ?? null;
+            }
+            if ("client_secret" in adapters.gmail) {
+                next.control_plane.adapters.gmail.client_secret = adapters.gmail.client_secret ?? null;
+            }
+            if ("refresh_token" in adapters.gmail) {
+                next.control_plane.adapters.gmail.refresh_token = adapters.gmail.refresh_token ?? null;
+            }
+        }
+    }
+    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;
+        }
+        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 ("provider" in metaAgent) {
+            next.control_plane.meta_agent.provider = metaAgent.provider ?? null;
+        }
+        if ("model" in metaAgent) {
+            next.control_plane.meta_agent.model = metaAgent.model ?? null;
+        }
+    }
+    return next;
+}
+export function getMuConfigPath(repoRoot) {
+    return join(repoRoot, ".mu", "config.json");
+}
+export async function readMuConfigFile(repoRoot) {
+    const path = getMuConfigPath(repoRoot);
+    try {
+        const raw = await Bun.file(path).text();
+        const parsed = JSON.parse(raw);
+        return normalizeMuConfig(parsed);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT") {
+            return cloneDefault();
+        }
+        throw err;
+    }
+}
+export async function writeMuConfigFile(repoRoot, config) {
+    const path = getMuConfigPath(repoRoot);
+    await mkdir(dirname(path), { recursive: true });
+    await Bun.write(path, `${JSON.stringify(normalizeMuConfig(config), null, 2)}\n`);
+    try {
+        await chmod(path, 0o600);
+    }
+    catch {
+        // Best effort only.
+    }
+    return path;
+}
+function redacted(value) {
+    if (!value)
+        return null;
+    return "***";
+}
+export function redactMuConfigSecrets(config) {
+    const next = normalizeMuConfig(config);
+    next.control_plane.adapters.slack.signing_secret = redacted(next.control_plane.adapters.slack.signing_secret);
+    next.control_plane.adapters.discord.signing_secret = redacted(next.control_plane.adapters.discord.signing_secret);
+    next.control_plane.adapters.telegram.webhook_secret = redacted(next.control_plane.adapters.telegram.webhook_secret);
+    next.control_plane.adapters.telegram.bot_token = redacted(next.control_plane.adapters.telegram.bot_token);
+    next.control_plane.adapters.gmail.webhook_secret = redacted(next.control_plane.adapters.gmail.webhook_secret);
+    next.control_plane.adapters.gmail.client_id = redacted(next.control_plane.adapters.gmail.client_id);
+    next.control_plane.adapters.gmail.client_secret = redacted(next.control_plane.adapters.gmail.client_secret);
+    next.control_plane.adapters.gmail.refresh_token = redacted(next.control_plane.adapters.gmail.refresh_token);
+    return next;
+}
+function isPresent(value) {
+    return typeof value === "string" && value.length > 0;
+}
+export function muConfigPresence(config) {
+    return {
+        control_plane: {
+            adapters: {
+                slack: {
+                    signing_secret: isPresent(config.control_plane.adapters.slack.signing_secret),
+                },
+                discord: {
+                    signing_secret: isPresent(config.control_plane.adapters.discord.signing_secret),
+                },
+                telegram: {
+                    webhook_secret: isPresent(config.control_plane.adapters.telegram.webhook_secret),
+                    bot_token: isPresent(config.control_plane.adapters.telegram.bot_token),
+                    bot_username: isPresent(config.control_plane.adapters.telegram.bot_username),
+                },
+                gmail: {
+                    enabled: config.control_plane.adapters.gmail.enabled,
+                    webhook_secret: isPresent(config.control_plane.adapters.gmail.webhook_secret),
+                    client_id: isPresent(config.control_plane.adapters.gmail.client_id),
+                    client_secret: isPresent(config.control_plane.adapters.gmail.client_secret),
+                    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),
+            },
+        },
+    };
+}

package/dist/control_plane.d.ts

@@ -1,29 +1,6 @@
-import { type Channel } from "@femtomc/mu-control-plane";
 import { type MessagingMetaAgentBackend, MessagingMetaAgentRuntime } from "@femtomc/mu-agent";
-export declare const ENV_VARS: {
-    readonly slack: {
-        readonly signingSecret: "MU_SLACK_SIGNING_SECRET";
-    };
-    readonly discord: {
-        readonly signingSecret: "MU_DISCORD_SIGNING_SECRET";
-    };
-    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";
-    };
-};
+import { type Channel } from "@femtomc/mu-control-plane";
+import { type MuConfig } from "./config.js";
 export type ActiveAdapter = {
     name: Channel;
     route: string;
@@ -33,6 +10,7 @@ export type ControlPlaneHandle = {
     handleWebhook(path: string, req: Request): Promise<Response | null>;
     stop(): Promise<void>;
 };
+export type ControlPlaneConfig = MuConfig["control_plane"];
 type DetectedAdapter = {
     name: "slack";
     signingSecret: string;
@@ -44,12 +22,11 @@ type DetectedAdapter = {
     webhookSecret: string;
     botToken: string | null;
     botUsername: string | null;
-    tenantId: string | null;
 };
-export declare function detectAdapters(env: Record<string, string | undefined>): DetectedAdapter[];
+export declare function detectAdapters(config: ControlPlaneConfig): DetectedAdapter[];
 export type BootstrapControlPlaneOpts = {
     repoRoot: string;
-    env?: Record<string, string | undefined>;
+    config?: ControlPlaneConfig;
     metaAgentRuntime?: MessagingMetaAgentRuntime | null;
     metaAgentBackend?: MessagingMetaAgentBackend;
 };