@femtomc/mu-server 26.2.90 → 26.2.91

package/README.md

@@ -86,7 +86,7 @@ Use `mu store paths --pretty` to resolve `<store>` for the active repo/workspace
     "patch": {
       "control_plane": {
         "adapters": {
-          "slack": { "signing_secret": "..." }
+          "slack": { "signing_secret": "...", "bot_token": "xoxb-..." }
         },
         "memory_index": {
           "enabled": true,
@@ -124,14 +124,7 @@ Use `mu store paths --pretty` to resolve `<store>` for the active repo/workspace
 
 ### Control-plane Coordination Endpoints
 
-- Runs:
-  - `GET /api/control-plane/runs`
-  - `POST /api/control-plane/runs/start`
-  - `POST /api/control-plane/runs/resume`
-  - `POST /api/control-plane/runs/interrupt`
-  - `GET /api/control-plane/runs/:id`
-  - `GET /api/control-plane/runs/:id/trace`
-- Scheduling + orchestration:
+- Scheduling + coordination:
   - `GET|POST|PATCH|DELETE /api/heartbeats...`
   - `GET|POST|PATCH|DELETE /api/cron...`
   - Heartbeat programs support an optional free-form `prompt` field; when present it becomes the primary wake instruction sent to the operator turn path.
@@ -156,7 +149,7 @@ mu control status --pretty
 
 2) Edit `<store>/config.json` and set adapter secrets:
 
-- Slack: `control_plane.adapters.slack.signing_secret`
+- Slack: `control_plane.adapters.slack.signing_secret`, `bot_token`
 - Discord: `control_plane.adapters.discord.signing_secret`
 - Telegram: `control_plane.adapters.telegram.webhook_secret`, `bot_token`, `bot_username`
 - Neovim: `control_plane.adapters.neovim.shared_secret`
@@ -178,6 +171,26 @@ mu control link --channel telegram --actor-id <chat-id> --tenant-id telegram-bot
 
 For Neovim, use `:Mu link` in `mu.nvim` after configuring `shared_secret`.
 
+## Media support operations checklist
+
+When validating attachment support end-to-end, use this sequence:
+
+1. Configure adapter secrets/tokens in `<store>/config.json` (Slack/Telegram need bot tokens for media egress).
+2. Reload control-plane (`mu control reload`).
+3. Verify `/api/control-plane/channels` media capability flags:
+   - `media.outbound_delivery`
+   - `media.inbound_attachment_download`
+4. Send a text-only control-plane turn and verify normal delivery semantics still hold.
+5. Send attachment-bearing ingress/outbox payloads and verify channel-specific routing:
+   - Slack media upload through `files.upload`
+   - Telegram PNG/JPEG/WEBP images through `sendPhoto`
+   - Telegram SVG/PDF through `sendDocument`
+
+Operational fallback expectations:
+
+- If media upload fails, Telegram delivery falls back to text `sendMessage`.
+- If Slack/Telegram bot token is missing, channel capability reason codes should report `*_bot_token_missing` and outbound delivery retries rather than hard-crashing runtime.
+
 ## Running the Server
 
 ### With terminal operator session (recommended)

package/dist/api/control_plane.js

@@ -1,8 +1,7 @@
-import { CONTROL_PLANE_CHANNEL_ADAPTER_SPECS } from "@femtomc/mu-control-plane";
+import { CONTROL_PLANE_CHANNEL_ADAPTER_SPECS, ingressModeForValue, summarizeInboundAttachmentPolicy, } from "@femtomc/mu-control-plane";
 import { configRoutes } from "./config.js";
 import { eventRoutes } from "./events.js";
 import { identityRoutes } from "./identities.js";
-import { runRoutes } from "./runs.js";
 import { sessionTurnRoutes } from "./session_turn.js";
 function asRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -35,6 +34,64 @@ function configuredForChannel(config, channel) {
             return false;
     }
 }
+function mediaOutboundCapability(config, channel) {
+    switch (channel) {
+        case "slack": {
+            const configured = typeof config.control_plane.adapters.slack.bot_token === "string";
+            return {
+                supported: true,
+                configured,
+                reason: configured ? null : "slack_bot_token_missing",
+            };
+        }
+        case "telegram": {
+            const configured = typeof config.control_plane.adapters.telegram.bot_token === "string";
+            return {
+                supported: true,
+                configured,
+                reason: configured ? null : "telegram_bot_token_missing",
+            };
+        }
+        default:
+            return {
+                supported: false,
+                configured: false,
+                reason: "channel_media_delivery_unsupported",
+            };
+    }
+}
+function mediaInboundAttachmentCapability(config, channel) {
+    if (channel !== "slack" && channel !== "telegram") {
+        return {
+            supported: false,
+            configured: false,
+            reason: "channel_attachment_ingress_unsupported",
+        };
+    }
+    const channelModes = summarizeInboundAttachmentPolicy().channel_modes;
+    const policyEnabled = channelModes[channel] === "enabled";
+    if (!policyEnabled) {
+        return {
+            supported: true,
+            configured: false,
+            reason: "inbound_attachment_channel_disabled",
+        };
+    }
+    if (channel === "slack") {
+        const hasToken = typeof config.control_plane.adapters.slack.bot_token === "string";
+        return {
+            supported: true,
+            configured: hasToken,
+            reason: hasToken ? null : "slack_bot_token_missing",
+        };
+    }
+    const hasToken = typeof config.control_plane.adapters.telegram.bot_token === "string";
+    return {
+        supported: true,
+        configured: hasToken,
+        reason: hasToken ? null : "telegram_bot_token_missing",
+    };
+}
 export async function controlPlaneRoutes(request, url, deps, headers) {
     const path = url.pathname;
     if (path === "/api/control-plane" || path === "/api/control-plane/status") {
@@ -99,9 +156,14 @@ export async function controlPlaneRoutes(request, url, deps, headers) {
             ack_format: spec.ack_format,
             delivery_semantics: spec.delivery_semantics,
             deferred_delivery: spec.deferred_delivery,
+            ingress_mode: ingressModeForValue(spec.channel),
             configured: configuredForChannel(config, spec.channel),
             active: activeChannels.has(spec.channel),
             frontend: spec.channel === "neovim",
+            media: {
+                outbound_delivery: mediaOutboundCapability(config, spec.channel),
+                inbound_attachment_download: mediaInboundAttachmentCapability(config, spec.channel),
+            },
         }));
         return Response.json({
             ok: true,
@@ -109,9 +171,6 @@ export async function controlPlaneRoutes(request, url, deps, headers) {
             channels,
         }, { headers });
     }
-    if (path === "/api/control-plane/runs" || path.startsWith("/api/control-plane/runs/")) {
-        return runRoutes(request, url, deps, headers);
-    }
     if (path === "/api/control-plane/turn") {
         return sessionTurnRoutes(request, url, deps, headers);
     }

package/dist/config.d.ts

@@ -4,6 +4,7 @@ export type MuConfig = {
         adapters: {
             slack: {
                 signing_secret: string | null;
+                bot_token: string | null;
             };
             discord: {
                 signing_secret: string | null;
@@ -19,7 +20,6 @@ export type MuConfig = {
         };
         operator: {
             enabled: boolean;
-            run_triggers_enabled: boolean;
             provider: string | null;
             model: string | null;
             thinking: string | null;
@@ -35,6 +35,7 @@ export type MuConfigPatch = {
         adapters?: {
             slack?: {
                 signing_secret?: string | null;
+                bot_token?: string | null;
             };
             discord?: {
                 signing_secret?: string | null;
@@ -50,7 +51,6 @@ export type MuConfigPatch = {
         };
         operator?: {
             enabled?: boolean;
-            run_triggers_enabled?: boolean;
             provider?: string | null;
             model?: string | null;
             thinking?: string | null;
@@ -66,6 +66,7 @@ export type MuConfigPresence = {
         adapters: {
             slack: {
                 signing_secret: boolean;
+                bot_token: boolean;
             };
             discord: {
                 signing_secret: boolean;
@@ -81,7 +82,6 @@ export type MuConfigPresence = {
         };
         operator: {
             enabled: boolean;
-            run_triggers_enabled: boolean;
             provider: boolean;
             model: boolean;
             thinking: boolean;

package/dist/config.js

@@ -7,6 +7,7 @@ export const DEFAULT_MU_CONFIG = {
         adapters: {
             slack: {
                 signing_secret: null,
+                bot_token: null,
             },
             discord: {
                 signing_secret: null,
@@ -22,7 +23,6 @@ export const DEFAULT_MU_CONFIG = {
         },
         operator: {
             enabled: true,
-            run_triggers_enabled: true,
             provider: null,
             model: null,
             thinking: null,
@@ -91,6 +91,9 @@ export function normalizeMuConfig(input) {
         if (slack && "signing_secret" in slack) {
             next.control_plane.adapters.slack.signing_secret = normalizeNullableString(slack.signing_secret);
         }
+        if (slack && "bot_token" in slack) {
+            next.control_plane.adapters.slack.bot_token = normalizeNullableString(slack.bot_token);
+        }
         const discord = asRecord(adapters.discord);
         if (discord && "signing_secret" in discord) {
             next.control_plane.adapters.discord.signing_secret = normalizeNullableString(discord.signing_secret);
@@ -117,9 +120,6 @@ export function normalizeMuConfig(input) {
         if ("enabled" in operator) {
             next.control_plane.operator.enabled = normalizeBoolean(operator.enabled, next.control_plane.operator.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 operator) {
             next.control_plane.operator.provider = normalizeNullableString(operator.provider);
         }
@@ -154,10 +154,17 @@ function normalizeMuConfigPatch(input) {
     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),
-            };
+        if (slack) {
+            const slackPatch = {};
+            if ("signing_secret" in slack) {
+                slackPatch.signing_secret = normalizeNullableString(slack.signing_secret);
+            }
+            if ("bot_token" in slack) {
+                slackPatch.bot_token = normalizeNullableString(slack.bot_token);
+            }
+            if (Object.keys(slackPatch).length > 0) {
+                patch.control_plane.adapters.slack = slackPatch;
+            }
         }
         const discord = asRecord(adapters.discord);
         if (discord && "signing_secret" in discord) {
@@ -198,9 +205,6 @@ function normalizeMuConfigPatch(input) {
         if ("enabled" in operator) {
             patch.control_plane.operator.enabled = normalizeBoolean(operator.enabled, DEFAULT_MU_CONFIG.control_plane.operator.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 operator) {
             patch.control_plane.operator.provider = normalizeNullableString(operator.provider);
         }
@@ -249,6 +253,9 @@ export function applyMuConfigPatch(base, patchInput) {
         if (adapters.slack && "signing_secret" in adapters.slack) {
             next.control_plane.adapters.slack.signing_secret = adapters.slack.signing_secret ?? null;
         }
+        if (adapters.slack && "bot_token" in adapters.slack) {
+            next.control_plane.adapters.slack.bot_token = adapters.slack.bot_token ?? null;
+        }
         if (adapters.discord && "signing_secret" in adapters.discord) {
             next.control_plane.adapters.discord.signing_secret = adapters.discord.signing_secret ?? null;
         }
@@ -272,9 +279,6 @@ export function applyMuConfigPatch(base, patchInput) {
         if ("enabled" in operator && typeof operator.enabled === "boolean") {
             next.control_plane.operator.enabled = operator.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 operator) {
             next.control_plane.operator.provider = operator.provider ?? null;
         }
@@ -334,6 +338,7 @@ function redacted(value) {
 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.slack.bot_token = redacted(next.control_plane.adapters.slack.bot_token);
     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);
@@ -349,6 +354,7 @@ export function muConfigPresence(config) {
             adapters: {
                 slack: {
                     signing_secret: isPresent(config.control_plane.adapters.slack.signing_secret),
+                    bot_token: isPresent(config.control_plane.adapters.slack.bot_token),
                 },
                 discord: {
                     signing_secret: isPresent(config.control_plane.adapters.discord.signing_secret),
@@ -364,7 +370,6 @@ export function muConfigPresence(config) {
             },
             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),
                 thinking: isPresent(config.control_plane.operator.thinking),

package/dist/control_plane.d.ts

@@ -1,7 +1,6 @@
 import type { MessagingOperatorBackend, MessagingOperatorRuntime } from "@femtomc/mu-agent";
-import { type GenerationTelemetryRecorder } from "@femtomc/mu-control-plane";
-import { type ControlPlaneConfig, type ControlPlaneGenerationContext, type ControlPlaneHandle, type ControlPlaneSessionLifecycle, type InterRootQueuePolicy, type TelegramGenerationSwapHooks, type WakeDeliveryObserver } from "./control_plane_contract.js";
-import { type ControlPlaneRunSupervisorOpts } from "./run_supervisor.js";
+import { type GenerationTelemetryRecorder, type OutboxDeliveryHandlerResult, type OutboxRecord } from "@femtomc/mu-control-plane";
+import { type ControlPlaneConfig, type ControlPlaneGenerationContext, type ControlPlaneHandle, type ControlPlaneSessionLifecycle, type TelegramGenerationSwapHooks, type WakeDeliveryObserver } from "./control_plane_contract.js";
 import { detectAdapters } from "./control_plane_adapter_registry.js";
 export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneGenerationContext, ControlPlaneHandle, ControlPlaneSessionLifecycle, ControlPlaneSessionMutationAction, ControlPlaneSessionMutationResult, NotifyOperatorsOpts, NotifyOperatorsResult, TelegramGenerationReloadResult, TelegramGenerationRollbackTrigger, TelegramGenerationSwapHooks, WakeDeliveryEvent, WakeDeliveryObserver, WakeNotifyContext, WakeNotifyDecision, } from "./control_plane_contract.js";
 export { detectAdapters };
@@ -11,6 +10,16 @@ export type TelegramSendMessagePayload = {
     parse_mode?: "Markdown";
     disable_web_page_preview?: boolean;
 };
+export type TelegramSendPhotoPayload = {
+    chat_id: string;
+    photo: string;
+    caption?: string;
+};
+export type TelegramSendDocumentPayload = {
+    chat_id: string;
+    document: string;
+    caption?: string;
+};
 /**
  * Telegram supports a markdown dialect that uses single markers for emphasis.
  * Normalize the most common LLM/GitHub-style markers (`**bold**`, `__italic__`, headings)
@@ -23,18 +32,24 @@ export declare function buildTelegramSendMessagePayload(opts: {
     text: string;
     richFormatting: boolean;
 }): TelegramSendMessagePayload;
+export declare function deliverTelegramOutboxRecord(opts: {
+    botToken: string;
+    record: OutboxRecord;
+}): Promise<OutboxDeliveryHandlerResult>;
+export declare function deliverSlackOutboxRecord(opts: {
+    botToken: string;
+    record: OutboxRecord;
+}): Promise<OutboxDeliveryHandlerResult>;
 export type BootstrapControlPlaneOpts = {
     repoRoot: string;
     config?: ControlPlaneConfig;
     operatorRuntime?: MessagingOperatorRuntime | null;
     operatorBackend?: MessagingOperatorBackend;
-    runSupervisorSpawnProcess?: ControlPlaneRunSupervisorOpts["spawnProcess"];
     sessionLifecycle: ControlPlaneSessionLifecycle;
     generation?: ControlPlaneGenerationContext;
     telemetry?: GenerationTelemetryRecorder | null;
     telegramGenerationHooks?: TelegramGenerationSwapHooks;
     wakeDeliveryObserver?: WakeDeliveryObserver | null;
     terminalEnabled?: boolean;
-    interRootQueuePolicy?: InterRootQueuePolicy;
 };
 export declare function bootstrapControlPlane(opts: BootstrapControlPlaneOpts): Promise<ControlPlaneHandle | null>;