mono-pilot 0.2.9 → 0.2.12

package/dist/src/cluster_v2/runtime.lifecycle.integration.test.js

@@ -0,0 +1,225 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { tryListen } from "./connection.js";
+import { bindRpcConnection, } from "./rpc.js";
+import { createEmbeddingHandlers } from "./services/embedding.js";
+import { createBusService } from "./services/bus.js";
+import { ServiceRegistry } from "./services/registry.js";
+import { closeClusterV2, initClusterV2 } from "./runtime.js";
+function createMockEmbeddingProvider(model) {
+    return {
+        id: "local",
+        model,
+        embedQuery: async (text) => [text.length],
+        embedBatch: async (texts) => texts.map((text) => [text.length]),
+        dispose: async () => {
+            // no-op in tests
+        },
+    };
+}
+vi.mock("../memory/embeddings/local.js", () => ({
+    createLocalEmbeddingProvider: async (params) => createMockEmbeddingProvider(params.modelPath ?? "mock-local"),
+}));
+let externalLeader = null;
+afterEach(async () => {
+    if (externalLeader) {
+        await externalLeader.close();
+        externalLeader = null;
+    }
+    await closeClusterV2();
+});
+function uniqueScope(prefix) {
+    return `${prefix}-${process.pid}-${Date.now()}-${Math.floor(Math.random() * 100000)}`;
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForRole(params, role, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let last = null;
+    while (Date.now() < deadline) {
+        last = await initClusterV2(params);
+        if (last.role === role) {
+            return last;
+        }
+        await sleep(25);
+    }
+    throw new Error(`timed out waiting for role=${role}, last=${last?.role ?? "none"}`);
+}
+function registerDefaultServices(registry) {
+    const services = [
+        { name: "embedding", version: "v2", capabilities: { methods: ["embedding.embedBatch"] } },
+        {
+            name: "bus",
+            version: "v2",
+            capabilities: {
+                methods: ["bus.register", "bus.subscribe", "bus.send", "bus.broadcast", "bus.roster"],
+            },
+        },
+    ];
+    for (const service of services) {
+        registry.register(service);
+    }
+}
+async function startExternalLeader(scope) {
+    const connection = await tryListen({ scope });
+    if (!connection) {
+        throw new Error("failed to start external leader for test");
+    }
+    const registry = new ServiceRegistry();
+    registerDefaultServices(registry);
+    const busService = createBusService();
+    const provider = createMockEmbeddingProvider("external-leader");
+    const embeddingHandlers = createEmbeddingHandlers(provider);
+    const handlers = {
+        "cluster.ping": async () => "pong",
+        "registry.list": async () => registry.snapshot(),
+        "registry.resolve": async (request) => {
+            const name = request.params?.name;
+            if (!name || typeof name !== "string") {
+                throw new Error("registry.resolve requires string name");
+            }
+            return {
+                revision: registry.getRevision(),
+                service: registry.resolve(name),
+            };
+        },
+        ...embeddingHandlers,
+        ...busService.handlers,
+    };
+    const sockets = new Set();
+    connection.server.on("connection", (socket) => {
+        sockets.add(socket);
+        socket.on("close", () => {
+            sockets.delete(socket);
+        });
+        bindRpcConnection(socket, async (request, rpcConnection) => {
+            const handler = handlers[request.method];
+            if (!handler) {
+                throw new Error(`unknown method: ${request.method}`);
+            }
+            return handler(request, rpcConnection);
+        }, {
+            onClose: (rpcConnection) => {
+                busService.onConnectionClosed(rpcConnection);
+            },
+        });
+    });
+    const bus = busService.createLeaderHandle("leader-harness", "Leader Harness");
+    return {
+        connection,
+        bus,
+        close: async () => {
+            for (const socket of sockets) {
+                socket.destroy();
+            }
+            await connection.close();
+            bus.close();
+        },
+    };
+}
+function parseLifecycleRecords(calls) {
+    const records = [];
+    for (const call of calls) {
+        const line = call[0];
+        if (typeof line !== "string" || !line.startsWith("[cluster_v2] ")) {
+            continue;
+        }
+        const payload = line.slice("[cluster_v2] ".length);
+        try {
+            const parsed = JSON.parse(payload);
+            records.push(parsed);
+        }
+        catch {
+            // ignore non-json log lines in tests
+        }
+    }
+    return records;
+}
+const ALLOWED_TRANSITIONS = new Set([
+    "disconnected->connecting",
+    "disconnected->closed",
+    "connecting->connected",
+    "connecting->disconnected",
+    "connecting->closed",
+    "connected->reconnecting",
+    "connected->disconnected",
+    "connected->closed",
+    "reconnecting->connecting",
+    "reconnecting->disconnected",
+    "reconnecting->closed",
+    "closed->connecting",
+]);
+describe("cluster_v2 runtime lifecycle integration", () => {
+    it("keeps leader lifecycle transitions within the state machine", async () => {
+        const scope = uniqueScope("runtime-leader-lifecycle");
+        const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {
+            // mute test logs
+        });
+        try {
+            const params = {
+                agentId: "leader-a",
+                displayName: "Leader A",
+                scope,
+                modelPath: "mock-local",
+                rpcTimeoutMs: 500,
+                getSessionId: () => "leader-session",
+            };
+            const service = await initClusterV2(params);
+            expect(service.role).toBe("leader");
+            await closeClusterV2();
+            const records = parseLifecycleRecords(infoSpy.mock.calls)
+                .filter((record) => record.event === "connection_lifecycle_transition" && record.scope === scope);
+            const leaderTransitions = records.filter((record) => record.role === "leader");
+            expect(leaderTransitions.length).toBeGreaterThanOrEqual(3);
+            for (const transition of leaderTransitions) {
+                const edge = `${transition.fromState ?? ""}->${transition.toState ?? ""}`;
+                expect(ALLOWED_TRANSITIONS.has(edge)).toBe(true);
+            }
+            expect(leaderTransitions.some((transition) => transition.fromState === "disconnected" && transition.toState === "connecting")).toBe(true);
+            expect(leaderTransitions.some((transition) => transition.fromState === "connecting" && transition.toState === "connected")).toBe(true);
+            expect(leaderTransitions.some((transition) => transition.fromState === "connected" &&
+                transition.toState === "closed" &&
+                transition.label?.startsWith("leader_close:"))).toBe(true);
+        }
+        finally {
+            infoSpy.mockRestore();
+        }
+    });
+    it("drives follower through reconnect lifecycle after leader loss", async () => {
+        const scope = uniqueScope("runtime-follower-lifecycle");
+        externalLeader = await startExternalLeader(scope);
+        const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {
+            // mute test logs
+        });
+        try {
+            const params = {
+                agentId: "follower-a",
+                displayName: "Follower A",
+                scope,
+                modelPath: "mock-local",
+                rpcTimeoutMs: 500,
+                getSessionId: () => "follower-session",
+            };
+            const follower = await initClusterV2(params);
+            expect(follower.role).toBe("follower");
+            await externalLeader.close();
+            externalLeader = null;
+            await waitForRole(params, "leader", 4000);
+            const records = parseLifecycleRecords(infoSpy.mock.calls)
+                .filter((record) => record.event === "connection_lifecycle_transition" && record.scope === scope);
+            for (const transition of records) {
+                const edge = `${transition.fromState ?? ""}->${transition.toState ?? ""}`;
+                expect(ALLOWED_TRANSITIONS.has(edge)).toBe(true);
+            }
+            const followerTransitions = records.filter((record) => record.role === "follower");
+            expect(followerTransitions.some((transition) => transition.fromState === "connecting" && transition.toState === "connected")).toBe(true);
+            expect(followerTransitions.some((transition) => transition.fromState === "connected" &&
+                transition.toState === "reconnecting" &&
+                transition.label === "follower_disconnect")).toBe(true);
+            expect(followerTransitions.some((transition) => transition.fromState === "reconnecting" && transition.toState === "disconnected")).toBe(true);
+        }
+        finally {
+            infoSpy.mockRestore();
+        }
+    });
+});

package/dist/src/cluster_v2/services/bus.integration.test.js

@@ -0,0 +1,140 @@
+import net from "node:net";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { bindRpcConnection, ClusterRpcClient, } from "../rpc.js";
+import { connectBusClient, createBusService } from "./bus.js";
+const activeServers = [];
+const activeClients = [];
+const activeBuses = [];
+afterEach(async () => {
+    for (const bus of activeBuses.splice(0)) {
+        bus.close();
+    }
+    for (const client of activeClients.splice(0)) {
+        client.close();
+    }
+    for (const server of activeServers.splice(0)) {
+        await new Promise((resolve) => server.server.close(() => resolve()));
+        await rm(server.dir, { recursive: true, force: true });
+    }
+});
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function startBusServer() {
+    const busService = createBusService();
+    const handlers = {
+        ...busService.handlers,
+    };
+    const dir = await mkdtemp(join(tmpdir(), "cluster-v2-bus-test-"));
+    const socketPath = join(dir, "bus.sock");
+    const server = net.createServer((socket) => {
+        bindRpcConnection(socket, async (request, connection) => {
+            const handler = handlers[request.method];
+            if (!handler) {
+                throw new Error(`unknown method: ${request.method}`);
+            }
+            return handler(request, connection);
+        }, {
+            onClose: (connection) => {
+                busService.onConnectionClosed(connection);
+            },
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(socketPath, () => resolve());
+    });
+    const handle = { dir, socketPath, server, busService };
+    activeServers.push(handle);
+    return handle;
+}
+async function connectClient(socketPath, agentId) {
+    const socket = await new Promise((resolve, reject) => {
+        const s = net.createConnection(socketPath);
+        s.once("connect", () => resolve(s));
+        s.once("error", reject);
+    });
+    const client = new ClusterRpcClient(socket, {
+        agentId,
+        sessionId: `${agentId}-session`,
+        scope: "bus-test",
+        role: "bus-test-client",
+    });
+    activeClients.push(client);
+    return client;
+}
+describe("cluster_v2 bus integration", () => {
+    it("keeps roster/presence consistent across join and leave", async () => {
+        const server = await startBusServer();
+        const aliceClient = await connectClient(server.socketPath, "alice");
+        const aliceBus = await connectBusClient(aliceClient, "alice", "Alice", ["public"]);
+        activeBuses.push(aliceBus);
+        const alicePresence = [];
+        aliceBus.onPresence((evt) => {
+            alicePresence.push(evt);
+        });
+        const bobClient = await connectClient(server.socketPath, "bob");
+        const bobBus = await connectBusClient(bobClient, "bob", "Bob", ["public"]);
+        activeBuses.push(bobBus);
+        const bobPresence = [];
+        bobBus.onPresence((evt) => {
+            bobPresence.push(evt);
+        });
+        await sleep(30);
+        expect(alicePresence.some((evt) => evt.agentId === "bob" && evt.status === "joined")).toBe(true);
+        expect(bobPresence.some((evt) => evt.agentId === "alice" && evt.status === "joined")).toBe(true);
+        const { agents } = await aliceBus.roster();
+        expect(agents.map((agent) => agent.agentId).sort()).toEqual(["alice", "bob"]);
+        expect(agents.map((agent) => agent.role).sort()).toEqual(["follower", "follower"]);
+        bobClient.close();
+        await sleep(30);
+        expect(alicePresence.some((evt) => evt.agentId === "bob" && evt.status === "left")).toBe(true);
+    });
+    it("enforces channel isolation and no self-broadcast delivery", async () => {
+        const server = await startBusServer();
+        const aliceClient = await connectClient(server.socketPath, "alice");
+        const bobClient = await connectClient(server.socketPath, "bob");
+        const aliceBus = await connectBusClient(aliceClient, "alice", "Alice", ["public"]);
+        const bobBus = await connectBusClient(bobClient, "bob", "Bob", ["public"]);
+        activeBuses.push(aliceBus, bobBus);
+        const aliceMessages = [];
+        const bobMessages = [];
+        aliceBus.onMessage((msg) => {
+            aliceMessages.push(msg);
+        });
+        bobBus.onMessage((msg) => {
+            bobMessages.push(msg);
+        });
+        await bobBus.subscribe(["secret"]);
+        await aliceBus.broadcast({ text: "private payload" }, "secret");
+        await sleep(30);
+        expect(bobMessages.some((msg) => msg.channel === "secret")).toBe(true);
+        expect(aliceMessages.length).toBe(0);
+        await aliceBus.broadcast({ text: "public payload" }, "public");
+        await sleep(30);
+        expect(bobMessages.some((msg) => msg.channel === "public")).toBe(true);
+        expect(aliceMessages.length).toBe(0);
+    });
+    it("keeps leader role when same agent re-registers as follower", async () => {
+        const server = await startBusServer();
+        const leaderBus = server.busService.createLeaderHandle("same-agent", "Leader");
+        activeBuses.push(leaderBus);
+        const duplicateClient = await connectClient(server.socketPath, "same-agent");
+        const duplicateBus = await connectBusClient(duplicateClient, "same-agent", "Follower", ["secret"]);
+        activeBuses.push(duplicateBus);
+        await sleep(30);
+        const firstRoster = await leaderBus.roster();
+        expect(firstRoster.agents).toHaveLength(1);
+        expect(firstRoster.agents[0].agentId).toBe("same-agent");
+        expect(firstRoster.agents[0].role).toBe("leader");
+        expect(firstRoster.agents[0].channels).toEqual(expect.arrayContaining(["public", "private:same-agent", "secret"]));
+        duplicateClient.close();
+        await sleep(30);
+        const secondRoster = await leaderBus.roster();
+        expect(secondRoster.agents).toHaveLength(1);
+        expect(secondRoster.agents[0].role).toBe("leader");
+    });
+});