@femtomc/mu-server 26.2.66 → 26.2.67

package/dist/control_plane.d.ts

@@ -101,6 +101,17 @@ export type TelegramGenerationSwapHooks = {
         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 ControlPlaneSessionMutationHooks = {
+    reload?: () => Promise<ControlPlaneSessionMutationResult>;
+    update?: () => Promise<ControlPlaneSessionMutationResult>;
+};
 type DetectedAdapter = {
     name: "slack";
     signingSecret: string;
@@ -140,6 +151,7 @@ export type BootstrapControlPlaneOpts = {
     heartbeatScheduler?: ActivityHeartbeatScheduler;
     runSupervisorSpawnProcess?: ControlPlaneRunSupervisorOpts["spawnProcess"];
     runSupervisorHeartbeatIntervalMs?: number;
+    sessionMutationHooks?: ControlPlaneSessionMutationHooks;
     generation?: ControlPlaneGenerationContext;
     telemetry?: GenerationTelemetryRecorder | null;
     telegramGenerationHooks?: TelegramGenerationSwapHooks;

package/dist/control_plane.js

@@ -745,6 +745,116 @@ export async function bootstrapControlPlane(opts) {
             runtime,
             operator,
             mutationExecutor: async (record) => {
+                if (record.target_type === "reload" || record.target_type === "update") {
+                    if (record.command_args.length > 0) {
+                        return {
+                            terminalState: "failed",
+                            errorCode: "cli_validation_failed",
+                            trace: {
+                                cliCommandKind: record.target_type,
+                                runRootId: null,
+                            },
+                            mutatingEvents: [
+                                {
+                                    eventType: "session.lifecycle.command.failed",
+                                    payload: {
+                                        action: record.target_type,
+                                        reason: "unexpected_args",
+                                        args: record.command_args,
+                                    },
+                                },
+                            ],
+                        };
+                    }
+                    const action = record.target_type;
+                    const hook = action === "reload"
+                        ? opts.sessionMutationHooks?.reload
+                        : opts.sessionMutationHooks?.update;
+                    if (!hook) {
+                        return {
+                            terminalState: "failed",
+                            errorCode: "session_lifecycle_unavailable",
+                            trace: {
+                                cliCommandKind: action,
+                                runRootId: null,
+                            },
+                            mutatingEvents: [
+                                {
+                                    eventType: "session.lifecycle.command.failed",
+                                    payload: {
+                                        action,
+                                        reason: "hook_missing",
+                                    },
+                                },
+                            ],
+                        };
+                    }
+                    try {
+                        const lifecycle = await hook();
+                        if (!lifecycle.ok) {
+                            return {
+                                terminalState: "failed",
+                                errorCode: "session_lifecycle_failed",
+                                trace: {
+                                    cliCommandKind: action,
+                                    runRootId: null,
+                                },
+                                mutatingEvents: [
+                                    {
+                                        eventType: "session.lifecycle.command.failed",
+                                        payload: {
+                                            action,
+                                            reason: lifecycle.message,
+                                            details: lifecycle.details ?? null,
+                                        },
+                                    },
+                                ],
+                            };
+                        }
+                        return {
+                            terminalState: "completed",
+                            result: {
+                                ok: true,
+                                action,
+                                message: lifecycle.message,
+                                details: lifecycle.details ?? null,
+                            },
+                            trace: {
+                                cliCommandKind: action,
+                                runRootId: null,
+                            },
+                            mutatingEvents: [
+                                {
+                                    eventType: `session.lifecycle.command.${action}`,
+                                    payload: {
+                                        action,
+                                        message: lifecycle.message,
+                                        details: lifecycle.details ?? null,
+                                    },
+                                },
+                            ],
+                        };
+                    }
+                    catch (err) {
+                        return {
+                            terminalState: "failed",
+                            errorCode: err instanceof Error && err.message ? err.message : "session_lifecycle_failed",
+                            trace: {
+                                cliCommandKind: action,
+                                runRootId: null,
+                            },
+                            mutatingEvents: [
+                                {
+                                    eventType: "session.lifecycle.command.failed",
+                                    payload: {
+                                        action,
+                                        reason: err instanceof Error && err.message ? err.message : "session_lifecycle_failed",
+                                    },
+                                },
+                            ],
+                        };
+                    }
+                }
                 if (record.target_type === "run start" || record.target_type === "run resume") {
                     try {
                         const launched = await runSupervisor?.startFromCommand(record);

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export type { ControlPlaneActivityEvent, ControlPlaneActivityEventKind, ControlP
 export { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 export type { MuConfig, MuConfigPatch, MuConfigPresence } from "./config.js";
 export { applyMuConfigPatch, DEFAULT_MU_CONFIG, getMuConfigPath, muConfigPresence, normalizeMuConfig, readMuConfigFile, redactMuConfigSecrets, writeMuConfigFile, } from "./config.js";
-export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneHandle } from "./control_plane.js";
+export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneHandle, ControlPlaneSessionMutationAction, ControlPlaneSessionMutationHooks, ControlPlaneSessionMutationResult, } from "./control_plane.js";
 export { bootstrapControlPlane, detectAdapters } from "./control_plane.js";
 export type { CronProgramLifecycleAction, CronProgramLifecycleEvent, CronProgramOperationResult, CronProgramRegistryOpts, CronProgramSnapshot, CronProgramStatusSnapshot, CronProgramTarget, CronProgramTickEvent, CronProgramWakeMode, } from "./cron_programs.js";
 export { CronProgramRegistry } from "./cron_programs.js";

package/dist/server.d.ts

@@ -5,7 +5,7 @@ import { ForumStore } from "@femtomc/mu-forum";
 import { IssueStore } from "@femtomc/mu-issue";
 import { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 import { type MuConfig } from "./config.js";
-import { type ControlPlaneConfig, type ControlPlaneHandle } from "./control_plane.js";
+import { type ControlPlaneConfig, type ControlPlaneHandle, type ControlPlaneSessionMutationHooks } from "./control_plane.js";
 import { CronProgramRegistry } from "./cron_programs.js";
 import { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
 import { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
@@ -30,6 +30,7 @@ export type ServerOptions = {
     config?: MuConfig;
     configReader?: ConfigReader;
     configWriter?: ConfigWriter;
+    sessionMutationHooks?: ControlPlaneSessionMutationHooks;
 };
 export type ServerContext = {
     repoRoot: string;

package/dist/server.js

@@ -46,6 +46,12 @@ function toNonNegativeInt(value, fallback) {
     }
     return Math.max(0, Math.trunc(fallback));
 }
+function shellQuoteArg(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function shellJoin(args) {
+    return args.map(shellQuoteArg).join(" ");
+}
 function describeError(err) {
     if (err instanceof Error)
         return err.message;
@@ -165,6 +171,144 @@ export function createServer(options = {}) {
     const autoRunHeartbeatEveryMs = Math.max(1_000, toNonNegativeInt(options.autoRunHeartbeatEveryMs, DEFAULT_AUTO_RUN_HEARTBEAT_EVERY_MS));
     const operatorWakeLastByKey = new Map();
     const autoRunHeartbeatProgramByJobId = new Map();
+    let sessionMutationScheduled = null;
+    const runShellCommand = async (command) => {
+        const proc = Bun.spawn({
+            cmd: ["bash", "-lc", command],
+            cwd: repoRoot,
+            env: Bun.env,
+            stdin: "ignore",
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        const [exitCode, stdout, stderr] = await Promise.all([
+            proc.exited,
+            proc.stdout ? new Response(proc.stdout).text() : Promise.resolve(""),
+            proc.stderr ? new Response(proc.stderr).text() : Promise.resolve(""),
+        ]);
+        return {
+            exitCode: Number.isFinite(exitCode) ? Number(exitCode) : 1,
+            stdout,
+            stderr,
+        };
+    };
+    const defaultSessionMutationHooks = {
+        reload: async () => {
+            if (sessionMutationScheduled) {
+                return {
+                    ok: true,
+                    action: sessionMutationScheduled.action,
+                    message: `session ${sessionMutationScheduled.action} already scheduled`,
+                    details: { scheduled_at_ms: sessionMutationScheduled.at_ms },
+                };
+            }
+            const nowMs = Date.now();
+            const restartCommand = Bun.env.MU_RESTART_COMMAND?.trim();
+            const inferredArgs = process.argv[0] === process.execPath
+                ? [process.execPath, ...process.argv.slice(1)]
+                : [process.execPath, ...process.argv];
+            const restartShellCommand = restartCommand && restartCommand.length > 0 ? restartCommand : shellJoin(inferredArgs);
+            if (!restartShellCommand.trim()) {
+                return {
+                    ok: false,
+                    action: "reload",
+                    message: "unable to determine restart command",
+                };
+            }
+            const exitDelayMs = 1_000;
+            const launchDelayMs = exitDelayMs + 300;
+            const delayedShellCommand = `sleep ${(launchDelayMs / 1_000).toFixed(2)}; ${restartShellCommand}`;
+            let spawnedPid = null;
+            try {
+                const proc = Bun.spawn({
+                    cmd: ["bash", "-lc", delayedShellCommand],
+                    cwd: repoRoot,
+                    env: Bun.env,
+                    stdin: "ignore",
+                    stdout: "inherit",
+                    stderr: "inherit",
+                });
+                spawnedPid = proc.pid ?? null;
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    action: "reload",
+                    message: `failed to spawn replacement process: ${describeError(err)}`,
+                };
+            }
+            sessionMutationScheduled = { action: "reload", at_ms: nowMs };
+            setTimeout(() => {
+                process.exit(0);
+            }, exitDelayMs);
+            return {
+                ok: true,
+                action: "reload",
+                message: "reload scheduled; restarting process",
+                details: {
+                    restart_command: restartShellCommand,
+                    restart_launch_command: delayedShellCommand,
+                    spawned_pid: spawnedPid,
+                    exit_delay_ms: exitDelayMs,
+                    launch_delay_ms: launchDelayMs,
+                },
+            };
+        },
+        update: async () => {
+            if (sessionMutationScheduled) {
+                return {
+                    ok: true,
+                    action: sessionMutationScheduled.action,
+                    message: `session ${sessionMutationScheduled.action} already scheduled`,
+                    details: { scheduled_at_ms: sessionMutationScheduled.at_ms },
+                };
+            }
+            const updateCommand = Bun.env.MU_UPDATE_COMMAND?.trim() || "npm install -g @femtomc/mu@latest";
+            const result = await runShellCommand(updateCommand);
+            if (result.exitCode !== 0) {
+                return {
+                    ok: false,
+                    action: "update",
+                    message: `update command failed (exit ${result.exitCode})`,
+                    details: {
+                        update_command: updateCommand,
+                        stdout: result.stdout.slice(-4_000),
+                        stderr: result.stderr.slice(-4_000),
+                    },
+                };
+            }
+            const reloadResult = await defaultSessionMutationHooks.reload?.();
+            if (!reloadResult) {
+                return {
+                    ok: false,
+                    action: "update",
+                    message: "reload hook unavailable after update",
+                };
+            }
+            if (!reloadResult.ok) {
+                return {
+                    ok: false,
+                    action: "update",
+                    message: reloadResult.message,
+                    details: {
+                        update_command: updateCommand,
+                        reload: reloadResult.details ?? null,
+                    },
+                };
+            }
+            return {
+                ok: true,
+                action: "update",
+                message: "update applied; reload scheduled",
+                details: {
+                    update_command: updateCommand,
+                    reload: reloadResult.details ?? null,
+                    update_stdout_tail: result.stdout.slice(-1_000),
+                },
+            };
+        },
+    };
+    const sessionMutationHooks = options.sessionMutationHooks ?? defaultSessionMutationHooks;
     const emitOperatorWake = async (opts) => {
         const dedupeKey = opts.dedupeKey.trim();
         if (!dedupeKey) {
@@ -214,6 +358,7 @@ export function createServer(options = {}) {
                 heartbeatScheduler,
                 generation,
                 telemetry: generationTelemetry,
+                sessionMutationHooks,
                 terminalEnabled: true,
             });
         });
@@ -1151,6 +1296,12 @@ export function createServer(options = {}) {
                     commandText = `mu! run interrupt${rootId ? ` ${rootId}` : ""}`;
                     break;
                 }
+                case "reload":
+                    commandText = "/mu reload";
+                    break;
+                case "update":
+                    commandText = "/mu update";
+                    break;
                 case "status":
                     commandText = "/mu status";
                     break;
@@ -2112,6 +2263,7 @@ export async function createServerAsync(options = {}) {
             generation_seq: 0,
         },
         telemetry: generationTelemetry,
+        sessionMutationHooks: options.sessionMutationHooks,
         terminalEnabled: true,
     });
     const serverConfig = createServer({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.66",
+  "version": "26.2.67",
   "description": "HTTP API server for mu status, work items, messaging setup, and web UI.",
   "keywords": [
     "mu",
@@ -31,10 +31,10 @@
     "start": "bun run dist/cli.js"
   },
   "dependencies": {
-    "@femtomc/mu-agent": "26.2.65",
-    "@femtomc/mu-control-plane": "26.2.65",
-    "@femtomc/mu-core": "26.2.65",
-    "@femtomc/mu-forum": "26.2.65",
-    "@femtomc/mu-issue": "26.2.65"
+    "@femtomc/mu-agent": "26.2.67",
+    "@femtomc/mu-control-plane": "26.2.67",
+    "@femtomc/mu-core": "26.2.67",
+    "@femtomc/mu-forum": "26.2.67",
+    "@femtomc/mu-issue": "26.2.67"
   }
 }