@femtomc/mu-server 26.2.69 → 26.2.70

package/dist/control_plane_bootstrap_helpers.d.ts

@@ -0,0 +1,15 @@
+import { type MessagingOperatorBackend, MessagingOperatorRuntime } from "@femtomc/mu-agent";
+import { ControlPlaneOutbox, type OutboxDeliveryHandlerResult, type OutboxRecord } from "@femtomc/mu-control-plane";
+import type { ControlPlaneConfig } from "./control_plane_contract.js";
+export declare function buildMessagingOperatorRuntime(opts: {
+    repoRoot: string;
+    config: ControlPlaneConfig;
+    backend?: MessagingOperatorBackend;
+}): MessagingOperatorRuntime | null;
+export declare function createOutboxDrainLoop(opts: {
+    outbox: ControlPlaneOutbox;
+    deliver: (record: OutboxRecord) => Promise<undefined | OutboxDeliveryHandlerResult>;
+}): {
+    scheduleOutboxDrain: () => void;
+    stop: () => void;
+};

package/dist/control_plane_bootstrap_helpers.js

@@ -0,0 +1,75 @@
+import { ApprovedCommandBroker, CommandContextResolver, MessagingOperatorRuntime, operatorExtensionPaths, PiMessagingOperatorBackend, } from "@femtomc/mu-agent";
+import { ControlPlaneOutboxDispatcher, } from "@femtomc/mu-control-plane";
+const OUTBOX_DRAIN_INTERVAL_MS = 500;
+export function buildMessagingOperatorRuntime(opts) {
+    if (!opts.config.operator.enabled) {
+        return null;
+    }
+    const backend = opts.backend ??
+        new PiMessagingOperatorBackend({
+            provider: opts.config.operator.provider ?? undefined,
+            model: opts.config.operator.model ?? undefined,
+            extensionPaths: operatorExtensionPaths,
+        });
+    return new MessagingOperatorRuntime({
+        backend,
+        broker: new ApprovedCommandBroker({
+            runTriggersEnabled: opts.config.operator.run_triggers_enabled,
+            contextResolver: new CommandContextResolver({ allowedRepoRoots: [opts.repoRoot] }),
+        }),
+        enabled: true,
+    });
+}
+export function createOutboxDrainLoop(opts) {
+    const dispatcher = new ControlPlaneOutboxDispatcher({
+        outbox: opts.outbox,
+        deliver: opts.deliver,
+    });
+    let drainingOutbox = false;
+    let drainRequested = false;
+    let stopped = false;
+    const drainOutboxNow = async () => {
+        if (stopped) {
+            return;
+        }
+        if (drainingOutbox) {
+            drainRequested = true;
+            return;
+        }
+        drainingOutbox = true;
+        try {
+            do {
+                drainRequested = false;
+                await dispatcher.drainDue();
+            } while (drainRequested && !stopped);
+        }
+        catch {
+            // Swallow errors — dispatcher handles retry progression internally.
+        }
+        finally {
+            drainingOutbox = false;
+        }
+    };
+    const scheduleOutboxDrain = () => {
+        if (stopped) {
+            return;
+        }
+        queueMicrotask(() => {
+            void drainOutboxNow();
+        });
+    };
+    const interval = setInterval(() => {
+        scheduleOutboxDrain();
+    }, OUTBOX_DRAIN_INTERVAL_MS);
+    scheduleOutboxDrain();
+    return {
+        scheduleOutboxDrain,
+        stop: () => {
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            clearInterval(interval);
+        },
+    };
+}

package/dist/control_plane_contract.d.ts

@@ -0,0 +1,119 @@
+import type { Channel, CommandPipelineResult, ReloadableGenerationIdentity } from "@femtomc/mu-control-plane";
+import type { ControlPlaneRunHeartbeatResult, ControlPlaneRunInterruptResult, ControlPlaneRunSnapshot, ControlPlaneRunTrace } from "./run_supervisor.js";
+import type { MuConfig } from "./config.js";
+/**
+ * Boundary contracts for server/control-plane composition.
+ *
+ * Dependency direction:
+ * - Domain/application code should depend on these contracts.
+ * - Interface adapters in `control_plane.ts` implement these seams.
+ */
+export type ControlPlaneConfig = MuConfig["control_plane"];
+export type ActiveAdapter = {
+    name: Channel;
+    route: string;
+};
+export type TelegramGenerationRollbackTrigger = "manual" | "warmup_failed" | "health_gate_failed" | "cutover_failed" | "post_cutover_health_failed" | "rollback_unavailable" | "rollback_failed";
+export type TelegramGenerationReloadResult = {
+    handled: boolean;
+    ok: boolean;
+    reason: string;
+    route: string;
+    from_generation: ReloadableGenerationIdentity | null;
+    to_generation: ReloadableGenerationIdentity | null;
+    active_generation: ReloadableGenerationIdentity | null;
+    warmup: {
+        ok: boolean;
+        elapsed_ms: number;
+        error?: string;
+    } | null;
+    cutover: {
+        ok: boolean;
+        elapsed_ms: number;
+        error?: string;
+    } | null;
+    drain: {
+        ok: boolean;
+        elapsed_ms: number;
+        timed_out: boolean;
+        forced_stop: boolean;
+        error?: string;
+    } | null;
+    rollback: {
+        requested: boolean;
+        trigger: TelegramGenerationRollbackTrigger | null;
+        attempted: boolean;
+        ok: boolean;
+        error?: string;
+    };
+    error?: string;
+};
+export type ControlPlaneGenerationContext = ReloadableGenerationIdentity;
+export type TelegramGenerationSwapHooks = {
+    onWarmup?: (ctx: {
+        generation: ReloadableGenerationIdentity;
+        reason: string;
+    }) => void | Promise<void>;
+    onCutover?: (ctx: {
+        from_generation: ReloadableGenerationIdentity | null;
+        to_generation: ReloadableGenerationIdentity;
+        reason: string;
+    }) => void | Promise<void>;
+    onDrain?: (ctx: {
+        generation: ReloadableGenerationIdentity;
+        reason: string;
+        timeout_ms: number;
+    }) => void | Promise<void>;
+};
+export type ControlPlaneSessionMutationAction = "reload" | "update";
+export type ControlPlaneSessionMutationResult = {
+    ok: boolean;
+    action: ControlPlaneSessionMutationAction;
+    message: string;
+    details?: Record<string, unknown>;
+};
+export type ControlPlaneSessionLifecycle = {
+    reload: () => Promise<ControlPlaneSessionMutationResult>;
+    update: () => Promise<ControlPlaneSessionMutationResult>;
+};
+export type ControlPlaneHandle = {
+    activeAdapters: ActiveAdapter[];
+    handleWebhook(path: string, req: Request): Promise<Response | null>;
+    reloadTelegramGeneration?(opts: {
+        config: ControlPlaneConfig;
+        reason: string;
+    }): Promise<TelegramGenerationReloadResult>;
+    listRuns?(opts?: {
+        status?: string;
+        limit?: number;
+    }): Promise<ControlPlaneRunSnapshot[]>;
+    getRun?(idOrRoot: string): Promise<ControlPlaneRunSnapshot | null>;
+    startRun?(opts: {
+        prompt: string;
+        maxSteps?: number;
+    }): Promise<ControlPlaneRunSnapshot>;
+    resumeRun?(opts: {
+        rootIssueId: string;
+        maxSteps?: number;
+    }): Promise<ControlPlaneRunSnapshot>;
+    interruptRun?(opts: {
+        jobId?: string | null;
+        rootIssueId?: string | null;
+    }): Promise<ControlPlaneRunInterruptResult>;
+    heartbeatRun?(opts: {
+        jobId?: string | null;
+        rootIssueId?: string | null;
+        reason?: string | null;
+        wakeMode?: string | null;
+    }): Promise<ControlPlaneRunHeartbeatResult>;
+    traceRun?(opts: {
+        idOrRoot: string;
+        limit?: number;
+    }): Promise<ControlPlaneRunTrace | null>;
+    submitTerminalCommand?(opts: {
+        commandText: string;
+        repoRoot: string;
+        requestId?: string;
+    }): Promise<CommandPipelineResult>;
+    stop(): Promise<void>;
+};

package/dist/control_plane_contract.js

@@ -0,0 +1 @@
+export {};

package/dist/control_plane_run_outbox.d.ts

@@ -0,0 +1,7 @@
+import { type ControlPlaneOutbox, type OutboxRecord } from "@femtomc/mu-control-plane";
+import type { ControlPlaneRunEvent } from "./run_supervisor.js";
+export declare function enqueueRunEventOutbox(opts: {
+    outbox: ControlPlaneOutbox;
+    event: ControlPlaneRunEvent;
+    nowMs: number;
+}): Promise<OutboxRecord | null>;

package/dist/control_plane_run_outbox.js

@@ -0,0 +1,52 @@
+import { correlationFromCommandRecord, } from "@femtomc/mu-control-plane";
+function sha256Hex(input) {
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(input);
+    return hasher.digest("hex");
+}
+function outboxKindForRunEvent(kind) {
+    switch (kind) {
+        case "run_completed":
+            return "result";
+        case "run_failed":
+            return "error";
+        default:
+            return "lifecycle";
+    }
+}
+export async function enqueueRunEventOutbox(opts) {
+    const command = opts.event.command;
+    if (!command) {
+        return null;
+    }
+    const baseCorrelation = correlationFromCommandRecord(command);
+    const correlation = {
+        ...baseCorrelation,
+        run_root_id: opts.event.run.root_issue_id ?? baseCorrelation.run_root_id,
+    };
+    const envelope = {
+        v: 1,
+        ts_ms: opts.nowMs,
+        channel: command.channel,
+        channel_tenant_id: command.channel_tenant_id,
+        channel_conversation_id: command.channel_conversation_id,
+        request_id: command.request_id,
+        response_id: `resp-${sha256Hex(`run-event:${opts.event.run.job_id}:${opts.event.seq}:${opts.nowMs}`).slice(0, 20)}`,
+        kind: outboxKindForRunEvent(opts.event.kind),
+        body: opts.event.message,
+        correlation,
+        metadata: {
+            async_run: true,
+            run_event_kind: opts.event.kind,
+            run_event_seq: opts.event.seq,
+            run: opts.event.run,
+        },
+    };
+    const decision = await opts.outbox.enqueue({
+        dedupeKey: `run-event:${opts.event.run.job_id}:${opts.event.seq}`,
+        envelope,
+        nowMs: opts.nowMs,
+        maxAttempts: 6,
+    });
+    return decision.record;
+}

package/dist/control_plane_telegram_generation.d.ts

@@ -0,0 +1,27 @@
+import { ControlPlaneCommandPipeline, ControlPlaneOutbox, type ControlPlaneSignalObserver, type ReloadableGenerationIdentity, TelegramControlPlaneAdapter } from "@femtomc/mu-control-plane";
+import type { ControlPlaneConfig, TelegramGenerationReloadResult, TelegramGenerationSwapHooks } from "./control_plane_contract.js";
+export declare class TelegramAdapterGenerationManager {
+    #private;
+    constructor(opts: {
+        pipeline: ControlPlaneCommandPipeline;
+        outbox: ControlPlaneOutbox;
+        initialConfig: ControlPlaneConfig;
+        nowMs?: () => number;
+        onOutboxEnqueued?: () => void;
+        signalObserver?: ControlPlaneSignalObserver;
+        hooks?: TelegramGenerationSwapHooks;
+    });
+    initialize(): Promise<void>;
+    hasActiveGeneration(): boolean;
+    activeGeneration(): ReloadableGenerationIdentity | null;
+    activeBotToken(): string | null;
+    activeAdapter(): TelegramControlPlaneAdapter | null;
+    canHandleConfig(nextConfig: ControlPlaneConfig, reason: string): boolean;
+    reload(opts: {
+        config: ControlPlaneConfig;
+        reason: string;
+        warmupTimeoutMs?: number;
+        drainTimeoutMs?: number;
+    }): Promise<TelegramGenerationReloadResult>;
+    stop(): Promise<void>;
+}