@minicor/mcp-server 4.7.0 → 4.8.0

package/dist/__tests__/vm-broker.test.js

@@ -0,0 +1,812 @@
+/**
+ * Multi-session (broker) coverage for the direct VM tools (plan §4.5):
+ * two-server isolation, standalone compatibility, broker targetUser routing,
+ * session tools, hosted gating, and mode-aware install/start refusals.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createMinicorServer } from "../lib.js";
+import * as lds from "../lds-client.js";
+import { createSessionState } from "../state.js";
+import { register as registerVmTools } from "../tools/vm.js";
+// ── Fixtures ──────────────────────────────────────────────────
+const STANDALONE_HEALTH = { status: "healthy", version: "1.0.0", uptime: 5 };
+const BROKER_HEALTH = { ...STANDALONE_HEALTH, mode: "broker" };
+const BROKER_STATUS = {
+    broker: { version: "0.4.0", uptimeS: 123 },
+    users: [
+        {
+            user: "robot1",
+            state: "active",
+            sessionId: 1,
+            agent: { state: "idle", executionId: null, version: "0.4.0", lastBeatMs: 1200, pendingJobs: 0 },
+        },
+        { user: "robot2", state: "stopped", sessionId: null, agent: null },
+    ],
+    queues: { robot1: 0, robot2: 2 },
+};
+const EXEC_OK = {
+    success: true,
+    skipped: false,
+    stopped: false,
+    exitCode: 0,
+    stdout: "hi",
+    stderr: "",
+    executionTimeMs: 12,
+};
+const SCREENSHOT_OK = {
+    success: true,
+    image: "aW1hZ2U=",
+    metadata: {
+        width: 10,
+        height: 10,
+        format: "png",
+        mime_type: "image/png",
+        size_bytes: 6,
+        timestamp: "2026-07-25T00:00:00Z",
+        capture_duration_ms: 3,
+    },
+};
+// ── Harness ───────────────────────────────────────────────────
+function jsonRes(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+/** Stub global fetch with a URL router; unexpected requests fail the test. */
+function stubFetch(route) {
+    const mock = vi.fn(async (input, init) => {
+        const url = new URL(String(input));
+        const res = route(url, init);
+        if (!res) {
+            throw new Error(`Unexpected fetch in test: ${init?.method ?? "GET"} ${url}`);
+        }
+        return res;
+    });
+    vi.stubGlobal("fetch", mock);
+    return mock;
+}
+async function startServer(opts = {}) {
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const embedded = await createMinicorServer(serverTransport, {
+        localTools: false,
+        codeMode: false,
+        directVmTools: opts.directVmTools,
+        credentials: {
+            access_token: "test-token",
+            refresh_token: "test-refresh-token",
+            expires_at: Date.now() + 3_600_000,
+        },
+        baseUrl: "https://api.test.com",
+        // stubFetch throws on unmatched hosts, so pin the VM service.
+        vmServiceBaseUrl: "https://vms.test.com",
+    });
+    const client = new Client({ name: "test-client", version: "1.0.0" });
+    await client.connect(clientTransport);
+    return {
+        client,
+        close: async () => {
+            await client.close();
+            await embedded.close();
+        },
+    };
+}
+function textOf(result) {
+    return result.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text ?? "")
+        .join("\n");
+}
+function callsTo(mock, pathname) {
+    return mock.mock.calls.filter(([input]) => new URL(String(input)).pathname === pathname);
+}
+afterEach(() => {
+    vi.unstubAllGlobals();
+});
+// ── Two-server isolation (plan §4.5.1 / §4.5.10) ──────────────
+describe("two-server isolation", () => {
+    it("keeps each server's VM connection private to that instance", async () => {
+        stubFetch((url) => url.pathname === "/health" ? jsonRes(STANDALONE_HEALTH) : undefined);
+        const a = await startServer();
+        const b = await startServer();
+        try {
+            const connected = await a.client.callTool({
+                name: "vm_connect",
+                arguments: { url: "https://vm-standalone.test" },
+            });
+            expect(textOf(connected)).toContain('"connected": true');
+            // Server B never connected — its tools must not see A's connection.
+            const statusB = await b.client.callTool({ name: "vm_status", arguments: {} });
+            expect(textOf(statusB)).toContain("No VM target");
+            const execB = await b.client.callTool({
+                name: "vm_execute_script",
+                arguments: { script: "print(1)" },
+            });
+            expect(textOf(execB)).toContain("No VM target");
+            expect(textOf(execB)).not.toContain("vm-standalone.test");
+            // A stays connected, and B disconnecting must not touch A.
+            await b.client.callTool({ name: "vm_disconnect", arguments: {} });
+            const statusA = await a.client.callTool({ name: "vm_status", arguments: {} });
+            expect(textOf(statusA)).toContain('"connected": true');
+            expect(textOf(statusA)).toContain("vm-standalone.test");
+        }
+        finally {
+            await a.close();
+            await b.close();
+        }
+    });
+});
+// ── Per-call VM targeting (vmId + workspaceId, no vm_connect) ──
+const CREDENTIALS_PATH = "/workspaces/42/vms/7/credentials";
+function routeResolvedVm(opts = {}) {
+    return (url) => {
+        if (url.hostname === "vms.test.com" && url.pathname === CREDENTIALS_PATH) {
+            return jsonRes(opts.credentials ?? {
+                id: 7,
+                vm_name: "vm-seven",
+                tunnel_url: "https://vm-seven.test",
+                api_key: "key-7",
+                service_id: "svc-7",
+            });
+        }
+        if (url.hostname !== "vm-seven.test")
+            return undefined;
+        if (url.pathname === "/health")
+            return jsonRes(opts.health ?? STANDALONE_HEALTH);
+        if (url.pathname === "/screenshot")
+            return jsonRes(SCREENSHOT_OK);
+        if (url.pathname === "/execute")
+            return jsonRes(EXEC_OK);
+        if (url.pathname === "/status")
+            return jsonRes(BROKER_STATUS);
+        return undefined;
+    };
+}
+describe("per-call VM targeting", () => {
+    it("resolves the VM on every call without a prior vm_connect", async () => {
+        const fetchMock = stubFetch(routeResolvedVm());
+        const s = await startServer();
+        try {
+            const shot = await s.client.callTool({
+                name: "vm_screenshot",
+                arguments: { vmId: 7, workspaceId: 42 },
+            });
+            expect(shot.content.some((c) => c.type === "image")).toBe(true);
+            const exec = await s.client.callTool({
+                name: "vm_execute_script",
+                arguments: { vmId: 7, workspaceId: 42, script: "print(1)", targetUser: "robot2" },
+            });
+            expect(textOf(exec)).toContain('"success": true');
+            expect(callsTo(fetchMock, CREDENTIALS_PATH)).toHaveLength(2);
+            for (const [, init] of callsTo(fetchMock, CREDENTIALS_PATH)) {
+                expect(init?.headers?.["Authorization"]).toBe("Bearer test-token");
+            }
+            const [, execInit] = fetchMock.mock.calls.find(([input]) => new URL(String(input)).pathname === "/execute");
+            const execHeaders = execInit?.headers;
+            expect(execHeaders["X-API-Key"]).toBe("key-7");
+            expect(execHeaders["X-Service-ID"]).toBe("svc-7");
+            expect(JSON.parse(String(execInit?.body)).targetUser).toBe("robot2");
+        }
+        finally {
+            await s.close();
+        }
+    });
+    it("routes vm-rpa tools (debug_rpa_step) the same way", async () => {
+        stubFetch(routeResolvedVm());
+        const s = await startServer();
+        try {
+            const result = await s.client.callTool({
+                name: "debug_rpa_step",
+                arguments: { vmId: 7, workspaceId: 42, script: "print(1)" },
+            });
+            expect(result.content.filter((c) => c.type === "image")).toHaveLength(2);
+            expect(textOf(result)).toContain('"success": true');
+        }
+        finally {
+            await s.close();
+        }
+    });
+    it("demands both vmId and workspaceId, never half a target", async () => {
+        stubFetch(() => undefined); // any network call fails the test
+        const s = await startServer();
+        try {
+            const half = await s.client.callTool({
+                name: "vm_execute_script",
+                arguments: { vmId: 7, script: "print(1)" },
+            });
+            expect(textOf(half)).toContain("BOTH vmId and workspaceId");
+        }
+        finally {
+            await s.close();
+        }
+    });
+    it("points an untargeted call at both ways to name a VM", async () => {
+        stubFetch(() => undefined);
+        const s = await startServer();
+        try {
+            const none = await s.client.callTool({
+                name: "vm_execute_script",
+                arguments: { script: "print(1)" },
+            });
+            const msg = textOf(none);
+            expect(msg).toContain("vmId");
+            expect(msg).toContain("workspaceId");
+            expect(msg).toContain("vm_connect");
+        }
+        finally {
+            await s.close();
+        }
+    });
+    it("surfaces a VM that has no tunnel URL instead of fetching undefined", async () => {
+        stubFetch(routeResolvedVm({ credentials: { id: 7, vm_name: "vm-seven", tunnel_url: null } }));
+        const s = await startServer();
+        try {
+            const result = await s.client.callTool({
+                name: "vm_screenshot",
+                arguments: { vmId: 7, workspaceId: 42 },
+            });
+            expect(textOf(result)).toContain("no tunnel URL");
+        }
+        finally {
+            await s.close();
+        }
+    });
+    it("records the resolved VM so a later untargeted call reuses it", async () => {
+        stubFetch(routeResolvedVm());
+        const s = await startServer();
+        try {
+            await s.client.callTool({
+                name: "vm_execute_script",
+                arguments: { vmId: 7, workspaceId: 42, script: "print(1)" },
+            });
+            const status = await s.client.callTool({ name: "vm_status", arguments: {} });
+            expect(textOf(status)).toContain("vm-seven.test");
+            expect(textOf(status)).toContain('"connected": true');
+        }
+        finally {
+            await s.close();
+        }
+    });
+    it("reports the VM service's refusal rather than a bare failure", async () => {
+        stubFetch((url) => url.hostname === "vms.test.com" && url.pathname === CREDENTIALS_PATH
+            ? jsonRes({ detail: "forbidden" }, 403)
+            : undefined);
+        const s = await startServer();
+        try {
+            const result = await s.client.callTool({
+                name: "vm_screenshot",
+                arguments: { vmId: 7, workspaceId: 42 },
+            });
+            expect(textOf(result)).toContain("HTTP 403");
+        }
+        finally {
+            await s.close();
+        }
+    });
+    it("connects by vmId + workspaceId with a cold cache (no vm_list first)", async () => {
+        stubFetch(routeResolvedVm({ health: BROKER_HEALTH }));
+        const s = await startServer();
+        try {
+            const result = await s.client.callTool({
+                name: "vm_connect",
+                arguments: { vmId: 7, workspaceId: 42 },
+            });
+            const msg = textOf(result);
+            expect(msg).toContain('"connected": true');
+            expect(msg).toContain('"mode": "broker"');
+            expect(msg).toContain("robot1");
+            expect(msg).toContain("without depending on the connection persisting");
+        }
+        finally {
+            await s.close();
+        }
+    });
+});
+// ── Standalone compatibility (no behavior change) ─────────────
+describe("standalone compatibility", () => {
+    it("reports standalone mode even for pre-multi-session MDS without health.mode", async () => {
+        const fetchMock = stubFetch((url) => url.pathname === "/health" ? jsonRes(STANDALONE_HEALTH) : undefined);
+        const server = await startServer();
+        try {
+            const connected = await server.client.callTool({
+                name: "vm_connect",
+                arguments: { url: "https://vm-standalone.test" },
+            });
+            expect(textOf(connected)).toContain('"mode": "standalone"');
+            // No broker /status probe on standalone connects.
+            expect(callsTo(fetchMock, "/status")).toHaveLength(0);
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("sends no targetUser field and no screenshot query on standalone VMs", async () => {
+        const fetchMock = stubFetch((url) => {
+            if (url.pathname === "/health")
+                return jsonRes(STANDALONE_HEALTH);
+            if (url.pathname === "/execute")
+                return jsonRes(EXEC_OK);
+            if (url.pathname === "/screenshot")
+                return jsonRes(SCREENSHOT_OK);
+            return undefined;
+        });
+        const server = await startServer();
+        try {
+            await server.client.callTool({
+                name: "vm_connect",
+                arguments: { url: "https://vm-standalone.test" },
+            });
+            const exec = await server.client.callTool({
+                name: "vm_execute_script",
+                arguments: { script: "print(1)" },
+            });
+            expect(textOf(exec)).toContain('"success": true');
+            const [, execInit] = callsTo(fetchMock, "/execute")[0];
+            const body = JSON.parse(String(execInit?.body));
+            expect(body.script).toBe("print(1)");
+            // The key must be ABSENT — standalone MDS rejects targetUser-bearing
+            // requests with typed not_supported_on_standalone.
+            expect("targetUser" in body).toBe(false);
+            await server.client.callTool({ name: "vm_screenshot", arguments: {} });
+            const [screenshotUrl] = callsTo(fetchMock, "/screenshot")[0];
+            expect(String(screenshotUrl)).toBe("https://vm-standalone.test/screenshot");
+        }
+        finally {
+            await server.close();
+        }
+    });
+});
+// ── Broker routing ────────────────────────────────────────────
+function brokerRoutes(overrides = () => undefined) {
+    return (url, init) => {
+        const custom = overrides(url, init);
+        if (custom)
+            return custom;
+        if (url.pathname === "/health")
+            return jsonRes(BROKER_HEALTH);
+        if (url.pathname === "/status")
+            return jsonRes(BROKER_STATUS);
+        return undefined;
+    };
+}
+async function connectBroker(server) {
+    return server.client.callTool({
+        name: "vm_connect",
+        arguments: {
+            url: "https://vm-broker.test",
+            apiKey: "key-1",
+            serviceId: "svc-1",
+        },
+    });
+}
+describe("broker routing", () => {
+    it("discovers broker mode on connect and lists the registered users", async () => {
+        stubFetch(brokerRoutes());
+        const server = await startServer();
+        try {
+            const connected = await connectBroker(server);
+            const out = textOf(connected);
+            expect(out).toContain('"mode": "broker"');
+            expect(out).toContain("robot1");
+            expect(out).toContain("robot2");
+            expect(out).toContain("targetUser");
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("passes targetUser through to POST /execute and surfaces attribution", async () => {
+        const fetchMock = stubFetch(brokerRoutes((url) => url.pathname === "/execute"
+            ? jsonRes({ ...EXEC_OK, targetUser: "robot2", sessionId: 2, queueWaitMs: 340 })
+            : undefined));
+        const server = await startServer();
+        try {
+            await connectBroker(server);
+            const exec = await server.client.callTool({
+                name: "vm_execute_script",
+                arguments: { script: "print(1)", targetUser: "robot2" },
+            });
+            const [, execInit] = callsTo(fetchMock, "/execute")[0];
+            const body = JSON.parse(String(execInit?.body));
+            expect(body.targetUser).toBe("robot2");
+            // Auth headers ride along.
+            const headers = execInit?.headers;
+            expect(headers["X-API-Key"]).toBe("key-1");
+            expect(headers["X-Service-ID"]).toBe("svc-1");
+            const out = textOf(exec);
+            expect(out).toContain('"targetUser": "robot2"');
+            expect(out).not.toContain("queueWaitMs");
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("surfaces the typed target_user_required error with the registered users", async () => {
+        stubFetch(brokerRoutes((url) => url.pathname === "/execute"
+            ? jsonRes({
+                success: false,
+                error: "target_user_required",
+                detail: "multi-session host: set targetUser",
+                knownUsers: ["robot1", "robot2"],
+            }, 400)
+            : undefined));
+        const server = await startServer();
+        try {
+            await connectBroker(server);
+            const exec = await server.client.callTool({
+                name: "vm_execute_script",
+                arguments: { script: "print(1)" },
+            });
+            const out = textOf(exec);
+            expect(out).toContain("target_user_required");
+            expect(out).toContain("Registered users on this VM: robot1, robot2");
+            expect(out).toContain("vm_list_sessions");
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("routes screenshots per user via the targetUser query parameter", async () => {
+        const fetchMock = stubFetch(brokerRoutes((url) => url.pathname === "/screenshot" ? jsonRes(SCREENSHOT_OK) : undefined));
+        const server = await startServer();
+        try {
+            await connectBroker(server);
+            await server.client.callTool({
+                name: "vm_screenshot",
+                arguments: { targetUser: "robot2" },
+            });
+            const [screenshotUrl] = callsTo(fetchMock, "/screenshot")[0];
+            expect(String(screenshotUrl)).toBe("https://vm-broker.test/screenshot?targetUser=robot2");
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("vm_list_sessions reads broker /status with API-key auth", async () => {
+        const fetchMock = stubFetch(brokerRoutes());
+        const server = await startServer();
+        try {
+            await connectBroker(server);
+            const sessions = await server.client.callTool({
+                name: "vm_list_sessions",
+                arguments: {},
+            });
+            const out = textOf(sessions);
+            expect(out).toContain('"user": "robot1"');
+            expect(out).toContain('"state": "stopped"');
+            expect(out).toContain('"robot2": 2');
+            const statusCalls = callsTo(fetchMock, "/status");
+            expect(statusCalls.length).toBeGreaterThan(0);
+            const [, statusInit] = statusCalls[statusCalls.length - 1];
+            const headers = statusInit?.headers;
+            expect(headers["X-API-Key"]).toBe("key-1");
+            expect(headers["X-Service-ID"]).toBe("svc-1");
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("vm_list_sessions explains itself on a standalone VM instead of failing", async () => {
+        const fetchMock = stubFetch((url) => url.pathname === "/health" ? jsonRes(STANDALONE_HEALTH) : undefined);
+        const server = await startServer();
+        try {
+            await server.client.callTool({
+                name: "vm_connect",
+                arguments: { url: "https://vm-standalone.test" },
+            });
+            const sessions = await server.client.callTool({
+                name: "vm_list_sessions",
+                arguments: {},
+            });
+            expect(textOf(sessions)).toContain("'standalone' mode");
+            expect(callsTo(fetchMock, "/status")).toHaveLength(0);
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("vm_start_session and vm_stop_session hit the /sessions/{user} endpoints", async () => {
+        const fetchMock = stubFetch(brokerRoutes((url, init) => {
+            if (url.pathname === "/sessions/robot1/start" && init?.method === "POST") {
+                return jsonRes({ success: true, user: "robot1", state: "active", sessionId: 1 });
+            }
+            if (url.pathname === "/sessions/robot2/stop" && init?.method === "POST") {
+                return jsonRes({ success: true, user: "robot2", state: "stopped" });
+            }
+            return undefined;
+        }));
+        const server = await startServer();
+        try {
+            await connectBroker(server);
+            const started = await server.client.callTool({
+                name: "vm_start_session",
+                arguments: { user: "robot1" },
+            });
+            expect(textOf(started)).toContain('"state": "active"');
+            expect(callsTo(fetchMock, "/sessions/robot1/start")).toHaveLength(1);
+            const stopped = await server.client.callTool({
+                name: "vm_stop_session",
+                arguments: { user: "robot2" },
+            });
+            expect(textOf(stopped)).toContain('"state": "stopped"');
+            expect(callsTo(fetchMock, "/sessions/robot2/stop")).toHaveLength(1);
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("renders the typed session_start_disabled refusal readably", async () => {
+        stubFetch(brokerRoutes((url, init) => url.pathname === "/sessions/robot1/start" && init?.method === "POST"
+            ? jsonRes({
+                success: false,
+                error: "session_start_disabled",
+                detail: "keeper_enabled=false",
+            }, 409)
+            : undefined));
+        const server = await startServer();
+        try {
+            await connectBroker(server);
+            const started = await server.client.callTool({
+                name: "vm_start_session",
+                arguments: { user: "robot1" },
+            });
+            const out = textOf(started);
+            expect(out).toContain("session_start_disabled");
+            expect(out).toContain("keeper_enabled=false");
+        }
+        finally {
+            await server.close();
+        }
+    });
+});
+// ── Hosted gating (plan §4.5.3) ───────────────────────────────
+describe("hosted stateless server (directVmTools=false)", () => {
+    it("keeps the tool surface identical but answers direct VM tools with a local-install pointer", async () => {
+        stubFetch(() => undefined); // no network traffic may happen
+        const hosted = await startServer({ directVmTools: false });
+        const local = await startServer({ directVmTools: true });
+        try {
+            const [hostedTools, localTools] = await Promise.all([
+                hosted.client.listTools(),
+                local.client.listTools(),
+            ]);
+            expect(hostedTools.tools.map((t) => t.name).sort()).toEqual(localTools.tools.map((t) => t.name).sort());
+            for (const name of [
+                "vm_connect",
+                "vm_execute_script",
+                "vm_screenshot",
+                "vm_list_sessions",
+                "vm_start_session",
+                "debug_rpa_step",
+            ]) {
+                const result = await hosted.client.callTool({
+                    name,
+                    arguments: name === "vm_execute_script"
+                        ? { script: "print(1)" }
+                        : name === "vm_start_session"
+                            ? { user: "robot1" }
+                            : name === "debug_rpa_step"
+                                ? { script: "print(1)" }
+                                : {},
+                });
+                expect(textOf(result), name).toContain("hosted Minicor MCP server");
+                expect(textOf(result), name).toContain("local MCP install");
+            }
+        }
+        finally {
+            await hosted.close();
+            await local.close();
+        }
+    });
+});
+// ── create_rpa_flow broker placeholder (plan §4.5.7) ──────────
+describe("create_rpa_flow target-user placeholder", () => {
+    async function createFlowProgram(server, extraArgs = {}) {
+        const result = await server.client.callTool({
+            name: "create_rpa_flow",
+            arguments: {
+                workflowId: 42,
+                name: "Step",
+                description: "Desc",
+                pythonScript: "print(1)",
+                executionOrder: 1,
+                flowId: "step-1",
+                ...extraArgs,
+            },
+        });
+        expect(textOf(result)).toContain('"flow"');
+        return textOf(result);
+    }
+    function withFlowsEndpoint(base) {
+        const capturedPrograms = [];
+        const route = (url, init) => {
+            if (url.pathname === "/flows" && init?.method === "POST") {
+                const body = JSON.parse(String(init.body));
+                capturedPrograms.push(body.program);
+                return jsonRes({ id: 7, ...body });
+            }
+            return base(url, init);
+        };
+        return { route, capturedPrograms };
+    }
+    it("includes the config placeholder when connected to a broker (inferred)", async () => {
+        const { route, capturedPrograms } = withFlowsEndpoint(brokerRoutes());
+        stubFetch(route);
+        const server = await startServer();
+        try {
+            await connectBroker(server);
+            const out = await createFlowProgram(server);
+            expect(capturedPrograms[0]).toContain('"targetUser": "{{config.minicor_desktop_service_target_user}}"');
+            expect(out).toContain("minicor_desktop_service_target_user");
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("keeps standalone-generated programs free of targetUser", async () => {
+        const { route, capturedPrograms } = withFlowsEndpoint((url) => url.pathname === "/health" ? jsonRes(STANDALONE_HEALTH) : undefined);
+        stubFetch(route);
+        const server = await startServer();
+        try {
+            await server.client.callTool({
+                name: "vm_connect",
+                arguments: { url: "https://vm-standalone.test" },
+            });
+            await createFlowProgram(server);
+            expect(capturedPrograms[0]).not.toContain("targetUser");
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("honors the explicit forBroker flag without any VM connection", async () => {
+        const { route, capturedPrograms } = withFlowsEndpoint(() => undefined);
+        stubFetch(route);
+        const server = await startServer();
+        try {
+            await createFlowProgram(server, { forBroker: true });
+            expect(capturedPrograms[0]).toContain('"targetUser": "{{config.minicor_desktop_service_target_user}}"');
+            await createFlowProgram(server, { forBroker: false });
+            expect(capturedPrograms[1]).not.toContain("targetUser");
+        }
+        finally {
+            await server.close();
+        }
+    });
+});
+// ── vm_execution_control stays removed (plan §4.5.9) ──────────
+describe("execution-control removal", () => {
+    it("exposes the session tools but never vm_execution_control", async () => {
+        stubFetch(() => undefined);
+        const server = await startServer();
+        try {
+            const tools = (await server.client.listTools()).tools.map((t) => t.name);
+            expect(tools).toContain("vm_list_sessions");
+            expect(tools).toContain("vm_start_session");
+            expect(tools).toContain("vm_stop_session");
+            expect(tools).not.toContain("vm_execution_control");
+        }
+        finally {
+            await server.close();
+        }
+    });
+    it("dropped the LDS client's executionControl entry point", () => {
+        expect(lds.executionControl).toBeUndefined();
+    });
+});
+function unitSetup() {
+    const handlers = new Map();
+    const server = {
+        tool: vi.fn((name, ...args) => {
+            handlers.set(name, args.at(-1));
+        }),
+    };
+    const state = createSessionState();
+    const deps = {
+        server,
+        state,
+        client: vi.fn(() => {
+            throw new Error("core API client not used in this test");
+        }),
+        getApiBase: () => "https://api.test.com",
+        getVmServiceBase: () => "https://vms.test.com",
+        getAuthToken: () => "token-1",
+        availableRegions: () => ["us"],
+    };
+    registerVmTools(deps);
+    state.setVmCache({
+        vms: [
+            {
+                id: 5,
+                vm_name: "vm-five",
+                tunnel_url: "https://vm-five.test",
+                api_key: "key-5",
+                service_id: "svc-5",
+            },
+        ],
+        fetchedAt: Date.now(),
+    });
+    return { deps, state, handlers };
+}
+async function callUnit(handlers, name, args) {
+    const handler = handlers.get(name);
+    if (!handler)
+        throw new Error(`Tool not registered: ${name}`);
+    return handler(args);
+}
+describe("mode-aware install/start tools", () => {
+    it("refuses start_mds_on_vm against a live broker and points at the mode-aware restart", async () => {
+        const { handlers } = unitSetup();
+        const fetchMock = stubFetch((url) => url.hostname === "vm-five.test" && url.pathname === "/health"
+            ? jsonRes(BROKER_HEALTH)
+            : undefined);
+        const result = await callUnit(handlers, "start_mds_on_vm", {
+            workspaceId: 1,
+            vmId: 5,
+        });
+        expect(textOf(result)).toContain("Refusing start_mds_on_vm");
+        expect(textOf(result)).toContain("broker (multi-session) mode");
+        expect(textOf(result)).toContain("MinicorBroker");
+        // Probed health only — the legacy run-script never fired.
+        expect(fetchMock.mock.calls).toHaveLength(1);
+        expect(String(fetchMock.mock.calls[0][0])).toBe("https://vm-five.test/health");
+    });
+    it("refuses install_mds_on_vm against a live broker", async () => {
+        const { handlers } = unitSetup();
+        const fetchMock = stubFetch((url) => url.hostname === "vm-five.test" && url.pathname === "/health"
+            ? jsonRes(BROKER_HEALTH)
+            : undefined);
+        const result = await callUnit(handlers, "install_mds_on_vm", {
+            workspaceId: 1,
+            vmId: 5,
+            enableRecording: true,
+            resolution: "1280x720",
+        });
+        expect(textOf(result)).toContain("Refusing install_mds_on_vm");
+        expect(textOf(result)).toContain("/MULTISESSION=1");
+        expect(fetchMock.mock.calls).toHaveLength(1);
+    });
+    it("still starts MDS on a standalone VM", async () => {
+        const { handlers } = unitSetup();
+        const fetchMock = stubFetch((url, init) => {
+            if (url.hostname === "vm-five.test" && url.pathname === "/health") {
+                return jsonRes(STANDALONE_HEALTH);
+            }
+            if (url.hostname === "vms.test.com" &&
+                url.pathname === "/workspaces/1/vms/5/run-script" &&
+                init?.method === "POST") {
+                return jsonRes({ stdout: "MDS running (PID 4242)", stderr: "" });
+            }
+            return undefined;
+        });
+        const result = await callUnit(handlers, "start_mds_on_vm", {
+            workspaceId: 1,
+            vmId: 5,
+        });
+        expect(textOf(result)).toContain("MDS start command executed");
+        expect(callsTo(fetchMock, "/workspaces/1/vms/5/run-script")).toHaveLength(1);
+    });
+    it("still starts MDS when the VM's health endpoint is unreachable (MDS down)", async () => {
+        const { handlers } = unitSetup();
+        const fetchMock = vi.fn(async (input, init) => {
+            const url = new URL(String(input));
+            if (url.pathname === "/health") {
+                throw new Error("ECONNREFUSED"); // MDS is down — the reason to start it
+            }
+            if (url.pathname === "/workspaces/1/vms/5/run-script" && init?.method === "POST") {
+                return jsonRes({ stdout: "started", stderr: "" });
+            }
+            throw new Error(`Unexpected fetch: ${url}`);
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const result = await callUnit(handlers, "start_mds_on_vm", {
+            workspaceId: 1,
+            vmId: 5,
+        });
+        expect(textOf(result)).toContain("MDS start command executed");
+        expect(callsTo(fetchMock, "/workspaces/1/vms/5/run-script")).toHaveLength(1);
+    });
+});
+//# sourceMappingURL=vm-broker.test.js.map