@graphty/remote-logger 1.2.2 → 1.3.0

package/src/server/dual-server.ts

@@ -8,16 +8,18 @@
 
 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";
 
 import { createMcpServer } from "../mcp/mcp-server.js";
 import { JsonlWriter } from "./jsonl-writer.js";
-import { createLogServer } from "./log-server.js";
+import { createLogServer, setProxy } from "./log-server.js";
 import { LogStorage, type ServerMode } from "./log-storage.js";
+import { createProxy, type ProxyInstance } from "./proxy.js";
 import { certFilesExist } from "./self-signed-cert.js";
 
 // ANSI color codes for terminal output
@@ -35,6 +37,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 +158,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 +199,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 +217,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 +237,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 +270,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 +279,7 @@ export async function createDualServer(options: DualServerOptions = {}): Promise
         logReceiveOnly = false,
         certPath,
         keyPath,
+        maxPortNumber = MAX_PORT_NUMBER,
     } = options;
 
     // Create or use provided JSONL writer
@@ -197,6 +292,7 @@ export async function createDualServer(options: DualServerOptions = {}): Promise
     let httpServer: http.Server | https.Server | undefined;
     let mcpServer: McpServer | undefined;
     let actualHttpPort: number | undefined;
+    let proxyInstance: ProxyInstance | undefined;
 
     // Track active connections for graceful shutdown
     const activeConnections = new Set<net.Socket>();
@@ -204,18 +300,31 @@ export async function createDualServer(options: DualServerOptions = {}): Promise
     // 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;
+            maxPortNumber,
+        );
+        httpServer = bindResult.server;
+        actualHttpPort = bindResult.port;
 
         // Track connections for graceful shutdown
         httpServer.on("connection", (socket: net.Socket) => {
@@ -225,40 +334,8 @@ export async function createDualServer(options: DualServerOptions = {}): Promise
             });
         });
 
-        // Set short keep-alive timeout for tests (connections close faster)
-        httpServer.keepAliveTimeout = 1000;
-        httpServer.headersTimeout = 2000;
-
-        // 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();
-            });
-        });
+        httpServer.keepAliveTimeout = 30000;
+        httpServer.headersTimeout = 35000;
 
         // Set server config in storage so MCP tools can report it
         // Determine protocol based on whether valid cert files were provided
@@ -273,13 +350,39 @@ 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}`,
+                    );
+                }
+            }
+        }
+        const scriptUrl = `${protocol}://${endpointHost}:${actualHttpPort}/remote-logger.js`;
+        const proxyBaseUrl = `/proxy/`;
+
         storage.setServerConfig({
             httpPort: actualHttpPort,
             httpHost,
             protocol,
-            httpEndpoint: `${protocol}://${httpHost}:${actualHttpPort}/log`,
+            httpEndpoint: `${protocol}://${endpointHost}:${actualHttpPort}/log`,
+            scriptUrl,
+            proxyBaseUrl: `${protocol}://${endpointHost}:${actualHttpPort}${proxyBaseUrl}`,
             mode,
         });
+
+        // Create and register the proxy instance
+        proxyInstance = createProxy(proxyBaseUrl, quiet);
+        setProxy(proxyInstance);
     }
 
     // Create and connect MCP server if enabled
@@ -307,6 +410,11 @@ export async function createDualServer(options: DualServerOptions = {}): Promise
             });
         }
 
+        // Close proxy
+        if (proxyInstance) {
+            proxyInstance.close();
+        }
+
         // Close JSONL writer only if we created it internally
         if (ownsJsonlWriter) {
             await jsonlWriter.close();

package/src/server/log-server.ts

@@ -18,10 +18,11 @@ import * as http from "http";
 import * as https from "https";
 import * as os from "os";
 import * as path from "path";
-import { URL } from "url";
+import { fileURLToPath,URL } from "url";
 
 import { JsonlWriter } from "./jsonl-writer.js";
 import { type LogEntry, LogStorage } from "./log-storage.js";
+import type { ProxyInstance } from "./proxy.js";
 import { certFilesExist, readCertFiles } from "./self-signed-cert.js";
 
 // Shared log storage instance
@@ -62,6 +63,55 @@ export function setLogStorage(storage: LogStorage): void {
     sharedStorage = storage;
 }
 
+// Shared proxy instance
+let sharedProxy: ProxyInstance | null = null;
+
+/**
+ * Set the shared proxy instance.
+ * @param proxy - The proxy instance to use
+ */
+export function setProxy(proxy: ProxyInstance): void {
+    sharedProxy = proxy;
+}
+
+
+// Browser bundle cache (loaded on first request)
+let browserBundleCache: string | null | undefined;
+
+function loadBrowserBundle(): string | null {
+    if (browserBundleCache !== undefined) {
+        return browserBundleCache;
+    }
+
+    const thisDir = path.dirname(fileURLToPath(import.meta.url));
+
+    // Try multiple locations: dist/ (when running from built output)
+    // and the package root dist/ (when running from source during tests)
+    const candidates = [
+        path.resolve(thisDir, "..", "remote-logger.browser.js"),
+        path.resolve(thisDir, "..", "..", "dist", "remote-logger.browser.js"),
+    ];
+
+    for (const candidate of candidates) {
+        try {
+            browserBundleCache = fs.readFileSync(candidate, "utf-8");
+            return browserBundleCache;
+        } catch {
+            // Try next candidate
+        }
+    }
+
+    browserBundleCache = null;
+    return browserBundleCache;
+}
+
+/**
+ * Reset the browser bundle cache. Used for testing.
+ */
+export function resetBrowserBundleCache(): void {
+    browserBundleCache = undefined;
+}
+
 // ANSI color codes for terminal output
 const colors = {
     reset: "\x1b[0m",
@@ -81,7 +131,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;
@@ -269,7 +319,36 @@ function handleRequest(
         return;
     }
 
-    // In logReceiveOnly mode, only /log and /health are available
+    // Serve browser-ready script bundle (available in all modes including logReceiveOnly)
+    if ((url === "/remote-logger.js" || url.startsWith("/remote-logger.js?")) && req.method === "GET") {
+        const bundle = loadBrowserBundle();
+        if (!bundle) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Browser bundle not found. Run 'npm run build' first." }));
+            return;
+        }
+
+        const hostHeader = req.headers.host ?? `${host}:${port}`;
+        const serverUrl = `${protocol}://${hostHeader}`;
+        const configPrefix = `window.__REMOTE_LOG_SERVER_URL__="${serverUrl}";\n`;
+
+        res.writeHead(200, {
+            "Content-Type": "application/javascript",
+            "Cache-Control": "no-cache",
+        });
+        res.end(configPrefix + bundle);
+        return;
+    }
+
+    // Reverse proxy with auto-injection (available in all modes including logReceiveOnly)
+    if (url.startsWith("/proxy/") && sharedProxy) {
+        const targetUrl = decodeURIComponent(url.substring("/proxy/".length));
+        const hostHeader = req.headers.host ?? `${host}:${port}`;
+        sharedProxy.handleRequest(req, res, targetUrl, protocol, hostHeader);
+        return;
+    }
+
+    // In logReceiveOnly mode, only /log, /health, /remote-logger.js, and /proxy/ are available
     if (logReceiveOnly) {
         res.writeHead(404, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Not found (log receive only mode)" }));
@@ -377,17 +456,21 @@ function printBanner(host: string, port: number, useHttps: boolean): void {
     // eslint-disable-next-line no-console
     console.log(`${colors.yellow}API Endpoints:${colors.reset}`);
     // eslint-disable-next-line no-console
-    console.log(`  ${colors.cyan}POST /log         ${colors.reset} - Receive logs from browser`);
+    console.log(`  ${colors.cyan}POST /log              ${colors.reset} - Receive logs from browser`);
+    // eslint-disable-next-line no-console
+    console.log(`  ${colors.cyan}GET  /remote-logger.js ${colors.reset} - Browser-ready auto-config script`);
     // eslint-disable-next-line no-console
-    console.log(`  ${colors.cyan}GET  /logs        ${colors.reset} - Get all logs as JSON`);
+    console.log(`  ${colors.cyan}*    /proxy/<url>      ${colors.reset} - Reverse proxy with script injection`);
     // eslint-disable-next-line no-console
-    console.log(`  ${colors.cyan}GET  /logs/recent ${colors.reset} - Get last 50 logs (?n=100 for more)`);
+    console.log(`  ${colors.cyan}GET  /logs             ${colors.reset} - Get all logs as JSON`);
     // eslint-disable-next-line no-console
-    console.log(`  ${colors.cyan}GET  /logs/errors ${colors.reset} - Get only error logs`);
+    console.log(`  ${colors.cyan}GET  /logs/recent      ${colors.reset} - Get last 50 logs (?n=100 for more)`);
     // eslint-disable-next-line no-console
-    console.log(`  ${colors.cyan}POST /logs/clear  ${colors.reset} - Clear all logs`);
+    console.log(`  ${colors.cyan}GET  /logs/errors      ${colors.reset} - Get only error logs`);
     // eslint-disable-next-line no-console
-    console.log(`  ${colors.cyan}GET  /health      ${colors.reset} - Health check`);
+    console.log(`  ${colors.cyan}POST /logs/clear       ${colors.reset} - Clear all logs`);
+    // eslint-disable-next-line no-console
+    console.log(`  ${colors.cyan}GET  /health           ${colors.reset} - Health check`);
     // eslint-disable-next-line no-console
     console.log("");
     // eslint-disable-next-line no-console
@@ -477,7 +560,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 +638,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 +760,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/log-storage.ts

@@ -141,6 +141,10 @@ export interface ServerConfig {
     protocol: "http" | "https";
     /** Full URL for browser clients to send logs to */
     httpEndpoint: string;
+    /** URL to the browser-ready auto-config script */
+    scriptUrl?: string;
+    /** Base URL for the reverse proxy (e.g., "http://host:port/proxy/") */
+    proxyBaseUrl?: string;
     /** Server mode (mcp-only, http-only, or dual) */
     mode: ServerMode;
 }