@graphty/remote-logger 1.2.1 → 1.2.3

package/src/server/dual-server.ts

@@ -8,8 +8,9 @@
 
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import type * as http from "http";
-import type * as https from "https";
+import * as http from "http";
+import * as https from "https";
+import { internalIpV4Sync } from "internal-ip";
 import * as net from "net";
 import * as os from "os";
 import * as path from "path";
@@ -35,6 +36,90 @@ const MAX_PORT_SCAN_ATTEMPTS = 100;
 /** Maximum port number allowed (ports 9000-9099 per project guidelines) */
 const MAX_PORT_NUMBER = 9099;
 
+/** Maximum retries for binding after EADDRINUSE during listen */
+const MAX_BIND_RETRIES = 10;
+
+/**
+ * Attempt to bind an HTTP/HTTPS server to a port with retry on EADDRINUSE.
+ * This handles race conditions where a port becomes unavailable between
+ * port scanning and actual binding.
+ * @param serverFactory - Function to create a new server instance
+ * @param startPort - Starting port to try
+ * @param host - Host to bind to
+ * @param quiet - Suppress output messages
+ * @param maxPort - Maximum port number to scan up to (default: 9099)
+ * @returns Promise resolving to bound server and actual port
+ */
+async function tryBindWithRetry(
+    serverFactory: () => http.Server | https.Server,
+    startPort: number,
+    host: string,
+    quiet: boolean,
+    maxPort: number = MAX_PORT_NUMBER,
+): Promise<{ server: http.Server | https.Server; port: number }> {
+    let port = startPort;
+    let attempts = 0;
+
+    while (attempts < MAX_BIND_RETRIES) {
+        if (port > maxPort) {
+            break;
+        }
+
+        const server = serverFactory();
+
+        try {
+            await new Promise<void>((resolve, reject) => {
+                const errorHandler = (err: NodeJS.ErrnoException): void => {
+                    if (err.code === "EADDRINUSE") {
+                        if (!quiet) {
+                            // eslint-disable-next-line no-console
+                            console.log(
+                                `${colors.yellow}Port ${port} claimed during bind, trying ${port + 1}...${colors.reset}`,
+                            );
+                        }
+                        reject(err);
+                    } else {
+                        reject(err);
+                    }
+                };
+
+                server.once("error", errorHandler);
+                server.listen({ port, host, exclusive: false }, () => {
+                    server.removeListener("error", errorHandler);
+                    resolve();
+                });
+            });
+
+            // Success - server is bound
+            if (!quiet) {
+                // eslint-disable-next-line no-console
+                console.log(
+                    `${colors.green}HTTP server listening on ${host}:${port}${colors.reset}`,
+                );
+            }
+            return { server, port };
+        } catch (err) {
+            if ((err as NodeJS.ErrnoException).code === "EADDRINUSE") {
+                port++;
+                attempts++;
+                continue;
+            }
+            // Re-throw non-EADDRINUSE errors
+            throw err;
+        }
+    }
+
+    // Exhausted retries
+    const errorMsg = `Could not bind to any port after ${attempts} attempts. ` +
+        `Ports ${startPort}-${port - 1} are all in use or were claimed during bind.`;
+
+    if (!quiet) {
+        console.error(`${colors.red}${errorMsg}${colors.reset}`);
+    }
+
+    throw new Error(errorMsg);
+}
+
 /**
  * Check if a port is available for binding.
  * @param port - Port number to check
@@ -72,16 +157,22 @@ async function isPortAvailable(port: number, host: string): Promise<boolean> {
  * @param basePort - Starting port number
  * @param host - Host to bind to
  * @param quiet - Suppress output messages
+ * @param maxPort - Maximum port number to scan up to (default: 9099)
  * @returns Promise resolving to available port number
  * @throws Error if no available port found within MAX_PORT_SCAN_ATTEMPTS
  */
-export async function findAvailablePort(basePort: number, host: string, quiet: boolean = false): Promise<number> {
+export async function findAvailablePort(
+    basePort: number,
+    host: string,
+    quiet: boolean = false,
+    maxPort: number = MAX_PORT_NUMBER,
+): Promise<number> {
     let port = basePort;
     let attempts = 0;
 
     while (attempts < MAX_PORT_SCAN_ATTEMPTS) {
-        if (port > MAX_PORT_NUMBER) {
-            // Wrap around if we exceed max port (shouldn't happen normally)
+        if (port > maxPort) {
+            // Stop if we exceed max port
             break;
         }
 
@@ -107,12 +198,12 @@ export async function findAvailablePort(basePort: number, host: string, quiet: b
     }
 
     // No available port found
-    const errorMsg = `Could not find available port after ${MAX_PORT_SCAN_ATTEMPTS} attempts starting from ${basePort}. ` +
-        `Ports ${basePort}-${port - 1} are all in use. ` +
+    const errorMsg = `Could not find available port after ${attempts} attempts starting from ${basePort}. ` +
+        `Ports ${basePort}-${Math.min(port - 1, maxPort)} are all in use. ` +
         `Try killing existing processes: pkill -f "remote-log-server"`;
 
     if (!quiet) {
-         
+
         console.error(`${colors.red}${errorMsg}${colors.reset}`);
     }
 
@@ -125,7 +216,7 @@ export async function findAvailablePort(basePort: number, host: string, quiet: b
 export interface DualServerOptions {
     /** Port for HTTP server (default: 9080) */
     httpPort?: number;
-    /** Host for HTTP server (default: localhost) */
+    /** Host for HTTP server (default: 0.0.0.0) */
     httpHost?: string;
     /** Enable MCP server (default: true) */
     mcpEnabled?: boolean;
@@ -145,6 +236,8 @@ export interface DualServerOptions {
     jsonlWriter?: JsonlWriter;
     /** Only serve /log POST and /health GET endpoints (default: false) */
     logReceiveOnly?: boolean;
+    /** Maximum port number to scan up to (default: 9099) */
+    maxPortNumber?: number;
 }
 
 /**
@@ -176,7 +269,7 @@ export interface DualServerResult {
 export async function createDualServer(options: DualServerOptions = {}): Promise<DualServerResult> {
     const {
         httpPort: requestedPort = 9080,
-        httpHost = "localhost",
+        httpHost = "0.0.0.0",
         mcpEnabled = true,
         httpEnabled = true,
         quiet = false,
@@ -185,6 +278,7 @@ export async function createDualServer(options: DualServerOptions = {}): Promise
         logReceiveOnly = false,
         certPath,
         keyPath,
+        maxPortNumber = MAX_PORT_NUMBER,
     } = options;
 
     // Create or use provided JSONL writer
@@ -198,53 +292,50 @@ export async function createDualServer(options: DualServerOptions = {}): Promise
     let mcpServer: McpServer | undefined;
     let actualHttpPort: number | undefined;
 
+    // Track active connections for graceful shutdown
+    const activeConnections = new Set<net.Socket>();
+
     // Start HTTP server if enabled
     if (httpEnabled) {
         // Find an available port starting from the requested port
-        actualHttpPort = await findAvailablePort(requestedPort, httpHost, quiet);
-
-        const result = createLogServer({
-            port: actualHttpPort,
-            host: httpHost,
-            storage,
+        const startPort = await findAvailablePort(requestedPort, httpHost, quiet, maxPortNumber);
+
+        // Factory function to create server instances (for retry on bind failure)
+        const createServerInstance = (): http.Server | https.Server => {
+            return createLogServer({
+                port: startPort, // Port is set but not used until bind
+                host: httpHost,
+                storage,
+                quiet: true, // Quiet during factory, messages handled by tryBindWithRetry
+                logReceiveOnly,
+                certPath,
+                keyPath,
+            }).server;
+        };
+
+        // Bind with retry logic to handle race conditions
+        const bindResult = await tryBindWithRetry(
+            createServerInstance,
+            startPort,
+            httpHost,
             quiet,
-            logReceiveOnly,
-            certPath,
-            keyPath,
-        });
-        httpServer = result.server;
-
-        // Wait for HTTP server to be listening
-        const serverToStart = httpServer;
-        const portToUse = actualHttpPort;
-        await new Promise<void>((resolve, reject) => {
-            serverToStart.on("error", (err: NodeJS.ErrnoException) => {
-                // Provide helpful error message for port conflicts
-                if (err.code === "EADDRINUSE") {
-                    const errorMsg = `Port ${portToUse} is already in use. ` +
-                        `This shouldn't happen after port scanning - there may be a race condition. ` +
-                        `Try again or kill existing processes: pkill -f "remote-log-server"`;
-                    if (!quiet) {
-                         
-                        console.error(`${colors.red}${errorMsg}${colors.reset}`);
-                    }
-                    reject(new Error(errorMsg));
-                } else {
-                    reject(err);
-                }
-            });
-            serverToStart.listen({ port: portToUse, host: httpHost, exclusive: false }, () => {
-                serverToStart.removeListener("error", reject);
-                if (!quiet) {
-                    // eslint-disable-next-line no-console
-                    console.log(
-                        `${colors.green}HTTP server listening on ${httpHost}:${portToUse}${colors.reset}`,
-                    );
-                }
-                resolve();
+            maxPortNumber,
+        );
+        httpServer = bindResult.server;
+        actualHttpPort = bindResult.port;
+
+        // Track connections for graceful shutdown
+        httpServer.on("connection", (socket: net.Socket) => {
+            activeConnections.add(socket);
+            socket.once("close", () => {
+                activeConnections.delete(socket);
             });
         });
 
+        // Set short keep-alive timeout for tests (connections close faster)
+        httpServer.keepAliveTimeout = 1000;
+        httpServer.headersTimeout = 2000;
+
         // Set server config in storage so MCP tools can report it
         // Determine protocol based on whether valid cert files were provided
         const useHttps = certPath && keyPath && certFilesExist(certPath, keyPath);
@@ -258,11 +349,28 @@ export async function createDualServer(options: DualServerOptions = {}): Promise
         } else {
             mode = "dual";
         }
+        // When bound to all interfaces (0.0.0.0), detect the machine's IP address
+        // for the endpoint URL since 0.0.0.0 is not a routable address for clients
+        let endpointHost = httpHost;
+        if (httpHost === "0.0.0.0") {
+            const internalIp = internalIpV4Sync();
+            if (internalIp) {
+                endpointHost = internalIp;
+            } else {
+                // Fallback for local-only use - don't use hostname as it may not resolve
+                endpointHost = "127.0.0.1";
+                if (!quiet) {
+                    console.warn(
+                        `${colors.yellow}Could not detect LAN IP. Endpoint URL will only work locally.${colors.reset}`,
+                    );
+                }
+            }
+        }
         storage.setServerConfig({
             httpPort: actualHttpPort,
             httpHost,
             protocol,
-            httpEndpoint: `${protocol}://${httpHost}:${actualHttpPort}/log`,
+            httpEndpoint: `${protocol}://${endpointHost}:${actualHttpPort}/log`,
             mode,
         });
     }
@@ -281,6 +389,12 @@ export async function createDualServer(options: DualServerOptions = {}): Promise
     const shutdown = async (): Promise<void> => {
         // Close HTTP server
         if (httpServer?.listening) {
+            // Destroy all active connections to ensure clean shutdown
+            for (const socket of activeConnections) {
+                socket.destroy();
+            }
+            activeConnections.clear();
+
             await new Promise<void>((resolve) => {
                 httpServer.close(() => { resolve(); });
             });

package/src/server/log-server.ts

@@ -81,7 +81,7 @@ const colors = {
 export interface LogServerOptions {
     /** Port to listen on (default: 9080) */
     port?: number;
-    /** Hostname to bind to (default: localhost) */
+    /** Hostname to bind to (default: 0.0.0.0) */
     host?: string;
     /** Path to SSL certificate file (HTTPS only used if both certPath and keyPath provided) */
     certPath?: string;
@@ -477,7 +477,7 @@ export function createLogServer(options: CreateLogServerOptions): CreateLogServe
  */
 export function startLogServer(options: LogServerOptions = {}): http.Server | https.Server {
     const port = options.port ?? 9080;
-    const host = options.host ?? "localhost";
+    const host = options.host ?? "0.0.0.0";
     const quiet = options.quiet ?? false;
 
     // Set up log file if specified
@@ -555,7 +555,7 @@ Usage:
 
 Options:
   --port, -p <port>       Port to listen on (default: 9080)
-  --host, -h <host>       Hostname to bind to (default: localhost)
+  --host, -h <host>       Hostname to bind to (default: 0.0.0.0)
   --cert, -c <path>       Path to SSL certificate file (enables HTTPS)
   --key, -k <path>        Path to SSL private key file (enables HTTPS)
   --log-file, -l <path>   Write logs to file
@@ -677,87 +677,62 @@ export async function main(): Promise<void> {
 
     const { options } = result;
 
+    // Common server options shared across all modes
+    const baseOptions = {
+        httpPort: options.port ?? 9080,
+        httpHost: options.host ?? "0.0.0.0",
+        quiet: options.quiet ?? false,
+        certPath: options.certPath,
+        keyPath: options.keyPath,
+    };
+
     // Determine mode: mcp-only, http-only, or dual (default)
     // All modes now use createDualServer with different options
     const { createDualServer } = await import("./dual-server.js");
 
+    let dualServer;
+    let modeMessage: string;
+
     if (options.mcpOnly) {
         // MCP-only mode: HTTP only serves /log endpoint, MCP enabled
-        const dualServer = await createDualServer({
-            httpPort: options.port ?? 9080,
-            httpHost: options.host ?? "localhost",
+        dualServer = await createDualServer({
+            ...baseOptions,
             httpEnabled: true,
             mcpEnabled: true,
-            quiet: options.quiet ?? false,
             logReceiveOnly: true, // Only serve /log and /health endpoints
-            certPath: options.certPath,
-            keyPath: options.keyPath,
-        });
-
-        // Handle graceful shutdown
-        process.on("SIGINT", () => {
-            // eslint-disable-next-line no-console
-            console.log("\nShutting down...");
-            void dualServer.shutdown().then(() => {
-                process.exit(0);
-            });
         });
-
-        if (!options.quiet) {
-            // eslint-disable-next-line no-console
-            console.log("MCP mode: Log receive endpoint and MCP tools running");
-        }
+        modeMessage = "MCP mode: Log receive endpoint and MCP tools running";
     } else if (options.httpOnly) {
         // HTTP-only mode: All HTTP endpoints, no MCP
-        const dualServer = await createDualServer({
-            httpPort: options.port ?? 9080,
-            httpHost: options.host ?? "localhost",
+        dualServer = await createDualServer({
+            ...baseOptions,
             httpEnabled: true,
             mcpEnabled: false,
-            quiet: options.quiet ?? false,
-            certPath: options.certPath,
-            keyPath: options.keyPath,
             logFile: options.logFile,
         });
-
-        // Handle graceful shutdown
-        process.on("SIGINT", () => {
-            // eslint-disable-next-line no-console
-            console.log("\nShutting down...");
-            void dualServer.shutdown().then(() => {
-                process.exit(0);
-            });
-        });
-
-        if (!options.quiet) {
-            // eslint-disable-next-line no-console
-            console.log("HTTP-only mode: All HTTP endpoints running");
-        }
+        modeMessage = "HTTP-only mode: All HTTP endpoints running";
     } else {
         // Dual mode (default): All HTTP endpoints and MCP
-        const dualServer = await createDualServer({
-            httpPort: options.port ?? 9080,
-            httpHost: options.host ?? "localhost",
+        dualServer = await createDualServer({
+            ...baseOptions,
             httpEnabled: true,
             mcpEnabled: true,
-            quiet: options.quiet ?? false,
-            certPath: options.certPath,
-            keyPath: options.keyPath,
             logFile: options.logFile,
         });
+        modeMessage = "Dual mode: HTTP and MCP servers running";
+    }
 
-        // Handle graceful shutdown
-        process.on("SIGINT", () => {
-            // eslint-disable-next-line no-console
-            console.log("\nShutting down...");
-            void dualServer.shutdown().then(() => {
-                process.exit(0);
-            });
+    // Single SIGINT handler for all modes
+    process.on("SIGINT", () => {
+        // eslint-disable-next-line no-console
+        console.log("\nShutting down...");
+        void dualServer.shutdown().then(() => {
+            process.exit(0);
         });
+    });
 
-        if (!options.quiet) {
-            // eslint-disable-next-line no-console
-            console.log("Dual mode: HTTP and MCP servers running");
-        }
+    if (!options.quiet) {
+        // eslint-disable-next-line no-console
+        console.log(modeMessage);
     }
 }

package/src/server/self-signed-cert.ts

@@ -14,8 +14,17 @@ export interface GeneratedCert {
 /**
  * Generate a self-signed certificate for HTTPS.
  * The certificate is valid for localhost and common local development hostnames.
+ *
+ * NOTE: This function is currently unused because modern browsers reject
+ * self-signed certificates by default. It is retained for potential use cases:
+ * - Node.js clients that can disable certificate verification
+ * - Testing environments
+ * - Development setups where users manually trust the certificate
+ *
+ * For browser use, provide valid certificates via --cert and --key flags.
  * @param hostname - Optional hostname to include in the certificate (default: localhost)
  * @returns Object containing PEM-encoded certificate and private key
+ * @internal
  */
 export function generateSelfSignedCert(hostname = "localhost"): GeneratedCert {
     const attrs = [

package/src/ui/ConsoleCaptureUI.ts

@@ -313,6 +313,8 @@ export class ConsoleCaptureUI {
      */
     private setupGlobalMethods(): void {
         if (typeof window !== "undefined") {
+            // Create a function that returns current logs to avoid stale reference
+            const getCurrentLogs = (): CapturedLogEntry[] => [...this.logs];
             window.__console__ = {
                 copy: () => this.copyLogs(),
                 download: () => {
@@ -322,7 +324,10 @@ export class ConsoleCaptureUI {
                     this.clearLogs();
                 },
                 get: () => this.getLogs(),
-                logs: this.logs,
+                // Use getter to always return fresh copy of current logs
+                get logs() {
+                    return getCurrentLogs();
+                },
             };
         }
     }