rterm-backend 3.8.6 → 3.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rterm-backend",
-  "version": "3.8.6",
+  "version": "3.8.7",
   "description": "AI-native terminal & agentic-AI operations platform for Forward Deployed Engineers & SREs: AIOps closed-loop remediation, AI SRE, self-healing infrastructure, runbook automation, ChatOps; executes over SSH/WinRM/serial under policy with tamper-evident audit.",
   "keywords": [
     "forward-deployed-engineer",

package/plugins/reactorpro-bridge/index.mjs

@@ -185,13 +185,30 @@ export async function discoverPeers(ctx, filter = {}) {
         if (isPublishAck(msg.data)) continue
         const env = uj(msg.data)
         if (env?.type !== 'respond' || env?.from === cfg.agentId) continue
-        const m = env?.payload?.manifest ?? env?.payload
-        if (m?.identity || m?.id) replies.push(m)
+        // SHAPE: the gateway's handleDiscoverRequest replies with the BARE
+        // manifest as the payload (attachPayload(reply, manifest)), and a
+        // registry may reply with {agents:[...]}. manifestsFrom on the gateway
+        // side accepts both; so do we. Some peers may still nest under
+        // payload.manifest, so accept that legacy shape too.
+        const p = env?.payload
+        const candidates = Array.isArray(p?.agents) ? p.agents
+          : (p?.id || p?.identity) ? [p]
+          : (p?.manifest?.id || p?.manifest?.identity) ? [p.manifest]
+          : []
+        for (const m of candidates) {
+          const id = m?.id ?? m?.identity
+          if (id && id !== cfg.agentId) replies.push(m)
+        }
       } catch { /* ignore malformed */ }
     }
   })()
   loop.catch(() => {})
-  nc.publish(`${cfg.prefix}.registry.discover`, j(signed))
+  // BUG FIX (found live against the real gateway): the discover publish MUST
+  // carry a reply subject. The gateway's handleDiscoverRequest returns
+  // immediately when message.Reply == "" ("a discovery query with no reply
+  // subject cannot be answered"), so the old bare publish made discovery
+  // silently return zero peers even though every peer was listening.
+  nc.publish(`${cfg.prefix}.registry.discover`, j(signed), { reply: '_INBOX.discover' })
   await new Promise((r) => setTimeout(r, windowMs))
   try { replySub.unsubscribe() } catch { /* best-effort */ }
 

package/plugins/reactorpro-bridge/reactorpro-bridge.extreme.spec.mts

@@ -26,6 +26,7 @@ import { join } from 'node:path'
 
 import {
   AUTH_KEYS,
+  buildManifest,
   buildRespond,
   checkIdentity,
   envelope,
@@ -211,6 +212,61 @@ function ok(cond: unknown, label: string, note = ''): void {
   ok(threw, 'a tampered identity file is rejected on load')
 }
 
+// ─── A2. Manifest shape contract (the gateway's Manifest struct) ─────────────
+// Found live: the plugin sent `identity` where the gateway's Manifest
+// unmarshals `json:"id"`, and bare-string skills where the gateway expects
+// []{id,name,description} objects. manifestMatches drops a manifest whose ID
+// is empty, so the peer was INVISIBLE to gateway discovery. These pin the
+// corrected contract so it cannot regress.
+
+{
+  const cfg = { agentId: 'rterm/xcheck/manifest', name: 'XCheck', fingerprint: 'sha256:abc123' }
+  const m = buildManifest(cfg, ['ping', 'describe', 'status', 'invoke'])
+  ok(m.id === 'rterm/xcheck/manifest',
+    'manifest uses id (json:"id") — the gateway drops a manifest with empty ID',
+    JSON.stringify(Object.keys(m)))
+  ok(!('identity' in m), 'manifest must NOT carry a legacy identity key')
+  ok(m.name === 'XCheck', 'manifest name is the display name')
+  ok(Array.isArray(m.capabilities) && m.capabilities.includes('rterm'),
+    'manifest advertises the rterm capability')
+  ok(Array.isArray(m.skills) && m.skills.length === 4
+    && m.skills.every((s: { id: string }) => typeof s?.id === 'string'),
+    'skills are []{id,...} objects, not bare strings (the gateway Skill struct unmarshals objects)',
+    JSON.stringify(m.skills))
+  ok(m.fingerprint === 'sha256:abc123', 'manifest carries the fingerprint for TOFU pinning')
+  ok(Array.isArray(m.local_agents) && m.local_agents[0]?.id === cfg.agentId,
+    'local_agents entries use id too')
+}
+
+// A string skill list must be normalized to objects without dropping any.
+{
+  const m = buildManifest({ agentId: 'a' }, ['ping', 'status'])
+  ok(m.skills.length === 2 && m.skills[0].id === 'ping' && m.skills[1].id === 'status',
+    'string skill ids normalize to {id,name} objects in order')
+}
+
+// A discover reply in the GATEWAY's bare-manifest shape must be accepted by
+// the plugin's parser (the old parser only read payload.manifest). The
+// candidates logic lives inline in discoverPeers; this pins the accepted
+// payload shapes by constructing them the way the gateway does.
+{
+  const bare = { id: 'gateway/edge-1', name: 'Edge', skills: [{ id: 'ping' }] }
+  const agents = { agents: [{ id: 'gateway/edge-2', name: 'Edge2' }] }
+  const legacy = { manifest: { id: 'old/peer', name: 'Old' } }
+  const shapes = [bare, agents, legacy]
+  for (const p of shapes) {
+    const candidates = Array.isArray((p as { agents?: unknown[] }).agents)
+      ? (p as { agents: unknown[] }).agents
+      : ((p as { id?: string }).id || (p as { identity?: string }).identity)
+        ? [p]
+        : ((p as { manifest?: { id?: string } }).manifest?.id
+          || (p as { manifest?: { identity?: string } }).manifest?.identity)
+          ? [(p as { manifest: unknown }).manifest]
+          : []
+    ok(candidates.length > 0, `discover parser accepts payload shape ${JSON.stringify(Object.keys(p))}`)
+  }
+}
+
 // ─── B. Go cross-check against the REAL gateway ──────────────────────────────
 
 const RP_CHECKOUT = process.env.RP_CHECKOUT ?? join(process.env.HOME ?? '', 'work', 'ReactorPro')

package/plugins/reactorpro-bridge/reactorproAgent.mjs

@@ -299,31 +299,50 @@ export function startHeartbeat(nc, cfg, identity, intervalMs = 30000, log = () =
 
 // ─── 5. REGISTRY ─────────────────────────────────────────────────────────────
 
-/** The manifest this RTerm advertises. */
+/** The manifest this RTerm advertises.
+ *
+ * SHAPE CONTRACT (mirrors the gateway's Manifest struct, envelope.go:146):
+ *   id            — json:"id" (NOT "identity"; manifestMatches drops a
+ *                   manifest whose ID is empty, so the old `identity` key made
+ *                   this peer invisible to gateway discovery)
+ *   skills        — []{id, name?, description?} objects, NOT bare strings
+ *                   (the gateway's Skill struct unmarshals objects)
+ *   fingerprint   — json:"fingerprint,omitempty" — pins trust-on-first-use
+ * The register/discover payloads are the BARE manifest (the gateway's
+ * Register/handleDiscoverRequest both attachPayload(manifest) directly), so
+ * callers must not nest it under a "manifest" key. */
 export function buildManifest(cfg, skillIds) {
+  const skills = (skillIds ?? []).map((s) =>
+    typeof s === 'string' ? { id: s, name: s } : s)
   return {
-    identity: cfg.agentId,
+    id: cfg.agentId,
     name: cfg.name ?? cfg.agentId,
     capabilities: ['rterm', 'agent', ...(cfg.capabilities ?? [])],
-    skills: skillIds,
+    skills,
     fingerprint: cfg.fingerprint ?? null,
     local_agents: [{ id: cfg.agentId, name: cfg.name ?? cfg.agentId, capabilities: ['rterm', 'agent'] }],
   }
 }
 
-/** Register with the mesh registry (mesh.registry.register). */
+/** Register with the mesh registry (mesh.registry.register).
+ * Payload is the BARE manifest — the gateway's Register does
+ * attachPayload(envelope, a.Manifest()) with no wrapper object. */
 export function registerManifest(nc, cfg, identity, manifest) {
-  const env = envelope('register', { manifest }, cfg, { to: 'REGISTRY' })
+  const env = envelope('register', manifest, cfg, { to: 'REGISTRY' })
   nc.publish(`${cfg.prefix}.registry.register`, j(signEnvelope(env, identity)))
 }
 
 /** Graceful exit. */
 export function deregisterManifest(nc, cfg, identity) {
-  const env = envelope('register', { manifest: { identity: cfg.agentId, gone: true } }, cfg, { to: 'REGISTRY' })
+  const env = envelope('register', { id: cfg.agentId, gone: true }, cfg, { to: 'REGISTRY' })
   nc.publish(`${cfg.prefix}.registry.deregister`, j(signEnvelope(env, identity)))
 }
 
-/** Answer discovery broadcasts with our manifest. */
+/** Answer discovery broadcasts with our manifest.
+ * The reply payload is the BARE manifest — the gateway's
+ * handleDiscoverRequest does attachPayload(reply, manifest), and its
+ * manifestsFrom accepts either {agents:[...]} or a bare manifest with
+ * id != "". Nesting under "manifest" would make it invisible. */
 export async function answerDiscovery(nc, cfg, identity, manifest, log = () => {}) {
   const subject = `${cfg.prefix}.registry.discover`
   const sub = nc.subscribe(subject)
@@ -336,7 +355,7 @@ export async function answerDiscovery(nc, cfg, identity, manifest, log = () => {
         const req = uj(msg.data)
         if (req?.from === cfg.agentId) continue // don't answer ourselves
         if (msg.reply) {
-          const env = envelope('respond', { manifest }, cfg, { to: req?.from, in_reply_to: req?.id })
+          const env = envelope('respond', manifest, cfg, { to: req?.from, in_reply_to: req?.id })
           nc.publish(msg.reply, j(signEnvelope(env, identity)))
         }
       } catch (e) { log(`[reactorpro] discovery answer failed: ${e?.message ?? e}`) }