codehere 0.3.0-rc.4 → 0.3.0-rc.5

package/dist/index.js

@@ -354,10 +354,30 @@ program
     const port = parseInt(options?.port ?? '3773', 10);
     const host = options?.host ?? '127.0.0.1';
     const shouldOpen = options?.open !== false;
+    const url = `http://${host}:${port}/`;
+    const openBrowser = async () => {
+        if (!shouldOpen)
+            return;
+        const { spawn } = await import('child_process');
+        const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+        try {
+            spawn(opener, [url], { detached: true, stdio: 'ignore' }).unref();
+        }
+        catch {
+            /* browser open is best-effort */
+        }
+    };
     try {
         const { startMCPServer } = await import('./infrastructure/protocols/mcp-server-impl.js');
         const server = startMCPServer({ port, host });
-        const url = `http://${host}:${port}/`;
+        // Wait for the server to either start listening or fail. The default
+        // Node behavior on listen() failure is an unhandled 'error' event which
+        // crashes the process with a stack trace. We catch it here so the user
+        // sees a friendly message instead.
+        await new Promise((resolve, reject) => {
+            server.once('listening', () => resolve());
+            server.once('error', reject);
+        });
         newline();
         console.log(success('codehere is running'));
         newline();
@@ -367,16 +387,7 @@ program
         newline();
         console.log(colors.dim('  Press Ctrl+C to stop'));
         newline();
-        if (shouldOpen) {
-            const { spawn } = await import('child_process');
-            const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-            try {
-                spawn(opener, [url], { detached: true, stdio: 'ignore' }).unref();
-            }
-            catch {
-                /* browser open is best-effort */
-            }
-        }
+        await openBrowser();
         process.on('SIGINT', () => {
             server.close();
             console.log(colors.dim('\ncodehere stopped'));
@@ -387,6 +398,28 @@ program
         });
     }
     catch (err) {
+        const code = err?.code;
+        if (code === 'EADDRINUSE') {
+            // Port is taken. Probe to find out by what — if it's a running codehere,
+            // we should hand the user the existing URL; if it's something else,
+            // tell them to pick a different port.
+            const { isCodehereOnPort } = await import('./infrastructure/protocols/probe-port.js');
+            const existing = await isCodehereOnPort(host, port);
+            newline();
+            if (existing.isCodehere) {
+                console.log(success(`codehere is already running at ${url}`));
+                if (existing.version) {
+                    console.log(colors.dim(`  version: ${existing.version}`));
+                }
+                newline();
+                console.log(colors.dim('  Opening browser...'));
+                await openBrowser();
+                process.exit(0);
+            }
+            console.error(error(`Port ${port} is in use by another process.`));
+            console.error(colors.dim(`  Try: codehere start --port ${port + 1}`));
+            process.exit(1);
+        }
         console.error(error('Failed to start:'), err instanceof Error ? err.message : String(err));
         process.exit(1);
     }

package/dist/infrastructure/protocols/probe-port.js

@@ -0,0 +1,36 @@
+/**
+ * Detect whether a given host:port is already serving a codehere instance.
+ *
+ * Used by `codehere start` when the listen() fails with EADDRINUSE: we'd
+ * rather give the user a friendly "codehere already running, opening browser"
+ * than a Node stack trace. If something ELSE holds the port we tell them to
+ * pick a different one.
+ *
+ * Approach: hit the existing server's /health endpoint. The codehere MCP
+ * server returns a JSON body with `server: 'codehere-mcp'` — no other tool
+ * uses that exact identifier. Generous 1.5-second timeout so a slow loopback
+ * doesn't false-negative.
+ */
+export async function isCodehereOnPort(host, port, timeoutMs = 1500) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+        const res = await fetch(`http://${host}:${port}/health`, { signal: ac.signal });
+        if (!res.ok)
+            return { isCodehere: false };
+        const body = (await res.json());
+        if (body?.server === 'codehere-mcp') {
+            return { isCodehere: true, version: body.version };
+        }
+        return { isCodehere: false };
+    }
+    catch {
+        // Connection refused, timeout, malformed response — anything that's not
+        // a positive codehere identification. Treat as "not codehere."
+        return { isCodehere: false };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=probe-port.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.3.0-rc.4",
+  "version": "0.3.0-rc.5",
   "description": "A PM for your AI coding agents. Delegate, orchestrate, and audit Claude Code, Codex, Aider, and OpenCode from one local web UI — every AI action traced, every file scored.",
   "main": "dist/index.js",
   "type": "module",