mono-pilot 0.2.10 → 0.2.13

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

@@ -0,0 +1,450 @@
+import { createClusterLogContext, logClusterEvent } from "../observability.js";
+export const BUS_METHOD_REGISTER = "bus.register";
+export const BUS_METHOD_SUBSCRIBE = "bus.subscribe";
+export const BUS_METHOD_SEND = "bus.send";
+export const BUS_METHOD_BROADCAST = "bus.broadcast";
+export const BUS_METHOD_ROSTER = "bus.roster";
+const CONNECTION_AGENT_ID_KEY = "bus.agentId";
+function parseRegisterParams(params) {
+    if (!params || typeof params !== "object") {
+        throw new Error("bus.register requires object params");
+    }
+    const p = params;
+    if (!p.agentId || typeof p.agentId !== "string") {
+        throw new Error("bus.register requires string agentId");
+    }
+    if (p.channels && (!Array.isArray(p.channels) || p.channels.some((c) => typeof c !== "string"))) {
+        throw new Error("bus.register channels must be string[]");
+    }
+    if (p.displayName !== undefined && typeof p.displayName !== "string") {
+        throw new Error("bus.register displayName must be string");
+    }
+    return p;
+}
+function parseSubscribeParams(params) {
+    if (!params || typeof params !== "object") {
+        throw new Error("bus.subscribe requires object params");
+    }
+    const p = params;
+    if (!Array.isArray(p.channels) || p.channels.some((c) => typeof c !== "string")) {
+        throw new Error("bus.subscribe requires string[] channels");
+    }
+    return p;
+}
+function parseSendParams(params) {
+    if (!params || typeof params !== "object") {
+        throw new Error("bus.send requires object params");
+    }
+    const p = params;
+    if (!p.to || typeof p.to !== "string") {
+        throw new Error("bus.send requires string to");
+    }
+    if (p.channel !== undefined && typeof p.channel !== "string") {
+        throw new Error("bus.send channel must be string");
+    }
+    return p;
+}
+function parseBroadcastParams(params) {
+    if (!params || typeof params !== "object") {
+        throw new Error("bus.broadcast requires object params");
+    }
+    const p = params;
+    if (p.channel !== undefined && typeof p.channel !== "string") {
+        throw new Error("bus.broadcast channel must be string");
+    }
+    return p;
+}
+export function createBusService() {
+    const agents = new Map();
+    let messageSeq = 0;
+    const getDefaultChannels = (agentId) => ["public", `private:${agentId}`];
+    const broadcastPresence = (agentId, status, exclude) => {
+        const payload = {
+            agentId,
+            displayName: agents.get(agentId)?.displayName,
+            status,
+        };
+        for (const [id, agent] of agents) {
+            if (id === exclude)
+                continue;
+            agent.push("presence", payload);
+        }
+    };
+    const registerAgent = (agentId, push, role, channels, displayName, connection) => {
+        const existing = agents.get(agentId);
+        const previousRole = existing?.role ?? null;
+        const roleDowngradePrevented = existing?.role === "leader" && role === "follower";
+        if (existing && roleDowngradePrevented) {
+            const allChannels = [...new Set([...existing.channels, ...getDefaultChannels(agentId), ...(channels ?? [])])];
+            agents.set(agentId, {
+                agentId,
+                displayName: existing.displayName ?? displayName,
+                role: existing.role,
+                push: existing.push,
+                channels: new Set(allChannels),
+                connection: existing.connection,
+            });
+            return {
+                channels: allChannels,
+                previousRole,
+                nextRole: existing.role,
+                roleDowngradePrevented,
+            };
+        }
+        if (existing) {
+            existing.push = () => {
+                // old connection is superseded by the new registration.
+            };
+        }
+        const allChannels = [...new Set([...getDefaultChannels(agentId), ...(channels ?? [])])];
+        agents.set(agentId, {
+            agentId,
+            displayName,
+            role,
+            push,
+            channels: new Set(allChannels),
+            connection,
+        });
+        broadcastPresence(agentId, "joined", agentId);
+        for (const [id, current] of agents) {
+            if (id === agentId)
+                continue;
+            push("presence", {
+                agentId: id,
+                displayName: current.displayName,
+                status: "joined",
+            });
+        }
+        return {
+            channels: allChannels,
+            previousRole,
+            nextRole: role,
+            roleDowngradePrevented,
+        };
+    };
+    const unregisterAgent = (agentId) => {
+        if (!agents.has(agentId))
+            return;
+        agents.delete(agentId);
+        broadcastPresence(agentId, "left");
+    };
+    const senderFromConnection = (connection) => {
+        const sender = connection.state.get(CONNECTION_AGENT_ID_KEY);
+        if (!sender || typeof sender !== "string") {
+            throw new Error("must register before calling bus method");
+        }
+        return sender;
+    };
+    const handlers = {
+        [BUS_METHOD_REGISTER]: async (request, connection) => {
+            const { agentId, channels, displayName } = parseRegisterParams(request.params);
+            const registration = registerAgent(agentId, (method, payload) => connection.sendPush(method, payload), "follower", channels, displayName, connection);
+            const fromSessionId = request.from?.sessionId;
+            logClusterEvent(registration.roleDowngradePrevented ? "warn" : "info", registration.roleDowngradePrevented
+                ? "bus_register_role_downgrade_prevented"
+                : "bus_register", createClusterLogContext({
+                agentId,
+                sessionId: fromSessionId,
+                role: "leader:bus",
+            }), {
+                previousRole: registration.previousRole,
+                nextRole: registration.nextRole,
+                requestedRole: "follower",
+                fromPid: request.from?.pid ?? null,
+                fromSessionId: fromSessionId ?? null,
+                fromAgentId: request.from?.agentId ?? null,
+                channels: registration.channels,
+            });
+            connection.state.set(CONNECTION_AGENT_ID_KEY, agentId);
+            return { agentId, channels: registration.channels };
+        },
+        [BUS_METHOD_SUBSCRIBE]: async (request, connection) => {
+            const sender = senderFromConnection(connection);
+            const { channels } = parseSubscribeParams(request.params);
+            const agent = agents.get(sender);
+            if (!agent) {
+                throw new Error("registered agent not found");
+            }
+            for (const channel of channels) {
+                agent.channels.add(channel);
+            }
+            return { channels: [...agent.channels] };
+        },
+        [BUS_METHOD_SEND]: async (request, connection) => {
+            const sender = senderFromConnection(connection);
+            const { to, channel, payload } = parseSendParams(request.params);
+            const target = agents.get(to);
+            if (!target) {
+                throw new Error(`agent not found: ${to}`);
+            }
+            const seq = ++messageSeq;
+            target.push("message", {
+                from: sender,
+                fromName: agents.get(sender)?.displayName,
+                channel,
+                payload,
+                seq,
+            });
+            return { seq };
+        },
+        [BUS_METHOD_BROADCAST]: async (request, connection) => {
+            const sender = senderFromConnection(connection);
+            const { channel, payload } = parseBroadcastParams(request.params);
+            const targetChannel = channel ?? "public";
+            const seq = ++messageSeq;
+            let delivered = 0;
+            const pushPayload = {
+                from: sender,
+                fromName: agents.get(sender)?.displayName,
+                channel: targetChannel,
+                payload,
+                seq,
+            };
+            for (const [id, agent] of agents) {
+                if (id === sender)
+                    continue;
+                if (agent.channels.has(targetChannel)) {
+                    agent.push("message", pushPayload);
+                    delivered++;
+                }
+            }
+            return { seq, delivered };
+        },
+        [BUS_METHOD_ROSTER]: async () => {
+            return {
+                agents: [...agents.entries()].map(([id, agent]) => ({
+                    agentId: id,
+                    displayName: agent.displayName,
+                    role: agent.role,
+                    channels: [...agent.channels],
+                })),
+            };
+        },
+    };
+    const onConnectionClosed = (connection) => {
+        const agentId = connection.state.get(CONNECTION_AGENT_ID_KEY);
+        if (!agentId || typeof agentId !== "string") {
+            return;
+        }
+        const current = agents.get(agentId);
+        if (current?.connection !== connection) {
+            return;
+        }
+        unregisterAgent(agentId);
+    };
+    const createLeaderHandle = (agentId, displayName) => {
+        let closed = false;
+        let messageHandlers = [];
+        let presenceHandlers = [];
+        const push = (method, payload) => {
+            if (closed)
+                return;
+            if (method === "message") {
+                for (const handler of messageHandlers) {
+                    handler(payload);
+                }
+                return;
+            }
+            if (method === "presence") {
+                for (const handler of presenceHandlers) {
+                    handler(payload);
+                }
+            }
+        };
+        registerAgent(agentId, push, "leader", undefined, displayName, undefined);
+        return {
+            async send(to, payload, channel) {
+                const target = agents.get(to);
+                if (!target) {
+                    throw new Error(`agent not found: ${to}`);
+                }
+                const seq = ++messageSeq;
+                target.push("message", {
+                    from: agentId,
+                    fromName: agents.get(agentId)?.displayName,
+                    channel,
+                    payload,
+                    seq,
+                });
+                return { seq };
+            },
+            async broadcast(payload, channel) {
+                const targetChannel = channel ?? "public";
+                const seq = ++messageSeq;
+                let delivered = 0;
+                const pushPayload = {
+                    from: agentId,
+                    fromName: agents.get(agentId)?.displayName,
+                    channel: targetChannel,
+                    payload,
+                    seq,
+                };
+                for (const [id, agent] of agents) {
+                    if (id === agentId)
+                        continue;
+                    if (agent.channels.has(targetChannel)) {
+                        agent.push("message", pushPayload);
+                        delivered++;
+                    }
+                }
+                return { seq, delivered };
+            },
+            async subscribe(channels) {
+                const agent = agents.get(agentId);
+                if (!agent)
+                    return { channels: [] };
+                for (const channel of channels) {
+                    agent.channels.add(channel);
+                }
+                return { channels: [...agent.channels] };
+            },
+            async roster() {
+                return {
+                    agents: [...agents.entries()].map(([id, agent]) => ({
+                        agentId: id,
+                        displayName: agent.displayName,
+                        role: agent.role,
+                        channels: [...agent.channels],
+                    })),
+                };
+            },
+            async resolveTarget(target) {
+                const { agents: roster } = await this.roster();
+                const byId = roster.find((agent) => agent.agentId === target);
+                if (byId)
+                    return { agentId: byId.agentId, displayName: byId.displayName };
+                const matches = roster.filter((agent) => agent.displayName?.trim() && agent.displayName.trim() === target);
+                if (matches.length === 1) {
+                    return { agentId: matches[0].agentId, displayName: matches[0].displayName };
+                }
+                if (matches.length === 0) {
+                    throw new Error(`No agent found for "${target}".`);
+                }
+                const ids = matches.map((agent) => agent.agentId).join(", ");
+                throw new Error(`DisplayName "${target}" is not unique. Candidates: ${ids}.`);
+            },
+            onMessage(handler) {
+                messageHandlers.push(handler);
+            },
+            onPresence(handler) {
+                presenceHandlers.push(handler);
+            },
+            close() {
+                if (closed)
+                    return;
+                closed = true;
+                messageHandlers = [];
+                presenceHandlers = [];
+                unregisterAgent(agentId);
+            },
+        };
+    };
+    return {
+        handlers,
+        onConnectionClosed,
+        createLeaderHandle,
+    };
+}
+export async function connectBusClient(client, agentId, displayName, channels) {
+    let closed = false;
+    let buffering = true;
+    const eventBuffer = [];
+    let messageHandlers = [];
+    let presenceHandlers = [];
+    const dispatch = (method, payload) => {
+        if (method === "message") {
+            for (const handler of messageHandlers) {
+                handler(payload);
+            }
+            return;
+        }
+        if (method === "presence") {
+            for (const handler of presenceHandlers) {
+                handler(payload);
+            }
+        }
+    };
+    const unbindMessage = client.onPush("message", (payload) => {
+        if (closed)
+            return;
+        if (buffering) {
+            eventBuffer.push({ method: "message", payload });
+            return;
+        }
+        dispatch("message", payload);
+    });
+    const unbindPresence = client.onPush("presence", (payload) => {
+        if (closed)
+            return;
+        if (buffering) {
+            eventBuffer.push({ method: "presence", payload });
+            return;
+        }
+        dispatch("presence", payload);
+    });
+    await client.call(BUS_METHOD_REGISTER, {
+        agentId,
+        displayName,
+        channels,
+    });
+    process.nextTick(() => {
+        buffering = false;
+        for (const evt of eventBuffer) {
+            dispatch(evt.method, evt.payload);
+        }
+        eventBuffer.length = 0;
+    });
+    const roster = async () => {
+        return client.call(BUS_METHOD_ROSTER, {});
+    };
+    return {
+        async send(to, payload, channel) {
+            return client.call(BUS_METHOD_SEND, {
+                to,
+                channel,
+                payload,
+            });
+        },
+        async broadcast(payload, channel) {
+            return client.call(BUS_METHOD_BROADCAST, {
+                channel,
+                payload,
+            });
+        },
+        async subscribe(chs) {
+            return client.call(BUS_METHOD_SUBSCRIBE, { channels: chs });
+        },
+        roster,
+        async resolveTarget(target) {
+            const { agents } = await roster();
+            const byId = agents.find((agent) => agent.agentId === target);
+            if (byId)
+                return { agentId: byId.agentId, displayName: byId.displayName };
+            const matches = agents.filter((agent) => agent.displayName?.trim() && agent.displayName.trim() === target);
+            if (matches.length === 1) {
+                return { agentId: matches[0].agentId, displayName: matches[0].displayName };
+            }
+            if (matches.length === 0) {
+                throw new Error(`No agent found for "${target}".`);
+            }
+            const ids = matches.map((agent) => agent.agentId).join(", ");
+            throw new Error(`DisplayName "${target}" is not unique. Candidates: ${ids}.`);
+        },
+        onMessage(handler) {
+            messageHandlers.push(handler);
+        },
+        onPresence(handler) {
+            presenceHandlers.push(handler);
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            messageHandlers = [];
+            presenceHandlers = [];
+            eventBuffer.length = 0;
+            unbindMessage();
+            unbindPresence();
+        },
+    };
+}

package/dist/src/cluster_v2/services/discord/auth-store.js

@@ -0,0 +1,82 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const AUTH_PATH = join(homedir(), ".mono-pilot", "auth.json");
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+async function loadAuthObject() {
+    if (!existsSync(AUTH_PATH)) {
+        return {};
+    }
+    const raw = await readFile(AUTH_PATH, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON in auth store: ${message}`);
+    }
+    if (!isRecord(parsed)) {
+        throw new Error("Auth store root must be a JSON object.");
+    }
+    return parsed;
+}
+function normalizeToken(value) {
+    const accessToken = readString(value.accessToken);
+    if (!accessToken) {
+        return null;
+    }
+    return {
+        accessToken,
+        refreshToken: readString(value.refreshToken),
+        tokenType: readString(value.tokenType),
+        scope: readString(value.scope),
+        expiresAt: readString(value.expiresAt),
+        updatedAt: readString(value.updatedAt) ?? new Date(0).toISOString(),
+    };
+}
+export function getAuthStorePath() {
+    return AUTH_PATH;
+}
+export async function readDiscordAuthToken(clientId) {
+    const root = await loadAuthObject();
+    const discord = isRecord(root.discord) ? root.discord : null;
+    const tokens = discord && isRecord(discord.tokens) ? discord.tokens : null;
+    if (!tokens) {
+        return null;
+    }
+    const raw = tokens[clientId];
+    if (!isRecord(raw)) {
+        return null;
+    }
+    return normalizeToken(raw);
+}
+export async function writeDiscordAuthToken(clientId, token) {
+    const root = await loadAuthObject();
+    const discord = isRecord(root.discord) ? { ...root.discord } : {};
+    const tokens = isRecord(discord.tokens) ? { ...discord.tokens } : {};
+    const normalized = {
+        accessToken: token.accessToken,
+        refreshToken: token.refreshToken,
+        tokenType: token.tokenType,
+        scope: token.scope,
+        expiresAt: token.expiresAt,
+        updatedAt: new Date().toISOString(),
+    };
+    tokens[clientId] = normalized;
+    discord.tokens = tokens;
+    root.discord = discord;
+    await mkdir(dirname(AUTH_PATH), { recursive: true });
+    await writeFile(AUTH_PATH, `${JSON.stringify(root, null, 2)}\n`, "utf-8");
+    return normalized;
+}