@nac3/forge-cli 1.0.20 → 1.0.21

package/dist/chat/server.js

@@ -50,7 +50,41 @@ import { beginTurn, endTurn, interruptActiveTurn, isTurnActive } from './turn_co
 import { manifest as nac3Manifest } from '../nac3/internal_manifest.js';
 import { buildManifestForPrompt } from '../nac3/manifest_lazy.js';
 import { popPending, logApproval } from '../nac3/approval_queue.js';
+/**
+ * Find the first free TCP port at or above `start` on `host`, so several
+ * `yf chat` instances can run side by side: each lands on the next free port
+ * instead of failing with EADDRINUSE (Pablo 2026-06-19).
+ */
+async function findFreePort(start, host, maxTries = 50) {
+    const net = await import('node:net');
+    for (let port = start; port < start + maxTries; port += 1) {
+        const free = await new Promise((resolve) => {
+            const tester = net.createServer();
+            tester.once('error', () => resolve(false));
+            tester.once('listening', () => tester.close(() => resolve(true)));
+            tester.listen(port, host);
+        });
+        if (free)
+            return port;
+    }
+    throw new Error('No free port found in ' + start + '..' + (start + maxTries));
+}
 export async function startChatServer(opts) {
+    /* Port auto-increment: if the requested port is taken (another yf chat is
+     * already there), step up to the next free one. Determined BEFORE anything
+     * reads opts.port (panel MCP bridge, relay consumer, url), so every consumer
+     * sees the real bound port. */
+    {
+        const requested = opts.port;
+        const free = await findFreePort(requested, '127.0.0.1');
+        if (free !== requested) {
+            try {
+                console.error('[yf] puerto ' + requested + ' ocupado -> usando ' + free);
+            }
+            catch { /* noop */ }
+            opts.port = free;
+        }
+    }
     const projectName = await readProjectName(opts.projectRoot);
     /* alpha.59u.2 -- distinct slug (machine id) vs projectName (display).
      *  Identity queries against the semantic graph use the slug so
@@ -345,6 +379,7 @@ export async function startChatServer(opts) {
                 panelPushToken,
                 reanchor,
                 setBrainProvider,
+                bridge: bridgeHandle,
             });
         }
         catch (err) {
@@ -364,9 +399,39 @@ export async function startChatServer(opts) {
     server.keepAliveTimeout = 1000;
     server.headersTimeout = 5000;
     server.requestTimeout = 30000;
+    /* Listen with EADDRINUSE retry (Pablo 2026-06-19). The pre-probe above wins
+     * the common case; this closes the rare race where two instances start at the
+     * same instant and both probed the same port as free. On collision we step
+     * to the next free port and update opts.port so relay + bridge + url stay
+     * correct. */
     await new Promise((resolve, reject) => {
-        server.once('error', reject);
-        server.listen(opts.port, '127.0.0.1', () => resolve());
+        let attempts = 0;
+        const tryListen = (p) => {
+            const onErr = (err) => {
+                server.removeListener('listening', onOk);
+                if (err && err.code === 'EADDRINUSE' && attempts < 50) {
+                    attempts += 1;
+                    findFreePort(p + 1, '127.0.0.1')
+                        .then((next) => {
+                        try {
+                            console.error('[yf] puerto ' + p + ' ocupado -> usando ' + next);
+                        }
+                        catch { /* noop */ }
+                        opts.port = next;
+                        tryListen(next);
+                    })
+                        .catch(reject);
+                }
+                else {
+                    reject(err);
+                }
+            };
+            const onOk = () => { server.removeListener('error', onErr); resolve(); };
+            server.once('error', onErr);
+            server.once('listening', onOk);
+            server.listen(p, '127.0.0.1');
+        };
+        tryListen(opts.port);
     });
     /* P2 -- relay command consumer (inbound phone chat) + the board ctx.
      * Start the consumer ALWAYS: it self-gates on relayEnabled() every tick,
@@ -379,6 +444,34 @@ export async function startChatServer(opts) {
     catch {
         commandConsumerHandle = null;
     }
+    /* Inter-instance coordination bridge (Pablo 2026-06-19). The first yf chat
+     * hosts a shared bus on a fixed port; the rest subscribe. Never blocks boot:
+     * any failure leaves bridgeHandle null and the panel bridge endpoints report
+     * "off". */
+    let bridgeHandle = null;
+    /* Skip under vitest (cross-process port 4836 contention between test workers)
+     * and when explicitly disabled. The bridge has its own dedicated unit test. */
+    const bridgeDisabled = process.env.VITEST != null || process.env.YF_BRIDGE_DISABLED === '1';
+    if (!bridgeDisabled) {
+        try {
+            const { startBridge } = await import('./bridge.js');
+            const selfId = projectSlug + '-' + opts.port + '-' + process.pid;
+            bridgeHandle = await startBridge({
+                id: selfId,
+                project_name: projectName,
+                project_slug: projectSlug,
+                panel_port: opts.port,
+                pid: process.pid,
+            });
+        }
+        catch (err) {
+            bridgeHandle = null;
+            try {
+                console.error('bridge boot failed (coordination off): ' + (err instanceof Error ? err.message : String(err)));
+            }
+            catch { /* swallow */ }
+        }
+    }
     /* Set the relay board ctx to the active project NOW so a paired phone
      * shows the project bubble + pizarron immediately -- the ctx used to be
      * set only on a chat turn or a project switch, so the phone saw nothing
@@ -421,6 +514,7 @@ export async function startChatServer(opts) {
     return {
         server,
         url,
+        port: opts.port,
         store,
         close: () => new Promise((resolve) => {
             /* alpha.59w -- stop the component watcher on shutdown so
@@ -435,6 +529,10 @@ export async function startChatServer(opts) {
                 }
                 catch { /* noop */ }
             }
+            /* Leave + tear down the coordination bridge (Pablo 2026-06-19). */
+            if (bridgeHandle) {
+                Promise.resolve(bridgeHandle.stop()).catch(() => undefined);
+            }
             /* alpha.59z.136 slice 14 -- flush in-flight ingest session
              * writes BEFORE the server closes so test teardowns that
              * fs.rm the home directory immediately after do not race
@@ -1201,6 +1299,58 @@ async function route(req, res, ctx) {
      *  reads this at boot to decide whether to auto-open the
      *  license + brain wizard modal. POST persists "user finished the
      *  wizard" or "user dismissed -> do not auto-open again". */
+    /* Inter-instance coordination bridge (Pablo 2026-06-19). The browser polls
+     * /state for the roster + shared messages and POSTs /send to broadcast. */
+    if (req.method === 'GET' && url.pathname === '/api/forge/bridge/state') {
+        if (!ctx.bridge) {
+            sendJson(res, 200, { ok: true, enabled: false });
+            return;
+        }
+        try {
+            const st = await ctx.bridge.state();
+            sendJson(res, 200, {
+                ok: true,
+                enabled: true,
+                role: ctx.bridge.role(),
+                self_id: ctx.bridge.selfId,
+                port: ctx.bridge.port,
+                instances: st.instances,
+                messages: st.messages,
+            });
+        }
+        catch (err) {
+            sendJson(res, 200, { ok: true, enabled: false, error: err instanceof Error ? err.message : String(err) });
+        }
+        return;
+    }
+    if (req.method === 'POST' && url.pathname === '/api/forge/bridge/send') {
+        if (!ctx.bridge) {
+            sendJson(res, 200, { ok: false, enabled: false });
+            return;
+        }
+        const raw = await readBody(req);
+        let body;
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            sendJson(res, 400, { ok: false, error: 'invalid JSON' });
+            return;
+        }
+        const text = String(body.text ?? '').trim();
+        if (!text) {
+            sendJson(res, 400, { ok: false, error: 'empty' });
+            return;
+        }
+        try {
+            await ctx.bridge.send(text);
+            sendJson(res, 200, { ok: true });
+        }
+        catch (err) {
+            sendJson(res, 200, { ok: false, error: err instanceof Error ? err.message : String(err) });
+        }
+        return;
+    }
     if (req.method === 'GET' && url.pathname === '/api/forge/wizard-state') {
         const { readWizardState, markWizardCompleted } = await import('../core/wizard_state.js');
         let state = await readWizardState();