@femtomc/mu-server 26.2.65 → 26.2.67

package/dist/control_plane.d.ts

@@ -1,5 +1,5 @@
 import { type MessagingOperatorBackend, MessagingOperatorRuntime } from "@femtomc/mu-agent";
-import { type Channel, type GenerationTelemetryRecorder, type ReloadableGenerationIdentity } from "@femtomc/mu-control-plane";
+import { type Channel, type CommandPipelineResult, type GenerationTelemetryRecorder, type ReloadableGenerationIdentity } from "@femtomc/mu-control-plane";
 import { type MuConfig } from "./config.js";
 import type { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
 import { type ControlPlaneRunHeartbeatResult, type ControlPlaneRunInterruptResult, type ControlPlaneRunSnapshot, type ControlPlaneRunSupervisorOpts, type ControlPlaneRunTrace } from "./run_supervisor.js";
@@ -76,6 +76,11 @@ export type ControlPlaneHandle = {
         idOrRoot: string;
         limit?: number;
     }): Promise<ControlPlaneRunTrace | null>;
+    submitTerminalCommand?(opts: {
+        commandText: string;
+        repoRoot: string;
+        requestId?: string;
+    }): Promise<CommandPipelineResult>;
     stop(): Promise<void>;
 };
 export type ControlPlaneConfig = MuConfig["control_plane"];
@@ -96,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;
@@ -135,9 +151,11 @@ export type BootstrapControlPlaneOpts = {
     heartbeatScheduler?: ActivityHeartbeatScheduler;
     runSupervisorSpawnProcess?: ControlPlaneRunSupervisorOpts["spawnProcess"];
     runSupervisorHeartbeatIntervalMs?: number;
+    sessionMutationHooks?: ControlPlaneSessionMutationHooks;
     generation?: ControlPlaneGenerationContext;
     telemetry?: GenerationTelemetryRecorder | null;
     telegramGenerationHooks?: TelegramGenerationSwapHooks;
+    terminalEnabled?: boolean;
 };
 export declare function bootstrapControlPlane(opts: BootstrapControlPlaneOpts): Promise<ControlPlaneHandle | null>;
 export {};

package/dist/control_plane.js

@@ -702,7 +702,7 @@ export async function bootstrapControlPlane(opts) {
             },
         }
         : undefined;
-    if (detected.length === 0) {
+    if (detected.length === 0 && !opts.terminalEnabled) {
         return null;
     }
     const paths = getControlPlanePaths(opts.repoRoot);
@@ -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);
@@ -1050,6 +1160,12 @@ export async function bootstrapControlPlane(opts) {
             async traceRun(traceOpts) {
                 return (await runSupervisor?.trace(traceOpts.idOrRoot, { limit: traceOpts.limit })) ?? null;
             },
+            async submitTerminalCommand(terminalOpts) {
+                if (!pipeline) {
+                    throw new Error("control_plane_pipeline_unavailable");
+                }
+                return await pipeline.handleTerminalInbound(terminalOpts);
+            },
             async stop() {
                 if (drainInterval) {
                     clearInterval(drainInterval);

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,8 @@ export function createServer(options = {}) {
                 heartbeatScheduler,
                 generation,
                 telemetry: generationTelemetry,
+                sessionMutationHooks,
+                terminalEnabled: true,
             });
         });
     const controlPlaneProxy = {
@@ -272,6 +418,13 @@ export function createServer(options = {}) {
                 return null;
             return await handle.traceRun(opts);
         },
+        async submitTerminalCommand(opts) {
+            const handle = controlPlaneCurrent;
+            if (!handle?.submitTerminalCommand) {
+                throw new Error("control_plane_unavailable");
+            }
+            return await handle.submitTerminalCommand(opts);
+        },
         async stop() {
             const handle = controlPlaneCurrent;
             controlPlaneCurrent = null;
@@ -1102,6 +1255,100 @@ export function createServer(options = {}) {
                 control_plane: controlPlane,
             }, { headers });
         }
+        if (path === "/api/commands/submit") {
+            if (request.method !== "POST") {
+                return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+            }
+            let body;
+            try {
+                body = (await request.json());
+            }
+            catch {
+                return Response.json({ error: "invalid json body" }, { status: 400, headers });
+            }
+            const kind = typeof body.kind === "string" ? body.kind.trim() : "";
+            if (!kind) {
+                return Response.json({ error: "kind is required" }, { status: 400, headers });
+            }
+            let commandText;
+            switch (kind) {
+                case "run_start": {
+                    const prompt = typeof body.prompt === "string" ? body.prompt.trim() : "";
+                    if (!prompt) {
+                        return Response.json({ error: "prompt is required for run_start" }, { status: 400, headers });
+                    }
+                    const maxStepsSuffix = typeof body.max_steps === "number" && Number.isFinite(body.max_steps)
+                        ? ` --max-steps ${Math.max(1, Math.trunc(body.max_steps))}`
+                        : "";
+                    commandText = `mu! run start ${prompt}${maxStepsSuffix}`;
+                    break;
+                }
+                case "run_resume": {
+                    const rootId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
+                    const maxSteps = typeof body.max_steps === "number" && Number.isFinite(body.max_steps)
+                        ? ` ${Math.max(1, Math.trunc(body.max_steps))}`
+                        : "";
+                    commandText = `mu! run resume${rootId ? ` ${rootId}` : ""}${maxSteps}`;
+                    break;
+                }
+                case "run_interrupt": {
+                    const rootId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
+                    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;
+                case "issue_list":
+                    commandText = "/mu issue list";
+                    break;
+                case "issue_get": {
+                    const issueId = typeof body.issue_id === "string" ? body.issue_id.trim() : "";
+                    commandText = `/mu issue get${issueId ? ` ${issueId}` : ""}`;
+                    break;
+                }
+                case "forum_read": {
+                    const topic = typeof body.topic === "string" ? body.topic.trim() : "";
+                    const limit = typeof body.limit === "number" && Number.isFinite(body.limit)
+                        ? ` ${Math.max(1, Math.trunc(body.limit))}`
+                        : "";
+                    commandText = `/mu forum read${topic ? ` ${topic}` : ""}${limit}`;
+                    break;
+                }
+                case "run_list":
+                    commandText = "/mu run list";
+                    break;
+                case "run_status": {
+                    const rootId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
+                    commandText = `/mu run status${rootId ? ` ${rootId}` : ""}`;
+                    break;
+                }
+                case "ready":
+                    commandText = "/mu ready";
+                    break;
+                default:
+                    return Response.json({ error: `unknown command kind: ${kind}` }, { status: 400, headers });
+            }
+            try {
+                if (!controlPlaneProxy.submitTerminalCommand) {
+                    return Response.json({ error: "control plane not available" }, { status: 503, headers });
+                }
+                const result = await controlPlaneProxy.submitTerminalCommand({
+                    commandText,
+                    repoRoot: context.repoRoot,
+                });
+                return Response.json({ ok: true, result }, { headers });
+            }
+            catch (err) {
+                return Response.json({ error: `command failed: ${describeError(err)}` }, { status: 500, headers });
+            }
+        }
         if (path === "/api/runs") {
             if (request.method !== "GET") {
                 return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
@@ -2016,6 +2263,8 @@ export async function createServerAsync(options = {}) {
             generation_seq: 0,
         },
         telemetry: generationTelemetry,
+        sessionMutationHooks: options.sessionMutationHooks,
+        terminalEnabled: true,
     });
     const serverConfig = createServer({
         ...options,

package/package.json

@@ -1,40 +1,40 @@
 {
-	"name": "@femtomc/mu-server",
-	"version": "26.2.65",
-	"description": "HTTP API server for mu status, work items, messaging setup, and web UI.",
-	"keywords": [
-		"mu",
-		"server",
-		"api",
-		"web",
-		"automation"
-	],
-	"type": "module",
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"bin": {
-		"mu-server": "./dist/cli.js"
-	},
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"default": "./dist/index.js"
-		}
-	},
-	"files": [
-		"dist/**",
-		"public/**"
-	],
-	"scripts": {
-		"build": "tsc -p tsconfig.build.json",
-		"test": "bun test",
-		"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"
-	}
+  "name": "@femtomc/mu-server",
+  "version": "26.2.67",
+  "description": "HTTP API server for mu status, work items, messaging setup, and web UI.",
+  "keywords": [
+    "mu",
+    "server",
+    "api",
+    "web",
+    "automation"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "mu-server": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**",
+    "public/**"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "bun test",
+    "start": "bun run dist/cli.js"
+  },
+  "dependencies": {
+    "@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"
+  }
 }