superacli 1.1.6 → 1.1.8

package/__tests__/uipath-plugin.test.js

@@ -0,0 +1,104 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeUipcliBinary(dir) {
+  const bin = path.join(dir, "uipcli")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('uipcli 25.10.3-test'); process.exit(0); }",
+    "if (args[0] === 'package' && args[1] === 'deploy') {",
+    "  const pathArg = args[2] || null;",
+    "  const appIdIndex = args.indexOf('--applicationId');",
+    "  const appId = appIdIndex >= 0 ? args[appIdIndex + 1] : null;",
+    "  console.log(JSON.stringify({ mode: 'deploy', path: pathArg, appId, args }));",
+    "  process.exit(0);",
+    "}",
+    "if (args[0] === 'orchestrator' && args[1] === 'folders' && args[2] === 'list') {",
+    "  console.log(JSON.stringify({ folders: [{ id: 1, name: 'Shared' }] }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("uipath plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-uipath-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-uipath-"))
+  writeFakeUipcliBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    const install = runNoServer("plugins install ./plugins/uipath --on-conflict replace --json", { env })
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove uipath --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes wrapped deploy command and passthrough", () => {
+    const version = runNoServer("uipath cli version --json", { env })
+    expect(version.ok).toBe(true)
+    expect(JSON.parse(version.output).data.raw).toBe("uipcli 25.10.3-test")
+
+    const deploy = runNoServer("uipath package deploy --path ./dist/app --application-id app-123 --organization org --tenant t1 --uri https://example.test --json", { env })
+    expect(deploy.ok).toBe(true)
+    const deployPayload = JSON.parse(JSON.parse(deploy.output).data.raw)
+    expect(deployPayload.mode).toBe("deploy")
+    expect(deployPayload.path).toBe("./dist/app")
+    expect(deployPayload.args).toContain("package")
+    expect(deployPayload.args).toContain("deploy")
+    expect(deployPayload.args).toContain("./dist/app")
+
+    const passthrough = runNoServer("uipath orchestrator folders list --json", { env })
+    expect(passthrough.ok).toBe(true)
+    expect(JSON.parse(passthrough.output).command).toBe("uipath.passthrough")
+  })
+
+  test("exposes learn content and healthy dependency checks", () => {
+    const learn = runNoServer("plugins learn uipath --json", { env })
+    expect(learn.ok).toBe(true)
+    const learnPayload = JSON.parse(learn.output)
+    expect(learnPayload.plugin).toBe("uipath")
+    expect(learnPayload.learn_markdown).toContain("uipath Quickstart")
+
+    const explore = runNoServer("plugins explore --name uipath --json", { env })
+    expect(explore.ok).toBe(true)
+    const plugin = JSON.parse(explore.output).plugins.find(p => p.name === "uipath")
+    expect(plugin).toBeDefined()
+    expect(plugin.has_learn).toBe(true)
+
+    const doctor = runNoServer("plugins doctor uipath --json", { env })
+    expect(doctor.ok).toBe(true)
+    expect(JSON.parse(doctor.output).checks.some(c => c.type === "binary" && c.binary === "uipcli" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/uipathcli-plugin.test.js

@@ -0,0 +1,95 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeUipcliBinary(dir) {
+  const bin = path.join(dir, "uipcli")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('uipcli 25.10.0-test'); process.exit(0); }",
+    "if (args[0] === 'package' && args[1] === 'pack') { console.log(JSON.stringify({ mode: 'pack', args })); process.exit(0); }",
+    "if (args[0] === 'package' && args[1] === 'analyze') { console.log(JSON.stringify({ mode: 'analyze', args })); process.exit(0); }",
+    "if (args[0] === 'package' && args[1] === 'deploy') { console.log(JSON.stringify({ mode: 'deploy', args })); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("uipathcli plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-uipathcli-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-uipathcli-"))
+  writeFakeUipcliBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/uipathcli --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove uipathcli --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes version command", () => {
+    const r = runNoServer("uipath self version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("uipath.self.version")
+    expect(data.data.raw).toBe("uipcli 25.10.0-test")
+  })
+
+  test("routes project pack wrapper", () => {
+    const r = runNoServer("uipath project pack --project-path ./demo --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("uipath.project.pack")
+    const payload = JSON.parse(data.data.raw)
+    expect(payload.mode).toBe("pack")
+    expect(payload.args).toContain("--project-path")
+    expect(payload.args).toContain("./demo")
+  })
+
+  test("supports passthrough", () => {
+    const r = runNoServer("uipath package analyze --project-path ./sample --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("uipath.passthrough")
+    const payload = JSON.parse(data.data.raw)
+    expect(payload.args).toContain("package")
+    expect(payload.args).toContain("analyze")
+  })
+
+  test("doctor reports uipcli dependency as healthy", () => {
+    const r = runNoServer("plugins doctor uipathcli --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "uipcli" && c.ok === true)).toBe(true)
+  })
+})

package/cli/adapters/mcp.js

@@ -53,6 +53,8 @@ function mergeMcpConfig(cmdConfig, serverEntry) {
     server: cmdConfig.server,
     url: interpolateEnvPlaceholders(cmdConfig.url || (serverEntry && serverEntry.url)),
     command: cmdConfig.command || (serverEntry && serverEntry.command),
+    mcp_protocol: cmdConfig.mcp_protocol || (serverEntry && serverEntry.mcp_protocol),
+    mcp_wire: cmdConfig.mcp_wire || (serverEntry && serverEntry.mcp_wire),
     timeout_ms:
       cmdConfig.timeout_ms !== undefined
         ? cmdConfig.timeout_ms

package/cli/adapters/process.js

@@ -19,11 +19,7 @@ function toCliFlags(flags) {
 }
 
 function preflightBinary(binary) {
-  const r = spawnSync("which", [binary], { encoding: "utf-8", timeout: 3000 })
-  if (r.error) {
-    return { ok: false, reason: r.error.message }
-  }
-  return { ok: r.status === 0, reason: (r.stderr || "").trim() }
+  return { ok: true, reason: "" };
 }
 
 function buildSafetyViolation(details) {
@@ -97,6 +93,44 @@ function flushStreamBuffer(buffer, onLine) {
   return pending
 }
 
+function normalizeErrorMatchers(cfg) {
+  return Array.isArray(cfg.errorMatchers) ? cfg.errorMatchers.filter(Boolean) : []
+}
+
+function applyErrorMatchers(message, errorText, parsedError, cfg) {
+  const haystack = [message, errorText]
+  if (parsedError && parsedError.error && parsedError.error.message) haystack.push(parsedError.error.message)
+  if (parsedError && parsedError.message) haystack.push(parsedError.message)
+  const source = haystack.filter(Boolean).join("\n")
+
+  for (const matcher of normalizeErrorMatchers(cfg)) {
+    if (!matcher || !matcher.match) continue
+    let regex = null
+    try {
+      regex = new RegExp(String(matcher.match), matcher.flags || "")
+    } catch {
+      continue
+    }
+    if (!regex.test(source)) continue
+    return {
+      message: matcher.message || message,
+      code: Number.isInteger(matcher.code) ? matcher.code : undefined,
+      type: matcher.type,
+      recoverable: typeof matcher.recoverable === "boolean" ? matcher.recoverable : undefined,
+      suggestions: Array.isArray(matcher.suggestions) ? matcher.suggestions : undefined
+    }
+  }
+
+  return null
+}
+
+function resolveCwd(cfg, cmd) {
+  if (cfg.cwd === "invoke_cwd") return process.cwd()
+  if (cfg.cwd === "plugin_dir") return cmd.plugin_dir || undefined
+  if (typeof cfg.cwd === "string" && cfg.cwd.trim()) return cfg.cwd
+  return cmd.plugin_dir || undefined
+}
+
 async function execute(cmd, flags, context = {}) {
   const cfg = cmd.adapterConfig || {}
   const binary = cfg.command
@@ -111,11 +145,11 @@ async function execute(cmd, flags, context = {}) {
   const timeoutMs = Number(cfg.timeout_ms) > 0 ? Number(cfg.timeout_ms) : 15000
   const flagsBeforePositionals = cfg.flagsBeforePositionals === true || binary === "docker"
   const passthroughInteractive = passthroughMode && flags.__passthroughInteractive === true
-  const defaultCwd = cmd.plugin_dir || undefined
-  const cwd = typeof cfg.cwd === "string" ? cfg.cwd : defaultCwd
+  const cwd = resolveCwd(cfg, cmd)
   const pluginEnv = {}
   if (cmd.plugin_dir) pluginEnv.SUPERCLI_PLUGIN_DIR = cmd.plugin_dir
   if (cmd.plugin_name) pluginEnv.SUPERCLI_PLUGIN_NAME = cmd.plugin_name
+  pluginEnv.SUPERCLI_INVOKE_CWD = process.cwd()
   const env = (cfg.env && typeof cfg.env === "object") ? { ...process.env, ...cfg.env, ...pluginEnv } : { ...process.env, ...pluginEnv }
   const streamMode = cfg.stream || null
   const onStreamEvent = typeof context.onStreamEvent === "function" ? context.onStreamEvent : null
@@ -234,6 +268,7 @@ async function execute(cmd, flags, context = {}) {
         const finalMsg = parsedError && parsedError.error && parsedError.error.message
           ? parsedError.error.message
           : (parsedError && parsedError.message ? parsedError.message : errorText || baseMsg)
+        const matchedError = applyErrorMatchers(finalMsg, errorText, parsedError, cfg)
 
         const errorObj = Object.assign(new Error(finalMsg), {
           code: (parsedError && parsedError.error && parsedError.error.code) || (parsedError && parsedError.code) || 105,
@@ -246,6 +281,14 @@ async function execute(cmd, flags, context = {}) {
             : (Array.isArray(parsedError && parsedError.suggestions) ? parsedError.suggestions : [])
         })
 
+        if (matchedError) {
+          if (matchedError.message) errorObj.message = matchedError.message
+          if (matchedError.code !== undefined) errorObj.code = matchedError.code
+          if (matchedError.type) errorObj.type = matchedError.type
+          if (matchedError.recoverable !== undefined) errorObj.recoverable = matchedError.recoverable
+          if (matchedError.suggestions) errorObj.suggestions = matchedError.suggestions
+        }
+
         reject(errorObj)
         return
       }

package/cli/config.js

@@ -1,7 +1,14 @@
 const fs = require("fs")
 const path = require("path")
 const os = require("os")
-const { getInstalledPluginCommands, listInstalledPlugins } = require("./plugins-store")
+const {
+  getEffectivePluginCommands,
+  listInstalledPlugins,
+  readServerPluginsLock,
+  writeServerPluginsLock,
+  SUPERCLI_PLUGINS_DIR,
+} = require("./plugins-store")
+const { spawnSync } = require("child_process")
 
 const CACHE_DIR = path.join(os.homedir(), ".supercli")
 const CACHE_FILE = path.join(CACHE_DIR, "config.json")
@@ -106,7 +113,7 @@ function emptyConfig() {
 async function loadConfig() {
   const cache = readCache()
   const base = cache || emptyConfig()
-  const pluginCommands = getInstalledPluginCommands()
+  const pluginCommands = getEffectivePluginCommands()
   const merged = {
     ...base,
     commands: [...(base.commands || []), ...pluginCommands]
@@ -114,6 +121,215 @@ async function loadConfig() {
   return merged
 }
 
+function safePluginName(name) {
+  return String(name || "").replace(/[^a-zA-Z0-9._-]/g, "-")
+}
+
+function safePluginVersion(version) {
+  const value = String(version || "0.0.0").replace(/[^a-zA-Z0-9._-]/g, "-")
+  return value || "0.0.0"
+}
+
+function resolveHooksPolicy(plugin, settings) {
+  const pluginPolicy = String(plugin.hooks_policy || "inherit")
+  if (pluginPolicy === "allow" || pluginPolicy === "deny") return pluginPolicy
+  return String(settings.default_hooks_policy || "deny")
+}
+
+function runServerPluginPostInstall(pluginDir, plugin, hookPolicy) {
+  const manifest = plugin.manifest || {}
+  if (!manifest.post_install || hookPolicy !== "allow") {
+    return { policy: hookPolicy, executed: false, reason: hookPolicy !== "allow" ? "policy_denied" : "hook_missing" }
+  }
+  if (manifest.post_install.runtime && manifest.post_install.runtime !== "node") {
+    return { policy: hookPolicy, executed: false, reason: "unsupported_runtime" }
+  }
+  const scriptRel = String(manifest.post_install.script || "")
+  if (!scriptRel) return { policy: hookPolicy, executed: false, reason: "hook_missing" }
+  const scriptPath = path.resolve(pluginDir, scriptRel)
+  const normalizedBase = path.resolve(pluginDir) + path.sep
+  if (!scriptPath.startsWith(normalizedBase) || !fs.existsSync(scriptPath)) {
+    return { policy: hookPolicy, executed: false, reason: "script_not_found" }
+  }
+  const timeoutMs = Number(manifest.post_install.timeout_ms)
+  const resolvedTimeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.min(timeoutMs, 15000) : 15000
+  const result = spawnSync("node", [scriptPath], {
+    encoding: "utf-8",
+    timeout: resolvedTimeout,
+    env: {
+      ...process.env,
+      SUPERCLI_PLUGIN_NAME: plugin.name,
+      SUPERCLI_PLUGIN_DIR: pluginDir,
+    },
+  })
+  if (result.error) {
+    return { policy: hookPolicy, executed: true, ok: false, error: result.error.message }
+  }
+  if (result.status !== 0) {
+    return {
+      policy: hookPolicy,
+      executed: true,
+      ok: false,
+      error: (result.stderr || "").trim() || `exit ${result.status}`,
+    }
+  }
+  return { policy: hookPolicy, executed: true, ok: true }
+}
+
+function ensurePluginDir(rootDir, pluginName, pluginVersion) {
+  const dir = path.join(rootDir, safePluginName(pluginName), safePluginVersion(pluginVersion))
+  fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+function extractZipToDir(archivePath, targetDir) {
+  const extract = spawnSync("unzip", ["-o", archivePath, "-d", targetDir], {
+    encoding: "utf-8",
+    timeout: 15000,
+  })
+  if (extract.error) {
+    const msg = extract.error.code === "ENOENT"
+      ? "'unzip' command is required for ZIP server plugins"
+      : extract.error.message
+    throw Object.assign(new Error(msg), {
+      code: 105,
+      type: "integration_error",
+      recoverable: true,
+      suggestions: ["Install unzip and run: supercli sync"],
+    })
+  }
+  if (extract.status !== 0) {
+    throw Object.assign(new Error(`Failed to extract ZIP server plugin: ${(extract.stderr || "").trim() || `exit ${extract.status}`}`), {
+      code: 105,
+      type: "integration_error",
+      recoverable: true,
+    })
+  }
+}
+
+async function syncServerPlugins(server) {
+  const lock = readServerPluginsLock()
+  const installed = lock.installed || {}
+
+  const r = await fetch(`${server}/api/plugins?format=json`)
+  if (r.status === 404) {
+    return {
+      total: 0,
+      enabled: 0,
+      updated: [],
+      unchanged: [],
+      removed: [],
+      shadowed_by_local: [],
+      hook_results: [],
+      skipped: true,
+      reason: "server_plugins_endpoint_missing",
+    }
+  }
+  if (!r.ok) {
+    throw new Error(`Failed to fetch server plugins: ${r.status} ${r.statusText}`)
+  }
+  const payload = await r.json()
+  const settings = payload.settings || { max_zip_mb: 10, default_hooks_policy: "deny" }
+  const allPlugins = Array.isArray(payload.plugins) ? payload.plugins : []
+  const enabledPlugins = allPlugins.filter(p => p && p.enabled !== false)
+
+  const pluginRoot = path.join(SUPERCLI_PLUGINS_DIR, "server")
+  fs.mkdirSync(pluginRoot, { recursive: true })
+
+  const localPlugins = listInstalledPlugins()
+  const localNames = new Set(localPlugins.map(p => p.name))
+  const nextInstalled = {}
+  const diagnostics = {
+    total: allPlugins.length,
+    enabled: enabledPlugins.length,
+    updated: [],
+    unchanged: [],
+    removed: [],
+    shadowed_by_local: [],
+    hook_results: [],
+  }
+
+  const expectedNames = new Set(enabledPlugins.map(p => p.name))
+  for (const [name, oldPlugin] of Object.entries(installed)) {
+    if (expectedNames.has(name)) continue
+    const oldPath = oldPlugin && oldPlugin.plugin_dir
+    if (oldPath && fs.existsSync(oldPath)) fs.rmSync(oldPath, { recursive: true, force: true })
+    diagnostics.removed.push(name)
+  }
+
+  for (const plugin of enabledPlugins) {
+    if (!plugin || !plugin.name) continue
+    if (localNames.has(plugin.name)) {
+      diagnostics.shadowed_by_local.push(plugin.name)
+      continue
+    }
+
+    const previous = installed[plugin.name]
+    const checksumUnchanged = previous && previous.checksum === plugin.checksum
+    if (checksumUnchanged) {
+      nextInstalled[plugin.name] = previous
+      diagnostics.unchanged.push(plugin.name)
+      continue
+    }
+
+    const pluginDir = ensurePluginDir(pluginRoot, plugin.name, plugin.version)
+    const manifest = plugin.manifest || null
+    if (!manifest || typeof manifest !== "object") {
+      throw Object.assign(new Error(`Server plugin '${plugin.name}' is missing manifest`), {
+        code: 105,
+        type: "integration_error",
+        recoverable: true,
+      })
+    }
+
+    fs.writeFileSync(path.join(pluginDir, "plugin.json"), JSON.stringify(manifest, null, 2))
+
+    if (plugin.source_type === "zip") {
+      const zipRes = await fetch(`${server}/api/plugins/${encodeURIComponent(plugin.name)}/archive`)
+      if (!zipRes.ok) {
+        throw Object.assign(new Error(`Failed to download ZIP for server plugin '${plugin.name}'`), {
+          code: 105,
+          type: "integration_error",
+          recoverable: true,
+        })
+      }
+      const bytes = Buffer.from(await zipRes.arrayBuffer())
+      const archivePath = path.join(pluginDir, "plugin.zip")
+      fs.writeFileSync(archivePath, bytes)
+      extractZipToDir(archivePath, pluginDir)
+    }
+
+    const hookPolicy = resolveHooksPolicy(plugin, settings)
+    const hookResult = runServerPluginPostInstall(pluginDir, { name: plugin.name, manifest }, hookPolicy)
+    diagnostics.hook_results.push({ plugin: plugin.name, ...hookResult })
+
+    nextInstalled[plugin.name] = {
+      name: plugin.name,
+      version: plugin.version,
+      description: plugin.description || "",
+      source: "server",
+      source_type: plugin.source_type,
+      checksum: plugin.checksum,
+      has_learn: plugin.has_learn === true,
+      tags: plugin.tags || [],
+      hooks_policy: plugin.hooks_policy || "inherit",
+      plugin_dir: pluginDir,
+      installed_at: new Date().toISOString(),
+      commands: Array.isArray(manifest.commands) ? manifest.commands.map(cmd => ({ ...cmd, plugin_name: plugin.name, plugin_dir: pluginDir })) : [],
+    }
+    diagnostics.updated.push(plugin.name)
+  }
+
+  writeServerPluginsLock({
+    version: 1,
+    fetched_at: new Date().toISOString(),
+    settings,
+    installed: nextInstalled,
+  })
+
+  return diagnostics
+}
+
 async function syncConfig(server) {
   const config = await fetchRemoteConfig(server)
 
@@ -136,7 +352,27 @@ async function syncConfig(server) {
   }
 
   if (!Array.isArray(config.commands)) config.commands = []
-  return writeCache(normalizeConfig(config))
+  let serverPlugins
+  try {
+    serverPlugins = await syncServerPlugins(server)
+  } catch (err) {
+    serverPlugins = {
+      total: 0,
+      enabled: 0,
+      updated: [],
+      unchanged: [],
+      removed: [],
+      shadowed_by_local: [],
+      hook_results: [],
+      skipped: true,
+      reason: err.message,
+    }
+  }
+  const written = writeCache(normalizeConfig(config))
+  return {
+    ...written,
+    server_plugins: serverPlugins,
+  }
 }
 
 async function setMcpServer(name, value) {
@@ -210,6 +446,7 @@ async function showConfig() {
     fetchedAt: new Date(cache.fetchedAt).toISOString(),
     commands: cache.commands ? cache.commands.length : 0,
     plugins: listInstalledPlugins().length,
+    server_plugins: Object.keys((readServerPluginsLock().installed || {})).length,
     mcp_servers: cache.mcp_servers ? cache.mcp_servers.length : 0,
     specs: cache.specs ? cache.specs.length : 0,
     cacheFile: CACHE_FILE