superacli 1.1.4 → 1.1.6

package/cli/mcp-discovery.js

@@ -0,0 +1,221 @@
+const { spawn } = require("child_process");
+const {
+  shouldUseStdioJsonRpc,
+  stdioListToolsJsonRpc,
+} = require("./mcp-stdio-jsonrpc");
+
+function interpolateEnvPlaceholders(text) {
+  if (typeof text !== "string") return text;
+  return text.replace(/\$\{([A-Z0-9_]+)\}/g, (_, name) => process.env[name] || "");
+}
+
+function interpolateStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((v) => typeof v === "string")
+    .map((v) => interpolateEnvPlaceholders(v));
+}
+
+function interpolateStringMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof k === "string" && typeof v === "string") {
+      out[k] = interpolateEnvPlaceholders(v);
+    }
+  }
+  return out;
+}
+
+function normalizeTools(payload) {
+  const source = payload && typeof payload === "object" ? payload : {};
+  const raw =
+    (Array.isArray(source.tools) && source.tools) ||
+    (source.result && Array.isArray(source.result.tools) && source.result.tools) ||
+    (Array.isArray(source.result) && source.result) ||
+    (Array.isArray(source.data) && source.data) ||
+    (Array.isArray(source) && source) ||
+    [];
+
+  const tools = [];
+  for (const item of raw) {
+    if (typeof item === "string") {
+      tools.push({ name: item, description: "" });
+      continue;
+    }
+    if (!item || typeof item !== "object") continue;
+    const name =
+      (typeof item.name === "string" && item.name) ||
+      (typeof item.tool === "string" && item.tool) ||
+      (typeof item.id === "string" && item.id) ||
+      null;
+    if (!name) continue;
+    tools.push({
+      name,
+      description: typeof item.description === "string" ? item.description : "",
+      input_schema:
+        item.inputSchema && typeof item.inputSchema === "object"
+          ? item.inputSchema
+          : item.input_schema && typeof item.input_schema === "object"
+            ? item.input_schema
+            : undefined,
+    });
+  }
+
+  const dedup = new Map();
+  for (const t of tools) dedup.set(t.name, t);
+  return [...dedup.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+async function tryHttpTools(baseUrl, headers = {}) {
+  const root = String(interpolateEnvPlaceholders(baseUrl || "")).replace(/\/+$/, "");
+  if (!root) return [];
+  const attempts = [
+    { method: "GET", url: `${root}/tools` },
+    { method: "POST", url: `${root}/tools`, body: {} },
+    { method: "POST", url: `${root}/tool`, body: { tool: "tools/list", input: {} } },
+    { method: "POST", url: `${root}/tool`, body: { tool: "list_tools", input: {} } },
+  ];
+
+  for (const attempt of attempts) {
+    try {
+      const res = await fetch(attempt.url, {
+        method: attempt.method,
+        headers: {
+          ...(attempt.body ? { "Content-Type": "application/json" } : {}),
+          ...headers,
+        },
+        body: attempt.body ? JSON.stringify(attempt.body) : undefined,
+      });
+      if (!res.ok) continue;
+      const data = await res.json().catch(() => null);
+      const tools = normalizeTools(data);
+      if (tools.length > 0) return tools;
+    } catch {
+      // keep probing
+    }
+  }
+  return [];
+}
+
+async function callStdioProbe(command, args, payload, timeoutMs, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args || [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: !Array.isArray(args) || args.length === 0,
+      env: env && typeof env === "object" ? { ...process.env, ...env } : process.env,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let finished = false;
+
+    const timer = setTimeout(() => {
+      if (finished) return;
+      finished = true;
+      child.kill("SIGKILL");
+      reject(new Error(`MCP tool discovery timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("error", (err) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      reject(new Error(`Failed to start MCP stdio command: ${err.message}`));
+    });
+
+    child.on("close", (code) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error(`MCP stdio discovery exited with code ${code}: ${stderr.trim()}`));
+        return;
+      }
+      try {
+        resolve(JSON.parse(String(stdout || "").trim() || "{}"));
+      } catch {
+        reject(new Error("MCP stdio discovery response is not valid JSON"));
+      }
+    });
+
+    child.stdin.write(JSON.stringify(payload));
+    child.stdin.end();
+  });
+}
+
+async function tryStdioTools(server) {
+  const args = interpolateStringArray(
+    Array.isArray(server && server.args)
+      ? server.args
+      : Array.isArray(server && server.commandArgs)
+        ? server.commandArgs
+        : [],
+  );
+  const env = interpolateStringMap(server && server.env);
+
+  if (shouldUseStdioJsonRpc(server)) {
+    try {
+      const rpc = await stdioListToolsJsonRpc({
+        command: server.command,
+        args,
+        timeoutMs:
+          Number(server && server.timeout_ms) > 0
+            ? Math.min(Number(server.timeout_ms), 15000)
+            : 15000,
+        env,
+      });
+      const tools = normalizeTools(rpc);
+      if (tools.length > 0) return tools;
+    } catch {
+      // fall back to legacy probes below
+    }
+  }
+
+  const timeoutMs =
+    Number(server && server.timeout_ms) > 0
+      ? Math.min(Number(server.timeout_ms), 15000)
+      : 3000;
+  const candidates = ["tools/list", "list_tools", "tools"];
+  for (const toolName of candidates) {
+    try {
+      const data = await callStdioProbe(
+        server.command,
+        args,
+        { tool: toolName, input: {} },
+        timeoutMs,
+        env,
+      );
+      const tools = normalizeTools(data);
+      if (tools.length > 0) return tools;
+    } catch {
+      // keep probing
+    }
+  }
+
+  return [];
+}
+
+async function discoverMcpTools(server) {
+  if (!server || (!server.url && !server.command)) return [];
+  if (server.url) {
+    const headers =
+      interpolateStringMap(server.headers);
+    const tools = await tryHttpTools(server.url, headers);
+    if (tools.length > 0) return tools;
+  }
+  if (server.command) {
+    const tools = await tryStdioTools(server);
+    if (tools.length > 0) return tools;
+  }
+  return [];
+}
+
+module.exports = { normalizeTools, discoverMcpTools };

package/cli/mcp-local.js

@@ -1,3 +1,59 @@
+const { discoverMcpTools, normalizeTools } = require("./mcp-discovery");
+const { diagnoseMcpServer } = require("./mcp-diagnostics");
+
+function parseJsonFlag(name, raw, outputError) {
+  if (raw === undefined) return undefined;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    outputError({
+      code: 85,
+      type: "invalid_argument",
+      message: `Invalid JSON for --${name}`,
+      recoverable: false,
+    });
+    return null;
+  }
+}
+
+function normalizeTransport(server) {
+  if (server && server.command) return "stdio";
+  if (server && server.url) return "http";
+  return "unknown";
+}
+
+
+function parseAsCommandId(value) {
+  const text = String(value || "").trim();
+  const parts = text.split(".").filter(Boolean);
+  if (parts.length !== 3) return null;
+  return { namespace: parts[0], resource: parts[1], action: parts[2], id: parts.join(".") };
+}
+
+function buildInputFromFlags(flags) {
+  const out = {};
+  const skip = new Set([
+    "human",
+    "json",
+    "compact",
+    "schema",
+    "help-json",
+    "show-dag",
+    "format",
+    "mcp-server",
+    "tool",
+    "input-json",
+    "timeout-ms",
+    "as",
+    "description",
+  ]);
+  for (const [k, v] of Object.entries(flags || {})) {
+    if (skip.has(k)) continue;
+    out[k] = v;
+  }
+  return out;
+}
+
 async function handleMcpRegistryCommand(options) {
   const {
     positional,
@@ -9,33 +65,29 @@ async function handleMcpRegistryCommand(options) {
     setMcpServer,
     removeMcpServer,
     listMcpServers,
+    loadConfig,
+    executeCommand,
+    upsertCommand,
+    serverUrl,
+    discoverTools = discoverMcpTools,
+    diagnoseServer = diagnoseMcpServer,
   } = options;
   const cliFlags = flags || {};
-
   const subcommand = positional[1];
 
-  function parseJsonFlag(name, raw) {
-    if (raw === undefined) return undefined;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      outputError({
-        code: 85,
-        type: "invalid_argument",
-        message: `Invalid JSON for --${name}`,
-        recoverable: false,
-      });
-      return null;
-    }
-  }
-
   if (subcommand === "list") {
     const servers = await listMcpServers();
     if (humanMode) {
+      const rows = servers.map((s) => ({
+        name: s.name,
+        transport: normalizeTransport(s),
+        source: s.url || s.command || "",
+      }));
       console.log("\n  ⚡ Local MCP Servers\n");
-      outputHumanTable(servers, [
+      outputHumanTable(rows, [
         { key: "name", label: "Name" },
-        { key: "url", label: "URL" },
+        { key: "transport", label: "Transport" },
+        { key: "source", label: "Source" },
       ]);
       console.log("");
     } else {
@@ -60,15 +112,24 @@ async function handleMcpRegistryCommand(options) {
       return true;
     }
 
-    const args = parseJsonFlag("args-json", cliFlags["args-json"]);
+    const args = parseJsonFlag("args-json", cliFlags["args-json"], outputError);
     if (args === null) return true;
-    const headers = parseJsonFlag("headers-json", cliFlags["headers-json"]);
+    const headers = parseJsonFlag(
+      "headers-json",
+      cliFlags["headers-json"],
+      outputError,
+    );
     if (headers === null) return true;
-    const env = parseJsonFlag("env-json", cliFlags["env-json"]);
+    const env = parseJsonFlag("env-json", cliFlags["env-json"], outputError);
     if (env === null) return true;
     const timeoutMs =
-      cliFlags["timeout-ms"] !== undefined ? Number(cliFlags["timeout-ms"]) : undefined;
-    if (cliFlags["timeout-ms"] !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) {
+      cliFlags["timeout-ms"] !== undefined
+        ? Number(cliFlags["timeout-ms"])
+        : undefined;
+    if (
+      cliFlags["timeout-ms"] !== undefined &&
+      (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    ) {
       outputError({
         code: 85,
         type: "invalid_argument",
@@ -90,6 +151,187 @@ async function handleMcpRegistryCommand(options) {
     return true;
   }
 
+  if (subcommand === "tools") {
+    const serverName = cliFlags["mcp-server"] || positional[2];
+    if (!serverName) {
+      outputError({
+        code: 85,
+        type: "invalid_argument",
+        message: "Usage: supercli mcp tools --mcp-server <name>",
+        recoverable: false,
+      });
+      return true;
+    }
+    const servers = await listMcpServers();
+    const server = servers.find((s) => s && s.name === serverName);
+    if (!server) {
+      outputError({
+        code: 92,
+        type: "resource_not_found",
+        message: `MCP server '${serverName}' not found`,
+        suggestions: ["Run: supercli mcp list --json"],
+      });
+      return true;
+    }
+    const tools = await discoverTools(server);
+    if (humanMode) {
+      console.log(`\n  ⚡ MCP Tools (${serverName})\n`);
+      if (tools.length > 0) {
+        outputHumanTable(tools, [
+          { key: "name", label: "Name" },
+          { key: "description", label: "Description" },
+        ]);
+      } else {
+        console.log("  No tools discovered. You can still call tools manually if you know the tool name.");
+        console.log(`  Tip: run supercli mcp doctor --mcp-server ${serverName} --json`);
+      }
+      console.log("");
+    } else {
+      output({ server: serverName, tools, discovered: tools.length });
+    }
+    return true;
+  }
+
+  if (subcommand === "call") {
+    const serverName = cliFlags["mcp-server"];
+    const tool = cliFlags.tool;
+    if (!serverName || !tool) {
+      outputError({
+        code: 85,
+        type: "invalid_argument",
+        message:
+          "Usage: supercli mcp call --mcp-server <name> --tool <tool> [--input-json '{}'] [--timeout-ms <ms>]",
+        recoverable: false,
+      });
+      return true;
+    }
+
+    const inputJson = parseJsonFlag("input-json", cliFlags["input-json"], outputError);
+    if (inputJson === null) return true;
+    const timeoutMs =
+      cliFlags["timeout-ms"] !== undefined
+        ? Number(cliFlags["timeout-ms"])
+        : undefined;
+    if (
+      cliFlags["timeout-ms"] !== undefined &&
+      (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 180000)
+    ) {
+      outputError({
+        code: 85,
+        type: "invalid_argument",
+        message: "--timeout-ms must be a positive number <= 180000",
+        recoverable: false,
+      });
+      return true;
+    }
+    const input =
+      inputJson !== undefined
+        ? inputJson && typeof inputJson === "object" && !Array.isArray(inputJson)
+          ? inputJson
+          : { input: inputJson }
+        : buildInputFromFlags(cliFlags);
+
+    const cmd = {
+      namespace: "mcp",
+      resource: "tool",
+      action: "call",
+      adapter: "mcp",
+      adapterConfig: {
+        server: serverName,
+        tool,
+        timeout_ms: timeoutMs,
+      },
+      args: [],
+    };
+
+    const config = await loadConfig();
+    const result = await executeCommand(cmd, input, {
+      server: serverUrl || "",
+      config,
+    });
+    output({ ok: true, server: serverName, tool, result });
+    return true;
+  }
+
+  if (subcommand === "bind") {
+    const serverName = cliFlags["mcp-server"];
+    const tool = cliFlags.tool;
+    const as = parseAsCommandId(cliFlags.as);
+    if (!serverName || !tool || !as) {
+      outputError({
+        code: 85,
+        type: "invalid_argument",
+        message:
+          "Usage: supercli mcp bind --mcp-server <name> --tool <tool> --as <namespace.resource.action> [--description <text>]",
+        recoverable: false,
+      });
+      return true;
+    }
+
+    const command = {
+      _id: `command:${as.namespace}.${as.resource}.${as.action}`,
+      namespace: as.namespace,
+      resource: as.resource,
+      action: as.action,
+      description:
+        cliFlags.description ||
+        `MCP tool '${tool}' via server '${serverName}'`,
+      adapter: "mcp",
+      adapterConfig: {
+        server: serverName,
+        tool,
+      },
+      args: [],
+    };
+
+    const saved = await upsertCommand(command);
+    output({ ok: true, command: `${saved.namespace}.${saved.resource}.${saved.action}`, saved });
+    return true;
+  }
+
+  if (subcommand === "doctor") {
+    const serverName = cliFlags["mcp-server"] || positional[2];
+    if (!serverName) {
+      outputError({
+        code: 85,
+        type: "invalid_argument",
+        message: "Usage: supercli mcp doctor --mcp-server <name>",
+        recoverable: false,
+      });
+      return true;
+    }
+    const servers = await listMcpServers();
+    const server = servers.find((s) => s && s.name === serverName);
+    if (!server) {
+      outputError({
+        code: 92,
+        type: "resource_not_found",
+        message: `MCP server '${serverName}' not found`,
+        suggestions: ["Run: supercli mcp list --json"],
+      });
+      return true;
+    }
+    const report = await diagnoseServer(server, { discoverTools });
+    if (humanMode) {
+      console.log(`\n  ⚡ MCP Doctor (${serverName})\n`);
+      console.log(`  Status: ${report.status}`);
+      console.log(`  Transport: ${report.transport}\n`);
+      outputHumanTable(report.checks, [
+        { key: "id", label: "Check" },
+        { key: "ok", label: "OK" },
+        { key: "message", label: "Message" },
+      ]);
+      if (report.issues.length > 0) {
+        console.log("\n  Issues:");
+        for (const issue of report.issues) console.log(`  - ${issue}`);
+      }
+      console.log("");
+    } else {
+      output(report);
+    }
+    return true;
+  }
+
   if (subcommand === "remove") {
     const name = positional[2];
     if (!name) {
@@ -109,10 +351,10 @@ async function handleMcpRegistryCommand(options) {
   outputError({
     code: 85,
     type: "invalid_argument",
-    message: "Unknown mcp subcommand. Use: list, add, remove",
+    message: "Unknown mcp subcommand. Use: list, add, tools, call, bind, doctor, remove",
     recoverable: false,
   });
   return true;
 }
 
-module.exports = { handleMcpRegistryCommand };
+module.exports = { handleMcpRegistryCommand, discoverMcpTools, normalizeTools };