@femtomc/mu-server 26.2.69 → 26.2.70

package/dist/server_runtime.d.ts

@@ -0,0 +1,30 @@
+import { GenerationTelemetryRecorder } from "@femtomc/mu-control-plane";
+import type { MuConfig } from "./config.js";
+import type { ControlPlaneHandle, ControlPlaneSessionLifecycle, ControlPlaneSessionMutationAction } from "./control_plane_contract.js";
+import { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
+type ConfigReader = (repoRoot: string) => Promise<MuConfig>;
+export type ServerRuntimeOptions = {
+    repoRoot?: string;
+    controlPlane?: ControlPlaneHandle | null;
+    heartbeatScheduler?: ActivityHeartbeatScheduler;
+    generationTelemetry?: GenerationTelemetryRecorder;
+    config?: MuConfig;
+    configReader?: ConfigReader;
+    sessionLifecycle?: ControlPlaneSessionLifecycle;
+};
+export type ServerRuntimeCapabilities = {
+    session_lifecycle_actions: readonly ControlPlaneSessionMutationAction[];
+    control_plane_bootstrapped: boolean;
+    control_plane_adapters: string[];
+};
+export type ServerRuntime = {
+    repoRoot: string;
+    config: MuConfig;
+    heartbeatScheduler: ActivityHeartbeatScheduler;
+    generationTelemetry: GenerationTelemetryRecorder;
+    sessionLifecycle: ControlPlaneSessionLifecycle;
+    controlPlane: ControlPlaneHandle | null;
+    capabilities: ServerRuntimeCapabilities;
+};
+export declare function composeServerRuntime(options?: ServerRuntimeOptions): Promise<ServerRuntime>;
+export {};

package/dist/server_runtime.js

@@ -0,0 +1,43 @@
+import { GenerationTelemetryRecorder } from "@femtomc/mu-control-plane";
+import { readMuConfigFile } from "./config.js";
+import { bootstrapControlPlane } from "./control_plane.js";
+import { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
+import { createProcessSessionLifecycle } from "./session_lifecycle.js";
+function computeServerRuntimeCapabilities(controlPlane) {
+    return {
+        session_lifecycle_actions: ["reload", "update"],
+        control_plane_bootstrapped: controlPlane !== null,
+        control_plane_adapters: controlPlane?.activeAdapters.map((adapter) => adapter.name) ?? [],
+    };
+}
+export async function composeServerRuntime(options = {}) {
+    const repoRoot = options.repoRoot || process.cwd();
+    const readConfig = options.configReader ?? readMuConfigFile;
+    const config = options.config ?? (await readConfig(repoRoot));
+    const heartbeatScheduler = options.heartbeatScheduler ?? new ActivityHeartbeatScheduler();
+    const generationTelemetry = options.generationTelemetry ?? new GenerationTelemetryRecorder();
+    const sessionLifecycle = options.sessionLifecycle ?? createProcessSessionLifecycle({ repoRoot });
+    const controlPlane = options.controlPlane !== undefined
+        ? options.controlPlane
+        : await bootstrapControlPlane({
+            repoRoot,
+            config: config.control_plane,
+            heartbeatScheduler,
+            generation: {
+                generation_id: "control-plane-gen-0",
+                generation_seq: 0,
+            },
+            telemetry: generationTelemetry,
+            sessionLifecycle,
+            terminalEnabled: true,
+        });
+    return {
+        repoRoot,
+        config,
+        heartbeatScheduler,
+        generationTelemetry,
+        sessionLifecycle,
+        controlPlane,
+        capabilities: computeServerRuntimeCapabilities(controlPlane),
+    };
+}

package/dist/server_types.d.ts

@@ -0,0 +1,3 @@
+export type ProgramWakeMode = "immediate" | "next_heartbeat";
+export declare function normalizeWakeMode(value: unknown): ProgramWakeMode;
+export declare function toNonNegativeInt(value: unknown, fallback: number): number;

package/dist/server_types.js

@@ -0,0 +1,16 @@
+export function normalizeWakeMode(value) {
+    if (typeof value !== "string") {
+        return "immediate";
+    }
+    const normalized = value.trim().toLowerCase().replaceAll("-", "_");
+    return normalized === "next_heartbeat" ? "next_heartbeat" : "immediate";
+}
+export function toNonNegativeInt(value, fallback) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.max(0, Math.trunc(value));
+    }
+    if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+        return Math.max(0, Number.parseInt(value, 10));
+    }
+    return Math.max(0, Math.trunc(fallback));
+}

package/dist/session_lifecycle.d.ts

@@ -0,0 +1,11 @@
+import type { ControlPlaneSessionLifecycle } from "./control_plane_contract.js";
+export type ShellCommandResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+export type ShellCommandRunner = (command: string) => Promise<ShellCommandResult>;
+export declare function createProcessSessionLifecycle(opts: {
+    repoRoot: string;
+    runShellCommand?: ShellCommandRunner;
+}): ControlPlaneSessionLifecycle;

package/dist/session_lifecycle.js

@@ -0,0 +1,149 @@
+function shellQuoteArg(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function shellJoin(args) {
+    return args.map(shellQuoteArg).join(" ");
+}
+function createShellCommandRunner(repoRoot) {
+    return 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,
+        };
+    };
+}
+function describeLifecycleError(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return String(err);
+}
+export function createProcessSessionLifecycle(opts) {
+    const runShellCommand = opts.runShellCommand ?? createShellCommandRunner(opts.repoRoot);
+    let sessionMutationScheduled = null;
+    const scheduleReload = 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: opts.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: ${describeLifecycleError(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,
+            },
+        };
+    };
+    const scheduleUpdate = 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 scheduleReload();
+        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),
+            },
+        };
+    };
+    return {
+        reload: scheduleReload,
+        update: scheduleUpdate,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.69",
+  "version": "26.2.70",
   "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.69",
-    "@femtomc/mu-control-plane": "26.2.69",
-    "@femtomc/mu-core": "26.2.69",
-    "@femtomc/mu-forum": "26.2.69",
-    "@femtomc/mu-issue": "26.2.69"
+    "@femtomc/mu-agent": "26.2.70",
+    "@femtomc/mu-control-plane": "26.2.70",
+    "@femtomc/mu-core": "26.2.70",
+    "@femtomc/mu-forum": "26.2.70",
+    "@femtomc/mu-issue": "26.2.70"
   }
 }