neuralos 3.3.8 → 3.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuralos",
-  "version": "3.3.8",
+  "version": "3.3.9",
   "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

@@ -1,12 +1,16 @@
 /**
- * monid-bridge — thin wrapper around the official Monid CLI.
+ * monid-bridge — thin wrapper around the official Monid CLI (v0.1.6).
  *
- * 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).
+ * Settings → Plugins → Monid (settings.monid): enabled, binaryPath, keyLabel
+ * API key is NEVER stored in settings.json (`monid keys add -k … -l …`).
  *
- * Agent tools: monid_health, monid_discover, monid_run.
+ * Agent tools: monid_health, monid_discover, monid_inspect, monid_run.
+ *
+ * Argv MUST match `monid <cmd> --help`:
+ *   discover --query <q> [--limit n] [--min-score s] --json
+ *   inspect  --provider <p> --endpoint <e> --json
+ *   run      --provider <p> --endpoint <e> [--input json] [--query json] [--path json] --json
+ * Bare `discover <query>` / `run <tool>` are false positives (CLI rejects them).
  */
 
 import { createRequire } from 'node:module'
@@ -23,25 +27,80 @@ export function resolveConfig(ctx = {}, env = process.env) {
   }
 }
 
-/** Build argv for a monid subcommand. Pure. */
+function reqStr(v, name) {
+  const s = String(v ?? '').trim()
+  if (!s) throw new Error(`${name} is required`)
+  return s
+}
+
+function optJsonFlag(argv, flag, value) {
+  if (value == null) return
+  const s = typeof value === 'string' ? value.trim() : JSON.stringify(value)
+  if (!s) return
+  argv.push(flag, s)
+}
+
+function optNumFlag(argv, flag, value) {
+  if (value == null || value === '') return
+  const n = Number(value)
+  if (!Number.isFinite(n)) throw new Error(`${flag} must be a number`)
+  argv.push(flag, String(n))
+}
+
+/**
+ * Build argv AFTER the binary name.
+ * Always pass --json so agents get structured output (no ANSI).
+ */
 export function buildMonidArgv(sub, params = {}) {
   switch (sub) {
     case 'version':
       return ['--version']
     case 'keys-list':
       return ['keys', 'list']
+    case 'whoami':
+      return ['whoami']
     case 'discover': {
-      const q = String(params.query || '').trim()
-      if (!q) throw new Error('monid_discover needs a query')
-      return ['discover', q]
+      const q = reqStr(params.query, 'query')
+      const argv = ['discover', '--query', q]
+      optNumFlag(argv, '--limit', params.limit)
+      optNumFlag(argv, '--min-score', params.minScore ?? params['min-score'])
+      argv.push('--json')
+      return argv
+    }
+    case 'inspect': {
+      const provider = reqStr(params.provider, 'provider')
+      const endpoint = reqStr(params.endpoint, 'endpoint')
+      return ['inspect', '--provider', provider, '--endpoint', endpoint, '--json']
     }
     case 'run': {
+      // FN: agents may pass tool="provider/endpoint" from older docs.
+      let provider = String(params.provider || '').trim()
+      let endpoint = String(params.endpoint || '').trim()
       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))
+      if ((!provider || !endpoint) && tool) {
+        const slash = tool.indexOf('/')
+        if (slash > 0) {
+          provider = provider || tool.slice(0, slash)
+          endpoint = endpoint || tool.slice(slash)
+        }
+      }
+      if (!provider) throw new Error('monid_run needs provider (slug from discover)')
+      if (!endpoint) throw new Error('monid_run needs endpoint (path from discover, e.g. /news/search)')
+      if (!endpoint.startsWith('/')) {
+        throw new Error('endpoint must start with / (Monid endpoint path, not a free-form tool name)')
+      }
+      const argv = ['run', '--provider', provider, '--endpoint', endpoint]
+      const input = params.input ?? params.body
+      if (input != null && String(input).trim()) {
+        argv.push('--input', typeof input === 'string' ? input : JSON.stringify(input))
       }
+      optJsonFlag(argv, '--query', params.queryParams ?? params.query)
+      optJsonFlag(argv, '--path', params.pathParams ?? params.path)
+      if (params.wait != null && params.wait !== false && params.wait !== '') {
+        argv.push('--wait')
+        if (params.wait !== true) argv.push(String(params.wait))
+      }
+      argv.push('--json')
       return argv
     }
     default:
@@ -49,21 +108,30 @@ export function buildMonidArgv(sub, params = {}) {
   }
 }
 
+/** True if argv looks like the broken 3.3.8 shapes (for tests / guards). */
+export function isLegacyBrokenArgv(argv) {
+  if (!Array.isArray(argv) || argv.length < 2) return false
+  if (argv[0] === 'discover' && argv[1] !== '--query' && !argv[1].startsWith('-')) return true
+  if (argv[0] === 'run' && argv[1] !== '--provider' && !String(argv[1]).startsWith('-')) return true
+  return false
+}
+
 async function runMonid(ctx, cfg, argv) {
+  const env = { ...process.env, NO_COLOR: '1' }
   if (typeof ctx.runCommand === 'function') {
-    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' ')
-    return ctx.runCommand({ command: cmdline })
+    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? JSON.stringify(a) : a)).join(' ')
+    return ctx.runCommand({ command: cmdline, env })
   }
   if (typeof ctx.exec === 'function') {
-    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' ')
-    return ctx.exec(cmdline)
+    const cmdline = [cfg.binaryPath, ...argv].map((a) => (/\s/.test(a) ? JSON.stringify(a) : a)).join(' ')
+    return ctx.exec(cmdline, { env })
   }
   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) => {
+    execFile(cfg.binaryPath, argv, { timeout: 120000, env }, (err, stdout, stderr) => {
       resolve({
         ok: !err,
-        exitCode: err?.code ?? 0,
+        exitCode: typeof err?.code === 'number' ? err.code : err ? 1 : 0,
         stdout: String(stdout ?? ''),
         stderr: String(stderr ?? ''),
         error: err ? String(err.message) : undefined,
@@ -80,7 +148,7 @@ async function guarded(fn, log) {
     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).',
+      hint: 'Install @monid-ai/cli (`npm i -g @monid-ai/cli`) and paste an API key in Settings → Plugins → Monid. discover needs --query; run needs --provider and --endpoint.',
     }
   }
 }
@@ -101,15 +169,19 @@ export function register(ctx) {
       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 }
+        const who = await runMonid(ctx, cfg, buildMonidArgv('whoami'))
+        return { binaryPath: cfg.binaryPath, keyLabel: cfg.keyLabel, version: ver, keys, whoami: who }
       }, 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.',
+    description:
+      'Search Monid data endpoints with natural language (company news, people, enrichment). Uses `monid discover --query`. Do not pass a bare positional query.',
     params: {
-      query: { type: 'string', description: 'What you need (e.g. "linkedin company employees")' },
+      query: { type: 'string', description: 'Natural-language search (required)' },
+      limit: { type: 'number', description: 'Max results (max 50)', optional: true },
+      minScore: { type: 'number', description: 'Minimum relevance score', optional: true },
     },
     handler: async (p) =>
       guarded(async () => {
@@ -119,12 +191,32 @@ export function register(ctx) {
       }, log),
   })
 
+  registerTool({
+    name: 'monid_inspect',
+    description: 'Get full details for one Monid endpoint (`monid inspect --provider --endpoint`).',
+    params: {
+      provider: { type: 'string', description: 'Provider slug (e.g. context.dev)' },
+      endpoint: { type: 'string', description: 'Endpoint path (e.g. /news/search)' },
+    },
+    handler: async (p) =>
+      guarded(async () => {
+        const argv = buildMonidArgv('inspect', 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.',
+    description:
+      'Execute a Monid endpoint (`monid run --provider --endpoint`). provider+endpoint from discover; optional JSON --input / --query / --path. Not `monid run <toolName>`.',
     params: {
-      tool: { type: 'string', description: 'Tool name from monid_discover' },
-      input: { type: 'string', description: 'JSON or text input for the tool', optional: true },
+      provider: { type: 'string', description: 'Provider slug', optional: true },
+      endpoint: { type: 'string', description: 'Endpoint path starting with /', optional: true },
+      tool: { type: 'string', description: 'Optional shorthand provider/endpoint', optional: true },
+      input: { type: 'string', description: 'Body JSON string', optional: true },
+      queryParams: { type: 'string', description: 'Query-parameters JSON string', optional: true },
+      pathParams: { type: 'string', description: 'Path-parameters JSON string', optional: true },
     },
     handler: async (p) =>
       guarded(async () => {

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

@@ -1,27 +1,75 @@
-import { buildMonidArgv, resolveConfig } from './index.mjs'
+import { buildMonidArgv, isLegacyBrokenArgv, resolveConfig } from './index.mjs'
 
 const assert = (c, m) => {
   if (!c) throw new Error(`assert failed: ${m}`)
 }
 
+// --- config ---
 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')
 
+// --- FP: 3.3.8 positional argv must be detected as broken ---
+assert(isLegacyBrokenArgv(['discover', 'company news']) === true, 'FP discover positional')
+assert(isLegacyBrokenArgv(['run', 'foo']) === true, 'FP run positional')
+assert(isLegacyBrokenArgv(['discover', '--query', 'company news']) === false, 'good discover')
+assert(isLegacyBrokenArgv(['run', '--provider', 'x', '--endpoint', '/y']) === false, 'good run')
+
+const disc = buildMonidArgv('discover', { query: 'company news', limit: 5 })
+assert(!isLegacyBrokenArgv(disc), 'new discover not legacy')
+assert(disc[0] === 'discover' && disc[1] === '--query' && disc[2] === 'company news', `disc=${disc}`)
+assert(disc.includes('--limit') && disc.includes('5') && disc.includes('--json'), 'limit+json')
+
 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')
+assert(buildMonidArgv('whoami').join(' ') === 'whoami', 'whoami')
+
+const insp = buildMonidArgv('inspect', { provider: 'context.dev', endpoint: '/news/search' })
+assert(insp.join(' ') === 'inspect --provider context.dev --endpoint /news/search --json', insp.join(' '))
+
+const run = buildMonidArgv('run', {
+  provider: 'context.dev',
+  endpoint: '/news/search',
+  input: '{"q":"acme"}',
+})
+assert(run[0] === 'run' && run.includes('--provider') && run.includes('context.dev'), 'run provider')
+assert(run.includes('--endpoint') && run.includes('/news/search'), 'run endpoint')
+assert(run.includes('--input') && run.includes('--json'), 'run input+json')
+assert(!isLegacyBrokenArgv(run), 'new run not legacy')
+
+// FN: tool="provider/endpoint" shorthand
+const fromTool = buildMonidArgv('run', { tool: 'apollo/mixed_companies/search' })
+assert(fromTool.includes('apollo') && fromTool.includes('/mixed_companies/search'), `fromTool=${fromTool}`)
 
+// FN: queryParams / pathParams
+const withQP = buildMonidArgv('run', {
+  provider: 'akta',
+  endpoint: '/v1/news',
+  queryParams: '{"q":"x"}',
+  pathParams: '{"id":"1"}',
+})
+assert(withQP.includes('--query') && withQP.includes('{"q":"x"}'), 'query flag')
+assert(withQP.includes('--path') && withQP.includes('{"id":"1"}'), 'path flag')
+
+// rejects
 let threw = false
-try { buildMonidArgv('discover', { query: '' }) } catch { threw = true }
-assert(threw, 'discover requires query')
+try { buildMonidArgv('discover', { query: '  ' }) } catch { threw = true }
+assert(threw, 'empty query')
+threw = false
+try { buildMonidArgv('run', { tool: 'not-a-path' }) } catch { threw = true }
+assert(threw, 'run without provider/endpoint')
 threw = false
-try { buildMonidArgv('run', {}) } catch { threw = true }
-assert(threw, 'run requires tool')
+try { buildMonidArgv('run', { provider: 'x', endpoint: 'news' }) } catch { threw = true }
+assert(threw, 'endpoint must start with /')
+threw = false
+try { buildMonidArgv('inspect', { provider: 'x' }) } catch { threw = true }
+assert(threw, 'inspect needs endpoint')
 threw = false
 try { buildMonidArgv('nope') } catch { threw = true }
 assert(threw, 'unknown sub')
+threw = false
+try { buildMonidArgv('discover', { query: 'q', limit: 'nope' }) } catch { threw = true }
+assert(threw, 'bad limit')
 
 console.log('monid-bridge: all cases passed')

package/plugins/monid-bridge/plugin.json

@@ -6,6 +6,7 @@
   "tools": [
     "monid_health",
     "monid_discover",
+    "monid_inspect",
     "monid_run"
   ],
   "permissions": [