superacli 1.1.21 → 1.1.23

package/.supercli/adapters/test-cli-adapter.js

@@ -0,0 +1,19 @@
+/**
+ * @name test-cli-adapter
+ * @description Test adapter for CLI
+ * @context cli
+ * @timeout 30000
+ * @memory 128
+ * @network false
+ * @updated 2026-04-27T14:40:52.449Z
+ */
+
+async function execute(cmd, flags, context) {
+  return {
+    ok: true,
+    message: "Hello from test adapter",
+    command: cmd.command
+  }
+}
+
+module.exports = { execute }

package/cli/adapters/mcp.js

@@ -220,7 +220,7 @@ async function execute(cmd, flags, context) {
 
   const input = {};
   for (const [k, v] of Object.entries(flags)) {
-    if (!["human", "json", "compact"].includes(k)) {
+    if (!["human", "json", "compact", "stream"].includes(k)) {
       input[k] = v;
     }
   }
@@ -271,11 +271,35 @@ async function execute(cmd, flags, context) {
     );
   }
 
+  const result = await callHttpMcpTool(config, toolName, input, flags.stream === true);
+  return result;
+}
+
+async function callHttpMcpTool(config, toolName, input, streamMode = false) {
   const toolUrl = config.url.replace(/\/+$/, "");
+  
+  // Try SSE first, then fallback to simple HTTP
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "text/event-stream, application/json",
+    ...(config.headers || {}),
+  };
+
+  // Use JSON-RPC format for MCP protocol compatibility
+  const body = JSON.stringify({
+    jsonrpc: "2.0",
+    method: "tools/call",
+    params: {
+      name: toolName,
+      arguments: input,
+    },
+    id: 1,
+  });
+
   const tr = await fetch(`${toolUrl}/tool`, {
     method: "POST",
-    headers: { "Content-Type": "application/json", ...(config.headers || {}) },
-    body: JSON.stringify({ tool: toolName, input }),
+    headers,
+    body,
   });
 
   if (!tr.ok) {
@@ -290,7 +314,69 @@ async function execute(cmd, flags, context) {
     );
   }
 
+  const contentType = tr.headers.get("content-type") || "";
+  
+  // Check if response is SSE
+  if (contentType.includes("text/event-stream")) {
+    return parseSseResponse(tr, streamMode);
+  }
+  
+  // Standard JSON response
   return tr.json();
 }
 
+async function parseSseResponse(response, streamMode) {
+  const body = await response.text();
+  const lines = body.split("\n");
+  const events = [];
+  let currentEvent = null;
+  
+  for (const line of lines) {
+    if (line.startsWith("event: ")) {
+      currentEvent = { event: line.substring(7), data: "" };
+    } else if (line.startsWith("data: ")) {
+      if (currentEvent) {
+        currentEvent.data += line.substring(6);
+      }
+    } else if (line === "" && currentEvent) {
+      // End of event
+      try {
+        currentEvent.parsed = JSON.parse(currentEvent.data);
+        events.push(currentEvent);
+        
+        // In stream mode, we could yield here
+        if (streamMode) {
+          // For now, just accumulate - streaming support would need generator
+        }
+      } catch {
+        // Invalid JSON, skip
+      }
+      currentEvent = null;
+    }
+  }
+  
+  // Handle final event if not terminated properly
+  if (currentEvent && currentEvent.data) {
+    try {
+      currentEvent.parsed = JSON.parse(currentEvent.data);
+      events.push(currentEvent);
+    } catch {
+      // Invalid JSON, skip
+    }
+  }
+  
+  // Find the result event (usually the last one with content)
+  const resultEvent = events.find(e => e.event === "message" || e.parsed?.content);
+  
+  if (resultEvent && resultEvent.parsed) {
+    return resultEvent.parsed;
+  }
+  
+  // Fallback: return all parsed events
+  return {
+    events: events.map(e => e.parsed || e.data),
+    stream: streamMode,
+  };
+}
+
 module.exports = { execute };

package/cli/adapters/openapi.js

@@ -98,6 +98,65 @@ function buildUrl(baseUrl, pathStr, method, operation, flags) {
   return { url: fullUrl, method };
 }
 
+function resolveAuthValue(authConfig, flags) {
+  if (!authConfig) return null;
+
+  const { argName, envVar } = authConfig;
+
+  // Check command arguments first (highest priority)
+  if (argName && flags[argName] !== undefined) {
+    return flags[argName];
+  }
+
+  // Check environment variable
+  if (envVar && process.env[envVar] !== undefined) {
+    return process.env[envVar];
+  }
+
+  return null;
+}
+
+function applyAuth(fetchOpts, authConfig, authValue) {
+  if (!authConfig || !authValue) return;
+
+  const { type, bearer, headerName, queryName, bodyName } = authConfig;
+
+  switch (type) {
+    case "bearer":
+      fetchOpts.headers["Authorization"] = `Bearer ${authValue}`;
+      break;
+    case "basic": {
+      const base64 = Buffer.from(authValue).toString("base64");
+      fetchOpts.headers["Authorization"] = `Basic ${base64}`;
+      break;
+    }
+    case "api-key":
+      if (headerName) {
+        fetchOpts.headers[headerName] = authValue;
+      } else if (queryName) {
+        // Add to URL query params
+        const url = new URL(fetchOpts.url || "");
+        url.searchParams.set(queryName, authValue);
+        fetchOpts.url = url.toString();
+      } else if (bodyName) {
+        // Add to body for POST/PUT/PATCH
+        if (fetchOpts.body) {
+          try {
+            const bodyObj = JSON.parse(fetchOpts.body);
+            bodyObj[bodyName] = authValue;
+            fetchOpts.body = JSON.stringify(bodyObj);
+          } catch {
+            // If body isn't JSON, can't add auth field
+          }
+        }
+      }
+      break;
+    default:
+      // Unknown auth type, ignore
+      break;
+  }
+}
+
 async function execute(cmd, flags, context) {
   const config = cmd.adapterConfig || {};
   const specName = config.spec;
@@ -123,7 +182,7 @@ async function execute(cmd, flags, context) {
     flags,
   );
 
-  const fetchOpts = { method: httpMethod, headers: {} };
+  const fetchOpts = { method: httpMethod, headers: {}, url };
 
   // Handle request body for POST/PUT/PATCH
   if (["POST", "PUT", "PATCH"].includes(httpMethod)) {
@@ -137,7 +196,17 @@ async function execute(cmd, flags, context) {
     fetchOpts.headers["Content-Type"] = "application/json";
   }
 
-  const r = await fetch(url, fetchOpts);
+  // Apply auth if configured
+  const authConfig = config.auth;
+  const authValue = resolveAuthValue(authConfig, flags);
+  if (authConfig && authValue) {
+    applyAuth(fetchOpts, authConfig, authValue);
+  }
+
+  const finalUrl = fetchOpts.url || url;
+  delete fetchOpts.url;
+
+  const r = await fetch(finalUrl, fetchOpts);
   if (!r.ok) {
     const text = await r.text().catch(() => "");
     throw Object.assign(

package/cli/config.js

@@ -1,6 +1,7 @@
 const fs = require("fs")
 const path = require("path")
 const os = require("os")
+const crypto = require("crypto")
 const {
   getEffectivePluginCommands,
   listInstalledPlugins,
@@ -13,6 +14,22 @@ const { spawnSync } = require("child_process")
 const CACHE_DIR = path.join(os.homedir(), ".supercli")
 const CACHE_FILE = path.join(CACHE_DIR, "config.json")
 
+function getClientId() {
+  // Allow ENV override for custom identification
+  if (process.env.SUPERCLI_CLIENT_ID) {
+    return String(process.env.SUPERCLI_CLIENT_ID).trim()
+  }
+  // Minimal machine fingerprint
+  const pieces = [
+    os.hostname(),
+    os.type(),
+    os.release(),
+    os.arch(),
+    os.userInfo().username,
+  ]
+  return crypto.createHash('sha256').update(pieces.join('|')).digest('hex')
+}
+
 function ensureCacheDir() {
   if (!fs.existsSync(CACHE_DIR)) {
     fs.mkdirSync(CACHE_DIR, { recursive: true })
@@ -331,6 +348,48 @@ async function syncServerPlugins(server) {
   return diagnostics
 }
 
+async function syncClientPluginResources(server) {
+  const { readPluginsLock } = require("./plugins-store")
+  const lock = readPluginsLock()
+  const installed = lock.installed || {}
+  const clientId = getClientId()
+  
+  // Filter plugins with server_resources
+  const pluginsWithResources = []
+  for (const [name, plugin] of Object.entries(installed)) {
+    if (plugin.server_resources && (plugin.server_resources.mcp || plugin.server_resources.specs)) {
+      pluginsWithResources.push({
+        name: name,
+        server_resources: plugin.server_resources
+      })
+    }
+  }
+  
+  if (pluginsWithResources.length === 0) {
+    return { synced: 0, errors: [] }
+  }
+  
+  try {
+    const r = await fetch(`${server}/api/plugins/client-resources`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ 
+        client_id: clientId,
+        plugins: pluginsWithResources 
+      })
+    })
+    
+    if (!r.ok) {
+      throw new Error(`Failed to sync plugin resources: ${r.status} ${r.statusText}`)
+    }
+    
+    const result = await r.json()
+    return { synced: pluginsWithResources.length, result }
+  } catch (err) {
+    return { synced: 0, errors: [err.message] }
+  }
+}
+
 async function syncConfig(server) {
   const config = await fetchRemoteConfig(server)
 
@@ -370,6 +429,14 @@ async function syncConfig(server) {
     }
   }
 
+  // Sync client plugin resources
+  let clientResources = { synced: 0, errors: [] }
+  try {
+    clientResources = await syncClientPluginResources(server)
+  } catch (err) {
+    clientResources = { synced: 0, errors: [err.message] }
+  }
+
   // Sync CLI-context adapters
   let cliAdapters = { total: 0, synced: 0, failed: 0 }
   try {
@@ -382,6 +449,7 @@ async function syncConfig(server) {
   return {
     ...written,
     server_plugins: serverPlugins,
+    client_resources: clientResources,
     cli_adapters: cliAdapters,
   }
 }
@@ -549,4 +617,4 @@ async function showConfig() {
   }
 }
 
-module.exports = { loadConfig, syncConfig, showConfig, setMcpServer, removeMcpServer, listMcpServers, upsertCommand, removeCommandsByNamespace }
+module.exports = { loadConfig, syncConfig, showConfig, setMcpServer, removeMcpServer, listMcpServers, upsertCommand, removeCommandsByNamespace, syncClientPluginResources, getClientId }

package/cli/daemon.js

@@ -0,0 +1,349 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { spawn } = require("child_process");
+
+const SUPERCLI_DIR = path.join(os.homedir(), ".supercli");
+const LOGS_DIR = path.join(SUPERCLI_DIR, "logs");
+const PID_FILE = path.join(SUPERCLI_DIR, "daemon.pid");
+const HEARTBEAT_FILE = path.join(SUPERCLI_DIR, "daemon.heartbeat");
+const CONFIG_FILE = path.join(SUPERCLI_DIR, "daemon.json");
+
+// Default daemon configuration
+const DEFAULT_CONFIG = {
+  enabled: true,
+  sync_interval_seconds: 60,
+  log_retention_hours: 24,
+  server_url: "http://localhost:3000",
+};
+
+// Ensure directories exist
+function ensureDirectories() {
+  if (!fs.existsSync(SUPERCLI_DIR)) {
+    fs.mkdirSync(SUPERCLI_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(LOGS_DIR)) {
+    fs.mkdirSync(LOGS_DIR, { recursive: true });
+  }
+}
+
+// Load daemon configuration
+function loadConfig() {
+  ensureDirectories();
+  if (!fs.existsSync(CONFIG_FILE)) {
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2));
+    return DEFAULT_CONFIG;
+  }
+  try {
+    return { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8")) };
+  } catch (err) {
+    return DEFAULT_CONFIG;
+  }
+}
+
+// Get daily log file path
+function getLogFilePath() {
+  const date = new Date().toISOString().split("T")[0];
+  return path.join(LOGS_DIR, `jobs-${date}.jsonl`);
+}
+
+// Write log entry to daily log file
+function writeLog(logEntry) {
+  ensureDirectories();
+  const logFile = getLogFilePath();
+  const entry = { ...logEntry, synced: false };
+  fs.appendFileSync(logFile, JSON.stringify(entry) + "\n");
+}
+
+// Check if daemon is running
+function isDaemonRunning() {
+  if (!fs.existsSync(PID_FILE)) {
+    return false;
+  }
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, "utf8").trim());
+    // Check if process is running
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (e) {
+      // Process not found, clean up stale PID file
+      fs.unlinkSync(PID_FILE);
+      return false;
+    }
+  } catch (err) {
+    return false;
+  }
+}
+
+// Write heartbeat timestamp
+function writeHeartbeat() {
+  ensureDirectories();
+  fs.writeFileSync(HEARTBEAT_FILE, new Date().toISOString());
+}
+
+// Get heartbeat timestamp
+function getHeartbeat() {
+  if (!fs.existsSync(HEARTBEAT_FILE)) {
+    return null;
+  }
+  try {
+    return new Date(fs.readFileSync(HEARTBEAT_FILE, "utf8").trim());
+  } catch (err) {
+    return null;
+  }
+}
+
+// Start daemon process
+function startDaemon() {
+  ensureDirectories();
+  if (isDaemonRunning()) {
+    return { ok: true, message: "Daemon already running" };
+  }
+
+  const config = loadConfig();
+  if (!config.enabled) {
+    return { ok: false, message: "Daemon is disabled in config" };
+  }
+
+  // Spawn daemon as independent process
+  const daemonScript = path.join(__dirname, "daemon.js");
+  const nodePath = process.execPath;
+
+  const child = spawn(nodePath, [daemonScript, "--daemon"], {
+    detached: true,
+    stdio: "ignore",
+  });
+
+  child.unref(); // Allow parent to exit without waiting for child
+
+  return { ok: true, message: "Daemon started" };
+}
+
+// Stop daemon process
+function stopDaemon() {
+  if (!isDaemonRunning()) {
+    return { ok: true, message: "Daemon not running" };
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, "utf8").trim());
+    process.kill(pid, "SIGTERM");
+    fs.unlinkSync(PID_FILE);
+    return { ok: true, message: "Daemon stopped" };
+  } catch (err) {
+    return { ok: false, message: `Failed to stop daemon: ${err.message}` };
+  }
+}
+
+// Get daemon status
+function getDaemonStatus() {
+  const running = isDaemonRunning();
+  const heartbeat = getHeartbeat();
+  const config = loadConfig();
+
+  return {
+    running,
+    enabled: config.enabled,
+    heartbeat: heartbeat ? heartbeat.toISOString() : null,
+    pid: running ? parseInt(fs.readFileSync(PID_FILE, "utf8").trim()) : null,
+  };
+}
+
+// Sync logs to server
+async function syncLogs(config) {
+  const logFile = getLogFilePath();
+  if (!fs.existsSync(logFile)) {
+    return { synced: 0, errors: 0 };
+  }
+
+  const lines = fs.readFileSync(logFile, "utf8").split("\n").filter(Boolean);
+  const unsyncedLogs = [];
+
+  for (const line of lines) {
+    try {
+      const log = JSON.parse(line);
+      if (!log.synced) {
+        unsyncedLogs.push(log);
+      }
+    } catch (err) {
+      // Skip invalid lines
+    }
+  }
+
+  if (unsyncedLogs.length === 0) {
+    return { synced: 0, errors: 0 };
+  }
+
+  let synced = 0;
+  let errors = 0;
+
+  // Upload logs one at a time (server expects single job object)
+  for (const log of unsyncedLogs) {
+    try {
+      const headers = { "Content-Type": "application/json" };
+      const apiKey = process.env.SUPERCLI_API_KEY;
+      if (apiKey) {
+        headers["X-API-Key"] = apiKey;
+      }
+
+      const response = await fetch(`${config.server_url}/api/jobs`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          command: log.command,
+          args: log.args,
+          status: log.status,
+          duration_ms: log.duration_ms,
+          timestamp: log.timestamp,
+          client_id: log.client_id,
+        }),
+      });
+
+      if (response.ok) {
+        synced++;
+        // Mark log as synced
+        updateSyncStatus(logFile, [log.timestamp]);
+      } else {
+        errors++;
+      }
+    } catch (err) {
+      errors++;
+    }
+  }
+
+  return { synced, errors };
+}
+
+// Update sync status in log file
+function updateSyncStatus(logFile, timestamps) {
+  const lines = fs.readFileSync(logFile, "utf8").split("\n").filter(Boolean);
+  const timestampSet = new Set(timestamps);
+  const updatedLines = lines.map((line) => {
+    try {
+      const log = JSON.parse(line);
+      if (timestampSet.has(log.timestamp)) {
+        log.synced = true;
+        return JSON.stringify(log);
+      }
+      return line;
+    } catch (err) {
+      return line;
+    }
+  });
+  fs.writeFileSync(logFile, updatedLines.join("\n") + "\n");
+}
+
+// Prune old logs
+function pruneLogs(config) {
+  ensureDirectories();
+  const retentionMs = config.log_retention_hours * 60 * 60 * 1000;
+  const cutoff = Date.now() - retentionMs;
+
+  const files = fs.readdirSync(LOGS_DIR);
+  let pruned = 0;
+
+  for (const file of files) {
+    if (!file.startsWith("jobs-") || !file.endsWith(".jsonl")) {
+      continue;
+    }
+
+    const filePath = path.join(LOGS_DIR, file);
+    const lines = fs.readFileSync(filePath, "utf8").split("\n").filter(Boolean);
+    const keptLines = [];
+
+    for (const line of lines) {
+      try {
+        const log = JSON.parse(line);
+        const logTime = new Date(log.timestamp).getTime();
+        // Keep if: not synced OR within retention period
+        if (!log.synced || logTime > cutoff) {
+          keptLines.push(line);
+        } else {
+          pruned++;
+        }
+      } catch (err) {
+        // Keep invalid lines
+        keptLines.push(line);
+      }
+    }
+
+    if (keptLines.length === 0) {
+      // Delete empty file
+      fs.unlinkSync(filePath);
+    } else {
+      fs.writeFileSync(filePath, keptLines.join("\n") + "\n");
+    }
+  }
+
+  return { pruned };
+}
+
+// Daemon main loop
+async function daemonMain() {
+  const config = loadConfig();
+  console.log("Daemon started, syncing every", config.sync_interval_seconds, "seconds");
+
+  while (true) {
+    try {
+      writeHeartbeat();
+      const syncResult = await syncLogs(config);
+      const pruneResult = pruneLogs(config);
+
+      if (syncResult.synced > 0 || pruneResult.pruned > 0) {
+        console.log(`Synced ${syncResult.synced} logs, pruned ${pruneResult.pruned} logs`);
+      }
+    } catch (err) {
+      console.error("Daemon error:", err);
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, config.sync_interval_seconds * 1000));
+  }
+}
+
+// CLI entry point
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  if (args.includes("--daemon")) {
+    // Run as daemon process
+    const pid = process.pid;
+    ensureDirectories();
+    fs.writeFileSync(PID_FILE, pid.toString());
+    daemonMain().catch((err) => {
+      console.error("Daemon fatal error:", err);
+      process.exit(1);
+    });
+  } else {
+    // CLI commands
+    const command = args[0];
+
+    switch (command) {
+      case "start":
+        console.log(JSON.stringify(startDaemon(), null, 2));
+        break;
+      case "stop":
+        console.log(JSON.stringify(stopDaemon(), null, 2));
+        break;
+      case "status":
+        console.log(JSON.stringify(getDaemonStatus(), null, 2));
+        break;
+      default:
+        console.log("Usage: node daemon.js {start|stop|status}");
+        process.exit(1);
+    }
+  }
+}
+
+module.exports = {
+  startDaemon,
+  stopDaemon,
+  isDaemonRunning,
+  writeLog,
+  syncLogs,
+  pruneLogs,
+  writeHeartbeat,
+  getHeartbeat,
+  getDaemonStatus,
+  loadConfig,
+};