superacli 1.1.20 → 1.1.21

package/server/services/adaptersService.js

@@ -0,0 +1,284 @@
+const { getStorage } = require("../storage/adapter")
+const { bumpVersion } = require("./configService")
+
+const ADAPTER_PREFIX = "adapter:"
+const ADAPTER_PACKAGES_PREFIX = "adapter_packages:"
+
+function invalid(message) {
+  return Object.assign(new Error(message), {
+    code: 85,
+    type: "invalid_argument",
+    recoverable: false,
+  })
+}
+
+function adapterKey(name) {
+  return `${ADAPTER_PREFIX}${name}`
+}
+
+function adapterPackagesKey(name) {
+  return `${ADAPTER_PACKAGES_PREFIX}${name}`
+}
+
+function sanitizeAdapter(adapter) {
+  if (!adapter || typeof adapter !== "object") {
+    throw invalid("adapter must be an object")
+  }
+  
+  const name = String(adapter.name || "").trim()
+  if (!name) throw invalid("adapter.name is required")
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)) {
+    throw invalid("adapter.name must start with letter and contain only letters, numbers, underscores, hyphens")
+  }
+  
+  const description = String(adapter.description || "")
+  const source = String(adapter.source || "").trim()
+  if (!source) throw invalid("adapter.source is required")
+  
+  const executionContext = ["server", "cli"].includes(adapter.execution_context) 
+    ? adapter.execution_context 
+    : "server"
+  
+  const dependencies = Array.isArray(adapter.dependencies) 
+    ? adapter.dependencies.filter(d => typeof d === "string") 
+    : []
+  
+  const timeoutMs = Number(adapter.timeout_ms) || 30000
+  const memoryLimitMb = Number(adapter.memory_limit_mb) || 128
+  const allowNetwork = adapter.allow_network === true
+  
+  return {
+    name,
+    description,
+    execution_context: executionContext,
+    source,
+    dependencies,
+    timeout_ms: timeoutMs,
+    memory_limit_mb: memoryLimitMb,
+    allow_network: allowNetwork,
+  }
+}
+
+async function listAdapters() {
+  const storage = getStorage()
+  const keys = await storage.listKeys(ADAPTER_PREFIX)
+  const records = await Promise.all(keys.map(k => storage.get(k)))
+  return records
+    .filter(Boolean)
+    .sort((a, b) => String(a.name || "").localeCompare(String(b.name || "")))
+    .map(toPublicAdapter)
+}
+
+async function getAdapter(name) {
+  const storage = getStorage()
+  const record = await storage.get(adapterKey(name))
+  if (!record) return null
+  return toPublicAdapter(record)
+}
+
+async function getAdapterSource(name) {
+  const storage = getStorage()
+  const record = await storage.get(adapterKey(name))
+  if (!record) return null
+  return record.source || null
+}
+
+function toPublicAdapter(record) {
+  return {
+    name: record.name,
+    description: record.description || "",
+    execution_context: record.execution_context || "server",
+    dependencies: record.dependencies || [],
+    timeout_ms: record.timeout_ms || 30000,
+    memory_limit_mb: record.memory_limit_mb || 128,
+    allow_network: record.allow_network === true,
+    created_at: record.created_at,
+    updated_at: record.updated_at,
+  }
+}
+
+async function createAdapter(payload) {
+  const sanitized = sanitizeAdapter(payload)
+  const now = new Date().toISOString()
+  
+  const record = {
+    ...sanitized,
+    created_at: now,
+    updated_at: now,
+  }
+  
+  const storage = getStorage()
+  await storage.set(adapterKey(sanitized.name), record)
+  await bumpVersion()
+  return toPublicAdapter(record)
+}
+
+async function updateAdapter(name, payload) {
+  const storage = getStorage()
+  const key = adapterKey(name)
+  const current = await storage.get(key)
+  
+  if (!current) {
+    throw Object.assign(new Error(`Adapter '${name}' not found`), {
+      code: 92,
+      type: "resource_not_found",
+      recoverable: false,
+    })
+  }
+  
+  const sanitized = sanitizeAdapter({ ...payload, name })
+  const now = new Date().toISOString()
+  
+  const record = {
+    ...sanitized,
+    created_at: current.created_at || now,
+    updated_at: now,
+  }
+  
+  await storage.set(key, record)
+  await bumpVersion()
+  return toPublicAdapter(record)
+}
+
+async function deleteAdapter(name) {
+  const storage = getStorage()
+  const key = adapterKey(name)
+  const current = await storage.get(key)
+  if (!current) return false
+  
+  await storage.delete(key)
+  await storage.delete(adapterPackagesKey(name))
+  await bumpVersion()
+  return true
+}
+
+async function getAdapterPackages(name) {
+  const storage = getStorage()
+  const packages = await storage.get(adapterPackagesKey(name))
+  return packages || []
+}
+
+async function addAdapterPackage(name, packageName, version = "latest") {
+  const { execSync } = require("child_process")
+  const path = require("path")
+  const fs = require("fs")
+  
+  const storage = getStorage()
+  const key = adapterPackagesKey(name)
+  const current = await storage.get(key) || []
+  
+  const packageSpec = version === "latest" ? packageName : `${packageName}@${version}`
+  
+  if (!current.includes(packageSpec)) {
+    // Create adapter directory if it doesn't exist
+    const adapterDir = path.join(process.cwd(), "supercli_storage", "adapters", name)
+    fs.mkdirSync(adapterDir, { recursive: true })
+    
+    // Initialize package.json if it doesn't exist
+    const packageJsonPath = path.join(adapterDir, "package.json")
+    if (!fs.existsSync(packageJsonPath)) {
+      fs.writeFileSync(packageJsonPath, JSON.stringify({ name, version: "1.0.0" }, null, 2))
+    }
+    
+    current.push(packageSpec)
+    await storage.set(key, current)
+    
+    try {
+      // Install only in adapter-specific directory
+      execSync(`npm install ${packageSpec}`, {
+        cwd: adapterDir,
+        stdio: "inherit",
+      })
+    } catch (err) {
+      // Rollback if install fails
+      const filtered = current.filter(p => p !== packageSpec)
+      await storage.set(key, filtered)
+      throw Object.assign(new Error(`Failed to install package ${packageSpec}`), {
+        code: 105,
+        type: "integration_error",
+        recoverable: false
+      })
+    }
+  }
+  
+  return current
+}
+
+async function removeAdapterPackage(name, packageName) {
+  const { execSync } = require("child_process")
+  const path = require("path")
+  const fs = require("fs")
+  
+  const storage = getStorage()
+  const key = adapterPackagesKey(name)
+  const current = await storage.get(key) || []
+  
+  const filtered = current.filter(p => !p.startsWith(`${packageName}@`) && p !== packageName)
+  
+  if (filtered.length !== current.length) {
+    await storage.set(key, filtered)
+    
+    // Uninstall from adapter-specific directory only
+    const adapterDir = path.join(process.cwd(), "supercli_storage", "adapters", name)
+    if (fs.existsSync(adapterDir)) {
+      try {
+        execSync(`npm uninstall ${packageName}`, {
+          cwd: adapterDir,
+          stdio: "inherit",
+        })
+      } catch (err) {
+        // Don't fail if uninstall fails, just log
+        console.error(`Failed to uninstall ${packageName} from adapter directory:`, err.message)
+      }
+    }
+  }
+  
+  return filtered
+}
+
+async function setAdapterPackages(name, packages) {
+  const { execSync } = require("child_process")
+  const path = require("path")
+  const fs = require("fs")
+  
+  const storage = getStorage()
+  const key = adapterPackagesKey(name)
+  
+  // Get current packages to determine which ones to uninstall
+  const current = await storage.get(key) || []
+  const newPackages = Array.isArray(packages) ? packages : []
+  
+  // Find packages that are being removed
+  const packagesToRemove = current.filter(p => !newPackages.includes(p))
+  
+  // Uninstall removed packages from adapter directory
+  const adapterDir = path.join(process.cwd(), "supercli_storage", "adapters", name)
+  if (packagesToRemove.length > 0 && fs.existsSync(adapterDir)) {
+    for (const pkg of packagesToRemove) {
+      const packageName = pkg.split('@')[0]
+      try {
+        execSync(`npm uninstall ${packageName}`, {
+          cwd: adapterDir,
+          stdio: "inherit",
+        })
+      } catch (err) {
+        console.error(`Failed to uninstall ${packageName} during prune:`, err.message)
+      }
+    }
+  }
+  
+  await storage.set(key, newPackages)
+}
+
+module.exports = {
+  listAdapters,
+  getAdapter,
+  getAdapterSource,
+  createAdapter,
+  updateAdapter,
+  deleteAdapter,
+  getAdapterPackages,
+  addAdapterPackage,
+  removeAdapterPackage,
+  setAdapterPackages,
+}

package/server/services/pluginsService.js

@@ -17,6 +17,7 @@ function defaultSettings() {
   return {
     max_zip_mb: 10,
     default_hooks_policy: "deny",
+    admin_mode_enabled: false,
   }
 }
 
@@ -115,6 +116,9 @@ async function updateSettings(patch = {}) {
   if (patch.default_hooks_policy !== undefined) {
     next.default_hooks_policy = sanitizeHooksPolicy(patch.default_hooks_policy, next.default_hooks_policy)
   }
+  if (patch.admin_mode_enabled !== undefined) {
+    next.admin_mode_enabled = patch.admin_mode_enabled === true || patch.admin_mode_enabled === "true"
+  }
   const storage = getStorage()
   await storage.set(SETTINGS_KEY, next)
   return next

package/server/views/adapter-edit.ejs

@@ -0,0 +1,226 @@
+<%- include("partials/head", { title: adapter ? "Edit Adapter" : "New Adapter" }) %>
+
+<div class="max-w-4xl">
+  <div class="flex justify-between items-center mb-6">
+    <div>
+      <p class="text-xs uppercase tracking-[0.2em] text-[#787774] mb-1">Management</p>
+      <h1 class="text-2xl editorial-heading text-[#111111]"><%= adapter ? "Edit Adapter" : "New Adapter" %></h1>
+    </div>
+    <div class="flex gap-2">
+      <% if (adapter) { %>
+        <a href="/api/adapters/<%= adapter.name %>/packages" class="btn">Packages</a>
+      <% } %>
+      <a href="/api/adapters" class="btn">Back</a>
+    </div>
+  </div>
+
+  <div id="adapter-editor">
+    <div v-if="message.text" :class="['alert mb-4', message.type === 'error' ? 'alert-error' : 'alert-success']">
+      <span>{{ message.text }}</span>
+    </div>
+
+    <form @submit.prevent="save" class="flex flex-col gap-4">
+      <div class="form-control">
+        <label class="label"><span class="label-text">Name</span></label>
+        <input v-model="form.name" class="input input-bordered input-sm" required 
+               placeholder="e.g. postgres" :disabled="!!editName"
+               pattern="[a-zA-Z][a-zA-Z0-9_-]*"
+               title="Must start with letter, contain only letters, numbers, underscores, hyphens">
+        <span class="text-xs text-[#787774] mt-1">Unique identifier for this adapter</span>
+      </div>
+
+      <div class="form-control">
+        <label class="label"><span class="label-text">Description</span></label>
+        <input v-model="form.description" class="input input-bordered input-sm" 
+               placeholder="What does this adapter do?">
+      </div>
+
+      <div class="form-control">
+        <label class="label"><span class="label-text">Execution Context</span></label>
+        <div class="flex gap-4 mt-2">
+          <label class="flex items-center gap-2 cursor-pointer">
+            <input type="radio" v-model="form.execution_context" value="server" class="radio">
+            <span>Server (runs on server, CLI receives result)</span>
+          </label>
+          <label class="flex items-center gap-2 cursor-pointer">
+            <input type="radio" v-model="form.execution_context" value="cli" class="radio">
+            <span>CLI (syncs to CLI, runs locally)</span>
+          </label>
+        </div>
+        <span class="text-xs text-[#787774] mt-1">
+          {{ form.execution_context === 'server' ? 
+             'Adapter runs on the server. Use for accessing server-side resources like internal databases.' :
+             'Adapter code is synced to CLI and runs locally. Use for accessing user machine resources.' }}
+        </span>
+      </div>
+
+      <div class="grid grid-cols-3 gap-4">
+        <div class="form-control">
+          <label class="label"><span class="label-text">Timeout (ms)</span></label>
+          <input v-model.number="form.timeout_ms" type="number" class="input input-bordered input-sm" 
+                 min="1000" max="300000" step="1000">
+        </div>
+        <div class="form-control">
+          <label class="label"><span class="label-text">Memory Limit (MB)</span></label>
+          <input v-model.number="form.memory_limit_mb" type="number" class="input input-bordered input-sm" 
+                 min="16" max="512" step="16">
+        </div>
+        <div class="form-control">
+          <label class="label"><span class="label-text">Allow Network</span></label>
+          <input v-model="form.allow_network" type="checkbox" class="checkbox">
+        </div>
+      </div>
+
+      <div class="form-control">
+        <label class="label flex justify-between">
+          <span>Source Code</span>
+          <span class="text-xs text-[#787774]">Must export an 'execute' function</span>
+        </label>
+        <div ref="editor" class="border border-[#EAEAEA] rounded" style="height: 400px;"></div>
+        <span class="text-xs text-[#787774] mt-1">
+          The adapter must export an 'execute' function: <code>function execute(cmd, flags, context)</code>
+        </span>
+      </div>
+
+      <div class="flex gap-2 mt-4">
+        <button type="submit" class="btn btn-primary">Save</button>
+        <button type="button" @click="testAdapter" class="btn" :disabled="form.execution_context === 'cli'">
+          {{ form.execution_context === 'cli' ? 'Test (CLI only)' : 'Test' }}
+        </button>
+        <a href="/api/adapters" class="btn">Cancel</a>
+      </div>
+    </form>
+
+    <div v-if="testResult" class="mt-6 p-4 rounded bg-[#F7F6F3]">
+      <h3 class="text-sm font-medium mb-2">Test Result</h3>
+      <div v-if="testResult.ok" class="text-green-600 text-sm">
+        ✓ Success ({{ testResult.duration_ms }}ms)
+      </div>
+      <div v-else class="text-red-600 text-sm">
+        ✗ Failed ({{ testResult.duration_ms }}ms): {{ testResult.error }}
+      </div>
+      <pre v-if="testResult.result" class="mt-2 p-2 bg-white rounded text-xs overflow-auto">{{ JSON.stringify(testResult.result, null, 2) }}</pre>
+    </div>
+  </div>
+</div>
+
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/codemirror.min.css">
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/theme/eclipse.min.css">
+<script src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/codemirror.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.2/mode/javascript/javascript.min.js"></script>
+
+<script>
+const defaultSource = `function execute(cmd, flags, context) {
+  // cmd: { namespace, resource, action, adapter, adapterConfig, args }
+  // flags: { key: value } - command line arguments
+  // context: { config, ... } - execution context
+
+  // Example: return data
+  return {
+    data: {
+      message: "Hello from custom adapter",
+      flags: flags
+    }
+  }
+}
+
+module.exports = { execute }
+`
+
+const editData = <%- JSON.stringify(adapter || null) %>
+const editName = '<%= adapter ? adapter.name : "" %>'
+
+Vue.createApp({
+  data() {
+    return {
+      editName,
+      form: {
+        name: editData?.name || '',
+        description: editData?.description || '',
+        execution_context: editData?.execution_context || 'server',
+        timeout_ms: editData?.timeout_ms || 30000,
+        memory_limit_mb: editData?.memory_limit_mb || 128,
+        allow_network: editData?.allow_network || false,
+      },
+      source: editData?.source || defaultSource,
+      message: { text: '', type: '' },
+      testResult: null,
+      editor: null,
+    }
+  },
+  mounted() {
+    this.editor = CodeMirror(this.$refs.editor, {
+      value: this.source,
+      mode: 'javascript',
+      theme: 'eclipse',
+      lineNumbers: true,
+      indentUnit: 2,
+      tabSize: 2,
+      lineWrapping: true,
+      viewportMargin: Infinity,
+    })
+    this.editor.on('change', () => {
+      this.source = this.editor.getValue()
+    })
+  },
+  methods: {
+    async save() {
+      this.message.text = ''
+      this.testResult = null
+      
+      const payload = {
+        ...this.form,
+        source: this.source,
+      }
+      
+      try {
+        const url = this.editName ? `/api/adapters/${this.editName}` : '/api/adapters'
+        const method = this.editName ? 'PUT' : 'POST'
+        
+        const res = await fetch(url, {
+          method,
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(payload)
+        })
+        
+        const data = await res.json()
+        
+        if (!res.ok) {
+          throw new Error(data.error || 'Save failed')
+        }
+        
+        this.message = { text: 'Adapter saved successfully', type: 'success' }
+        
+        if (!this.editName) {
+          setTimeout(() => {
+            window.location.href = `/api/adapters/${data.adapter.name}/edit`
+          }, 500)
+        }
+      } catch (err) {
+        this.message = { text: err.message, type: 'error' }
+      }
+    },
+    
+    async testAdapter() {
+      if (this.form.execution_context === 'cli') return
+      
+      this.testResult = null
+      this.message.text = ''
+      
+      try {
+        const res = await fetch(`/api/adapters/${this.editName}/test`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ flags: { test: true } })
+        })
+        
+        this.testResult = await res.json()
+      } catch (err) {
+        this.testResult = { ok: false, error: err.message, duration_ms: 0 }
+      }
+    }
+  }
+}).mount('#adapter-editor')
+</script>
+
+<%- include("partials/foot") %>