@femtomc/mu-server 26.2.73 → 26.2.75

package/dist/api/session_turn.js

@@ -0,0 +1,423 @@
+import { createMuSession, DEFAULT_OPERATOR_SYSTEM_PROMPT, DEFAULT_ORCHESTRATOR_PROMPT, DEFAULT_REVIEWER_PROMPT, DEFAULT_WORKER_PROMPT, operatorExtensionPaths, orchestratorToolExtensionPaths, workerToolExtensionPaths, } from "@femtomc/mu-agent";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+export class SessionTurnError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+function nonEmptyString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function normalizeSessionKind(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase().replaceAll("-", "_");
+    if (normalized === "cpoperator" || normalized === "control_plane_operator") {
+        return "cp_operator";
+    }
+    return normalized;
+}
+function normalizeExtensionProfile(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "operator" ||
+        normalized === "worker" ||
+        normalized === "orchestrator" ||
+        normalized === "reviewer" ||
+        normalized === "none") {
+        return normalized;
+    }
+    return null;
+}
+function sessionFileStem(sessionId) {
+    const normalized = sessionId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+    const compact = normalized.replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+    return compact.length > 0 ? compact : "session";
+}
+function resolveRepoPath(repoRoot, candidate) {
+    return isAbsolute(candidate) ? resolve(candidate) : resolve(repoRoot, candidate);
+}
+function defaultSessionDirForKind(repoRoot, sessionKind) {
+    switch (sessionKind) {
+        case "operator":
+            return join(repoRoot, ".mu", "operator", "sessions");
+        case "cp_operator":
+            return join(repoRoot, ".mu", "control-plane", "operator-sessions");
+        case "orchestrator":
+            return join(repoRoot, ".mu", "orchestrator", "sessions");
+        case "worker":
+            return join(repoRoot, ".mu", "worker", "sessions");
+        case "reviewer":
+            return join(repoRoot, ".mu", "reviewer", "sessions");
+        default:
+            return join(repoRoot, ".mu", "control-plane", "operator-sessions");
+    }
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function directoryExists(path) {
+    try {
+        const info = await stat(path);
+        return info.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readSessionHeaderId(sessionFile) {
+    let raw;
+    try {
+        raw = await readFile(sessionFile, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const firstLine = raw
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstLine) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(firstLine);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        const header = parsed;
+        if (header.type !== "session") {
+            return null;
+        }
+        return nonEmptyString(header.id);
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveSessionFileById(opts) {
+    const direct = join(opts.sessionDir, `${sessionFileStem(opts.sessionId)}.jsonl`);
+    if (await pathExists(direct)) {
+        const headerId = await readSessionHeaderId(direct);
+        if (headerId === opts.sessionId) {
+            return direct;
+        }
+    }
+    const entries = await readdir(opts.sessionDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+            continue;
+        }
+        const filePath = join(opts.sessionDir, entry.name);
+        if (filePath === direct) {
+            continue;
+        }
+        const headerId = await readSessionHeaderId(filePath);
+        if (headerId === opts.sessionId) {
+            return filePath;
+        }
+    }
+    return null;
+}
+function extensionPathsForTurn(opts) {
+    if (opts.extensionProfile === "none") {
+        return [];
+    }
+    if (opts.extensionProfile === "operator") {
+        return [...operatorExtensionPaths];
+    }
+    if (opts.extensionProfile === "orchestrator") {
+        return [...orchestratorToolExtensionPaths];
+    }
+    if (opts.extensionProfile === "worker" || opts.extensionProfile === "reviewer") {
+        return [...workerToolExtensionPaths];
+    }
+    if (opts.sessionKind === "operator" || opts.sessionKind === "cp_operator") {
+        return [...operatorExtensionPaths];
+    }
+    if (opts.sessionKind === "orchestrator") {
+        return [...orchestratorToolExtensionPaths];
+    }
+    if (opts.sessionKind === "worker" || opts.sessionKind === "reviewer") {
+        return [...workerToolExtensionPaths];
+    }
+    return [...operatorExtensionPaths];
+}
+function systemPromptForTurn(opts) {
+    const role = opts.extensionProfile ?? opts.sessionKind;
+    if (role === "operator" || role === "cp_operator") {
+        return DEFAULT_OPERATOR_SYSTEM_PROMPT;
+    }
+    if (role === "orchestrator") {
+        return DEFAULT_ORCHESTRATOR_PROMPT;
+    }
+    if (role === "reviewer") {
+        return DEFAULT_REVIEWER_PROMPT;
+    }
+    if (role === "worker") {
+        return DEFAULT_WORKER_PROMPT;
+    }
+    return undefined;
+}
+function extractAssistantText(message) {
+    if (!message || typeof message !== "object") {
+        return "";
+    }
+    const record = message;
+    if (typeof record.text === "string") {
+        return record.text;
+    }
+    if (typeof record.content === "string") {
+        return record.content;
+    }
+    if (Array.isArray(record.content)) {
+        const parts = [];
+        for (const item of record.content) {
+            if (typeof item === "string") {
+                if (item.trim().length > 0) {
+                    parts.push(item);
+                }
+                continue;
+            }
+            if (!item || typeof item !== "object") {
+                continue;
+            }
+            const text = nonEmptyString(item.text);
+            if (text) {
+                parts.push(text);
+            }
+        }
+        return parts.join("\n");
+    }
+    return "";
+}
+function safeLeafId(session) {
+    const manager = session.sessionManager;
+    if (!manager || typeof manager.getLeafId !== "function") {
+        return null;
+    }
+    const value = manager.getLeafId();
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function safeSessionId(session) {
+    const value = session.sessionId;
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function safeSessionFile(session) {
+    const value = session.sessionFile;
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+async function resolveSessionTarget(opts) {
+    const sessionDir = opts.request.session_dir
+        ? resolveRepoPath(opts.repoRoot, opts.request.session_dir)
+        : defaultSessionDirForKind(opts.repoRoot, opts.normalizedSessionKind);
+    if (opts.request.session_file) {
+        const sessionFile = resolveRepoPath(opts.repoRoot, opts.request.session_file);
+        if (!(await pathExists(sessionFile))) {
+            throw new SessionTurnError(404, `session_file not found: ${sessionFile}`);
+        }
+        const headerId = await readSessionHeaderId(sessionFile);
+        if (!headerId) {
+            throw new SessionTurnError(400, `session_file is missing a valid session header: ${sessionFile}`);
+        }
+        if (headerId !== opts.request.session_id) {
+            throw new SessionTurnError(409, `session_file header id mismatch (expected ${opts.request.session_id}, found ${headerId})`);
+        }
+        return {
+            sessionFile,
+            sessionDir: opts.request.session_dir ? sessionDir : dirname(sessionFile),
+        };
+    }
+    if (!(await directoryExists(sessionDir))) {
+        throw new SessionTurnError(404, `session directory not found: ${sessionDir}`);
+    }
+    const sessionFile = await resolveSessionFileById({
+        sessionDir,
+        sessionId: opts.request.session_id,
+    });
+    if (!sessionFile) {
+        throw new SessionTurnError(404, `session_id not found in ${sessionDir}: ${opts.request.session_id}`);
+    }
+    return { sessionFile, sessionDir };
+}
+export function parseSessionTurnRequest(body) {
+    const sessionId = nonEmptyString(body.session_id);
+    if (!sessionId) {
+        return { request: null, error: "session_id is required" };
+    }
+    const messageBody = nonEmptyString(body.body) ?? nonEmptyString(body.message) ?? nonEmptyString(body.prompt);
+    if (!messageBody) {
+        return { request: null, error: "body (or message/prompt) is required" };
+    }
+    const extensionProfileRaw = nonEmptyString(body.extension_profile);
+    if (extensionProfileRaw && !normalizeExtensionProfile(extensionProfileRaw)) {
+        return {
+            request: null,
+            error: "extension_profile must be one of operator|worker|orchestrator|reviewer|none",
+        };
+    }
+    return {
+        request: {
+            session_id: sessionId,
+            session_kind: nonEmptyString(body.session_kind),
+            body: messageBody,
+            source: nonEmptyString(body.source),
+            provider: nonEmptyString(body.provider),
+            model: nonEmptyString(body.model),
+            thinking: nonEmptyString(body.thinking),
+            session_file: nonEmptyString(body.session_file),
+            session_dir: nonEmptyString(body.session_dir),
+            extension_profile: extensionProfileRaw,
+        },
+        error: null,
+    };
+}
+export async function executeSessionTurn(opts) {
+    const normalizedSessionKind = normalizeSessionKind(opts.request.session_kind);
+    const extensionProfile = normalizeExtensionProfile(opts.request.extension_profile);
+    const target = await resolveSessionTarget({
+        repoRoot: opts.repoRoot,
+        request: opts.request,
+        normalizedSessionKind,
+    });
+    const sessionFactory = opts.sessionFactory ?? createMuSession;
+    const session = await sessionFactory({
+        cwd: opts.repoRoot,
+        systemPrompt: systemPromptForTurn({
+            sessionKind: normalizedSessionKind,
+            extensionProfile,
+        }),
+        provider: opts.request.provider ?? undefined,
+        model: opts.request.model ?? undefined,
+        thinking: opts.request.thinking ?? undefined,
+        extensionPaths: extensionPathsForTurn({
+            sessionKind: normalizedSessionKind,
+            extensionProfile,
+        }),
+        session: {
+            mode: "open",
+            sessionDir: target.sessionDir,
+            sessionFile: target.sessionFile,
+        },
+    });
+    let assistantText = "";
+    let contextEntryId = null;
+    let resolvedSessionId = null;
+    let resolvedSessionFile = null;
+    const nowMs = opts.nowMs ?? Date.now;
+    try {
+        await session.bindExtensions({
+            commandContextActions: {
+                waitForIdle: () => session.agent.waitForIdle(),
+                newSession: async () => ({ cancelled: true }),
+                fork: async () => ({ cancelled: true }),
+                navigateTree: async () => ({ cancelled: true }),
+                switchSession: async () => ({ cancelled: true }),
+                reload: async () => { },
+            },
+            onError: () => { },
+        });
+        const unsubscribe = session.subscribe((event) => {
+            const rec = asRecord(event);
+            if (!rec || rec.type !== "message_end") {
+                return;
+            }
+            const message = asRecord(rec.message);
+            if (!message || message.role !== "assistant") {
+                return;
+            }
+            const text = extractAssistantText(message);
+            if (text.trim().length > 0) {
+                assistantText = text;
+            }
+        });
+        try {
+            await session.prompt(opts.request.body, { expandPromptTemplates: false });
+            await session.agent.waitForIdle();
+        }
+        finally {
+            unsubscribe();
+        }
+        contextEntryId = safeLeafId(session);
+        resolvedSessionId = safeSessionId(session) ?? opts.request.session_id;
+        resolvedSessionFile = safeSessionFile(session) ?? target.sessionFile;
+    }
+    finally {
+        try {
+            session.dispose();
+        }
+        catch {
+            // Best effort cleanup.
+        }
+    }
+    const reply = assistantText.trim();
+    if (reply.length === 0) {
+        throw new SessionTurnError(502, "session turn completed without an assistant reply");
+    }
+    return {
+        session_id: resolvedSessionId ?? opts.request.session_id,
+        session_kind: normalizedSessionKind,
+        session_file: resolvedSessionFile ?? target.sessionFile,
+        context_entry_id: contextEntryId,
+        reply,
+        source: opts.request.source ?? null,
+        completed_at_ms: Math.trunc(nowMs()),
+    };
+}
+export async function sessionTurnRoutes(request, url, deps, headers) {
+    if (url.pathname !== "/api/session-turn") {
+        return Response.json({ error: "Not Found" }, { status: 404, headers });
+    }
+    if (request.method !== "POST") {
+        return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+    }
+    let body;
+    try {
+        const parsed = (await request.json());
+        const rec = asRecord(parsed);
+        if (!rec) {
+            return Response.json({ error: "invalid json body" }, { status: 400, headers });
+        }
+        body = rec;
+    }
+    catch {
+        return Response.json({ error: "invalid json body" }, { status: 400, headers });
+    }
+    const parsedRequest = parseSessionTurnRequest(body);
+    if (!parsedRequest.request) {
+        return Response.json({ error: parsedRequest.error ?? "invalid session turn request" }, { status: 400, headers });
+    }
+    try {
+        const turn = await executeSessionTurn({
+            repoRoot: deps.context.repoRoot,
+            request: parsedRequest.request,
+        });
+        return Response.json({ ok: true, turn }, { headers });
+    }
+    catch (error) {
+        const status = error instanceof SessionTurnError ? error.status : 500;
+        return Response.json({ error: deps.describeError(error) }, { status, headers });
+    }
+}

package/dist/config.d.ts

@@ -1,4 +1,3 @@
-export type WakeTurnMode = "off" | "shadow" | "active";
 export type MuConfig = {
     version: 1;
     control_plane: {
@@ -14,11 +13,13 @@ export type MuConfig = {
                 bot_token: string | null;
                 bot_username: string | null;
             };
+            neovim: {
+                shared_secret: string | null;
+            };
         };
         operator: {
             enabled: boolean;
             run_triggers_enabled: boolean;
-            wake_turn_mode: WakeTurnMode;
             provider: string | null;
             model: string | null;
         };
@@ -38,11 +39,13 @@ export type MuConfigPatch = {
                 bot_token?: string | null;
                 bot_username?: string | null;
             };
+            neovim?: {
+                shared_secret?: string | null;
+            };
         };
         operator?: {
             enabled?: boolean;
             run_triggers_enabled?: boolean;
-            wake_turn_mode?: WakeTurnMode;
             provider?: string | null;
             model?: string | null;
         };
@@ -62,11 +65,13 @@ export type MuConfigPresence = {
                 bot_token: boolean;
                 bot_username: boolean;
             };
+            neovim: {
+                shared_secret: boolean;
+            };
         };
         operator: {
             enabled: boolean;
             run_triggers_enabled: boolean;
-            wake_turn_mode: WakeTurnMode;
             provider: boolean;
             model: boolean;
         };

package/dist/config.js

@@ -15,11 +15,13 @@ export const DEFAULT_MU_CONFIG = {
                 bot_token: null,
                 bot_username: null,
             },
+            neovim: {
+                shared_secret: null,
+            },
         },
         operator: {
             enabled: true,
             run_triggers_enabled: true,
-            wake_turn_mode: "off",
             provider: null,
             model: null,
         },
@@ -54,19 +56,6 @@ function normalizeBoolean(value, fallback) {
     }
     return fallback;
 }
-function normalizeWakeTurnMode(value, fallback) {
-    if (typeof value !== "string") {
-        return fallback;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "shadow") {
-        return "shadow";
-    }
-    if (normalized === "active") {
-        return "active";
-    }
-    return "off";
-}
 export function normalizeMuConfig(input) {
     const next = cloneDefault();
     const root = asRecord(input);
@@ -97,6 +86,10 @@ export function normalizeMuConfig(input) {
                 next.control_plane.adapters.telegram.bot_username = normalizeNullableString(telegram.bot_username);
             }
         }
+        const neovim = asRecord(adapters.neovim);
+        if (neovim && "shared_secret" in neovim) {
+            next.control_plane.adapters.neovim.shared_secret = normalizeNullableString(neovim.shared_secret);
+        }
     }
     const operator = asRecord(controlPlane.operator);
     if (operator) {
@@ -106,9 +99,6 @@ export function normalizeMuConfig(input) {
         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 ("wake_turn_mode" in operator) {
-            next.control_plane.operator.wake_turn_mode = normalizeWakeTurnMode(operator.wake_turn_mode, next.control_plane.operator.wake_turn_mode);
-        }
         if ("provider" in operator) {
             next.control_plane.operator.provider = normalizeNullableString(operator.provider);
         }
@@ -158,6 +148,16 @@ function normalizeMuConfigPatch(input) {
                 patch.control_plane.adapters.telegram = telegramPatch;
             }
         }
+        const neovim = asRecord(adapters.neovim);
+        if (neovim) {
+            const neovimPatch = {};
+            if ("shared_secret" in neovim) {
+                neovimPatch.shared_secret = normalizeNullableString(neovim.shared_secret);
+            }
+            if (Object.keys(neovimPatch).length > 0) {
+                patch.control_plane.adapters.neovim = neovimPatch;
+            }
+        }
     }
     const operator = asRecord(controlPlane.operator);
     if (operator) {
@@ -168,9 +168,6 @@ function normalizeMuConfigPatch(input) {
         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 ("wake_turn_mode" in operator) {
-            patch.control_plane.operator.wake_turn_mode = normalizeWakeTurnMode(operator.wake_turn_mode, DEFAULT_MU_CONFIG.control_plane.operator.wake_turn_mode);
-        }
         if ("provider" in operator) {
             patch.control_plane.operator.provider = normalizeNullableString(operator.provider);
         }
@@ -214,6 +211,9 @@ export function applyMuConfigPatch(base, patchInput) {
                 next.control_plane.adapters.telegram.bot_username = adapters.telegram.bot_username ?? null;
             }
         }
+        if (adapters.neovim && "shared_secret" in adapters.neovim) {
+            next.control_plane.adapters.neovim.shared_secret = adapters.neovim.shared_secret ?? null;
+        }
     }
     const operator = patch.control_plane.operator;
     if (operator) {
@@ -223,9 +223,6 @@ export function applyMuConfigPatch(base, patchInput) {
         if ("run_triggers_enabled" in operator && typeof operator.run_triggers_enabled === "boolean") {
             next.control_plane.operator.run_triggers_enabled = operator.run_triggers_enabled;
         }
-        if ("wake_turn_mode" in operator) {
-            next.control_plane.operator.wake_turn_mode = normalizeWakeTurnMode(operator.wake_turn_mode, next.control_plane.operator.wake_turn_mode);
-        }
         if ("provider" in operator) {
             next.control_plane.operator.provider = operator.provider ?? null;
         }
@@ -276,6 +273,7 @@ export function redactMuConfigSecrets(config) {
     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);
+    next.control_plane.adapters.neovim.shared_secret = redacted(next.control_plane.adapters.neovim.shared_secret);
     return next;
 }
 function isPresent(value) {
@@ -296,11 +294,13 @@ export function muConfigPresence(config) {
                     bot_token: isPresent(config.control_plane.adapters.telegram.bot_token),
                     bot_username: isPresent(config.control_plane.adapters.telegram.bot_username),
                 },
+                neovim: {
+                    shared_secret: isPresent(config.control_plane.adapters.neovim.shared_secret),
+                },
             },
             operator: {
                 enabled: config.control_plane.operator.enabled,
                 run_triggers_enabled: config.control_plane.operator.run_triggers_enabled,
-                wake_turn_mode: config.control_plane.operator.wake_turn_mode,
                 provider: isPresent(config.control_plane.operator.provider),
                 model: isPresent(config.control_plane.operator.model),
             },

package/dist/control_plane.d.ts

@@ -1,22 +1,10 @@
 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 { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
 import { type ControlPlaneRunSupervisorOpts } from "./run_supervisor.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";
-type DetectedAdapter = {
-    name: "slack";
-    signingSecret: string;
-} | {
-    name: "discord";
-    signingSecret: string;
-} | {
-    name: "telegram";
-    webhookSecret: string;
-    botToken: string | null;
-    botUsername: string | null;
-};
-export declare function detectAdapters(config: ControlPlaneConfig): DetectedAdapter[];
+export { detectAdapters };
 export type TelegramSendMessagePayload = {
     chat_id: string;
     text: string;
@@ -40,9 +28,7 @@ export type BootstrapControlPlaneOpts = {
     config?: ControlPlaneConfig;
     operatorRuntime?: MessagingOperatorRuntime | null;
     operatorBackend?: MessagingOperatorBackend;
-    heartbeatScheduler?: ActivityHeartbeatScheduler;
     runSupervisorSpawnProcess?: ControlPlaneRunSupervisorOpts["spawnProcess"];
-    runSupervisorHeartbeatIntervalMs?: number;
     sessionLifecycle: ControlPlaneSessionLifecycle;
     generation?: ControlPlaneGenerationContext;
     telemetry?: GenerationTelemetryRecorder | null;