@femtomc/mu-server 26.2.27 → 26.2.28

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { createServer } from "./server.js";
+import { createServerAsync } from "./server.js";
 import { findRepoRoot } from "@femtomc/mu-core/node";
 const port = parseInt(process.env.PORT || "3000", 10);
 let repoRoot;
@@ -12,8 +12,24 @@ catch {
 }
 console.log(`Starting mu-server on port ${port}...`);
 console.log(`Repository root: ${repoRoot}`);
-const server = createServer({ repoRoot, port });
-Bun.serve(server);
+const { serverConfig, controlPlane } = await createServerAsync({ repoRoot, port });
+const server = Bun.serve(serverConfig);
 console.log(`Server running at http://localhost:${port}`);
-console.log(`Health check: http://localhost:${port}/healthz`);
-console.log(`API Status: http://localhost:${port}/api/status`);
+if (controlPlane && controlPlane.activeAdapters.length > 0) {
+    console.log("Control plane: active");
+    for (const a of controlPlane.activeAdapters) {
+        console.log(`  ${a.name.padEnd(12)} ${a.route}`);
+    }
+}
+else {
+    console.log(`Health check: http://localhost:${port}/healthz`);
+    console.log(`API Status: http://localhost:${port}/api/status`);
+}
+const cleanup = async () => {
+    await controlPlane?.stop();
+    server.stop();
+    process.exit(0);
+};
+process.on("SIGINT", cleanup);
+process.on("SIGTERM", cleanup);
+console.log("Press Ctrl+C to stop");

package/dist/control_plane.d.ts

@@ -0,0 +1,41 @@
+import { type Channel } from "@femtomc/mu-control-plane";
+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 botUsername: "MU_TELEGRAM_BOT_USERNAME";
+        readonly tenantId: "MU_TELEGRAM_TENANT_ID";
+    };
+};
+export type ActiveAdapter = {
+    name: Channel;
+    route: string;
+};
+export type ControlPlaneHandle = {
+    activeAdapters: ActiveAdapter[];
+    handleWebhook(path: string, req: Request): Promise<Response | null>;
+    stop(): Promise<void>;
+};
+type DetectedAdapter = {
+    name: "slack";
+    signingSecret: string;
+} | {
+    name: "discord";
+    signingSecret: string;
+} | {
+    name: "telegram";
+    webhookSecret: string;
+    botUsername: string | null;
+    tenantId: string | null;
+};
+export declare function detectAdapters(env: Record<string, string | undefined>): DetectedAdapter[];
+export declare function bootstrapControlPlane(opts: {
+    repoRoot: string;
+    env?: Record<string, string | undefined>;
+}): Promise<ControlPlaneHandle | null>;
+export {};

package/dist/control_plane.js

@@ -0,0 +1,94 @@
+import { ControlPlaneRuntime, ControlPlaneCommandPipeline, ControlPlaneOutbox, SlackControlPlaneAdapter, DiscordControlPlaneAdapter, TelegramControlPlaneAdapter, getControlPlanePaths, } 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",
+        botUsername: "MU_TELEGRAM_BOT_USERNAME",
+        tenantId: "MU_TELEGRAM_TENANT_ID",
+    },
+};
+const ROUTE_MAP = {
+    slack: "/webhooks/slack",
+    discord: "/webhooks/discord",
+    telegram: "/webhooks/telegram",
+};
+export function detectAdapters(env) {
+    const adapters = [];
+    const slackSecret = env[ENV_VARS.slack.signingSecret];
+    if (slackSecret) {
+        adapters.push({ name: "slack", signingSecret: slackSecret });
+    }
+    const discordSecret = env[ENV_VARS.discord.signingSecret];
+    if (discordSecret) {
+        adapters.push({ name: "discord", signingSecret: discordSecret });
+    }
+    const telegramSecret = env[ENV_VARS.telegram.webhookSecret];
+    if (telegramSecret) {
+        adapters.push({
+            name: "telegram",
+            webhookSecret: telegramSecret,
+            botUsername: env[ENV_VARS.telegram.botUsername] ?? null,
+            tenantId: env[ENV_VARS.telegram.tenantId] ?? null,
+        });
+    }
+    return adapters;
+}
+export async function bootstrapControlPlane(opts) {
+    const env = opts.env ?? process.env;
+    const detected = detectAdapters(env);
+    if (detected.length === 0) {
+        return null;
+    }
+    const paths = getControlPlanePaths(opts.repoRoot);
+    const runtime = new ControlPlaneRuntime({ repoRoot: opts.repoRoot });
+    await runtime.start();
+    const pipeline = new ControlPlaneCommandPipeline({ runtime });
+    await pipeline.start();
+    const outbox = new ControlPlaneOutbox(paths.outboxPath);
+    await outbox.load();
+    const adapterMap = new Map();
+    for (const d of detected) {
+        const route = ROUTE_MAP[d.name];
+        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,
+                    tenantId: d.tenantId ?? undefined,
+                });
+                break;
+        }
+        adapterMap.set(route, { adapter, info: { name: d.name, route } });
+    }
+    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() {
+            await pipeline.stop();
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,2 +1,4 @@
-export type { ServerOptions, ServerContext } from "./server.js";
-export { createServer, createContext } from "./server.js";
+export type { ServerOptions, ServerContext, ServerWithControlPlane } from "./server.js";
+export { createServer, createServerAsync, createContext } from "./server.js";
+export type { ControlPlaneHandle, ActiveAdapter } from "./control_plane.js";
+export { bootstrapControlPlane, detectAdapters, ENV_VARS } from "./control_plane.js";

package/dist/index.js

@@ -1 +1,2 @@
-export { createServer, createContext } from "./server.js";
+export { createServer, createServerAsync, createContext } from "./server.js";
+export { bootstrapControlPlane, detectAdapters, ENV_VARS } from "./control_plane.js";

package/dist/server.d.ts

@@ -1,9 +1,11 @@
 import { EventLog } from "@femtomc/mu-core/node";
 import { IssueStore } from "@femtomc/mu-issue";
 import { ForumStore } from "@femtomc/mu-forum";
+import { type ControlPlaneHandle } from "./control_plane.js";
 export type ServerOptions = {
     repoRoot?: string;
     port?: number;
+    controlPlane?: ControlPlaneHandle | null;
 };
 export type ServerContext = {
     repoRoot: string;
@@ -17,3 +19,10 @@ export declare function createServer(options?: ServerOptions): {
     fetch: (request: Request) => Promise<Response>;
     hostname: string;
 };
+export type ServerWithControlPlane = {
+    serverConfig: ReturnType<typeof createServer>;
+    controlPlane: ControlPlaneHandle | null;
+};
+export declare function createServerAsync(options?: Omit<ServerOptions, "controlPlane"> & {
+    env?: Record<string, string | undefined>;
+}): Promise<ServerWithControlPlane>;

package/dist/server.js

@@ -6,6 +6,7 @@ import { IssueStore } from "@femtomc/mu-issue";
 import { ForumStore } from "@femtomc/mu-forum";
 import { issueRoutes } from "./api/issues.js";
 import { forumRoutes } from "./api/forum.js";
+import { bootstrapControlPlane } from "./control_plane.js";
 const MIME_TYPES = {
     ".html": "text/html; charset=utf-8",
     ".js": "text/javascript; charset=utf-8",
@@ -30,6 +31,7 @@ export function createContext(repoRoot) {
 export function createServer(options = {}) {
     const repoRoot = options.repoRoot || process.cwd();
     const context = createContext(repoRoot);
+    const controlPlane = options.controlPlane ?? null;
     const handleRequest = async (request) => {
         const url = new URL(request.url);
         const path = url.pathname;
@@ -55,7 +57,10 @@ export function createServer(options = {}) {
             return Response.json({
                 repo_root: context.repoRoot,
                 open_count: openIssues.length,
-                ready_count: readyIssues.length
+                ready_count: readyIssues.length,
+                control_plane: controlPlane
+                    ? { active: true, adapters: controlPlane.activeAdapters.map(a => a.name) }
+                    : { active: false, adapters: [] },
             }, { headers });
         }
         // Issue routes
@@ -72,6 +77,14 @@ export function createServer(options = {}) {
             headers.forEach((value, key) => response.headers.set(key, value));
             return response;
         }
+        // Webhook routes (control plane)
+        if (path.startsWith("/webhooks/") && controlPlane) {
+            const response = await controlPlane.handleWebhook(path, request);
+            if (response) {
+                headers.forEach((value, key) => response.headers.set(key, value));
+                return response;
+            }
+        }
         // Static file serving (bundled web UI)
         if (existsSync(PUBLIC_DIR)) {
             // Try to serve the exact file (with path traversal protection)
@@ -103,3 +116,9 @@ export function createServer(options = {}) {
     };
     return server;
 }
+export async function createServerAsync(options = {}) {
+    const repoRoot = options.repoRoot || process.cwd();
+    const controlPlane = await bootstrapControlPlane({ repoRoot, env: options.env });
+    const serverConfig = createServer({ ...options, controlPlane });
+    return { serverConfig, controlPlane };
+}

package/package.json

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