@archlast/server 0.0.1

package/dist/ipc/socket-bridge.js

@@ -0,0 +1,724 @@
+"use strict";
+/**
+ * Generic IPC Transport Layer
+ *
+ * Provides high-performance Unix Socket transport with Request/Response + Pub/Sub patterns.
+ * Protocol-agnostic - can be used for any IPC communication needs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpcClient = exports.IpcServer = void 0;
+const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const logger_js_1 = require("../logging/logger.js");
+/**
+ * IPC Server - Listens on Unix socket and handles messages
+ */
+class IpcServer {
+    socketPath;
+    server;
+    handlers = new Map();
+    subscribers = new Map(); // channel -> Set<socket>
+    clients = new Set();
+    messageBuffers = new Map();
+    constructor(socketPath) {
+        this.socketPath = socketPath;
+    }
+    /**
+     * Register a handler for a specific message type
+     */
+    handle(type, handler) {
+        this.handlers.set(type, handler);
+    }
+    /**
+     * Publish event to all subscribers of a channel
+     */
+    publish(channel, payload) {
+        const subscribers = this.subscribers.get(channel);
+        if (!subscribers || subscribers.size === 0) {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "debug",
+                kind: "system",
+                message: `IPC: No subscribers for channel ${channel}`,
+                context: { channel },
+            });
+            return;
+        }
+        const message = {
+            id: (0, crypto_1.randomUUID)(),
+            type: "EVENT",
+            channel,
+            payload,
+        };
+        const data = this.serializeMessage(message);
+        let sentCount = 0;
+        for (const socket of subscribers) {
+            try {
+                socket.write(data);
+                sentCount++;
+            }
+            catch (err) {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "error",
+                    kind: "system",
+                    message: "IPC: Failed to publish to subscriber",
+                    context: { channel, error: err instanceof Error ? err.message : String(err) },
+                });
+            }
+        }
+    }
+    /**
+     * Start listening on Unix socket
+     */
+    async listen() {
+        // If already listening, do nothing
+        if (this.server) {
+            return;
+        }
+        // Clean up existing socket
+        if ((0, fs_1.existsSync)(this.socketPath)) {
+            try {
+                await (0, promises_1.unlink)(this.socketPath);
+            }
+            catch {
+                // Ignore unlink errors (e.g., Windows named pipes)
+            }
+        }
+        this.server = Bun.listen({
+            unix: this.socketPath,
+            socket: {
+                data: (socket, data) => {
+                    this.handleData(socket, data);
+                },
+                open: (socket) => {
+                    this.clients.add(socket);
+                },
+                close: (socket) => {
+                    this.clients.delete(socket);
+                    this.messageBuffers.delete(socket);
+                    // Remove from all subscriptions
+                    for (const subscribers of this.subscribers.values()) {
+                        subscribers.delete(socket);
+                    }
+                },
+                error: (socket, error) => {
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "error",
+                        kind: "system",
+                        message: "IPC socket error",
+                        context: { error: error instanceof Error ? error.message : String(error) },
+                    });
+                },
+            },
+        });
+        logger_js_1.logger.log({
+            timestamp: Date.now(),
+            level: "info",
+            kind: "system",
+            message: `IPC server listening`,
+            context: { socketPath: this.socketPath },
+        });
+        // On Windows, Bun's Unix sockets use named pipes which don't create filesystem entries
+        // Create a marker file so other processes can detect the socket is ready
+        if (process.platform === "win32") {
+            const { writeFileSync, mkdirSync } = await import("fs");
+            const { dirname } = await import("path");
+            try {
+                const markerPath = this.socketPath + ".ready";
+                // Ensure directory exists
+                const dir = dirname(markerPath);
+                try {
+                    mkdirSync(dir, { recursive: true });
+                }
+                catch {
+                    // Ignore if directory already exists or can't be created
+                }
+                writeFileSync(markerPath, "ready");
+            }
+            catch (err) {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "error",
+                    kind: "system",
+                    message: "IPC: Failed to create marker file",
+                    context: { error: err instanceof Error ? err.message : String(err) },
+                });
+            }
+        }
+    }
+    /**
+     * Get subscriber count for a channel (for debugging)
+     */
+    getSubscriberCount(channel) {
+        const subscribers = this.subscribers.get(channel);
+        return subscribers?.size ?? 0;
+    }
+    /**
+     * Stop the server
+     */
+    async stop() {
+        if (this.server) {
+            this.server.stop();
+            this.server = null;
+        }
+        // Clean up socket file (not applicable on Windows for named pipes)
+        if ((0, fs_1.existsSync)(this.socketPath) && process.platform !== "win32") {
+            try {
+                await (0, promises_1.unlink)(this.socketPath);
+            }
+            catch {
+                // Ignore unlink errors
+            }
+        }
+        // Clean up marker file on Windows
+        if (process.platform === "win32") {
+            const { unlinkSync } = await import("fs");
+            try {
+                unlinkSync(this.socketPath + ".ready");
+            }
+            catch {
+                // Ignore unlink errors
+            }
+        }
+        this.clients.clear();
+        this.subscribers.clear();
+        this.handlers.clear();
+        this.messageBuffers.clear();
+    }
+    handleData(socket, data) {
+        // Get or create buffer for this socket
+        let buffer = this.messageBuffers.get(socket) || Buffer.alloc(0);
+        buffer = Buffer.concat([buffer, data]);
+        this.messageBuffers.set(socket, buffer);
+        // Process complete messages
+        while (buffer.length >= 4) {
+            const length = buffer.readUInt32BE(0);
+            const totalLength = 4 + length;
+            // Wait for complete message
+            if (buffer.length < totalLength) {
+                break;
+            }
+            // Extract message
+            const messageData = buffer.subarray(0, totalLength);
+            buffer = buffer.subarray(totalLength);
+            this.messageBuffers.set(socket, buffer);
+            try {
+                const message = this.deserializeMessage(messageData);
+                this.handleMessage(socket, message);
+            }
+            catch (err) {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "error",
+                    kind: "system",
+                    message: "[IpcServer] Failed to parse message:",
+                    context: { err },
+                });
+            }
+        }
+    }
+    async handleMessage(socket, message) {
+        // Handle subscription
+        if (message.type === "SUBSCRIBE") {
+            const channel = message.channel || message.payload?.channel;
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "info",
+                kind: "system",
+                message: "[IpcServer] SUBSCRIBE request",
+                context: { data: [{ channel, hasSocket: !!socket }] },
+            });
+            if (channel) {
+                if (!this.subscribers.has(channel)) {
+                    this.subscribers.set(channel, new Set());
+                }
+                this.subscribers.get(channel).add(socket);
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "info",
+                    kind: "system",
+                    message: "[IpcServer] ✅ Client subscribed to channel:",
+                    context: {
+                        data: [channel, "Total subscribers:", this.subscribers.get(channel).size],
+                    },
+                });
+                // Send acknowledgment
+                this.sendResponse(socket, message.id, { subscribed: true });
+            }
+            return;
+        }
+        // Handle unsubscribe
+        if (message.type === "UNSUBSCRIBE") {
+            const channel = message.channel || message.payload?.channel;
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "info",
+                kind: "system",
+                message: "[IpcServer] UNSUBSCRIBE request",
+                context: { channel },
+            });
+            if (channel) {
+                const subscribers = this.subscribers.get(channel);
+                if (subscribers) {
+                    subscribers.delete(socket);
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "info",
+                        kind: "system",
+                        message: "[IpcServer] ✅ Client unsubscribed from channel:",
+                        context: { data: [channel, "Remaining:", subscribers.size] },
+                    });
+                }
+                this.sendResponse(socket, message.id, { unsubscribed: true });
+            }
+            return;
+        }
+        // Handle request/response
+        const handler = this.handlers.get(message.type);
+        if (!handler) {
+            this.sendError(socket, message.id, `No handler for type: ${message.type}`);
+            return;
+        }
+        try {
+            const result = await handler(message.payload);
+            this.sendResponse(socket, message.id, result);
+        }
+        catch (err) {
+            this.sendError(socket, message.id, err instanceof Error ? err.message : "Unknown error");
+        }
+    }
+    sendResponse(socket, id, payload) {
+        const message = {
+            id,
+            type: "RESPONSE",
+            payload,
+        };
+        const data = this.serializeMessage(message);
+        try {
+            socket.write(data);
+        }
+        catch (err) {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "error",
+                kind: "system",
+                message: "[IpcServer] Failed to send response:",
+                context: { err },
+            });
+        }
+    }
+    sendError(socket, id, error) {
+        const message = {
+            id,
+            type: "ERROR",
+            payload: { error },
+        };
+        const data = this.serializeMessage(message);
+        try {
+            socket.write(data);
+        }
+        catch (err) {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "error",
+                kind: "system",
+                message: "[IpcServer] Failed to send error:",
+                context: { err },
+            });
+        }
+    }
+    serializeMessage(msg) {
+        const json = JSON.stringify(msg);
+        const length = Buffer.byteLength(json);
+        const buffer = Buffer.allocUnsafe(4 + length);
+        buffer.writeUInt32BE(length, 0);
+        buffer.write(json, 4);
+        return buffer;
+    }
+    deserializeMessage(data) {
+        const length = data.readUInt32BE(0);
+        const json = data.toString("utf8", 4, 4 + length);
+        return JSON.parse(json);
+    }
+}
+exports.IpcServer = IpcServer;
+/**
+ * IPC Client - Connects to Unix socket and sends messages
+ */
+class IpcClient {
+    socketPath;
+    socket = null;
+    connected = false;
+    connecting = false;
+    messageBuffer = Buffer.alloc(0);
+    pendingRequests = new Map();
+    eventHandlers = new Map();
+    requestTimeout;
+    reconnectTimer = null;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = Infinity;
+    reconnectBackoffMs = [100, 200, 500, 1000, 2000, 5000];
+    pendingSends = [];
+    maxPendingSends = 100;
+    constructor(socketPath, requestTimeout = 5000) {
+        this.socketPath = socketPath;
+        this.requestTimeout = requestTimeout;
+    }
+    /**
+     * Connect to the IPC server
+     */
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        if (this.connecting) {
+            while (this.connecting) {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+            return;
+        }
+        this.connecting = true;
+        try {
+            this.socket = await Bun.connect({
+                unix: this.socketPath,
+                socket: {
+                    data: (socket, data) => {
+                        this.handleData(data);
+                    },
+                    open: () => {
+                        this.connected = true;
+                        this.connecting = false;
+                        this.reconnectAttempts = 0;
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "info",
+                            kind: "system",
+                            message: "[IpcClient] Connected to server",
+                        });
+                    },
+                    close: () => {
+                        this.connected = false;
+                        this.connecting = false;
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "warn",
+                            kind: "system",
+                            message: "[IpcClient] Disconnected from server",
+                        });
+                        for (const [id, pending] of this.pendingRequests) {
+                            clearTimeout(pending.timeout);
+                            pending.reject(new Error("Connection closed"));
+                        }
+                        this.pendingRequests.clear();
+                        this.startReconnectionLoop();
+                    },
+                    error: (socket, error) => {
+                        this.connecting = false;
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "error",
+                            kind: "system",
+                            message: "[IpcClient] Socket error:",
+                            context: { error },
+                        });
+                    },
+                },
+            });
+        }
+        catch (err) {
+            this.connecting = false;
+            throw err;
+        }
+    }
+    startReconnectionLoop() {
+        if (this.reconnectTimer) {
+            return;
+        }
+        const attemptReconnect = async () => {
+            if (this.connected) {
+                this.reconnectTimer = null;
+                return;
+            }
+            this.reconnectAttempts++;
+            const backoffIndex = Math.min(this.reconnectAttempts - 1, this.reconnectBackoffMs.length - 1);
+            const delay = this.reconnectBackoffMs[backoffIndex];
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "info",
+                kind: "system",
+                message: `[IpcClient] Starting reconnect (attempt ${this.reconnectAttempts})`,
+            });
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            try {
+                await this.connect();
+                if (this.connected) {
+                    this.reconnectTimer = null;
+                    logger_js_1.logger.log({
+                        timestamp: Date.now(),
+                        level: "info",
+                        kind: "system",
+                        message: "[IpcClient] Reconnected successfully",
+                    });
+                    await this.restoreSubscriptions();
+                    this.flushPendingSends();
+                }
+                else {
+                    this.reconnectTimer = setTimeout(attemptReconnect, 0);
+                }
+            }
+            catch {
+                this.reconnectTimer = setTimeout(attemptReconnect, 0);
+            }
+        };
+        this.reconnectTimer = setTimeout(attemptReconnect, 0);
+    }
+    async restoreSubscriptions() {
+        const channels = Array.from(this.eventHandlers.keys());
+        if (channels.length === 0) {
+            return;
+        }
+        logger_js_1.logger.log({
+            timestamp: Date.now(),
+            level: "info",
+            kind: "system",
+            message: `[IpcClient] Restoring ${channels.length} subscriptions`,
+        });
+        for (const channel of channels) {
+            try {
+                await this.request("SUBSCRIBE", { channel });
+            }
+            catch (err) {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "error",
+                    kind: "system",
+                    message: `[IpcClient] Failed to restore subscription to ${channel}`,
+                    context: { err },
+                });
+            }
+        }
+    }
+    flushPendingSends() {
+        if (this.pendingSends.length === 0) {
+            return;
+        }
+        const count = this.pendingSends.length;
+        logger_js_1.logger.log({
+            timestamp: Date.now(),
+            level: "info",
+            kind: "system",
+            message: `[IpcClient] Flushed ${count} pending sends`,
+        });
+        for (const { type, payload } of this.pendingSends) {
+            try {
+                this.sendImmediate(type, payload);
+            }
+            catch {
+                // Drop if still failing
+            }
+        }
+        this.pendingSends = [];
+    }
+    sendImmediate(type, payload) {
+        if (!this.connected || !this.socket) {
+            throw new Error("Not connected");
+        }
+        const message = {
+            id: (0, crypto_1.randomUUID)(),
+            type,
+            payload,
+        };
+        const data = this.serializeMessage(message);
+        this.socket.write(data);
+    }
+    async ensureConnected() {
+        if (this.connected) {
+            return;
+        }
+        if (!this.connecting) {
+            await this.connect();
+        }
+        else {
+            while (this.connecting) {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+        }
+    }
+    /**
+     * Send request and wait for response
+     */
+    async request(type, payload) {
+        await this.ensureConnected();
+        const id = (0, crypto_1.randomUUID)();
+        const message = {
+            id,
+            type,
+            payload,
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timeout: ${type}`));
+            }, this.requestTimeout);
+            this.pendingRequests.set(id, { resolve, reject, timeout });
+            const data = this.serializeMessage(message);
+            this.socket.write(data);
+        });
+    }
+    /**
+     * Send message without waiting for response (fire and forget)
+     */
+    send(type, payload) {
+        if (this.connected && this.socket) {
+            this.sendImmediate(type, payload);
+            return;
+        }
+        if (this.pendingSends.length >= this.maxPendingSends) {
+            logger_js_1.logger.log({
+                timestamp: Date.now(),
+                level: "warn",
+                kind: "system",
+                message: "[IpcClient] Pending sends queue full, dropping message",
+                context: { type, maxSize: this.maxPendingSends },
+            });
+            return;
+        }
+        this.pendingSends.push({ type, payload });
+    }
+    /**
+     * Subscribe to events on a channel
+     */
+    async subscribe(channel, handler) {
+        if (!this.eventHandlers.has(channel)) {
+            this.eventHandlers.set(channel, new Set());
+            // Send subscription message
+            await this.request("SUBSCRIBE", { channel });
+        }
+        this.eventHandlers.get(channel).add(handler);
+    }
+    /**
+     * Unsubscribe from events on a channel
+     */
+    async unsubscribe(channel, handler) {
+        const handlers = this.eventHandlers.get(channel);
+        if (!handlers) {
+            return;
+        }
+        if (handler) {
+            handlers.delete(handler);
+            if (handlers.size > 0) {
+                return; // Still have other handlers
+            }
+        }
+        // Remove all handlers and unsubscribe
+        this.eventHandlers.delete(channel);
+        await this.request("UNSUBSCRIBE", { channel });
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Disconnect from server
+     */
+    disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.socket) {
+            this.socket.end();
+            this.socket = null;
+        }
+        this.connected = false;
+        this.connecting = false;
+        this.pendingRequests.clear();
+        this.pendingSends = [];
+        this.eventHandlers.clear();
+    }
+    handleData(data) {
+        // Append new data to buffer
+        this.messageBuffer = Buffer.concat([this.messageBuffer, data]);
+        // Process complete messages
+        while (this.messageBuffer.length >= 4) {
+            const length = this.messageBuffer.readUInt32BE(0);
+            const totalLength = 4 + length;
+            // Wait for complete message
+            if (this.messageBuffer.length < totalLength) {
+                break;
+            }
+            // Extract message
+            const messageData = this.messageBuffer.subarray(0, totalLength);
+            this.messageBuffer = this.messageBuffer.subarray(totalLength);
+            try {
+                const message = this.deserializeMessage(messageData);
+                this.handleMessage(message);
+            }
+            catch (err) {
+                logger_js_1.logger.log({
+                    timestamp: Date.now(),
+                    level: "error",
+                    kind: "system",
+                    message: "[IpcClient] Failed to parse message:",
+                    context: { err },
+                });
+            }
+        }
+    }
+    handleMessage(message) {
+        // Handle events
+        if (message.type === "EVENT" && message.channel) {
+            const handlers = this.eventHandlers.get(message.channel);
+            if (handlers) {
+                for (const handler of handlers) {
+                    try {
+                        handler(message.payload);
+                    }
+                    catch (err) {
+                        logger_js_1.logger.log({
+                            timestamp: Date.now(),
+                            level: "error",
+                            kind: "system",
+                            message: `[IpcClient] Event handler error:`,
+                            context: { err },
+                        });
+                    }
+                }
+            }
+            return;
+        }
+        // Handle responses and errors
+        const pending = this.pendingRequests.get(message.id);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(message.id);
+        if (message.type === "ERROR") {
+            pending.reject(new Error(message.payload?.error || "Unknown error"));
+        }
+        else {
+            pending.resolve(message.payload);
+        }
+    }
+    serializeMessage(msg) {
+        const json = JSON.stringify(msg);
+        const length = Buffer.byteLength(json);
+        const buffer = Buffer.allocUnsafe(4 + length);
+        buffer.writeUInt32BE(length, 0);
+        buffer.write(json, 4);
+        return buffer;
+    }
+    deserializeMessage(data) {
+        const length = data.readUInt32BE(0);
+        const json = data.toString("utf8", 4, 4 + length);
+        return JSON.parse(json);
+    }
+}
+exports.IpcClient = IpcClient;
+//# sourceMappingURL=socket-bridge.js.map