neuralos 3.1.4 → 3.1.5

package/bin/gybackend.cjs

@@ -285128,24 +285128,41 @@ var init_natsEventBus = __esm({
         if (a.tlsCa) tls.ca = a.tlsCa;
         return tls;
       }
-      /** Connect to NATS (idempotent). Wires lifecycle event handlers. */
+      /** Connect to NATS (idempotent). Wires lifecycle event handlers.
+       * Concurrent callers share one in-flight attempt; a failed attempt clears the
+       * slot so the next call retries (no permanent half-connected state). */
+      connectPromise = null;
       async connect() {
-        if (this.conn) return;
-        const connectFn = this.opts.connectFn ?? ((o) => (0, import_transport_node.connect)(o));
-        const authenticator = this.buildAuthenticator();
-        const tls = this.buildTls();
-        const copts = {
-          servers: this.opts.servers,
-          name: this.opts.name ?? "rterm-backend",
-          ...authenticator ? { authenticator } : {},
-          ...tls ? { tls } : {},
-          ...this.opts.maxReconnectAttempts !== void 0 ? { maxReconnectAttempts: this.opts.maxReconnectAttempts } : {},
-          ...this.opts.reconnectTimeWait !== void 0 ? { reconnectTimeWait: this.opts.reconnectTimeWait } : {},
-          ...this.opts.timeout !== void 0 ? { timeout: this.opts.timeout } : {}
-        };
-        this.conn = await connectFn(copts);
-        this.wireStatusHandlers(this.conn);
-        this.log(`[nats] connected to ${Array.isArray(this.opts.servers) ? this.opts.servers.join(",") : this.opts.servers}`);
+        if (this.conn && !this.conn.isClosed()) return;
+        if (this.conn) {
+          this.conn = null;
+        }
+        if (this.connectPromise) return this.connectPromise;
+        const attempt = (async () => {
+          const connectFn = this.opts.connectFn ?? ((o) => (0, import_transport_node.connect)(o));
+          const authenticator = this.buildAuthenticator();
+          const tls = this.buildTls();
+          const copts = {
+            servers: this.opts.servers,
+            name: this.opts.name ?? "rterm-backend",
+            ...authenticator ? { authenticator } : {},
+            ...tls ? { tls } : {},
+            ...this.opts.maxReconnectAttempts !== void 0 ? { maxReconnectAttempts: this.opts.maxReconnectAttempts } : {},
+            ...this.opts.reconnectTimeWait !== void 0 ? { reconnectTimeWait: this.opts.reconnectTimeWait } : {},
+            ...this.opts.timeout !== void 0 ? { timeout: this.opts.timeout } : {}
+          };
+          const c = await connectFn(copts);
+          if (c.isClosed()) throw new Error("NATS connection closed immediately after connect");
+          this.conn = c;
+          this.wireStatusHandlers(c);
+          this.log(`[nats] connected to ${Array.isArray(this.opts.servers) ? this.opts.servers.join(",") : this.opts.servers}`);
+        })();
+        this.connectPromise = attempt;
+        try {
+          await attempt;
+        } finally {
+          this.connectPromise = null;
+        }
       }
       /** Attach reconnect/disconnect/error/lame-duck handlers (best-effort). */
       wireStatusHandlers(conn) {
@@ -289757,6 +289774,8 @@ function constructPort(Ctor, path32, opts) {
 }
 var SerialBackend = class {
   instances = /* @__PURE__ */ new Map();
+  /** ids whose port errored (removed from instances but remembered as 'failed'). */
+  failedIds = /* @__PURE__ */ new Set();
   /** For tests: inject a fake serialport constructor/factory. */
   static setSerialModuleForTest(mod) {
     injectedSerial = mod;
@@ -289811,7 +289830,10 @@ var SerialBackend = class {
     port.on("error", (err) => {
       instance.dataCallback?.(`\x1B[31m\u2718 Serial error: ${err.message}\x1B[0m\r
 `);
+      instance.failed = true;
       instance.exitCallback?.(-1);
+      this.instances.delete(ptyId);
+      this.failedIds.add(ptyId);
     });
     return Promise.resolve(ptyId);
   }
@@ -289822,6 +289844,7 @@ var SerialBackend = class {
   resize(_ptyId, _cols, _rows) {
   }
   kill(ptyId) {
+    this.failedIds.delete(ptyId);
     const inst = this.instances.get(ptyId);
     if (!inst) return;
     this.instances.delete(ptyId);
@@ -289853,8 +289876,9 @@ var SerialBackend = class {
   }
   getInitializationState(ptyId) {
     const inst = this.instances.get(ptyId);
-    if (!inst) return void 0;
-    return inst.ready ? "ready" : void 0;
+    if (inst) return inst.ready ? "ready" : void 0;
+    if (this.failedIds.has(ptyId)) return "failed";
+    return void 0;
   }
   // --- Serial-specific controls (v3.0.5) ---
   /** Send a BREAK signal (Cisco password recovery / ROMMON). Default 500ms. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "neuralos",
-  "version": "3.1.4",
-  "description": "Headless AI-native backend for RTerm / neuralOS — v3.1.4: synapse-bridge (Synapse mesh interop: discover/dispatch/register mesh agents) + numbat-bridge (Numbat endpoint AI-agent detection → triggers) plugins. 11 plugins total. Transports (SSH/serial/local), SQLite, and NATS libs install automatically.",
+  "version": "3.1.5",
+  "description": "Headless AI-native backend for RTerm / neuralOS — v3.1.5: latent connection-state bug fixes (NATS connect concurrency/DOA guard, synapse-bridge config-keyed connections, serial port error leak). 11 plugins. Transports (SSH/serial/local), SQLite, and NATS libs install automatically.",
   "main": "bin/gybackend.cjs",
   "bin": { "gybackend": "bin/gybackend.cjs" },
   "license": "MIT",

package/plugins/synapse-bridge/index.mjs

@@ -75,20 +75,47 @@ function buildAuthenticator(t, auth) {
   return undefined
 }
 
-let _conn = null
+// Connection cache keyed by config fingerprint — a settings change (different
+// server/auth/agentId) opens a NEW connection instead of reusing a stale one to
+// the wrong server. A failed connect clears the slot so the next call retries.
+const _conns = new Map() // key -> Promise<conn> | conn
+function _configKey(cfg) {
+  const servers = Array.isArray(cfg.servers) ? cfg.servers.join(',') : cfg.servers
+  const authKeys = cfg.auth ? Object.keys(cfg.auth).sort().join(',') : ''
+  return `${servers}|${cfg.agentId}|${authKeys}`
+}
+
 async function connectMesh(ctx) {
-  if (_conn && !_conn.isClosed()) return _conn
   const cfg = resolveConfig(ctx)
+  const key = _configKey(cfg)
+  const existing = _conns.get(key)
+  if (existing) {
+    const c = await existing
+    if (c && !c.isClosed()) return c
+    _conns.delete(key) // stale/closed — fall through and reconnect
+  }
   const t = loadTransport()
   const auth = buildAuthenticator(t, resolveAuth(ctx, cfg.auth))
   const copts = { servers: cfg.servers, name: cfg.agentId, ...(auth ? { authenticator: auth } : {}) }
   const connectFn = (typeof ctx.natsConnect === 'function') ? ctx.natsConnect : (o) => t.connect(o)
-  _conn = await connectFn(copts)
-  return _conn
+  const p = (async () => {
+    try {
+      return await connectFn(copts)
+    } catch (e) {
+      _conns.delete(key) // don't cache a failed attempt — allow retry
+      throw e
+    }
+  })()
+  _conns.set(key, p)
+  return p
 }
 
-/** Test hook: inject a fake connection. */
-export function __setConnForTest(c) { _conn = c }
+/** Test hook: inject a fake connection for a given config (or clear all with null). */
+export function __setConnForTest(c, cfg) {
+  if (c === null || c === undefined) { _conns.clear(); return }
+  const key = _configKey(cfg ?? resolveConfig({ settings: {} }))
+  _conns.set(key, Promise.resolve(c))
+}
 
 // ─── Synapse envelope ───────────────────────────────────────────────────────
 

package/plugins/synapse-bridge/synapse-bridge.extreme.spec.mjs

@@ -161,6 +161,51 @@ test('synapse_mesh_event trigger matches only synapse-source events', () => {
   assert(!t.match({}), 'rejects empty')
 })
 
+// ─── connection cache (config-keyed, the stale-connection bug fix) ──────────
+
+test('connection is keyed by config — a settings change opens a NEW connection (no stale reuse)', async () => {
+  __setConnForTest(null)
+  const connA = fakeConn()
+  const connB = fakeConn()
+  const connsMade = []
+  // ctx whose natsConnect returns a different fake per call, tracking which config connected
+  const mkCtxMulti = (settings) => ({
+    settings: { synapse: settings },
+    natsConnect: async (copts) => { connsMade.push(copts); return connsMade.length === 1 ? connA : connB },
+    registerTool: () => {}, registerTrigger: () => {}, registerPanel: () => {}, log: () => {},
+  })
+  // connect with config A (server A)
+  const { discoverAgents: dA } = await import('./index.mjs')
+  connA._on('mesh.registry.discover', () => [])
+  await dA(mkCtxMulti({ url: 'nats://a:4222' }), {})
+  if (connsMade.length !== 1) throw new Error(`expected 1 connection for config A, got ${connsMade.length}`)
+  // same config A again — must REUSE (no new connection)
+  await dA(mkCtxMulti({ url: 'nats://a:4222' }), {})
+  if (connsMade.length !== 1) throw new Error(`expected reuse for same config A, got ${connsMade.length} connections`)
+  // config B (different server) — must open a NEW connection (the bug was reusing A's)
+  connB._on('mesh.registry.discover', () => [])
+  await dA(mkCtxMulti({ url: 'nats://b:4222' }), {})
+  if (connsMade.length !== 2) throw new Error(`expected a NEW connection for config B, got ${connsMade.length}`)
+})
+
+test('a failed connect is not cached — the next call retries', async () => {
+  __setConnForTest(null)
+  const conn = fakeConn()
+  conn._on('mesh.registry.discover', () => [])
+  let attempts = 0
+  const ctx = {
+    settings: { synapse: { url: 'nats://a:4222' } },
+    natsConnect: async () => { attempts++; if (attempts === 1) throw new Error('down'); return conn },
+    registerTool: () => {}, registerTrigger: () => {}, registerPanel: () => {}, log: () => {},
+  }
+  const { discoverAgents } = await import('./index.mjs')
+  let threw = false
+  try { await discoverAgents(ctx, {}) } catch { threw = true }
+  if (!threw) throw new Error('expected first attempt to throw')
+  await discoverAgents(ctx, {}) // retry succeeds
+  if (attempts !== 2) throw new Error(`expected 2 attempts (fail + retry), got ${attempts}`)
+})
+
 // ─── runner ─────────────────────────────────────────────────────────────────
 async function main() {
   let pass = 0, fail = 0