neuralos 3.3.6 → 3.3.8

package/bin/gybackend.cjs

@@ -377393,6 +377393,7 @@ function pickBackendSnapshot(raw) {
     nats: raw.nats,
     synapse: raw.synapse,
     numbat: raw.numbat,
+    monid: raw.monid,
     gateway: raw.gateway,
     layout: raw.layout,
     recursionLimit: raw.recursionLimit,
@@ -377476,6 +377477,7 @@ function normalizeBackendSettings(settings) {
   next.nats = normalizeNatsSettings(next.nats);
   next.synapse = normalizeSynapseSettings(next.synapse);
   next.numbat = normalizeNumbatSettings(next.numbat);
+  next.monid = normalizeMonidSettings(next.monid);
   next.schemaVersion = BACKEND_SETTINGS_SCHEMA_VERSION;
   return next;
 }
@@ -377730,6 +377732,16 @@ function normalizeNumbatSettings(raw) {
     ...minSeverity ? { minSeverity } : {}
   };
 }
+function normalizeMonidSettings(raw) {
+  const src = isObject5(raw) ? raw : {};
+  const binaryPath = typeof src.binaryPath === "string" && src.binaryPath.trim() ? src.binaryPath.trim() : void 0;
+  const keyLabel = typeof src.keyLabel === "string" && src.keyLabel.trim() ? src.keyLabel.trim() : void 0;
+  return {
+    enabled: src.enabled !== false,
+    ...binaryPath ? { binaryPath } : {},
+    ...keyLabel ? { keyLabel } : {}
+  };
+}
 function migrateBackendToV3(settings) {
   const next = { ...settings };
   delete next.language;
@@ -395968,8 +395980,29 @@ var ResourceMonitorService = class {
   sessions = /* @__PURE__ */ new Map();
   sourceKeyByTerminalId = /* @__PURE__ */ new Map();
   publisher = null;
+  /** Extra listeners (UI window registry, triggers, observability). Fan-out so
+   * later setPublisher callers cannot steal snapshots from earlier ones. */
+  extraPublishers = [];
   setPublisher(publisher) {
-    this.publisher = publisher;
+    if (!this.publisher) {
+      this.publisher = publisher;
+      return;
+    }
+    if (this.publisher === publisher) return;
+    if (!this.extraPublishers.includes(publisher)) {
+      this.extraPublishers.push(publisher);
+    }
+  }
+  emitSnapshot(channel, data) {
+    const pubs = [this.publisher, ...this.extraPublishers].filter(
+      (p) => typeof p === "function"
+    );
+    for (const pub of pubs) {
+      try {
+        pub(channel, data);
+      } catch {
+      }
+    }
   }
   start(terminalId, ownerId = "default", intervalMs) {
     const normalizedTerminalId = String(terminalId || "").trim();
@@ -396191,14 +396224,12 @@ var ResourceMonitorService = class {
       const sourceTerminalId = session.sourceTerminalId || terminalIds[0];
       const snapshot = await this.collectSnapshot(sourceTerminalId);
       session.lastCollectAt = Date.now();
-      if (this.publisher) {
-        terminalIds.forEach((terminalId) => {
-          this.publisher?.(
-            "monitor:snapshot",
-            terminalId === snapshot.terminalId ? snapshot : { ...snapshot, terminalId }
-          );
-        });
-      }
+      terminalIds.forEach((terminalId) => {
+        this.emitSnapshot(
+          "monitor:snapshot",
+          terminalId === snapshot.terminalId ? snapshot : { ...snapshot, terminalId }
+        );
+      });
     } finally {
       session.inFlight = false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuralos",
-  "version": "3.3.6",
+  "version": "3.3.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/monid-bridge/index.mjs

@@ -0,0 +1,136 @@
+/**
+ * monid-bridge — thin wrapper around the official Monid CLI.
+ *
+ * Settings → Plugins → Monid (settings.monid):
+ *   enabled, binaryPath, keyLabel
+ * The API key is NEVER stored in settings.json. Saving a key in the UI runs
+ * `monid keys add -k <key> -l <label>` (see applyMonidApiKey).
+ *
+ * Agent tools: monid_health, monid_discover, monid_run.
+ */
+
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+
+export function resolveConfig(ctx = {}, env = process.env) {
+  const s = (typeof ctx.getSettings === 'function' ? ctx.getSettings() : ctx.settings) || {}
+  const b = s.monid || {}
+  return {
+    enabled: b.enabled !== false,
+    binaryPath: b.binaryPath || env.MONID_BIN || 'monid',
+    keyLabel: b.keyLabel || 'rterm',
+  }
+}
+
+/** Build argv for a monid subcommand. Pure. */
+export function buildMonidArgv(sub, params = {}) {
+  switch (sub) {
+    case 'version':
+      return ['--version']
+    case 'keys-list':
+      return ['keys', 'list']
+    case 'discover': {
+      const q = String(params.query || '').trim()
+      if (!q) throw new Error('monid_discover needs a query')
+      return ['discover', q]
+    }
+    case 'run': {
+      const tool = String(params.tool || '').trim()
+      if (!tool) throw new Error('monid_run needs a tool name')
+      const argv = ['run', tool]
+      if (params.input != null && String(params.input).trim()) {
+        argv.push('--input', String(params.input))
+      }
+      return argv
+    }
+    default:
+      throw new Error(`unknown monid subcommand: ${sub}`)
+  }
+}
+
+async function runMonid(ctx, cfg, argv) {
+  if (typeof ctx.runCommand === 'function') {
+    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' ')
+    return ctx.runCommand({ command: cmdline })
+  }
+  if (typeof ctx.exec === 'function') {
+    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' ')
+    return ctx.exec(cmdline)
+  }
+  const { execFile } = require('node:child_process')
+  return new Promise((resolve) => {
+    execFile(cfg.binaryPath, argv, { timeout: 120000, env: { ...process.env, NO_COLOR: '1' } }, (err, stdout, stderr) => {
+      resolve({
+        ok: !err,
+        exitCode: err?.code ?? 0,
+        stdout: String(stdout ?? ''),
+        stderr: String(stderr ?? ''),
+        error: err ? String(err.message) : undefined,
+      })
+    })
+  })
+}
+
+async function guarded(fn, log) {
+  try {
+    return await fn()
+  } catch (e) {
+    const msg = e?.message ?? String(e)
+    log?.(`[monid] ${msg}`)
+    return {
+      error: msg,
+      hint: 'Install @monid-ai/cli (`npm i -g @monid-ai/cli`) and paste an API key in Settings → Plugins → Monid (https://app.monid.ai/access/api-keys).',
+    }
+  }
+}
+
+export function register(ctx) {
+  const { registerTool, log } = ctx
+  const cfg = resolveConfig(ctx)
+  if (!cfg.enabled) {
+    log?.('[monid] disabled in settings.monid.enabled')
+    return
+  }
+
+  registerTool({
+    name: 'monid_health',
+    description: 'Check the Monid CLI is installed and list configured key labels (never the secret).',
+    params: {},
+    handler: async () =>
+      guarded(async () => {
+        const ver = await runMonid(ctx, cfg, buildMonidArgv('version'))
+        const keys = await runMonid(ctx, cfg, buildMonidArgv('keys-list'))
+        return { binaryPath: cfg.binaryPath, keyLabel: cfg.keyLabel, version: ver, keys }
+      }, log),
+  })
+
+  registerTool({
+    name: 'monid_discover',
+    description: 'Discover Monid tools/endpoints for a task (web data, enrichment, social, company/people). Use before writing a scraper or when a generic fetch is not enough.',
+    params: {
+      query: { type: 'string', description: 'What you need (e.g. "linkedin company employees")' },
+    },
+    handler: async (p) =>
+      guarded(async () => {
+        const argv = buildMonidArgv('discover', p)
+        const r = await runMonid(ctx, cfg, argv)
+        return { argv: [cfg.binaryPath, ...argv], ...r }
+      }, log),
+  })
+
+  registerTool({
+    name: 'monid_run',
+    description: 'Run a named Monid tool with optional JSON/text input. Prefer this over hand-rolled scrapers when discover returned a tool.',
+    params: {
+      tool: { type: 'string', description: 'Tool name from monid_discover' },
+      input: { type: 'string', description: 'JSON or text input for the tool', optional: true },
+    },
+    handler: async (p) =>
+      guarded(async () => {
+        const argv = buildMonidArgv('run', p)
+        const r = await runMonid(ctx, cfg, argv)
+        return { argv: [cfg.binaryPath, ...argv], ...r }
+      }, log),
+  })
+}

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

@@ -0,0 +1,27 @@
+import { buildMonidArgv, resolveConfig } from './index.mjs'
+
+const assert = (c, m) => {
+  if (!c) throw new Error(`assert failed: ${m}`)
+}
+
+assert(resolveConfig({ settings: {} }).enabled === true, 'enabled default')
+assert(resolveConfig({ settings: { monid: { enabled: false } } }).enabled === false, 'disabled')
+assert(resolveConfig({ settings: { monid: { binaryPath: '/opt/monid' } } }).binaryPath === '/opt/monid', 'bin')
+assert(resolveConfig({}, { MONID_BIN: 'custom-monid' }).binaryPath === 'custom-monid', 'env bin')
+
+assert(buildMonidArgv('version').join(' ') === '--version', 'version')
+assert(buildMonidArgv('keys-list').join(' ') === 'keys list', 'keys list')
+assert(buildMonidArgv('discover', { query: 'company news' }).join(' ') === 'discover company news', 'discover')
+assert(buildMonidArgv('run', { tool: 'foo', input: '{"a":1}' }).join(' ') === 'run foo --input {"a":1}', 'run')
+
+let threw = false
+try { buildMonidArgv('discover', { query: '' }) } catch { threw = true }
+assert(threw, 'discover requires query')
+threw = false
+try { buildMonidArgv('run', {}) } catch { threw = true }
+assert(threw, 'run requires tool')
+threw = false
+try { buildMonidArgv('nope') } catch { threw = true }
+assert(threw, 'unknown sub')
+
+console.log('monid-bridge: all cases passed')

package/plugins/monid-bridge/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "monid-bridge",
+  "version": "1.0.0",
+  "description": "Thin Monid CLI bridge: paste an API key in Settings → Plugins; agents get monid_discover / monid_run / monid_health wrapping the official CLI. Does not reimplement TinyFish.",
+  "entry": "index.mjs",
+  "tools": [
+    "monid_health",
+    "monid_discover",
+    "monid_run"
+  ],
+  "permissions": [
+    "exec"
+  ]
+}