rterm-backend 3.8.6 → 3.8.8

package/bin/gybackend.cjs

@@ -366235,6 +366235,15 @@ var AgentHelpers = class {
   setEventPublisher(publisher) {
     this.eventPublisher = publisher;
   }
+  /**
+   * Current event publisher (or null). Lets a runtime CHAIN onto the
+   * publisher temporarily — e.g. the plugin runAgentTask hook captures
+   * `say` events for one mesh-invoke session while passing everything
+   * through to the gateway's broadcast unchanged.
+   */
+  getEventPublisher() {
+    return this.eventPublisher;
+  }
   /**
    * Build a temporary history for the action model to make decisions.
    * This includes the last 3 special marker messages and recent execution details.
@@ -368273,6 +368282,11 @@ var AgentService_v2 = class {
   setEventPublisher(publisher) {
     this.helpers.setEventPublisher(publisher);
   }
+  /** Current event publisher (or null) — lets a runtime chain onto it
+   * temporarily (plugin runAgentTask hook) without replacing it. */
+  getEventPublisher() {
+    return this.helpers.getEventPublisher();
+  }
   /** Wire the connection manager so `manage_ssh_connection` can mutate saved
    * connections + notify the UI. Optional; only needed in full runtimes. */
   setConnectionManager(manager) {
@@ -392163,7 +392177,7 @@ var PluginRegistry = class {
   }
   /** Build the default PluginContext for a record (registers into the record's
    * capability lists; exec/readLedger/log are delegated to the injected fns). */
-  static defaultContext(record2, exec, readLedger, log, spawnProcess, getSettings) {
+  static defaultContext(record2, exec, readLedger, log, spawnProcess, getSettings, runAgentTask) {
     return {
       registerTool: (tool2) => {
         record2.tools.push(tool2);
@@ -392184,7 +392198,8 @@ var PluginRegistry = class {
       ...spawnProcess ? { spawnProcess } : {},
       ...getSettings ? { getSettings, get settings() {
         return getSettings();
-      } } : {}
+      } } : {},
+      ...runAgentTask ? { runAgentTask } : {}
     };
   }
 };
@@ -394723,7 +394738,50 @@ function createObservability(deps) {
         });
       },
       // Live settings snapshot for plugins that read config blocks (webIntel, agentspan, …).
-      () => deps.settingsService?.getSettings?.() ?? {}
+      () => deps.settingsService?.getSettings?.() ?? {},
+      // Real agent turns for plugins that serve an inbound `invoke` skill
+      // (reactorpro-bridge): a mesh peer sends a prompt, RTerm runs it as a
+      // genuine agent turn and the answer goes back over the mesh.
+      // Chained onto the agent's event publisher for the duration of the
+      // turn: `say` events for OUR session are captured, everything passes
+      // through to the original (gateway) publisher unchanged, and the
+      // publisher is restored in finally. dispatchTask resolves when the
+      // run completes, so the last captured `say` is the final answer.
+      deps.agentService ? async (prompt, opts) => {
+        const agent = deps.agentService;
+        const sessionId = opts?.sessionId ?? `mesh-invoke-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const timeoutMs = Math.min(Math.max(opts?.timeoutMs ?? 17e4, 5e3), 6e5);
+        const previous = agent.getEventPublisher();
+        const sayParts = [];
+        const chained = (sid, ev) => {
+          if (sid === sessionId && ev?.type === "say" && typeof ev.content === "string" && ev.content) {
+            sayParts.push(ev.content);
+          }
+          if (previous) {
+            try {
+              previous(sid, ev);
+            } catch {
+            }
+          }
+        };
+        agent.setEventPublisher(chained);
+        let timer;
+        try {
+          await Promise.race([
+            deps.gatewayService.dispatchTask(sessionId, prompt, void 0),
+            new Promise((_, reject) => {
+              timer = setTimeout(() => reject(new Error(`agent turn timed out after ${timeoutMs}ms`)), timeoutMs);
+            })
+          ]);
+        } finally {
+          if (timer) clearTimeout(timer);
+          agent.setEventPublisher((sid, ev) => {
+            if (previous) previous(sid, ev);
+          });
+        }
+        const answer = sayParts.join("");
+        return { ok: answer.trim() !== "", answer, sessionId };
+      } : void 0
     ),
     onLog: deps.onLog
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rterm-backend",
-  "version": "3.8.6",
+  "version": "3.8.8",
   "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 */ }
 
@@ -389,7 +406,7 @@ export async function register(ctx) {
     const nc = await connectMesh(ctx)
     const identity = loadOrCreateIdentity(cfg)
     const effCfg = { ...cfg, fingerprint: identity.fingerprint }
-    const serveCtx = { skills: skills ?? defaultServeSkills(effCfg, { startedAt }), identity, getSkills: () => serveCtx.skills }
+    const serveCtx = { skills: skills ?? defaultServeSkills(effCfg, { startedAt, runAgentTask: ctx.runAgentTask }), identity, getSkills: () => serveCtx.skills }
     if (responderStop) responderStop()
     responderStop = await startResponder(nc, effCfg, serveCtx, log)
     if (heartbeatStop) heartbeatStop()
@@ -409,7 +426,7 @@ export async function register(ctx) {
       skills: { type: 'object', description: 'Map of skillId -> async (input, ctx) => output (defaults to ping/describe/status/invoke)', optional: true },
     },
     handler: async (p) => guarded(async () => {
-      const base = defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg).fingerprint }, { startedAt })
+      const base = defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg).fingerprint }, { startedAt, runAgentTask: ctx.runAgentTask })
       const skills = p?.skills ?? base
       const served = await serveSkills(skills)
       return { serving: true, inbox: `${cfg.prefix}.agent.${cfg.agentId}.inbox`, skills: served, note: 'RTerm is now a full ReactorPro mesh citizen (responder + heartbeat + registry live)' }
@@ -470,7 +487,7 @@ export async function register(ctx) {
   if (cfg.enabled && cfg.autoServe) {
     setTimeout(() => {
       Promise.race([
-        serveSkills(defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg, log).fingerprint }, { startedAt })),
+        serveSkills(defaultServeSkills({ ...cfg, fingerprint: loadOrCreateIdentity(cfg, log).fingerprint }, { startedAt, runAgentTask: ctx.runAgentTask })),
         new Promise((_, reject) => setTimeout(() => reject(new Error('auto-serve connect timeout (5s)')), 5000)),
       ])
         .then((skills) => log(`[reactorpro] auto-started citizen on ${cfg.prefix}.agent.${cfg.agentId}.inbox (skills: ${skills.join(', ')})`))

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

@@ -26,8 +26,10 @@ import { join } from 'node:path'
 
 import {
   AUTH_KEYS,
+  buildManifest,
   buildRespond,
   checkIdentity,
+  defaultServeSkills,
   envelope,
   fingerprintFor,
   mintIdentity,
@@ -211,6 +213,140 @@ 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))}`)
+  }
+}
+
+// ─── A3. Inbound invoke skill (v3.8.8) ───────────────────────────────────────
+// Found live: the manifest ADVERTISED invoke but defaultServeSkills had no
+// handler, so a peer dispatching invoke got SKILL_NOT_FOUND while the
+// manifest promised it. These pin the corrected contract.
+
+{
+  // A3.1 invoke exists in the default skills and routes to runAgentTask.
+  const cfg = { agentId: 'rterm/xcheck/invoke', dispatchTimeout: 180000 }
+  const skills = defaultServeSkills(cfg, {
+    startedAt: Date.now(),
+    runAgentTask: async (prompt: string, opts?: { sessionId?: string; timeoutMs?: number }) => {
+      ok(prompt === 'Reply with exactly one word: PONG',
+        'invoke passes the prompt through to runAgentTask (arguments.prompt)',
+        JSON.stringify({ prompt }))
+      ok(typeof opts?.timeoutMs === 'number' && opts.timeoutMs === 170000,
+        'invoke stays under the mesh dispatch budget (dispatchTimeout - 10s)',
+        JSON.stringify(opts))
+      return { ok: true, answer: 'PONG', sessionId: 'mesh-invoke-test' }
+    },
+  })
+  ok(typeof skills.invoke === 'function', 'defaultServeSkills includes an invoke handler')
+
+  const r1 = await skills.invoke({ arguments: { prompt: 'Reply with exactly one word: PONG' } } as never)
+  ok(r1?.output === 'PONG', 'invoke returns the agent answer as output', JSON.stringify(r1))
+  ok(r1?.conversation_id === 'mesh-invoke-test', 'invoke returns conversation_id for session persistence')
+
+  // A3.2 prompt extraction: text/ prompt/ message all work.
+  const skills2 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async (prompt: string) => ({ ok: true, answer: `got:${prompt}`, sessionId: 's' }),
+  })
+  const viaText = await skills2.invoke({ text: 'hello' } as never)
+  ok(viaText?.output === 'got:hello', 'invoke extracts input.text')
+  const viaPrompt = await skills2.invoke({ prompt: 'hi' } as never)
+  ok(viaPrompt?.output === 'got:hi', 'invoke extracts input.prompt')
+  const viaString = await skills2.invoke('plain' as never)
+  ok(viaString?.output === 'got:plain', 'invoke extracts a bare string input')
+
+  // A3.3 conversation_id routes the follow-up to the same agent session.
+  const seenSessions: Array<string | undefined> = []
+  const skills3 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async (_p: string, o?: { sessionId?: string }) => {
+      seenSessions.push(o?.sessionId)
+      return { ok: true, answer: 'x', sessionId: o?.sessionId ?? 'new' }
+    },
+  })
+  const first = await skills3.invoke({ text: 'one' } as never)
+  // First call: no conversation_id yet -> the hook generates a session.
+  ok(seenSessions[0] === undefined, 'first invoke has no session yet (the hook mints one)')
+  await skills3.invoke({ text: 'two', conversation_id: first.conversation_id } as never)
+  ok(seenSessions[1] === first.conversation_id && first.conversation_id !== undefined,
+    'conversation_id reuses the same agent session on the follow-up',
+    JSON.stringify({ seenSessions, firstId: first.conversation_id }))
+
+  // A3.4 no runAgentTask hook -> a CLEAR error, not SKILL_NOT_FOUND.
+  const skills4 = defaultServeSkills({ agentId: 'a' }, {})
+  const r4 = await skills4.invoke({ text: 'x' } as never)
+  ok(r4?.error?.code === 3002 && String(r4?.error?.message).includes('INVOKE_UNAVAILABLE'),
+    'invoke without the runAgentTask hook returns INVOKE_UNAVAILABLE (not SKILL_NOT_FOUND)',
+    JSON.stringify(r4))
+
+  // A3.5 empty prompt -> a clear error.
+  const skills5 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async () => ({ ok: true, answer: 'should not run', sessionId: 's' }),
+  })
+  const r5 = await skills5.invoke({} as never)
+  ok(r5?.error?.code === 3003 && String(r5?.error?.message).includes('INVOKE_NEEDS_PROMPT'),
+    'invoke with no prompt returns INVOKE_NEEDS_PROMPT without running the agent',
+    JSON.stringify(r5))
+
+  // A3.6 a failed agent turn -> a retryable error carrying the reason.
+  const skills6 = defaultServeSkills({ agentId: 'a' }, {
+    runAgentTask: async () => ({ ok: false, answer: '', error: 'model offline', sessionId: 's' }),
+  })
+  const r6 = await skills6.invoke({ text: 'x' } as never)
+  ok(r6?.error?.code === 5001 && String(r6?.error?.message).includes('model offline'),
+    'a failed agent turn surfaces as a retryable error with the reason',
+    JSON.stringify(r6))
+}
+
 // ─── 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

@@ -224,6 +224,39 @@ export function defaultServeSkills(cfg, deps = {}) {
       skills: ['ping', 'describe', 'status', 'invoke'],
       uptime_seconds: Math.floor((Date.now() - (deps.startedAt ?? Date.now())) / 1000),
     }),
+    // `invoke` routes a prompt into a REAL RTerm agent turn (tools, policy,
+    // audit all apply) and returns the final assistant text. Requires the
+    // runAgentTask PluginContext hook — present on the daemon and desktop,
+    // absent in bare test harnesses. When absent, return a clear error
+    // instead of pretending: a peer must know invoke is unavailable here.
+    invoke: async (input = {}) => {
+      const runner = deps.runAgentTask
+      if (typeof runner !== 'function') {
+        return { error: { code: 3002, message: 'INVOKE_UNAVAILABLE: this runtime does not expose agent turns (runAgentTask hook absent)', retryable: false } }
+      }
+      const prompt = input?.arguments?.prompt
+        ?? input?.prompt
+        ?? input?.text
+        ?? input?.message
+        ?? (typeof input === 'string' ? input : '')
+      if (!prompt || !String(prompt).trim()) {
+        return { error: { code: 3003, message: 'INVOKE_NEEDS_PROMPT: pass arguments.prompt (or text)', retryable: false } }
+      }
+      const conversationId = typeof input?.conversation_id === 'string' ? input.conversation_id : undefined
+      const result = await runner(String(prompt), {
+        sessionId: conversationId,
+        // Stay under the mesh dispatch budget (180s default) so the reply
+        // reaches the caller before its own timeout fires.
+        timeoutMs: Math.max(5_000, (cfg.dispatchTimeout ?? 180_000) - 10_000),
+      })
+      if (!result?.ok) {
+        return { error: { code: 5001, message: result?.error || 'agent turn produced no answer', retryable: true } }
+      }
+      return {
+        output: result.answer,
+        conversation_id: result.sessionId,
+      }
+    },
     ...(deps.skills ?? {}),
   }
 }
@@ -299,31 +332,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 +388,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}`) }