@graphty/remote-logger 1.1.1 → 1.2.0

package/src/server/log-server.ts

@@ -16,9 +16,51 @@
 import * as fs from "fs";
 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 { certFilesExist, generateSelfSignedCert, readCertFiles } from "./self-signed-cert.js";
+import { JsonlWriter } from "./jsonl-writer.js";
+import { type LogEntry, LogStorage } from "./log-storage.js";
+import { certFilesExist, readCertFiles } from "./self-signed-cert.js";
+
+// Shared log storage instance
+let sharedStorage: LogStorage | null = null;
+// Shared JSONL writer instance
+let sharedJsonlWriter: JsonlWriter | null = null;
+
+/**
+ * Get the shared LogStorage instance, creating it if needed.
+ * Creates a JsonlWriter for JSONL file streaming by default.
+ * @returns The shared LogStorage instance
+ */
+export function getLogStorage(): LogStorage {
+    if (!sharedStorage) {
+        // Create JSONL writer for file streaming
+        const jsonlBaseDir = path.join(os.tmpdir(), "remote-logger");
+        sharedJsonlWriter = new JsonlWriter(jsonlBaseDir);
+
+        // Create storage with JSONL writer
+        sharedStorage = new LogStorage({ jsonlWriter: sharedJsonlWriter });
+    }
+    return sharedStorage;
+}
+
+/**
+ * Get the shared JsonlWriter instance.
+ * @returns The shared JsonlWriter instance or null if not initialized
+ */
+export function getJsonlWriter(): JsonlWriter | null {
+    return sharedJsonlWriter;
+}
+
+/**
+ * Set the shared LogStorage instance (for testing or external injection).
+ * @param storage - The LogStorage instance to use
+ */
+export function setLogStorage(storage: LogStorage): void {
+    sharedStorage = storage;
+}
 
 // ANSI color codes for terminal output
 const colors = {
@@ -41,32 +83,33 @@ export interface LogServerOptions {
     port?: number;
     /** Hostname to bind to (default: localhost) */
     host?: string;
-    /** Path to SSL certificate file */
+    /** Path to SSL certificate file (HTTPS only used if both certPath and keyPath provided) */
     certPath?: string;
-    /** Path to SSL private key file */
+    /** Path to SSL private key file (HTTPS only used if both certPath and keyPath provided) */
     keyPath?: string;
     /** Path to file for writing logs (optional) */
     logFile?: string;
-    /** Use HTTP instead of HTTPS (default: false) */
-    useHttp?: boolean;
+    /** Start in MCP server mode (default: false) @deprecated Use mcpOnly instead */
+    mcp?: boolean;
+    /** Start only MCP server (no HTTP) */
+    mcpOnly?: boolean;
+    /** Start only HTTP server (no MCP) - legacy mode */
+    httpOnly?: boolean;
     /** Suppress startup banner (default: false) */
     quiet?: boolean;
 }
 
-export interface LogEntry {
-    time: string;
-    level: string;
-    message: string;
-}
+// Re-export LogEntry from log-storage for backward compatibility
+export type { LogEntry } from "./log-storage.js";
 
 interface LogBatch {
     sessionId: string;
     logs: LogEntry[];
+    projectMarker?: string;
+    worktreePath?: string;
+    pageUrl?: string;
 }
 
-// Store for remote logs by session
-const remoteLogs = new Map<string, LogEntry[]>();
-
 // File stream for log file
 let logFileStream: fs.WriteStream | null = null;
 
@@ -75,7 +118,7 @@ let logFileStream: fs.WriteStream | null = null;
  * Useful for testing.
  */
 export function clearLogs(): void {
-    remoteLogs.clear();
+    getLogStorage().clear();
 }
 
 /**
@@ -144,6 +187,7 @@ function displayLog(sessionId: string, log: LogEntry, quiet: boolean): void {
  * @param port - The server port number
  * @param useHttps - Whether HTTPS is being used
  * @param quiet - If true, suppress terminal output
+ * @param logReceiveOnly - If true, only serve /log POST and /health GET endpoints
  */
 function handleRequest(
     req: http.IncomingMessage,
@@ -152,6 +196,7 @@ function handleRequest(
     port: number,
     useHttps: boolean,
     quiet: boolean,
+    logReceiveOnly: boolean = false,
 ): void {
     // CORS headers
     res.setHeader("Access-Control-Allow-Origin", "*");
@@ -176,36 +221,30 @@ function handleRequest(
         req.on("end", () => {
             try {
                 const data = JSON.parse(body) as LogBatch;
-                const { sessionId, logs } = data;
-
-                // Initialize session if new
-                if (!remoteLogs.has(sessionId)) {
-                    remoteLogs.set(sessionId, []);
-                    if (!quiet) {
-                        // eslint-disable-next-line no-console
-                        console.log(
-                            `\n${colors.bright}${colors.magenta}═══════════════════════════════════════════════════════════${colors.reset}`,
-                        );
-                        // eslint-disable-next-line no-console
-                        console.log(`${colors.bright}${colors.magenta}  NEW SESSION: ${sessionId}${colors.reset}`);
-                        // eslint-disable-next-line no-console
-                        console.log(
-                            `${colors.bright}${colors.magenta}═══════════════════════════════════════════════════════════${colors.reset}\n`,
-                        );
-                    }
+                const { sessionId, logs, projectMarker, worktreePath, pageUrl } = data;
+
+                const storage = getLogStorage();
+                const isNewSession = !storage.hasSession(sessionId);
+
+                // Show new session banner
+                if (isNewSession && !quiet) {
+                    // eslint-disable-next-line no-console
+                    console.log(
+                        `\n${colors.bright}${colors.magenta}═══════════════════════════════════════════════════════════${colors.reset}`,
+                    );
+                    // eslint-disable-next-line no-console
+                    console.log(`${colors.bright}${colors.magenta}  NEW SESSION: ${sessionId}${colors.reset}`);
+                    // eslint-disable-next-line no-console
+                    console.log(
+                        `${colors.bright}${colors.magenta}═══════════════════════════════════════════════════════════${colors.reset}\n`,
+                    );
                 }
 
-                const sessionLogs = remoteLogs.get(sessionId);
-                if (!sessionLogs) {
-                    // Should not happen since we just set it above, but satisfy TypeScript
-                    res.writeHead(500, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ error: "Internal error" }));
-                    return;
-                }
+                // Add logs to storage
+                storage.addLogs(sessionId, logs, { projectMarker, worktreePath, pageUrl });
 
-                // Display and store each log
+                // Display each log in terminal
                 for (const log of logs) {
-                    sessionLogs.push(log);
                     displayLog(sessionId, log, quiet);
                 }
 
@@ -222,12 +261,24 @@ function handleRequest(
         return;
     }
 
+    // Health check endpoint (always available)
+    if (url === "/health" && req.method === "GET") {
+        const health = getLogStorage().getHealth();
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: health.status, sessions: health.sessionCount }));
+        return;
+    }
+
+    // In logReceiveOnly mode, only /log and /health are available
+    if (logReceiveOnly) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found (log receive only mode)" }));
+        return;
+    }
+
     // Handle logs viewer endpoint - GET all logs
     if (url === "/logs" && req.method === "GET") {
-        const allLogs: Record<string, LogEntry[]> = {};
-        for (const [sessionId, logs] of remoteLogs) {
-            allLogs[sessionId] = logs;
-        }
+        const allLogs = getLogStorage().getAllLogsBySession();
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify(allLogs, null, 2));
         return;
@@ -239,25 +290,16 @@ function handleRequest(
         const count = parseInt(urlObj.searchParams.get("n") ?? "50", 10);
         const errorsOnly = urlObj.searchParams.get("errors") === "true";
 
-        // Collect all logs with session info
-        const allLogs: (LogEntry & { sessionId: string })[] = [];
-        for (const [sessionId, logs] of remoteLogs) {
-            for (const log of logs) {
-                if (!errorsOnly || log.level.toUpperCase() === "ERROR") {
-                    allLogs.push({ sessionId, ...log });
-                }
-            }
-        }
-
-        // Sort by time descending and take last N
-        allLogs.sort((a, b) => new Date(b.time).getTime() - new Date(a.time).getTime());
-        const recentLogs = allLogs.slice(0, count).reverse(); // Reverse to show oldest first
+        const storage = getLogStorage();
+        const filter = errorsOnly ? { level: "ERROR" } : {};
+        const recentLogs = storage.getRecentLogs(count, filter);
+        const totalLogs = storage.getLogs(filter).length;
 
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(
             JSON.stringify(
                 {
-                    total: allLogs.length,
+                    total: totalLogs,
                     showing: recentLogs.length,
                     logs: recentLogs,
                 },
@@ -270,15 +312,7 @@ function handleRequest(
 
     // Handle errors-only endpoint
     if (url === "/logs/errors" && req.method === "GET") {
-        const errorLogs: (LogEntry & { sessionId: string })[] = [];
-        for (const [sessionId, logs] of remoteLogs) {
-            for (const log of logs) {
-                if (log.level.toUpperCase() === "ERROR") {
-                    errorLogs.push({ sessionId, ...log });
-                }
-            }
-        }
-        errorLogs.sort((a, b) => new Date(a.time).getTime() - new Date(b.time).getTime());
+        const errorLogs = getLogStorage().getErrors();
 
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(
@@ -296,7 +330,7 @@ function handleRequest(
 
     // Handle clear logs endpoint
     if (url === "/logs/clear" && req.method === "POST") {
-        remoteLogs.clear();
+        getLogStorage().clear();
         if (!quiet) {
             // eslint-disable-next-line no-console
             console.log(`\n${colors.yellow}Logs cleared${colors.reset}\n`);
@@ -306,13 +340,6 @@ function handleRequest(
         return;
     }
 
-    // Health check endpoint
-    if (url === "/health" && req.method === "GET") {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ status: "ok", sessions: remoteLogs.size }));
-        return;
-    }
-
     // Default: 404
     res.writeHead(404, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ error: "Not found" }));
@@ -369,6 +396,80 @@ function printBanner(host: string, port: number, useHttps: boolean): void {
     console.log(`${colors.cyan}────────────────────────────────────────────────────────────${colors.reset}`);
 }
 
+/**
+ * Options for creating a log server without starting it.
+ */
+export interface CreateLogServerOptions {
+    /** Port to listen on */
+    port: number;
+    /** Hostname to bind to */
+    host: string;
+    /** Shared log storage instance */
+    storage: LogStorage;
+    /** Suppress terminal output (default: false) */
+    quiet?: boolean;
+    /** Only serve /log POST and /health GET endpoints (default: false) */
+    logReceiveOnly?: boolean;
+    /** Path to SSL certificate file (HTTPS only used if both certPath and keyPath provided) */
+    certPath?: string;
+    /** Path to SSL private key file (HTTPS only used if both certPath and keyPath provided) */
+    keyPath?: string;
+}
+
+/**
+ * Result of creating a log server.
+ */
+export interface CreateLogServerResult {
+    /** The HTTP or HTTPS server instance (not yet listening) */
+    server: http.Server | https.Server;
+}
+
+/**
+ * Create a log server with shared storage.
+ * The server is not started - call server.listen() to start it.
+ * @param options - Server configuration options
+ * @returns The server instance
+ */
+export function createLogServer(options: CreateLogServerOptions): CreateLogServerResult {
+    const {
+        port,
+        host,
+        storage,
+        quiet = true,
+        logReceiveOnly = false,
+        certPath,
+        keyPath,
+    } = options;
+
+    // Set the shared storage
+    setLogStorage(storage);
+
+    let server: http.Server | https.Server;
+
+    // Use HTTPS only if valid certificate files are provided
+    const useHttps = certPath && keyPath && certFilesExist(certPath, keyPath);
+
+    if (useHttps) {
+        // HTTPS server with provided certificates
+        const { cert, key } = readCertFiles(certPath, keyPath);
+        if (!quiet) {
+            // eslint-disable-next-line no-console
+            console.log(`${colors.green}Using SSL certificates from: ${certPath}${colors.reset}`);
+        }
+
+        server = https.createServer({ cert, key }, (req, res) => {
+            handleRequest(req, res, host, port, true, quiet, logReceiveOnly);
+        });
+    } else {
+        // HTTP server (default - no self-signed certs as browsers reject them)
+        server = http.createServer((req, res) => {
+            handleRequest(req, res, host, port, false, quiet, logReceiveOnly);
+        });
+    }
+
+    return { server };
+}
+
 /**
  * Start the log server.
  * @param options - Server configuration options
@@ -377,7 +478,6 @@ function printBanner(host: string, port: number, useHttps: boolean): void {
 export function startLogServer(options: LogServerOptions = {}): http.Server | https.Server {
     const port = options.port ?? 9080;
     const host = options.host ?? "localhost";
-    const useHttp = options.useHttp ?? false;
     const quiet = options.quiet ?? false;
 
     // Set up log file if specified
@@ -390,50 +490,34 @@ export function startLogServer(options: LogServerOptions = {}): http.Server | ht
     }
 
     // Determine SSL configuration
+    // Use HTTPS only if valid certificate files are provided
     let server: https.Server | http.Server;
+    let useHttps = false;
+    const { certPath, keyPath } = options;
 
-    if (useHttp) {
-        // Plain HTTP server
-        server = http.createServer((req, res) => {
-            handleRequest(req, res, host, port, false, quiet);
-        });
-    } else {
-        // HTTPS server
-        let cert: string;
-        let key: string;
-
-        if (options.certPath && options.keyPath && certFilesExist(options.certPath, options.keyPath)) {
-            // Use provided certificates
-            ({ cert, key } = readCertFiles(options.certPath, options.keyPath));
-            if (!quiet) {
-                // eslint-disable-next-line no-console
-                console.log(`${colors.green}Using SSL certificates from: ${options.certPath}${colors.reset}`);
-            }
-        } else {
-            // Generate self-signed certificate
-            if (!quiet) {
-                // eslint-disable-next-line no-console
-                console.log(`${colors.yellow}Generating self-signed certificate for ${host}...${colors.reset}`);
-            }
-
-            ({ cert, key } = generateSelfSignedCert(host));
-            if (!quiet) {
-                // eslint-disable-next-line no-console
-                console.log(
-                    `${colors.yellow}Note: Browser will show certificate warning - this is expected for self-signed certs${colors.reset}`,
-                );
-            }
+    if (certPath && keyPath && certFilesExist(certPath, keyPath)) {
+        // HTTPS server with provided certificates
+        useHttps = true;
+        const { cert, key } = readCertFiles(certPath, keyPath);
+        if (!quiet) {
+            // eslint-disable-next-line no-console
+            console.log(`${colors.green}Using SSL certificates from: ${certPath}${colors.reset}`);
         }
 
         server = https.createServer({ cert, key }, (req, res) => {
             handleRequest(req, res, host, port, true, quiet);
         });
+    } else {
+        // HTTP server (default - no self-signed certs as browsers reject them)
+        server = http.createServer((req, res) => {
+            handleRequest(req, res, host, port, false, quiet);
+        });
     }
 
     // Start listening
     server.listen(port, host, () => {
         if (!quiet) {
-            printBanner(host, port, !useHttp);
+            printBanner(host, port, useHttps);
         }
     });
 
@@ -445,6 +529,12 @@ export function startLogServer(options: LogServerOptions = {}): http.Server | ht
             logFileStream.end();
         }
 
+        // Close JSONL writer to flush pending writes
+        const jsonlWriter = getJsonlWriter();
+        if (jsonlWriter) {
+            void jsonlWriter.close();
+        }
+
         server.close(() => {
             process.exit(0);
         });
@@ -466,18 +556,29 @@ Usage:
 Options:
   --port, -p <port>       Port to listen on (default: 9080)
   --host, -h <host>       Hostname to bind to (default: localhost)
-  --cert, -c <path>       Path to SSL certificate file
-  --key, -k <path>        Path to SSL private key file
+  --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
-  --http                  Use HTTP instead of HTTPS
+  --mcp-only              Start only MCP server (no HTTP)
+  --http-only             Start only HTTP server (legacy mode)
+  --mcp                   Alias for --mcp-only (deprecated)
   --quiet, -q             Suppress startup banner
   --help                  Show this help message
 
+Protocol:
+  HTTP is used by default. To use HTTPS, provide both --cert and --key.
+
+Modes:
+  Default (no flags)      Dual mode: HTTP + MCP running together
+  --mcp-only              MCP only: For Claude Code integration
+  --http-only             HTTP only: Legacy mode for browser debugging
+
 Examples:
-  npx remote-log-server                           # Start with defaults (port 9080, self-signed cert)
-  npx remote-log-server --port 9085               # Custom port
-  npx remote-log-server --http                    # Use HTTP instead of HTTPS
-  npx remote-log-server --cert cert.crt --key key.key  # Custom SSL certs
+  npx remote-log-server                                # Start dual mode (HTTP + MCP)
+  npx remote-log-server --port 9085                    # Custom port
+  npx remote-log-server --mcp-only                     # MCP server only (for Claude Code)
+  npx remote-log-server --http-only                    # HTTP server only (legacy)
+  npx remote-log-server --cert cert.crt --key key.key  # Use HTTPS with custom certs
   npx remote-log-server --log-file ./tmp/logs.jsonl    # Also write to file
 `;
 
@@ -532,8 +633,15 @@ export function parseArgs(args: string[]): ParseArgsResult {
                 options.logFile = nextArg;
                 i++;
                 break;
-            case "--http":
-                options.useHttp = true;
+            case "--mcp":
+                // Legacy alias for --mcp-only. Only set mcpOnly now.
+                options.mcpOnly = true;
+                break;
+            case "--mcp-only":
+                options.mcpOnly = true;
+                break;
+            case "--http-only":
+                options.httpOnly = true;
                 break;
             case "--quiet":
             case "-q":
@@ -552,7 +660,7 @@ export function parseArgs(args: string[]): ParseArgsResult {
 /**
  * Parse command line arguments and start the server.
  */
-export function main(): void {
+export async function main(): Promise<void> {
     const args = process.argv.slice(2);
     const result = parseArgs(args);
 
@@ -567,5 +675,89 @@ export function main(): void {
         process.exit(1);
     }
 
-    startLogServer(result.options);
+    const { options } = result;
+
+    // Determine mode: mcp-only, http-only, or dual (default)
+    // All modes now use createDualServer with different options
+    const { createDualServer } = await import("./dual-server.js");
+
+    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",
+            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");
+        }
+    } else if (options.httpOnly) {
+        // HTTP-only mode: All HTTP endpoints, no MCP
+        const dualServer = await createDualServer({
+            httpPort: options.port ?? 9080,
+            httpHost: options.host ?? "localhost",
+            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");
+        }
+    } else {
+        // Dual mode (default): All HTTP endpoints and MCP
+        const dualServer = await createDualServer({
+            httpPort: options.port ?? 9080,
+            httpHost: options.host ?? "localhost",
+            httpEnabled: true,
+            mcpEnabled: true,
+            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("Dual mode: HTTP and MCP servers running");
+        }
+    }
 }