openwriter 0.5.1 → 0.5.3

package/dist/bin/pad.js

@@ -19,6 +19,34 @@
 // Redirect all console output to stderr so MCP stdio protocol stays clean on stdout
 const originalLog = console.log;
 console.log = (...args) => console.error(...args);
+// ── Crash guards ──
+// The MCP StdioServerTransport writes to stdout with no error handler.
+// When Claude Code closes the pipe, the write throws EPIPE and kills the process,
+// taking the HTTP server (browser UI) down with it. Catch everything so the
+// HTTP server survives MCP disconnects.
+process.on('uncaughtException', (err) => {
+    // EPIPE / ERR_STREAM_DESTROYED from broken MCP pipe — non-fatal, ignore
+    if (err?.code === 'EPIPE' || err?.code === 'ERR_STREAM_DESTROYED')
+        return;
+    console.error('[FATAL] Uncaught exception:', err);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[WARN] Unhandled rejection:', reason);
+});
+// Catch broken-pipe errors on stdout directly (MCP transport writes here)
+process.stdout.on('error', (err) => {
+    if (err?.code === 'EPIPE' || err?.code === 'ERR_STREAM_DESTROYED')
+        return;
+    console.error('[stdout error]', err);
+});
+// Monitor stdin lifecycle — when Claude Code closes the pipe, stdin ends.
+// Log it so we know exactly when MCP disconnects.
+process.stdin.on('end', () => {
+    console.error('[MCP] stdin EOF — Claude Code disconnected. HTTP server still running.');
+});
+process.stdin.on('close', () => {
+    console.error('[MCP] stdin closed.');
+});
 // Only light imports here — helpers.js uses fs/path/os/crypto (all Node stdlib)
 import { createConnection } from 'net';
 import { readConfig, saveConfig } from '../server/helpers.js';
@@ -76,15 +104,42 @@ else {
         process.env.AV_API_KEY = avApiKey;
     if (avBackendUrl)
         process.env.AV_BACKEND_URL = avBackendUrl;
-    // Fast port check — determines primary vs client mode
-    const portTaken = await new Promise((resolve) => {
-        const socket = createConnection({ port, host: '127.0.0.1' });
-        socket.once('connect', () => { socket.destroy(); resolve(true); });
-        socket.once('error', () => { resolve(false); });
-    });
-    if (portTaken) {
+    // Port check with health verification — detects orphaned servers
+    async function checkPort() {
+        const taken = await new Promise((resolve) => {
+            const socket = createConnection({ port, host: '127.0.0.1' });
+            socket.once('connect', () => { socket.destroy(); resolve(true); });
+            socket.once('error', () => { resolve(false); });
+        });
+        if (!taken)
+            return 'free';
+        // Port is taken — verify it's a healthy OpenWriter server
+        try {
+            const res = await fetch(`http://127.0.0.1:${port}/api/status`, { signal: AbortSignal.timeout(2000) });
+            return res.ok ? 'healthy' : 'orphaned';
+        }
+        catch {
+            return 'orphaned';
+        }
+    }
+    let portState = await checkPort();
+    // Orphaned server: wait for it to die, then claim primary mode
+    if (portState === 'orphaned') {
+        console.error(`[OpenWriter] Port ${port} held by unresponsive process — waiting for release...`);
+        await new Promise(r => setTimeout(r, 3000));
+        portState = await checkPort();
+        if (portState === 'orphaned') {
+            // Still held — wait once more
+            await new Promise(r => setTimeout(r, 3000));
+            portState = await checkPort();
+        }
+        if (portState !== 'free') {
+            console.error(`[OpenWriter] Port ${port} still unavailable — entering client mode`);
+        }
+    }
+    if (portState === 'healthy') {
         // Client mode: proxy MCP calls to existing primary server via HTTP
-        console.error(`[OpenWriter] Port ${port} in use — entering client mode (proxying to existing server)`);
+        console.error(`[OpenWriter] Port ${port} in use by healthy server — entering client mode`);
         const { startMcpClientServer } = await import('../server/mcp-client.js');
         startMcpClientServer(port).catch((err) => {
             console.error('[MCP-Client] Failed to start:', err);
@@ -100,6 +155,8 @@ else {
         });
         // Deferred: load Express + plugins (heavy deps) after MCP is connecting
         const { startHttpServer } = await import('../server/index.js');
-        startHttpServer({ port, noOpen, plugins });
+        startHttpServer({ port, noOpen, plugins }).catch((err) => {
+            console.error('[HTTP] Failed to start:', err);
+        });
     }
 }