superacli 1.0.1 → 1.1.2

package/cli/adapters/process.js

@@ -0,0 +1,262 @@
+const { spawn, spawnSync } = require("child_process")
+
+function toCliFlags(flags) {
+  const args = []
+  for (const [k, v] of Object.entries(flags)) {
+    if (["human", "json", "compact"].includes(k) || k.startsWith("__")) continue
+    if (v === false || v === undefined || v === null) continue
+    if (Array.isArray(v)) {
+      for (const item of v) {
+        args.push(`--${k}`, String(item))
+      }
+      continue
+    }
+    if (v === true) args.push(`--${k}`)
+    else if (typeof v === "object") args.push(`--${k}`, JSON.stringify(v))
+    else args.push(`--${k}`, String(v))
+  }
+  return args
+}
+
+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() }
+}
+
+function buildSafetyViolation(details) {
+  return Object.assign(new Error(`Operation rejected: Cannot run interactive command in a non-TTY environment. Use non-interactive flags instead.${details ? ` ${details}` : ""}`), {
+    code: 91,
+    type: "safety_violation",
+    recoverable: false
+  })
+}
+
+function detectInteractiveFlags(args, interactiveFlags) {
+  const configured = new Set((interactiveFlags || []).map(f => String(f)))
+  if (configured.size === 0) return []
+
+  const hits = new Set()
+  for (const token of args) {
+    const value = String(token)
+    if (configured.has(value)) {
+      hits.add(value)
+      continue
+    }
+
+    if (value.startsWith("--") && value.includes("=")) {
+      const key = value.slice(0, value.indexOf("="))
+      if (configured.has(key)) hits.add(key)
+      continue
+    }
+
+    if (value.startsWith("-") && !value.startsWith("--") && value.length > 2) {
+      for (const ch of value.slice(1)) {
+        const shortFlag = `-${ch}`
+        if (configured.has(shortFlag)) hits.add(shortFlag)
+      }
+    }
+  }
+
+  return [...hits]
+}
+
+function validateNonTtySafety(cfg, args) {
+  const isTty = !!process.stdout.isTTY
+  if (isTty) return
+
+  if (cfg.requiresInteractive === true) {
+    throw buildSafetyViolation("Command requires an interactive TTY session.")
+  }
+
+  const hits = detectInteractiveFlags(args, cfg.interactiveFlags)
+  if (hits.length > 0) {
+    throw buildSafetyViolation(`Blocked interactive flags: ${hits.join(", ")}.`)
+  }
+}
+
+function parseJsonLine(text) {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return { raw: text }
+  }
+}
+
+function flushStreamBuffer(buffer, onLine) {
+  let pending = buffer
+  let newlineIndex = pending.indexOf("\n")
+  while (newlineIndex >= 0) {
+    const line = pending.slice(0, newlineIndex).trim()
+    pending = pending.slice(newlineIndex + 1)
+    if (line) onLine(line)
+    newlineIndex = pending.indexOf("\n")
+  }
+  return pending
+}
+
+async function execute(cmd, flags, context = {}) {
+  const cfg = cmd.adapterConfig || {}
+  const binary = cfg.command
+  if (!binary) throw new Error("Process adapter requires adapterConfig.command")
+
+  const baseArgs = Array.isArray(cfg.baseArgs) ? cfg.baseArgs.slice() : []
+  const nonTtyBaseArgs = Array.isArray(cfg.nonTtyBaseArgs) ? cfg.nonTtyBaseArgs.slice() : []
+  const passthroughMode = cfg.passthrough === true
+  const positionalNames = Array.isArray(cfg.positionalArgs) ? cfg.positionalArgs : []
+  const parsedAsJson = cfg.parseJson !== false
+  const includeJsonFlag = cfg.jsonFlag || null
+  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 cwd = typeof cfg.cwd === "string" ? cfg.cwd : undefined
+  const env = (cfg.env && typeof cfg.env === "object") ? { ...process.env, ...cfg.env } : process.env
+  const streamMode = cfg.stream || null
+  const onStreamEvent = typeof context.onStreamEvent === "function" ? context.onStreamEvent : null
+
+  const check = preflightBinary(binary)
+  if (!check.ok) {
+    const help = cfg.missingDependencyHelp || `Run: dcli plugins doctor`
+    throw Object.assign(new Error(`Missing dependency '${binary}'. ${help}`), {
+      code: 85,
+      type: "invalid_argument",
+      recoverable: false
+    })
+  }
+
+  const remainingFlags = { ...flags }
+  const args = [...baseArgs]
+  if (!process.stdout.isTTY && nonTtyBaseArgs.length > 0) {
+    args.push(...nonTtyBaseArgs)
+  }
+
+  if (passthroughMode) {
+    const passthroughArgs = Array.isArray(flags.__rawArgs) ? flags.__rawArgs : []
+    args.push(...passthroughArgs)
+  } else {
+    const positionalValues = []
+    for (const name of positionalNames) {
+      if (remainingFlags[name] !== undefined) {
+        positionalValues.push(String(remainingFlags[name]))
+        delete remainingFlags[name]
+      }
+    }
+
+    const flagArgs = []
+    if (includeJsonFlag) flagArgs.push(includeJsonFlag)
+    flagArgs.push(...toCliFlags(remainingFlags))
+
+    if (flagsBeforePositionals) args.push(...flagArgs, ...positionalValues)
+    else args.push(...positionalValues, ...flagArgs)
+  }
+
+  validateNonTtySafety(cfg, args)
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(binary, args, { stdio: passthroughInteractive ? "inherit" : ["ignore", "pipe", "pipe"], cwd, env })
+    let out = ""
+    let err = ""
+    let streamBuffer = ""
+    let streamEventCount = 0
+    let lastStreamEvent = null
+    let settled = false
+
+    const timer = setTimeout(() => {
+      if (settled) return
+      settled = true
+      child.kill("SIGTERM")
+      reject(Object.assign(new Error(`Process command timed out after ${timeoutMs}ms`), {
+        code: 105,
+        type: "integration_error",
+        recoverable: true
+      }))
+    }, timeoutMs)
+
+    if (!passthroughInteractive) {
+      child.stdout.setEncoding("utf-8")
+      child.stderr.setEncoding("utf-8")
+      child.stdout.on("data", chunk => {
+        out += chunk
+        if (streamMode !== "jsonl") return
+        streamBuffer = flushStreamBuffer(streamBuffer + chunk, line => {
+          const event = parseJsonLine(line)
+          streamEventCount += 1
+          lastStreamEvent = event
+          if (onStreamEvent) onStreamEvent(event)
+        })
+      })
+      child.stderr.on("data", chunk => { err += chunk })
+    }
+
+    child.on("error", e => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (e && e.code === "ENOENT") {
+        const help = cfg.missingDependencyHelp || `Run: dcli plugins doctor`
+        reject(Object.assign(new Error(`Missing dependency '${binary}'. ${help}`), {
+          code: 85,
+          type: "invalid_argument",
+          recoverable: false
+        }))
+        return
+      }
+      reject(Object.assign(new Error(`Failed to start process adapter: ${e.message}`), {
+        code: 105,
+        type: "integration_error",
+        recoverable: true
+      }))
+    })
+
+    child.on("close", code => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (code !== 0) {
+        reject(Object.assign(new Error(`Process adapter failed (${binary} ${args.join(" ")}): ${err.trim()}`), {
+          code: 105,
+          type: "integration_error",
+          recoverable: true
+        }))
+        return
+      }
+
+      if (passthroughInteractive) {
+        resolve({ ok: true, passthrough: true })
+        return
+      }
+
+      if (streamMode === "jsonl") {
+        const trailing = streamBuffer.trim()
+        if (trailing) {
+          const event = parseJsonLine(trailing)
+          streamEventCount += 1
+          lastStreamEvent = event
+          if (onStreamEvent) onStreamEvent(event)
+        }
+        resolve({
+          streamed: true,
+          stream: streamMode,
+          event_count: streamEventCount,
+          last_event: lastStreamEvent
+        })
+        return
+      }
+
+      const text = out.trim()
+      if (!parsedAsJson) {
+        resolve({ raw: text })
+        return
+      }
+      try {
+        resolve(text ? JSON.parse(text) : {})
+      } catch {
+        resolve({ raw: text })
+      }
+    })
+  })
+}
+
+module.exports = { execute }

package/cli/adapters/shell.js

@@ -0,0 +1,82 @@
+const { spawn } = require("child_process")
+
+function interpolateScript(script, flags) {
+  let out = script
+  for (const [k, v] of Object.entries(flags)) {
+    if (["human", "json", "compact"].includes(k)) continue
+    const value = String(v).replace(/"/g, '\\"')
+    out = out.replaceAll(`{{${k}}}`, value)
+  }
+  return out
+}
+
+async function execute(cmd, flags) {
+  const cfg = cmd.adapterConfig || {}
+  const shellBin = cfg.shell || "bash"
+  const script = interpolateScript(cfg.script, flags)
+  const timeoutMs = Number(cfg.timeout_ms) > 0 ? Number(cfg.timeout_ms) : 15000
+  const parseJson = cfg.parseJson !== false
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(shellBin, ["-lc", script], {
+      stdio: ["ignore", "pipe", "pipe"]
+    })
+
+    let stdout = ""
+    let stderr = ""
+    let settled = false
+
+    const timer = setTimeout(() => {
+      if (settled) return
+      settled = true
+      child.kill("SIGTERM")
+      reject(Object.assign(new Error(`Shell command timed out after ${timeoutMs}ms`), {
+        code: 105,
+        type: "integration_error",
+        recoverable: true
+      }))
+    }, timeoutMs)
+
+    child.stdout.setEncoding("utf-8")
+    child.stderr.setEncoding("utf-8")
+    child.stdout.on("data", chunk => { stdout += chunk })
+    child.stderr.on("data", chunk => { stderr += chunk })
+
+    child.on("error", err => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      reject(Object.assign(new Error(`Failed to start shell adapter: ${err.message}`), {
+        code: 105,
+        type: "integration_error",
+        recoverable: true
+      }))
+    })
+
+    child.on("close", code => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (code !== 0) {
+        reject(Object.assign(new Error(`Shell adapter failed (${shellBin} -lc ...): ${stderr.trim()}`), {
+          code: 105,
+          type: "integration_error",
+          recoverable: true
+        }))
+        return
+      }
+      const text = stdout.trim()
+      if (!parseJson) {
+        resolve({ raw: text })
+        return
+      }
+      try {
+        resolve(text ? JSON.parse(text) : {})
+      } catch {
+        resolve({ raw: text })
+      }
+    })
+  })
+}
+
+module.exports = { execute }

package/cli/config.js

@@ -1,6 +1,7 @@
 const fs = require("fs")
 const path = require("path")
 const os = require("os")
+const { getInstalledPluginCommands, listInstalledPlugins } = require("./plugins-store")
 
 const CACHE_DIR = path.join(os.homedir(), ".supercli")
 const CACHE_FILE = path.join(CACHE_DIR, "config.json")
@@ -33,12 +34,6 @@ function writeCache(config) {
   return data
 }
 
-function ttlValid(cache) {
-  if (!cache || !cache.fetchedAt) return false
-  const ttl = (cache.ttl || 3600) * 1000
-  return (Date.now() - cache.fetchedAt) < ttl
-}
-
 async function fetchRemoteConfig(server) {
   if (!server) throw new Error("SUPERCLI_SERVER is not configured")
   const url = `${server}/api/config`
@@ -59,8 +54,13 @@ function emptyConfig() {
 
 async function loadConfig() {
   const cache = readCache()
-  if (cache) return cache
-  return emptyConfig()
+  const base = cache || emptyConfig()
+  const pluginCommands = getInstalledPluginCommands()
+  const merged = {
+    ...base,
+    commands: [...(base.commands || []), ...pluginCommands]
+  }
+  return merged
 }
 
 async function syncConfig(server) {
@@ -95,7 +95,9 @@ async function setMcpServer(name, url) {
   const next = { name, url }
   if (idx >= 0) servers[idx] = next
   else servers.push(next)
-  cfg.mcp_servers = servers.sort((a, b) => a.name.localeCompare(b.name))
+  cfg.mcp_servers = servers
+    .filter(s => s && typeof s.name === "string")
+    .sort((a, b) => a.name.localeCompare(b.name))
   return writeCache(cfg)
 }
 
@@ -124,6 +126,7 @@ async function showConfig() {
     ttl: cache.ttl,
     fetchedAt: new Date(cache.fetchedAt).toISOString(),
     commands: cache.commands ? cache.commands.length : 0,
+    plugins: listInstalledPlugins().length,
     mcp_servers: cache.mcp_servers ? cache.mcp_servers.length : 0,
     specs: cache.specs ? cache.specs.length : 0,
     cacheFile: CACHE_FILE

package/cli/executor.js

@@ -1,10 +1,14 @@
 const path = require("path")
+const { validateAdapterConfig } = require("./adapter-schema")
 
 // Adapter registry — lazy-loaded
 const ADAPTERS = {
   openapi: () => require("./adapters/openapi"),
   mcp: () => require("./adapters/mcp"),
-  http: () => require("./adapters/http")
+  http: () => require("./adapters/http"),
+  process: () => require("./adapters/process"),
+  builtin: () => require("./adapters/builtin"),
+  shell: () => require("./adapters/shell")
 }
 
 async function execute(cmd, flags, context) {
@@ -15,6 +19,7 @@ async function execute(cmd, flags, context) {
   }
 
   const adapterName = cmd.adapter
+  validateAdapterConfig(cmd)
 
   if (!ADAPTERS[adapterName]) {
     try {

package/cli/help-json.js

@@ -2,6 +2,7 @@ function buildCapabilities(config, hasServer) {
   const commands = {
     help: { description: "List namespaces and commands" },
     config: { subcommands: ["show"] },
+    plugins: { subcommands: ["list", "explore", "install", "remove", "show", "doctor"], description: "Manage local and remote command plugins" },
     mcp: { subcommands: ["list", "add", "remove"], description: "Manage local MCP server registry" },
     commands: { description: "List all commands" },
     inspect: { description: "Inspect command details", usage: "supercli inspect <ns> <res> <act>" },
@@ -9,7 +10,7 @@ function buildCapabilities(config, hasServer) {
     execute: { description: "Execute a stored plan", usage: "supercli execute <plan_id>" },
     skills: {
       description: "Skill discovery and SKILL.md generation",
-      subcommands: ["list", "get", "teach"]
+      subcommands: ["list", "get", "teach", "sync", "search", "providers"]
     }
   }
   if (hasServer) commands.sync = { description: "Sync local config from SUPERCLI_SERVER" }
@@ -34,6 +35,7 @@ function buildCapabilities(config, hasServer) {
     },
     exit_codes: {
       "0": "success",
+      "91": "safety_violation",
       "82": "validation_error",
       "85": "invalid_argument",
       "92": "resource_not_found",

package/cli/namespace-passthrough.js

@@ -0,0 +1,38 @@
+function findNamespacePassthrough(config, positional, rawArgs) {
+  const namespace = positional[0]
+  if (!namespace || !config || !Array.isArray(config.commands)) return null
+
+  const passthroughCommand = config.commands.find(c => (
+    c.namespace === namespace &&
+    c.adapterConfig &&
+    c.adapterConfig.passthrough === true
+  ))
+  if (!passthroughCommand) return null
+
+  const namespaceIndex = rawArgs.indexOf(namespace)
+  const passthroughArgs = namespaceIndex >= 0 ? rawArgs.slice(namespaceIndex + 1) : []
+
+  const maybeResource = passthroughArgs[0]
+  const maybeAction = passthroughArgs[1]
+  const hasExactCommand = (
+    typeof maybeResource === "string" &&
+    typeof maybeAction === "string" &&
+    !maybeResource.startsWith("-") &&
+    !maybeAction.startsWith("-") &&
+    config.commands.some(c => (
+      c.namespace === namespace &&
+      c.resource === maybeResource &&
+      c.action === maybeAction
+    ))
+  )
+
+  if (hasExactCommand) return null
+
+  return {
+    namespace,
+    command: passthroughCommand,
+    passthroughArgs
+  }
+}
+
+module.exports = { findNamespacePassthrough }