agent-comms 1.0.14 → 1.2.0

package/dist/core/mesh-store.js

@@ -0,0 +1,790 @@
+/**
+ * MeshStore — TCP localhost peer mesh for agent communication.
+ *
+ * Each bridge instance is a peer in the mesh. Peers discover each other
+ * via a coordinator (the first instance to bind the well-known port).
+ * All state is held in memory and synchronised between peers.
+ * Delivery events are pushed directly over TCP — no polling, no filesystem.
+ *
+ * Falls back to FileStore if the mesh is unavailable.
+ */
+import * as net from "node:net";
+import { nanoid } from "./nanoid.js";
+import { CommsError } from "./store.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const DEFAULT_COORDINATOR_PORT = 19876;
+const COORDINATOR_HOST = "127.0.0.1";
+// ---------------------------------------------------------------------------
+// Framing
+// ---------------------------------------------------------------------------
+function encode(msg) {
+    return JSON.stringify(msg) + "\n";
+}
+class MessageBuffer {
+    buffer = "";
+    append(data) {
+        this.buffer += data;
+        const results = [];
+        let idx = this.buffer.indexOf("\n");
+        while (idx !== -1) {
+            const line = this.buffer.slice(0, idx);
+            this.buffer = this.buffer.slice(idx + 1);
+            if (line.length > 0) {
+                try {
+                    results.push(JSON.parse(line));
+                }
+                catch {
+                    /* skip malformed lines */
+                }
+            }
+            idx = this.buffer.indexOf("\n");
+        }
+        return results;
+    }
+}
+function isMeshMessage(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    if (!("method" in value))
+        return false;
+    return typeof value.method === "string";
+}
+function dmKey(a, b) {
+    const sorted = [a, b].sort();
+    return `${sorted[0] ?? a}--${sorted[1] ?? b}`;
+}
+// ---------------------------------------------------------------------------
+// Async socket write
+// ---------------------------------------------------------------------------
+function writeAsync(socket, data) {
+    return new Promise((resolve, reject) => {
+        socket.write(data, "utf-8", (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// MeshStore
+// ---------------------------------------------------------------------------
+export class MeshStore {
+    peerId;
+    startedAt;
+    coordinatorPort;
+    agents = new Map();
+    rooms = new Map();
+    messages = new Map();
+    dms = new Map();
+    deliveryQueues = new Map();
+    identityCache = new Map();
+    dataServer;
+    dataPort = 0;
+    coordinatorServer;
+    isCoordinator = false;
+    peerConnections = new Map();
+    peerInfo = new Map();
+    staleCheckTimer;
+    onDelivery;
+    constructor(coordinatorPort = DEFAULT_COORDINATOR_PORT) {
+        this.peerId = nanoid(8);
+        this.startedAt = new Date().toISOString();
+        this.coordinatorPort = coordinatorPort;
+    }
+    // -----------------------------------------------------------------------
+    // Mesh lifecycle
+    // -----------------------------------------------------------------------
+    async init() {
+        await this.startDataServer();
+        await this.tryJoinMesh();
+    }
+    startDataServer() {
+        return new Promise((resolve, reject) => {
+            this.dataServer = net.createServer((socket) => {
+                this.handleDataConnection(socket);
+            });
+            this.dataServer.listen(0, COORDINATOR_HOST, () => {
+                const addr = this.dataServer?.address();
+                if (addr && typeof addr === "object") {
+                    this.dataPort = addr.port;
+                }
+                resolve();
+            });
+            this.dataServer.on("error", reject);
+        });
+    }
+    async tryJoinMesh() {
+        try {
+            await this.connectToCoordinator();
+        }
+        catch {
+            await this.becomeCoordinator();
+        }
+    }
+    connectToCoordinator() {
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection({ port: this.coordinatorPort, host: COORDINATOR_HOST }, () => {
+                const intro = {
+                    method: "introduce",
+                    peerId: this.peerId,
+                    dataPort: this.dataPort,
+                };
+                socket.write(encode(intro));
+                // Read the peer_list response
+                const buf = new MessageBuffer();
+                socket.on("data", (data) => {
+                    const items = buf.append(data.toString());
+                    for (const item of items) {
+                        if (isMeshMessage(item)) {
+                            this.handleCoordinatorResponse(item);
+                        }
+                    }
+                });
+                socket.on("error", () => {
+                    /* ignore late errors */
+                });
+                resolve();
+            });
+            const timer = setTimeout(() => {
+                socket.destroy();
+                reject(new Error("Coordinator connection timeout"));
+            }, 2000);
+            socket.on("error", (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+    }
+    handleCoordinatorResponse(msg) {
+        if (msg.method === "peer_list") {
+            for (const peer of msg.peers) {
+                this.peerInfo.set(peer.id, peer);
+                void this.connectToPeerData(peer);
+            }
+        }
+        else if (msg.method === "peer_joined") {
+            this.peerInfo.set(msg.peer.id, msg.peer);
+            void this.connectToPeerData(msg.peer);
+        }
+    }
+    becomeCoordinator() {
+        return new Promise((resolve, reject) => {
+            this.coordinatorServer = net.createServer((socket) => {
+                this.handleCoordinatorConnection(socket);
+            });
+            this.coordinatorServer.listen(this.coordinatorPort, COORDINATOR_HOST, () => {
+                this.isCoordinator = true;
+                this.startStaleCheck();
+                this.peerInfo.set(this.peerId, {
+                    id: this.peerId,
+                    port: this.dataPort,
+                    startedAt: this.startedAt,
+                });
+                resolve();
+            });
+            this.coordinatorServer.on("error", (err) => {
+                const isAddrInUse = err instanceof Error && "code" in err && err.code === "EADDRINUSE";
+                if (isAddrInUse) {
+                    this.coordinatorServer = undefined;
+                    void this.connectToCoordinator().then(resolve, reject);
+                }
+                else {
+                    reject(err instanceof Error ? err : new Error(String(err)));
+                }
+            });
+        });
+    }
+    // -----------------------------------------------------------------------
+    // Coordinator protocol
+    // -----------------------------------------------------------------------
+    handleCoordinatorConnection(socket) {
+        const buffer = new MessageBuffer();
+        socket.on("data", (data) => {
+            const items = buffer.append(data.toString());
+            for (const item of items) {
+                if (isMeshMessage(item) && item.method === "introduce") {
+                    void this.handleIntroduction(socket, item);
+                }
+            }
+        });
+    }
+    async handleIntroduction(socket, msg) {
+        const newPeer = {
+            id: msg.peerId,
+            port: msg.dataPort,
+            startedAt: new Date().toISOString(),
+        };
+        this.peerInfo.set(msg.peerId, newPeer);
+        // Send full peer list to the new peer
+        const peerList = {
+            method: "peer_list",
+            peers: [...this.peerInfo.values()],
+        };
+        await writeAsync(socket, encode(peerList));
+        // Broadcast arrival to all existing data connections
+        const joined = { method: "peer_joined", peer: newPeer };
+        await this.broadcastToDataConnections(joined);
+        // Connect to the new peer's data server
+        void this.connectToPeerData(newPeer);
+    }
+    // -----------------------------------------------------------------------
+    // Data connections
+    // -----------------------------------------------------------------------
+    handleDataConnection(socket) {
+        const buffer = new MessageBuffer();
+        let remotePeerId;
+        socket.on("data", (data) => {
+            const items = buffer.append(data.toString());
+            for (const item of items) {
+                if (isMeshMessage(item)) {
+                    this.handleDataMessage(item);
+                    if (item.method === "pong") {
+                        remotePeerId = item.peerId;
+                    }
+                }
+            }
+            if (remotePeerId && !this.peerConnections.has(remotePeerId)) {
+                this.peerConnections.set(remotePeerId, { socket, buffer });
+            }
+        });
+        socket.on("close", () => {
+            if (remotePeerId)
+                this.peerConnections.delete(remotePeerId);
+        });
+        socket.on("error", () => {
+            if (remotePeerId)
+                this.peerConnections.delete(remotePeerId);
+        });
+    }
+    handleDataMessage(msg) {
+        if (msg.method === "state_sync") {
+            // Merge — don't replace — so our own state isn't lost
+            const incoming = {
+                agents: new Map(Object.entries(msg.state.agents)),
+                rooms: new Map(Object.entries(msg.state.rooms)),
+                messages: new Map(Object.entries(msg.state.messages)),
+                dms: new Map(Object.entries(msg.state.dms)),
+            };
+            for (const [id, agent] of incoming.agents) {
+                if (!this.agents.has(id))
+                    this.agents.set(id, agent);
+            }
+            for (const [id, room] of incoming.rooms) {
+                if (!this.rooms.has(id))
+                    this.rooms.set(id, room);
+            }
+            for (const [id, msgs] of incoming.messages) {
+                if (!this.messages.has(id))
+                    this.messages.set(id, msgs);
+            }
+            for (const [id, dmMsgs] of incoming.dms) {
+                if (!this.dms.has(id))
+                    this.dms.set(id, dmMsgs);
+            }
+        }
+        else if (msg.method === "state_update") {
+            this.applyPatch(msg.patch);
+        }
+    }
+    applyPatch(patch) {
+        switch (patch.type) {
+            case "agent_upsert":
+                this.agents.set(patch.agent.id, patch.agent);
+                break;
+            case "agent_offline": {
+                const agent = this.agents.get(patch.agentId);
+                if (agent) {
+                    agent.status = "offline";
+                    this.agents.set(patch.agentId, agent);
+                }
+                break;
+            }
+            case "room_upsert":
+                this.rooms.set(patch.room.id, patch.room);
+                break;
+            case "room_delete":
+                this.rooms.delete(patch.roomId);
+                break;
+            case "message_add": {
+                const arr = this.messages.get(patch.roomId) ?? [];
+                arr.push(patch.message);
+                this.messages.set(patch.roomId, arr);
+                break;
+            }
+            case "dm_add": {
+                const arr = this.dms.get(patch.key) ?? [];
+                arr.push(patch.message);
+                this.dms.set(patch.key, arr);
+                break;
+            }
+            case "delivery": {
+                const arr = this.deliveryQueues.get(patch.agentId) ?? [];
+                arr.push(patch.event);
+                this.deliveryQueues.set(patch.agentId, arr);
+                if (patch.agentId === this.peerId && this.onDelivery) {
+                    void this.onDelivery(patch.agentId, patch.event);
+                }
+                break;
+            }
+        }
+    }
+    async connectToPeerData(peer) {
+        if (peer.id === this.peerId)
+            return;
+        if (this.peerConnections.has(peer.id))
+            return;
+        return new Promise((resolve) => {
+            const socket = net.createConnection({ port: peer.port, host: COORDINATOR_HOST }, () => {
+                const buf = new MessageBuffer();
+                this.peerConnections.set(peer.id, { socket, buffer: buf });
+                // Identify ourselves
+                const pong = { method: "pong", peerId: this.peerId };
+                socket.write(encode(pong));
+                // If we have state and peer doesn't, send state sync
+                if (this.agents.size > 0) {
+                    const state = {
+                        agents: Object.fromEntries(this.agents),
+                        rooms: Object.fromEntries(this.rooms),
+                        messages: Object.fromEntries(this.messages),
+                        dms: Object.fromEntries(this.dms),
+                    };
+                    socket.write(encode({ method: "state_sync", state }));
+                }
+                // Wire up ongoing message handling
+                socket.on("data", (data) => {
+                    const items = buf.append(data.toString());
+                    for (const item of items) {
+                        if (isMeshMessage(item)) {
+                            this.handleDataMessage(item);
+                        }
+                    }
+                });
+                resolve();
+            });
+            socket.on("close", () => this.peerConnections.delete(peer.id));
+            socket.on("error", () => {
+                this.peerConnections.delete(peer.id);
+                resolve();
+            });
+        });
+    }
+    // -----------------------------------------------------------------------
+    // Broadcast (async — writes to TCP sockets)
+    // -----------------------------------------------------------------------
+    async broadcastToDataConnections(msg) {
+        const data = encode(msg);
+        const writes = [];
+        for (const [, peer] of this.peerConnections) {
+            writes.push(writeAsync(peer.socket, data).catch(() => {
+                /* broken connection — cleanup handled by close/error listeners */
+            }));
+        }
+        await Promise.all(writes);
+    }
+    async broadcastPatch(patch) {
+        await this.broadcastToDataConnections({ method: "state_update", patch });
+    }
+    async deliverLocallyAndBroadcast(agentId, event) {
+        // Local delivery
+        const arr = this.deliveryQueues.get(agentId) ?? [];
+        arr.push(event);
+        this.deliveryQueues.set(agentId, arr);
+        if (agentId === this.peerId && this.onDelivery) {
+            void this.onDelivery(agentId, event);
+        }
+        // Remote delivery
+        const patch = { type: "delivery", agentId, event };
+        await this.broadcastPatch(patch);
+    }
+    // -----------------------------------------------------------------------
+    // CommsStore — Identity
+    // -----------------------------------------------------------------------
+    async readIdentity(harness, cwd) {
+        await Promise.resolve();
+        return this.identityCache.get(`${harness}--${cwd}`);
+    }
+    async writeIdentity(harness, cwd, id) {
+        await Promise.resolve();
+        this.identityCache.set(`${harness}--${cwd}`, { id });
+    }
+    // -----------------------------------------------------------------------
+    // CommsStore — Agent registry
+    // -----------------------------------------------------------------------
+    async registerAgent(opts) {
+        const existing = await this.readIdentity(opts.harness, opts.cwd);
+        if (existing) {
+            return this.updateAgent(existing.id, {
+                name: opts.name,
+                visibility: opts.visibility,
+                tags: opts.tags,
+                status: "active",
+                pid: opts.pid,
+            });
+        }
+        const id = this.peerId;
+        const agent = {
+            id,
+            name: opts.name,
+            harness: opts.harness,
+            pid: opts.pid,
+            startedAt: this.startedAt,
+            visibility: opts.visibility,
+            status: "active",
+            tags: opts.tags,
+            subscribedRooms: [],
+        };
+        this.agents.set(id, agent);
+        await this.writeIdentity(opts.harness, opts.cwd, id);
+        await this.broadcastPatch({ type: "agent_upsert", agent });
+        return agent;
+    }
+    async getAgent(id) {
+        await Promise.resolve();
+        return this.agents.get(id);
+    }
+    async updateAgent(id, patch) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            throw new CommsError(`Agent ${id} not found`, "AGENT_NOT_FOUND");
+        Object.assign(agent, patch);
+        this.agents.set(id, agent);
+        await this.broadcastPatch({ type: "agent_upsert", agent });
+        return agent;
+    }
+    async listAgents(requesterId) {
+        await Promise.resolve();
+        const result = [];
+        for (const agent of this.agents.values()) {
+            if (agent.visibility === "ghost" && agent.id !== requesterId)
+                continue;
+            result.push(agent);
+        }
+        return result;
+    }
+    async setAgentOffline(id) {
+        const agent = this.agents.get(id);
+        if (agent) {
+            agent.status = "offline";
+            this.agents.set(id, agent);
+            await this.broadcastPatch({ type: "agent_offline", agentId: id });
+        }
+        if (this.isCoordinator) {
+            await this.handoverCoordinator();
+        }
+    }
+    // -----------------------------------------------------------------------
+    // CommsStore — Rooms
+    // -----------------------------------------------------------------------
+    async createRoom(opts) {
+        const id = opts.type === "secret" ? `_${opts.name}` : opts.name;
+        if (this.rooms.has(id))
+            throw new CommsError(`Room ${id} already exists`, "ROOM_EXISTS");
+        const room = {
+            id,
+            name: opts.name,
+            type: opts.type,
+            owner: opts.owner,
+            createdAt: new Date().toISOString(),
+            description: opts.description,
+            members: [opts.owner],
+            invited: [],
+        };
+        this.rooms.set(id, room);
+        this.messages.set(id, []);
+        await this.broadcastPatch({ type: "room_upsert", room });
+        return room;
+    }
+    async getRoom(id) {
+        await Promise.resolve();
+        return this.rooms.get(id);
+    }
+    async listRooms(requesterId) {
+        await Promise.resolve();
+        const result = [];
+        for (const room of this.rooms.values()) {
+            if (room.type === "secret" && !room.members.includes(requesterId))
+                continue;
+            result.push(room);
+        }
+        return result;
+    }
+    async joinRoom(roomId, agentId) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            throw new CommsError(`Room ${roomId} not found`, "ROOM_NOT_FOUND");
+        if (room.type === "public") {
+            if (!room.members.includes(agentId))
+                room.members.push(agentId);
+        }
+        else {
+            if (!room.invited.includes(agentId) &&
+                room.owner !== agentId &&
+                !room.members.includes(agentId)) {
+                throw new CommsError(`Not invited to room ${roomId}`, "NOT_INVITED");
+            }
+            room.invited = room.invited.filter((id) => id !== agentId);
+            if (!room.members.includes(agentId))
+                room.members.push(agentId);
+        }
+        this.rooms.set(roomId, room);
+        const agent = this.agents.get(agentId);
+        if (agent && !agent.subscribedRooms.includes(roomId)) {
+            agent.subscribedRooms.push(roomId);
+            this.agents.set(agentId, agent);
+            await this.broadcastPatch({ type: "agent_upsert", agent });
+        }
+        await this.broadcastPatch({ type: "room_upsert", room });
+        await this.deliverLocallyAndBroadcast(roomId, {
+            type: "member_joined",
+            room: roomId,
+            agent: agentId,
+        });
+        return room;
+    }
+    async leaveRoom(roomId, agentId) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            throw new CommsError(`Room ${roomId} not found`, "ROOM_NOT_FOUND");
+        room.members = room.members.filter((id) => id !== agentId);
+        this.rooms.set(roomId, room);
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.subscribedRooms = agent.subscribedRooms.filter((id) => id !== roomId);
+            this.agents.set(agentId, agent);
+            await this.broadcastPatch({ type: "agent_upsert", agent });
+        }
+        await this.broadcastPatch({ type: "room_upsert", room });
+        await this.deliverLocallyAndBroadcast(roomId, {
+            type: "member_left",
+            room: roomId,
+            agent: agentId,
+        });
+        if (room.members.length === 0 && room.owner === agentId) {
+            await this.destroyRoom(roomId, agentId);
+        }
+    }
+    async inviteToRoom(roomId, targetId, inviterId) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            throw new CommsError(`Room ${roomId} not found`, "ROOM_NOT_FOUND");
+        if (room.owner !== inviterId)
+            throw new CommsError("Only the room owner can invite", "NOT_OWNER");
+        if (!room.invited.includes(targetId) && !room.members.includes(targetId)) {
+            room.invited.push(targetId);
+        }
+        this.rooms.set(roomId, room);
+        await this.broadcastPatch({ type: "room_upsert", room });
+        await this.deliverLocallyAndBroadcast(targetId, {
+            type: "room_invite",
+            room: roomId,
+            from: inviterId,
+        });
+    }
+    async kickFromRoom(roomId, targetId, kickerId) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            throw new CommsError(`Room ${roomId} not found`, "ROOM_NOT_FOUND");
+        if (room.owner !== kickerId)
+            throw new CommsError("Only the room owner can kick", "NOT_OWNER");
+        room.members = room.members.filter((id) => id !== targetId);
+        room.invited = room.invited.filter((id) => id !== targetId);
+        this.rooms.set(roomId, room);
+        await this.broadcastPatch({ type: "room_upsert", room });
+    }
+    async destroyRoom(roomId, agentId) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            throw new CommsError(`Room ${roomId} not found`, "ROOM_NOT_FOUND");
+        if (room.owner !== agentId)
+            throw new CommsError("Only the room owner can destroy", "NOT_OWNER");
+        for (const memberId of room.members) {
+            const member = this.agents.get(memberId);
+            if (member) {
+                member.subscribedRooms = member.subscribedRooms.filter((id) => id !== roomId);
+                this.agents.set(memberId, member);
+                await this.broadcastPatch({ type: "agent_upsert", agent: member });
+            }
+        }
+        this.rooms.delete(roomId);
+        this.messages.delete(roomId);
+        await this.broadcastPatch({ type: "room_delete", roomId });
+    }
+    // -----------------------------------------------------------------------
+    // CommsStore — Messages
+    // -----------------------------------------------------------------------
+    async sendRoomMessage(roomId, from, content, replyTo) {
+        const room = this.rooms.get(roomId);
+        if (!room)
+            throw new CommsError(`Room ${roomId} not found`, "ROOM_NOT_FOUND");
+        if (!room.members.includes(from))
+            throw new CommsError(`Not a member of ${roomId}`, "NOT_MEMBER");
+        const id = `${String(Date.now())}-${nanoid(6)}`;
+        const message = {
+            id,
+            from,
+            room: roomId,
+            content,
+            timestamp: new Date().toISOString(),
+            replyTo,
+        };
+        const arr = this.messages.get(roomId) ?? [];
+        arr.push(message);
+        this.messages.set(roomId, arr);
+        await this.broadcastPatch({ type: "message_add", roomId, message });
+        for (const memberId of room.members) {
+            if (memberId !== from) {
+                await this.deliverLocallyAndBroadcast(memberId, {
+                    type: "room_message",
+                    message,
+                });
+            }
+        }
+        return message;
+    }
+    async readRoomMessages(roomId, since) {
+        await Promise.resolve();
+        const arr = this.messages.get(roomId) ?? [];
+        if (!since)
+            return [...arr];
+        return arr.filter((m) => m.timestamp > since);
+    }
+    // -----------------------------------------------------------------------
+    // CommsStore — DMs
+    // -----------------------------------------------------------------------
+    async sendDm(from, to, content) {
+        if (to !== from) {
+            const recipient = this.agents.get(to);
+            if (!recipient)
+                throw new CommsError(`Agent ${to} not found`, "AGENT_NOT_FOUND");
+            if (recipient.visibility === "ghost")
+                throw new CommsError(`Cannot DM agent ${to}`, "AGENT_NOT_FOUND");
+        }
+        const id = `${String(Date.now())}-${nanoid(6)}`;
+        const message = {
+            id,
+            from,
+            to,
+            content,
+            timestamp: new Date().toISOString(),
+        };
+        const key = dmKey(from, to);
+        const arr = this.dms.get(key) ?? [];
+        arr.push(message);
+        this.dms.set(key, arr);
+        await this.broadcastPatch({ type: "dm_add", key, message });
+        await this.deliverLocallyAndBroadcast(to, { type: "dm", message });
+        return message;
+    }
+    // -----------------------------------------------------------------------
+    // CommsStore — Delivery
+    // -----------------------------------------------------------------------
+    async deliver(agentId, event) {
+        await this.deliverLocallyAndBroadcast(agentId, event);
+    }
+    async drainDelivery(agentId) {
+        await Promise.resolve();
+        const events = this.deliveryQueues.get(agentId) ?? [];
+        this.deliveryQueues.set(agentId, []);
+        return events;
+    }
+    // -----------------------------------------------------------------------
+    // Stale agent cleanup (coordinator only)
+    // -----------------------------------------------------------------------
+    startStaleCheck() {
+        if (this.staleCheckTimer)
+            return;
+        this.staleCheckTimer = setInterval(() => {
+            void this.probeStaleAgents();
+        }, 5000);
+    }
+    stopStaleCheck() {
+        if (this.staleCheckTimer) {
+            clearInterval(this.staleCheckTimer);
+            this.staleCheckTimer = undefined;
+        }
+    }
+    async probeStaleAgents() {
+        const deadIds = [];
+        for (const [id, agent] of this.agents) {
+            if (agent.status !== "active")
+                continue;
+            if (!this.isProcessAlive(agent.pid)) {
+                deadIds.push(id);
+            }
+        }
+        for (const id of deadIds) {
+            const agent = this.agents.get(id);
+            if (agent) {
+                agent.status = "offline";
+                this.agents.set(id, agent);
+            }
+            await this.broadcastPatch({ type: "agent_offline", agentId: id });
+        }
+    }
+    isProcessAlive(pid) {
+        try {
+            // Sending signal 0 doesn't kill the process — it just checks existence
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Coordinator handover
+    // -----------------------------------------------------------------------
+    async handoverCoordinator() {
+        if (!this.isCoordinator)
+            return;
+        let successor;
+        for (const [id, info] of this.peerInfo) {
+            if (id === this.peerId)
+                continue;
+            if (!successor || info.startedAt < successor.startedAt) {
+                successor = info;
+            }
+        }
+        if (!successor)
+            return;
+        const peer = this.peerConnections.get(successor.id);
+        if (peer) {
+            const msg = {
+                method: "become_coordinator",
+                peerList: [...this.peerInfo.values()].filter((p) => p.id !== this.peerId),
+            };
+            await writeAsync(peer.socket, encode(msg));
+        }
+        this.stopStaleCheck();
+        this.coordinatorServer?.close();
+        this.coordinatorServer = undefined;
+        this.isCoordinator = false;
+    }
+    // -----------------------------------------------------------------------
+    // Shutdown
+    // -----------------------------------------------------------------------
+    async shutdown() {
+        const agent = this.agents.get(this.peerId);
+        if (agent) {
+            agent.status = "offline";
+            await this.broadcastPatch({
+                type: "agent_offline",
+                agentId: this.peerId,
+            });
+        }
+        await this.handoverCoordinator();
+        for (const [, peer] of this.peerConnections) {
+            peer.socket.destroy();
+        }
+        this.peerConnections.clear();
+        this.stopStaleCheck();
+        this.dataServer?.close();
+        this.dataServer = undefined;
+        this.coordinatorServer?.close();
+        this.coordinatorServer = undefined;
+    }
+}
+//# sourceMappingURL=mesh-store.js.map