superacli 1.1.20 → 1.1.21

package/cli/adapter-schema.js

@@ -1,4 +1,4 @@
-const SUPPORTED_ADAPTERS = ["http", "openapi", "mcp", "process", "builtin", "shell"]
+const SUPPORTED_ADAPTERS = ["http", "openapi", "mcp", "process", "shell"]
 
 function asInvalid(message, suggestions = []) {
   return Object.assign(new Error(message), {
@@ -94,11 +94,6 @@ function validateAdapterConfig(cmd) {
     return
   }
 
-  if (adapterName === "builtin") {
-    if (!config.builtin || typeof config.builtin !== "string") throw asInvalid("Builtin adapter requires adapterConfig.builtin")
-    return
-  }
-
   if (adapterName === "shell") {
     if (config.unsafe !== true) {
       throw asInvalid("Shell adapter requires adapterConfig.unsafe=true")

package/cli/config.js

@@ -369,10 +369,105 @@ async function syncConfig(server) {
       reason: err.message,
     }
   }
+
+  // Sync CLI-context adapters
+  let cliAdapters = { total: 0, synced: 0, failed: 0 }
+  try {
+    cliAdapters = await syncCliAdapters(server)
+  } catch (err) {
+    cliAdapters = { total: 0, synced: 0, failed: 0, error: err.message }
+  }
+
   const written = writeCache(normalizeConfig(config))
   return {
     ...written,
     server_plugins: serverPlugins,
+    cli_adapters: cliAdapters,
+  }
+}
+
+async function syncCliAdapters(server) {
+  const fs = require("fs")
+  const path = require("path")
+  
+  // Fetch all adapters from server
+  const res = await fetch(`${server}/api/adapters`, {
+    headers: { Accept: "application/json" },
+  })
+  
+  if (!res.ok) {
+    throw new Error(`Failed to fetch adapters: ${res.status}`)
+  }
+  
+  const data = await res.json()
+  const adapters = data.adapters || []
+  
+  // Filter CLI-context adapters
+  const cliAdapters = adapters.filter(a => a.execution_context === "cli")
+  const cliAdapterNames = new Set(cliAdapters.map(a => a.name))
+  
+  // Ensure adapters directory exists
+  const adaptersDir = path.join(process.cwd(), ".supercli", "adapters")
+  fs.mkdirSync(adaptersDir, { recursive: true })
+  
+  // Remove local adapter files that are no longer CLI-context
+  if (fs.existsSync(adaptersDir)) {
+    const localFiles = fs.readdirSync(adaptersDir)
+    for (const file of localFiles) {
+      if (file.endsWith('.js')) {
+        const adapterName = file.slice(0, -3) // Remove .js extension
+        if (!cliAdapterNames.has(adapterName)) {
+          // Remove local file since adapter is no longer CLI-context
+          const filePath = path.join(adaptersDir, file)
+          fs.unlinkSync(filePath)
+        }
+      }
+    }
+  }
+  
+  let synced = 0
+  let failed = 0
+  
+  for (const adapter of cliAdapters) {
+    try {
+      // Fetch adapter source
+      const sourceRes = await fetch(`${server}/api/adapters/${adapter.name}/source`, {
+        headers: { Accept: "application/json" },
+      })
+      
+      if (!sourceRes.ok) {
+        throw new Error(`Failed to fetch source for ${adapter.name}`)
+      }
+      
+      const sourceData = await sourceRes.json()
+      const source = sourceData.source || ""
+      
+      // Write adapter file with metadata header
+      const adapterPath = path.join(adaptersDir, `${adapter.name}.js`)
+      const metadataHeader = `/**
+ * @name ${adapter.name}
+ * @description ${adapter.description || ""}
+ * @context cli
+ * @timeout ${adapter.timeout_ms || 30000}
+ * @memory ${adapter.memory_limit_mb || 128}
+ * @network ${adapter.allow_network || false}
+ * @updated ${adapter.updated_at}
+ */
+
+`
+      
+      fs.writeFileSync(adapterPath, metadataHeader + source, "utf-8")
+      synced++
+    } catch (err) {
+      console.error(`Failed to sync adapter ${adapter.name}:`, err.message)
+      failed++
+    }
+  }
+  
+  return {
+    total: cliAdapters.length,
+    synced,
+    failed,
   }
 }
 

package/cli/executor.js

@@ -1,4 +1,6 @@
 const path = require("path")
+const fs = require("fs")
+const { NodeVM } = require("vm2")
 const { validateAdapterConfig } = require("./adapter-schema")
 
 // Adapter registry — lazy-loaded
@@ -7,7 +9,6 @@ const ADAPTERS = {
   mcp: () => require("./adapters/mcp"),
   http: () => require("./adapters/http"),
   process: () => require("./adapters/process"),
-  builtin: () => require("./adapters/builtin"),
   shell: () => require("./adapters/shell")
 }
 
@@ -22,16 +23,7 @@ async function execute(cmd, flags, context) {
   validateAdapterConfig(cmd)
 
   if (!ADAPTERS[adapterName]) {
-    try {
-      const custom = require(path.resolve("adapters", adapterName))
-      return custom.execute(cmd, flags, context)
-    } catch (e) {
-      throw Object.assign(new Error(`Unknown adapter: ${adapterName}`), {
-        code: 110,
-        type: "internal_error",
-        recoverable: false
-      })
-    }
+    return executeCustomAdapter(adapterName, cmd, flags, context)
   }
 
   const adapter = ADAPTERS[adapterName]()
@@ -119,4 +111,91 @@ async function executeWorkflow(workflow, flags, context, steps) {
   return { workflow: workflow.namespace + "." + workflow.resource + "." + workflow.action, steps: results }
 }
 
+async function executeCustomAdapter(adapterName, cmd, flags, context) {
+  // Check if adapter exists in local .supercli/adapters/ directory
+  const localAdapterPath = path.join(process.cwd(), ".supercli", "adapters", `${adapterName}.js`)
+  
+  if (fs.existsSync(localAdapterPath)) {
+    // Execute locally using vm2
+    return executeLocalAdapter(localAdapterPath, cmd, flags, context)
+  }
+  
+  // If server is available, delegate to server
+  if (context.server) {
+    const res = await fetch(`${context.server}/api/adapters/execute`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ cmd, flags })
+    })
+    
+    if (!res.ok) {
+      const err = await res.json()
+      const errorMessage = err.error?.message || err.error || `Adapter '${adapterName}' execution failed`
+      throw Object.assign(new Error(errorMessage), {
+        code: err.error?.code || 110,
+        type: err.error?.type || "internal_error",
+        recoverable: err.error?.recoverable || false
+      })
+    }
+    
+    return res.json()
+  }
+  
+  throw Object.assign(new Error(`Adapter '${adapterName}' not found locally and server is unavailable`), {
+    code: 110,
+    type: "internal_error",
+    recoverable: false
+  })
+}
+
+async function executeLocalAdapter(adapterPath, cmd, flags, context) {
+  const source = fs.readFileSync(adapterPath, "utf-8")
+  
+  // Extract metadata from adapter (first comment block if exists)
+  const metadataMatch = source.match(/\/\*\*?\s*\n([\s\S]*?)\n\s*\*\//)
+  const metadata = {}
+  if (metadataMatch) {
+    const metaText = metadataMatch[1]
+    const timeoutMatch = metaText.match(/@timeout\s+(\d+)/)
+    const memoryMatch = metaText.match(/@memory\s+(\d+)/)
+    const networkMatch = metaText.match(/@network\s+(true|false)/)
+    if (timeoutMatch) metadata.timeout = parseInt(timeoutMatch[1])
+    if (memoryMatch) metadata.memory = parseInt(memoryMatch[1])
+    if (networkMatch) metadata.network = networkMatch[1] === "true"
+  }
+  
+  const vm = new NodeVM({
+    timeout: metadata.timeout || 30000,
+    sandbox: {
+      console: {
+        log: (...args) => {},
+        error: (...args) => {},
+        warn: (...args) => {},
+      },
+    },
+    require: {
+      external: metadata.network !== false,
+      root: path.dirname(adapterPath),
+    },
+    memoryLimit: (metadata.memory || 128) * 1024 * 1024,
+  })
+  
+  const script = `
+    ${source}
+    module.exports = { execute }
+  `
+  
+  const fn = vm.run(script, adapterPath)
+  
+  if (typeof fn.execute !== "function") {
+    throw Object.assign(new Error(`Adapter must export an 'execute' function`), {
+      code: 85,
+      type: "invalid_argument",
+      recoverable: false
+    })
+  }
+  
+  return fn.execute(cmd, flags, context)
+}
+
 module.exports = { execute }

package/cli/server-command.js

@@ -0,0 +1,395 @@
+const fs = require("fs")
+const path = require("path")
+
+const SERVER = process.env.SUPERCLI_SERVER
+
+function getServerUrl() {
+  return SERVER ? SERVER.replace(/\/$/, "") : null
+}
+
+async function serverFetch(endpoint, options = {}) {
+  const base = getServerUrl()
+  if (!base) {
+    throw new Error("SUPERCLI_SERVER not set. Set it to your server URL.")
+  }
+  const url = `${base}${endpoint}`
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  })
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(`Server error ${res.status}: ${text}`)
+  }
+  return res.json()
+}
+
+function readJsonFile(filePath) {
+  const fullPath = path.resolve(filePath)
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`File not found: ${filePath}`)
+  }
+  const content = fs.readFileSync(fullPath, "utf-8")
+  return JSON.parse(content)
+}
+
+function readFileBuffer(filePath) {
+  const fullPath = path.resolve(filePath)
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`File not found: ${filePath}`)
+  }
+  return fs.readFileSync(fullPath)
+}
+
+async function handleServerCommand(options) {
+  const { positional, flags, humanMode, output, outputHumanTable, outputError } = options
+  const resource = positional[1]
+  const action = positional[2]
+  const arg = positional[3]
+
+  if (!resource) {
+    outputError({ code: 85, type: "invalid_argument", message: "Usage: supercli server <resource> <action> [args]", recoverable: false })
+    return true
+  }
+
+  if (!getServerUrl()) {
+    outputError({ code: 85, type: "invalid_argument", message: "SUPERCLI_SERVER not set", recoverable: false })
+    return true
+  }
+
+  try {
+    switch (resource) {
+      case "status":
+        return await handleStatus({ humanMode, output })
+      case "plugins":
+        return await handlePlugins({ action, arg, flags, humanMode, output, outputHumanTable })
+      case "mcp":
+        return await handleMcp({ action, arg, flags, humanMode, output, outputHumanTable })
+      case "commands":
+        return await handleCommands({ action, arg, flags, humanMode, output, outputHumanTable })
+      case "specs":
+        return await handleSpecs({ action, arg, flags, humanMode, output, outputHumanTable })
+      case "openapi":
+        return await handleOpenapi({ action, arg, flags, humanMode, output })
+      case "jobs":
+        return await handleJobs({ action, flags, humanMode, output, outputHumanTable })
+      default:
+        outputError({ code: 85, type: "invalid_argument", message: `Unknown server resource: ${resource}`, recoverable: false })
+        return true
+    }
+  } catch (err) {
+    outputError({ code: 500, type: "server_error", message: err.message, recoverable: false })
+    return true
+  }
+}
+
+async function handleStatus({ humanMode, output }) {
+  const settings = await serverFetch("/api/plugins/settings")
+  const result = {
+    admin_mode: settings.admin_mode_enabled === true,
+    server: getServerUrl(),
+    max_zip_mb: settings.max_zip_mb,
+    default_hooks_policy: settings.default_hooks_policy,
+  }
+  if (humanMode) {
+    console.log(`\n  ⚡ Server Status\n`)
+    console.log(`  Server: ${result.server}`)
+    console.log(`  Admin Mode: ${result.admin_mode ? "ENABLED (⚠️ CLI modifications allowed)" : "disabled"}`)
+    console.log(`  Max ZIP Size: ${result.max_zip_mb}MB`)
+    console.log(`  Hooks Policy: ${result.default_hooks_policy}`)
+    console.log("")
+  } else {
+    output(result)
+  }
+  return true
+}
+
+async function handlePlugins({ action, arg, flags, humanMode, output, outputHumanTable }) {
+  if (action === "list") {
+    const data = await serverFetch("/api/plugins?format=json")
+    if (humanMode) {
+      console.log("\n  ⚡ Server Plugins\n")
+      outputHumanTable(data.plugins, [
+        { key: "name", label: "Name" },
+        { key: "source_type", label: "Type" },
+        { key: "enabled", label: "Enabled" },
+        { key: "version", label: "Version" },
+      ])
+      console.log("")
+    } else {
+      output(data)
+    }
+    return true
+  }
+
+  if (action === "add") {
+    let payload
+    const zipPath = flags["from-zip"]
+    const jsonPath = flags["from-json"]
+
+    if (zipPath) {
+      const buffer = readFileBuffer(zipPath)
+      const base64 = buffer.toString("base64")
+      const manifest = flags.manifest ? JSON.parse(flags.manifest) : {}
+      payload = {
+        source_type: "zip",
+        name: manifest.name || path.basename(zipPath, ".zip"),
+        version: manifest.version || "0.1.0",
+        manifest,
+        archive_base64: base64,
+      }
+    } else if (jsonPath) {
+      payload = readJsonFile(jsonPath)
+      payload.source_type = "json"
+    } else if (arg) {
+      payload = JSON.parse(arg)
+      payload.source_type = payload.source_type || "json"
+    } else {
+      throw new Error("Usage: supercli server plugins add '{json}' or --from-json <path> or --from-zip <path> --manifest '{json}'")
+    }
+
+    const result = await serverFetch("/api/plugins", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    })
+    output(result)
+    return true
+  }
+
+  if (action === "remove") {
+    if (!arg) {
+      throw new Error("Usage: supercli server plugins remove <name>")
+    }
+    const result = await serverFetch(`/api/plugins/${encodeURIComponent(arg)}`, {
+      method: "DELETE",
+    })
+    output(result)
+    return true
+  }
+
+  throw new Error(`Unknown plugins action: ${action}. Use: list, add, remove`)
+}
+
+async function handleMcp({ action, arg, flags, humanMode, output, outputHumanTable }) {
+  if (action === "list") {
+    const servers = await serverFetch("/api/mcp?format=json")
+    if (humanMode) {
+      console.log("\n  ⚡ MCP Servers\n")
+      outputHumanTable(servers, [
+        { key: "name", label: "Name" },
+        { key: "url", label: "URL" },
+        { key: "command", label: "Command" },
+      ])
+      console.log("")
+    } else {
+      output({ servers })
+    }
+    return true
+  }
+
+  if (action === "add") {
+    let payload
+    if (flags["from-json"]) {
+      payload = readJsonFile(flags["from-json"])
+    } else if (arg) {
+      payload = JSON.parse(arg)
+    } else {
+      throw new Error("Usage: supercli server mcp add '{json}' or --from-json <path>")
+    }
+
+    const result = await serverFetch("/api/mcp", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    })
+    output(result)
+    return true
+  }
+
+  if (action === "remove") {
+    if (!arg) {
+      throw new Error("Usage: supercli server mcp remove <name>")
+    }
+    const result = await serverFetch(`/api/mcp/${encodeURIComponent(arg)}`, {
+      method: "DELETE",
+    })
+    output(result)
+    return true
+  }
+
+  throw new Error(`Unknown mcp action: ${action}. Use: list, add, remove`)
+}
+
+async function handleCommands({ action, arg, flags, humanMode, output, outputHumanTable }) {
+  if (action === "list") {
+    const commands = await serverFetch("/api/commands?format=json")
+    if (humanMode) {
+      console.log("\n  ⚡ Server Commands\n")
+      outputHumanTable(commands.map(c => ({
+        id: c._id,
+        namespace: c.namespace,
+        resource: c.resource,
+        action: c.action,
+        adapter: c.adapter,
+      })), [
+        { key: "id", label: "ID" },
+        { key: "namespace", label: "NS" },
+        { key: "resource", label: "Resource" },
+        { key: "action", label: "Action" },
+        { key: "adapter", label: "Adapter" },
+      ])
+      console.log("")
+    } else {
+      output({ commands })
+    }
+    return true
+  }
+
+  if (action === "add") {
+    let payload
+    if (flags["from-json"]) {
+      payload = readJsonFile(flags["from-json"])
+    } else if (arg) {
+      payload = JSON.parse(arg)
+    } else {
+      throw new Error("Usage: supercli server commands add '{json}' or --from-json <path>")
+    }
+
+    const result = await serverFetch("/api/commands", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    })
+    output(result)
+    return true
+  }
+
+  if (action === "remove") {
+    if (!arg) {
+      throw new Error("Usage: supercli server commands remove <namespace.resource.action>")
+    }
+    const id = arg.startsWith("command:") ? arg : `command:${arg}`
+    const result = await serverFetch(`/api/commands/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+    })
+    output(result)
+    return true
+  }
+
+  throw new Error(`Unknown commands action: ${action}. Use: list, add, remove`)
+}
+
+async function handleSpecs({ action, arg, flags, humanMode, output, outputHumanTable }) {
+  if (action === "list") {
+    const specs = await serverFetch("/api/specs?format=json")
+    if (humanMode) {
+      console.log("\n  ⚡ OpenAPI Specs\n")
+      outputHumanTable(specs, [
+        { key: "name", label: "Name" },
+        { key: "url", label: "URL" },
+        { key: "auth", label: "Auth" },
+      ])
+      console.log("")
+    } else {
+      output({ specs })
+    }
+    return true
+  }
+
+  if (action === "add") {
+    let payload
+    if (flags["from-json"]) {
+      payload = readJsonFile(flags["from-json"])
+    } else if (arg) {
+      payload = JSON.parse(arg)
+    } else {
+      throw new Error("Usage: supercli server specs add '{json}' or --from-json <path>")
+    }
+
+    const result = await serverFetch("/api/specs", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    })
+    output(result)
+    return true
+  }
+
+  if (action === "remove") {
+    if (!arg) {
+      throw new Error("Usage: supercli server specs remove <name>")
+    }
+    const id = arg.startsWith("spec:") ? arg : `spec:${arg}`
+    const result = await serverFetch(`/api/specs/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+    })
+    output(result)
+    return true
+  }
+
+  throw new Error(`Unknown specs action: ${action}. Use: list, add, remove`)
+}
+
+async function handleOpenapi({ action, arg, flags, humanMode, output }) {
+  // OpenAPI specs are managed via specs endpoint
+  if (action === "add") {
+    let payload
+    if (flags["from-json"]) {
+      payload = readJsonFile(flags["from-json"])
+    } else if (arg) {
+      payload = JSON.parse(arg)
+    } else {
+      throw new Error("Usage: supercli server openapi add '{json}' or --from-json <path>")
+    }
+
+    const result = await serverFetch("/api/specs", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    })
+    output(result)
+    return true
+  }
+
+  throw new Error(`Unknown openapi action: ${action}. Use: add`)
+}
+
+async function handleJobs({ action, flags, humanMode, output, outputHumanTable }) {
+  if (action === "list") {
+    const jobs = await serverFetch("/api/jobs?format=json")
+    if (humanMode) {
+      console.log("\n  ⚡ Jobs\n")
+      outputHumanTable(jobs.slice(0, 20).map(j => ({
+        id: j._id,
+        command: j.command,
+        status: j.status,
+        timestamp: j.timestamp,
+      })), [
+        { key: "id", label: "ID" },
+        { key: "command", label: "Command" },
+        { key: "status", label: "Status" },
+        { key: "timestamp", label: "Timestamp" },
+      ])
+      console.log("")
+    } else {
+      output({ jobs })
+    }
+    return true
+  }
+
+  if (action === "prune") {
+    const days = parseInt(flags["older-than"]) || 7
+    const result = await serverFetch(`/api/jobs?older_than=${days}`, {
+      method: "DELETE",
+    })
+    if (humanMode) {
+      console.log(`\n  Pruned ${result.pruned} jobs older than ${result.older_than_days} days\n`)
+    } else {
+      output(result)
+    }
+    return true
+  }
+
+  throw new Error(`Unknown jobs action: ${action}. Use: list, prune`)
+}
+
+module.exports = { handleServerCommand }