superacli 1.0.0

package/server/routes/jobs.js

@@ -0,0 +1,122 @@
+const { Router } = require("express")
+const { getStorage } = require("../storage/adapter")
+
+const router = Router()
+
+// POST /api/jobs — record a command execution job
+router.post("/", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const { command, args, status, duration_ms, timestamp, plan_id, error } = req.body
+    
+    // Generate a unique sequential-ish ID
+    const jobId = `job:${Date.now()}_${Math.random().toString(36).substring(2, 9)}`
+    
+    const doc = {
+      _id: jobId,
+      command,
+      args: args || {},
+      status: status || "unknown",
+      duration_ms: duration_ms || 0,
+      plan_id: plan_id || null,
+      error: error || null,
+      timestamp: timestamp || new Date().toISOString()
+    }
+    
+    await storage.set(jobId, doc)
+    res.status(201).json(doc)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/jobs — list recent jobs
+router.get("/", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const limit = parseInt(req.query.limit) || 50
+    const commandQuery = req.query.command
+    
+    const keys = await storage.listKeys("job:")
+    let jobs = await Promise.all(keys.map(k => storage.get(k)))
+    
+    jobs = jobs.filter(j => !!j)
+    if (commandQuery) {
+      jobs = jobs.filter(j => j.command === commandQuery)
+    }
+    
+    // Sort descending by timestamp
+    jobs.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp))
+    jobs = jobs.slice(0, limit)
+
+    // If HTML request, render
+    if (req.query.format !== "json" && req.accepts("html") && !req.xhr && !req.headers["x-requested-with"]) {
+      return res.render("jobs", { jobs })
+    }
+
+    res.json(jobs)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/jobs/stats — aggregate stats
+router.get("/stats", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const keys = await storage.listKeys("job:")
+    const jobs = await Promise.all(keys.map(k => storage.get(k)))
+    
+    const total = jobs.length
+    let success = 0
+    let failed = 0
+    const commandStats = {}
+    
+    for (const job of jobs) {
+      if (!job) continue
+      if (job.status === "success") success++
+      if (job.status === "failed") failed++
+      
+      const cmd = job.command
+      if (!commandStats[cmd]) {
+        commandStats[cmd] = { count: 0, sum_ms: 0 }
+      }
+      commandStats[cmd].count++
+      commandStats[cmd].sum_ms += job.duration_ms
+    }
+    
+    const topCommands = Object.entries(commandStats)
+      .map(([cmd, stats]) => ({
+        command: cmd,
+        count: stats.count,
+        avg_ms: Math.round(stats.sum_ms / stats.count) || 0
+      }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 10)
+
+    res.json({
+      total,
+      success,
+      failed,
+      failure_rate: total > 0 ? (failed / total * 100).toFixed(1) + "%" : "0%",
+      top_commands: topCommands
+    })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/jobs/:id — get job details
+router.get("/:id", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    const job = await storage.get(id.startsWith("job:") ? id : `job:${id}`)
+    if (!job) return res.status(404).json({ error: "Job not found" })
+    res.json(job)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router

package/server/routes/mcp.js

@@ -0,0 +1,79 @@
+const { Router } = require("express")
+const { getStorage } = require("../storage/adapter")
+const { bumpVersion } = require("../services/configService")
+
+const router = Router()
+
+async function getAllMCPs() {
+  const storage = getStorage()
+  const keys = await storage.listKeys("mcp:")
+  const servers = await Promise.all(keys.map(k => storage.get(k)))
+  return servers.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+// GET /api/mcp
+router.get("/", async (req, res) => {
+  try {
+    const servers = await getAllMCPs()
+    if (req.query.format !== "json" && req.accepts("html") && !req.xhr && !req.headers["x-requested-with"]) {
+      return res.render("mcp", { servers })
+    }
+    res.json(servers)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// POST /api/mcp
+router.post("/", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const { name, url } = req.body
+    const key = `mcp:${name}`
+    const doc = { _id: key, name, url, createdAt: new Date() }
+    await storage.set(key, doc)
+    await bumpVersion()
+    if (req.headers["content-type"]?.includes("urlencoded")) {
+      return res.redirect("/api/mcp")
+    }
+    res.status(201).json(doc)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// PUT /api/mcp/:id
+router.put("/:id", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    const { name, url } = req.body
+    
+    const newKey = `mcp:${name}`
+    if (newKey !== id) {
+      await storage.delete(id)
+    }
+
+    const doc = { _id: newKey, name, url }
+    await storage.set(newKey, doc)
+    await bumpVersion()
+    res.json({ ok: true })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// DELETE /api/mcp/:id
+router.delete("/:id", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    await storage.delete(id)
+    await bumpVersion()
+    res.json({ ok: true })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router

package/server/routes/plans.js

@@ -0,0 +1,134 @@
+const { Router } = require("express")
+const { getStorage } = require("../storage/adapter")
+const { createPlan } = require("../../cli/planner")
+
+const router = Router()
+
+// POST /api/plans — create a plan
+router.post("/", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const { command, args, cmd } = req.body
+
+    let planCmd = cmd
+    if (!planCmd) {
+      // Resolve command from DB
+      const [namespace, resource, action] = command.split(".")
+      planCmd = await storage.get(`command:${namespace}.${resource}.${action}`)
+      if (!planCmd) return res.status(404).json({ error: "Command not found" })
+    }
+
+    const plan = createPlan(planCmd, args || {})
+    
+    // Auto-expiry for file storage logic could go here, but for now we just store it
+    await storage.set(`plan:${plan.plan_id}`, plan)
+    res.status(201).json(plan)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/plans — list recent plans
+router.get("/", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const keys = await storage.listKeys("plan:")
+    const plans = await Promise.all(keys.map(k => storage.get(k)))
+    
+    // Sort descending by created_at and limit to 50
+    const sorted = plans
+      .filter(p => !!p)
+      .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))
+      .slice(0, 50)
+      
+    res.json(sorted)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/plans/:id — inspect plan
+router.get("/:id", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    const plan = await storage.get(`plan:${id}`)
+    if (!plan) return res.status(404).json({ error: "Plan not found" })
+    res.json(plan)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// POST /api/plans/:id/execute — execute a stored plan
+router.post("/:id/execute", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    const plan = await storage.get(`plan:${id}`)
+    if (!plan) return res.status(404).json({ error: "Plan not found" })
+    if (plan.status !== "planned") {
+      return res.status(400).json({ error: `Plan status is '${plan.status}', expected 'planned'` })
+    }
+
+    // Resolve command
+    const [namespace, resource, action] = plan.command.split(".")
+    const cmd = await storage.get(`command:${namespace}.${resource}.${action}`)
+    if (!cmd) return res.status(404).json({ error: "Command no longer exists" })
+
+    // Execute via adapter
+    const { execute } = require("../../cli/executor")
+    const start = Date.now()
+    let result, status = "success"
+    try {
+      result = await execute(cmd, plan.args || {}, { server: `http://localhost:${process.env.PORT || 3000}` })
+    } catch (err) {
+      result = { error: err.message }
+      status = "failed"
+    }
+    const duration = Date.now() - start
+
+    // Update plan status
+    plan.status = status
+    plan.executed_at = new Date().toISOString()
+    plan.duration_ms = duration
+    await storage.set(`plan:${id}`, plan)
+
+    // Record job
+    const jobId = `job:${Date.now()}_${Math.random().toString(36).substring(2, 9)}`
+    await storage.set(jobId, {
+      _id: jobId,
+      command: plan.command,
+      plan_id: plan.plan_id,
+      args: plan.args,
+      status,
+      duration_ms: duration,
+      timestamp: new Date().toISOString()
+    })
+
+    res.json({
+      version: "1.0",
+      plan_id: plan.plan_id,
+      command: plan.command,
+      status,
+      duration_ms: duration,
+      data: result
+    })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// DELETE /api/plans/:id — cancel plan
+router.delete("/:id", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    await storage.delete(`plan:${id}`)
+    res.json({ ok: true })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router

package/server/routes/specs.js

@@ -0,0 +1,79 @@
+const { Router } = require("express")
+const { getStorage } = require("../storage/adapter")
+const { bumpVersion } = require("../services/configService")
+
+const router = Router()
+
+async function getAllSpecs() {
+  const storage = getStorage()
+  const keys = await storage.listKeys("spec:")
+  const specs = await Promise.all(keys.map(k => storage.get(k)))
+  return specs.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+// GET /api/specs
+router.get("/", async (req, res) => {
+  try {
+    const specs = await getAllSpecs()
+    if (req.query.format !== "json" && req.accepts("html") && !req.xhr && !req.headers["x-requested-with"]) {
+      return res.render("specs", { specs })
+    }
+    res.json(specs)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// POST /api/specs
+router.post("/", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const { name, url, auth } = req.body
+    const key = `spec:${name}`
+    const doc = { _id: key, name, url, auth: auth || "none", createdAt: new Date() }
+    await storage.set(key, doc)
+    await bumpVersion()
+    if (req.headers["content-type"]?.includes("urlencoded")) {
+      return res.redirect("/api/specs")
+    }
+    res.status(201).json(doc)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// PUT /api/specs/:id
+router.put("/:id", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    const { name, url, auth } = req.body
+    
+    const newKey = `spec:${name}`
+    if (newKey !== id) {
+      await storage.delete(id)
+    }
+
+    const doc = { _id: newKey, name, url, auth: auth || "none" }
+    await storage.set(newKey, doc)
+    await bumpVersion()
+    res.json({ ok: true })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// DELETE /api/specs/:id
+router.delete("/:id", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    await storage.delete(id)
+    await bumpVersion()
+    res.json({ ok: true })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router

package/server/services/configService.js

@@ -0,0 +1,88 @@
+const { getStorage } = require("../storage/adapter")
+
+async function getCLIConfig() {
+  const storage = getStorage()
+  const keys = await storage.listKeys("command:")
+  const commands = await Promise.all(keys.map(k => storage.get(k)))
+  const mcpKeys = await storage.listKeys("mcp:")
+  const mcpServers = await Promise.all(mcpKeys.map(k => storage.get(k)))
+  const specKeys = await storage.listKeys("spec:")
+  const specs = await Promise.all(specKeys.map(k => storage.get(k)))
+  const version = await storage.get("settings:config_version")
+
+  return {
+    version: version || "1",
+    ttl: 3600,
+    mcp_servers: mcpServers
+      .filter(Boolean)
+      .map(s => ({ name: s.name, url: s.url })),
+    specs: specs
+      .filter(Boolean)
+      .map(s => ({ name: s.name, url: s.url, auth: s.auth || "none" })),
+    commands: commands.map(c => ({
+      _id: c._id, // this will now be the natural key
+      namespace: c.namespace,
+      resource: c.resource,
+      action: c.action,
+      description: c.description || "",
+      adapter: c.adapter,
+      adapterConfig: c.adapterConfig || {},
+      args: c.args || []
+    }))
+  }
+}
+
+async function bumpVersion() {
+  const storage = getStorage()
+  const current = await storage.get("settings:config_version")
+  const next = String(parseInt(current || "0", 10) + 1)
+  await storage.set("settings:config_version", next)
+  return next
+}
+
+async function getNamespaces() {
+  const storage = getStorage()
+  const keys = await storage.listKeys("command:")
+  const namespaces = new Set()
+  for (const k of keys) {
+    const parts = k.replace("command:", "").split(".")
+    namespaces.add(parts[0])
+  }
+  return Array.from(namespaces)
+}
+
+async function getResources(namespace) {
+  const storage = getStorage()
+  const keys = await storage.listKeys(`command:${namespace}.`)
+  const resources = new Set()
+  for (const k of keys) {
+    const parts = k.replace("command:", "").split(".")
+    resources.add(parts[1])
+  }
+  return Array.from(resources)
+}
+
+async function getActions(namespace, resource) {
+  const storage = getStorage()
+  const keys = await storage.listKeys(`command:${namespace}.${resource}.`)
+  const actions = new Set()
+  for (const k of keys) {
+    const parts = k.replace("command:", "").split(".")
+    actions.add(parts[2])
+  }
+  return Array.from(actions)
+}
+
+async function getCommand(namespace, resource, action) {
+  const storage = getStorage()
+  return storage.get(`command:${namespace}.${resource}.${action}`)
+}
+
+module.exports = {
+  getCLIConfig,
+  bumpVersion,
+  getNamespaces,
+  getResources,
+  getActions,
+  getCommand
+}

package/server/storage/adapter.js

@@ -0,0 +1,32 @@
+/**
+ * Storage Adapter Factory
+ * Provides a unified KV store interface (get, set, delete, listKeys)
+ * driven by either MongoDB or local JSON files.
+ */
+const MongoAdapter = require("./mongo");
+const FileAdapter = require("./file");
+
+// Singleton storage instance
+let currentAdapter = null;
+
+function getStorage() {
+  if (currentAdapter) return currentAdapter;
+
+  const useMongo = process.env.SUPERCLI_USE_MONGO === "true";
+  if (useMongo) {
+    const mongoUrl = process.env.MONGO_URL || "mongodb://localhost:27017";
+    const dbName = process.env.SUPERCLI_DB || "supercli";
+    currentAdapter = new MongoAdapter(mongoUrl, dbName);
+    console.log(
+      `[Storage] Initialized MongoDB adapter (${mongoUrl}/${dbName})`,
+    );
+  } else {
+    const storageDir = process.env.SUPERCLI_STORAGE_DIR || "./supercli_storage";
+    currentAdapter = new FileAdapter(storageDir);
+    console.log(`[Storage] Initialized File adapter (${storageDir})`);
+  }
+
+  return currentAdapter;
+}
+
+module.exports = { getStorage };

package/server/storage/file.js

@@ -0,0 +1,64 @@
+/**
+ * FileAdapter implementation for SUPERCLI Storage using JSON files
+ */
+const fs = require("fs").promises;
+const path = require("path");
+
+class FileAdapter {
+  constructor(baseDir = "./supercli_storage") {
+    this.baseDir = path.resolve(baseDir);
+  }
+
+  filePath(key) {
+    // Basic sanitization to avoid directory traversal inside the storage scope
+    const safeKey = key.replace(/[^a-zA-Z0-9_.-]/g, "_");
+    return path.join(this.baseDir, `${safeKey}.json`);
+  }
+
+  async get(key) {
+    try {
+      const data = await fs.readFile(this.filePath(key), "utf-8");
+      return JSON.parse(data);
+    } catch (e) {
+      if (e.code === "ENOENT") return null;
+      throw e;
+    }
+  }
+
+  async set(key, value) {
+    await fs.mkdir(this.baseDir, { recursive: true });
+    await fs.writeFile(
+      this.filePath(key),
+      JSON.stringify(value, null, 2),
+      "utf-8",
+    );
+  }
+
+  async delete(key) {
+    try {
+      await fs.unlink(this.filePath(key));
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  }
+
+  async listKeys(prefix = "") {
+    try {
+      const files = await fs.readdir(this.baseDir);
+      // Reverse the sanitization mapping in listKeys if we can,
+      // but for prefix search, we just look at files matching the sanitized prefix.
+      const safePrefix = prefix.replace(/[^a-zA-Z0-9_.-]/g, "_");
+      return (
+        files
+          .filter((f) => f.endsWith(".json") && f.startsWith(safePrefix))
+          // Here we just strip .json. Actual key might be slightly different if it had chars we sanitized out
+          .map((f) => f.replace(/\.json$/, ""))
+      );
+    } catch (e) {
+      if (e.code === "ENOENT") return [];
+      throw e;
+    }
+  }
+}
+
+module.exports = FileAdapter;

package/server/storage/mongo.js

@@ -0,0 +1,55 @@
+/**
+ * MongoAdapter implementation for SUPERCLI Storage
+ */
+const { MongoClient } = require("mongodb");
+
+class MongoAdapter {
+  constructor(uri, dbName = "supercli", collectionName = "storage") {
+    this.client = new MongoClient(uri);
+    this.dbName = dbName;
+    this.collectionName = collectionName;
+    this.connected = false;
+    this.collection = null;
+  }
+
+  async connect() {
+    if (!this.connected) {
+      await this.client.connect();
+      this.collection = this.client
+        .db(this.dbName)
+        .collection(this.collectionName);
+      this.connected = true;
+    }
+  }
+
+  async get(key) {
+    await this.connect();
+    const doc = await this.collection.findOne({ _id: key });
+    return doc ? doc.value : null;
+  }
+
+  async set(key, value) {
+    await this.connect();
+    await this.collection.updateOne(
+      { _id: key },
+      { $set: { value } },
+      { upsert: true },
+    );
+  }
+
+  async delete(key) {
+    await this.connect();
+    await this.collection.deleteOne({ _id: key });
+  }
+
+  async listKeys(prefix = "") {
+    await this.connect();
+    const query = prefix ? { _id: { $regex: `^${prefix}` } } : {};
+    const docs = await this.collection
+      .find(query, { projection: { _id: 1 } })
+      .toArray();
+    return docs.map((doc) => doc._id);
+  }
+}
+
+module.exports = MongoAdapter;