@hasna/mcps 0.0.14 → 0.0.15

package/bin/index.js

@@ -19412,7 +19412,7 @@ var init_sources = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/mcps",
-    version: "0.0.14",
+    version: "0.0.15",
     description: "Meta-MCP registry & CLI \u2014 discover, manage, and proxy MCP servers",
     type: "module",
     repository: {
@@ -35591,6 +35591,185 @@ class StreamableHTTPClientTransport {
 // src/lib/proxy.ts
 init_config2();
 init_db();
+
+// src/lib/local-command-consent.ts
+class LocalCommandConsentError extends Error {
+  review;
+  constructor(message, review) {
+    super(message);
+    this.name = "LocalCommandConsentError";
+    this.review = review;
+  }
+}
+var SHELL_COMMANDS = new Set(["bash", "sh", "zsh", "fish", "cmd", "cmd.exe", "powershell", "powershell.exe", "pwsh"]);
+var DESTRUCTIVE_COMMANDS = new Set([
+  "rm",
+  "dd",
+  "mkfs",
+  "shutdown",
+  "reboot",
+  "poweroff",
+  "halt",
+  "killall",
+  "pkill"
+]);
+var SHELL_EVAL_FLAGS = new Set(["-c", "/c", "-Command", "-command", "-EncodedCommand", "-encodedcommand"]);
+var SECRET_FLAG_PATTERN = /(?:^|[-_])(api[-_]?key|token|secret|password|passwd|credential|auth|private[-_]?key)(?:$|[-_])/i;
+var SECRET_KEY_PATTERN = /(?:^|[_-])(api[_-]?key|token|secret|password|passwd|credential|auth|private[_-]?key)(?:$|[_-])/i;
+var SECRET_VALUE_PATTERN = /^(sk_(?:live|test)_[A-Za-z0-9_]+|ghp_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+|xox[baprs]-[A-Za-z0-9-]+|AIza[A-Za-z0-9_-]{20,}|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)$/;
+var SHELL_META_PATTERN = /[;&|`<>]|\$\(/;
+function commandBase(command) {
+  return command.trim().split(/[\\/]/).pop()?.toLowerCase() || command.trim().toLowerCase();
+}
+function normalizeArgs(args) {
+  return (args ?? []).map((arg) => String(arg));
+}
+function isSecretKey(key) {
+  return SECRET_KEY_PATTERN.test(key) || SECRET_FLAG_PATTERN.test(key);
+}
+function isSecretValue(value) {
+  return SECRET_VALUE_PATTERN.test(value.trim());
+}
+function isSecretAssignment(arg) {
+  const eqIdx = arg.indexOf("=");
+  if (eqIdx <= 0)
+    return false;
+  const key = arg.slice(0, eqIdx);
+  const value = arg.slice(eqIdx + 1);
+  return isSecretKey(key) || isSecretValue(value);
+}
+function isSecretArg(args, index) {
+  const arg = args[index] ?? "";
+  const previous = args[index - 1] ?? "";
+  return isSecretAssignment(arg) || isSecretValue(arg) || SECRET_FLAG_PATTERN.test(previous);
+}
+function quoteArg(value) {
+  return JSON.stringify(value);
+}
+function displayCommand(command, args) {
+  return [quoteArg(command), ...args.map((arg, index) => quoteArg(isSecretArg(args, index) ? "<redacted>" : arg))].join(" ");
+}
+function pushRisk(risks, risk) {
+  if (risks.some((existing) => existing.code === risk.code && existing.evidence === risk.evidence))
+    return;
+  risks.push(risk);
+}
+function inspectRisks(command, args, env) {
+  const risks = [];
+  const base = commandBase(command);
+  const joined = [command, ...args].join(" ");
+  if (SHELL_COMMANDS.has(base)) {
+    pushRisk(risks, {
+      code: "shell_interpreter",
+      severity: "warning",
+      message: "Command launches a shell interpreter.",
+      evidence: base
+    });
+    if (args.some((arg) => SHELL_EVAL_FLAGS.has(arg))) {
+      pushRisk(risks, {
+        code: "shell_eval",
+        severity: "danger",
+        message: "Shell command evaluates an inline script.",
+        evidence: base
+      });
+    }
+  }
+  if (base === "sudo") {
+    pushRisk(risks, {
+      code: "privilege_escalation",
+      severity: "danger",
+      message: "Command requests elevated privileges.",
+      evidence: base
+    });
+  }
+  if (DESTRUCTIVE_COMMANDS.has(base) || /\brm\s+-[^\s]*[rf][^\s]*\b/.test(joined) || /--no-preserve-root\b/.test(joined)) {
+    pushRisk(risks, {
+      code: "destructive_command",
+      severity: "danger",
+      message: "Command includes a destructive system operation.",
+      evidence: base
+    });
+  }
+  if (/\b(curl|wget)\b[\s\S]*\|[\s\S]*\b(sh|bash|zsh|fish)\b/.test(joined)) {
+    pushRisk(risks, {
+      code: "download_pipe_shell",
+      severity: "danger",
+      message: "Command downloads remote content and pipes it to a shell."
+    });
+  }
+  if ([command, ...args].some((part) => SHELL_META_PATTERN.test(part))) {
+    pushRisk(risks, {
+      code: "shell_metacharacters",
+      severity: "warning",
+      message: "Command or arguments contain shell metacharacters."
+    });
+  }
+  if (args.some((arg, index) => isSecretArg(args, index))) {
+    pushRisk(risks, {
+      code: "inline_secret",
+      severity: "danger",
+      message: "Command arguments appear to contain inline secret material."
+    });
+  }
+  const secretEnvKeys = Object.keys(env).filter(isSecretKey).sort();
+  if (secretEnvKeys.length > 0) {
+    pushRisk(risks, {
+      code: "secret_env",
+      severity: "warning",
+      message: "Environment contains secret-like keys; values are redacted from consent output.",
+      evidence: secretEnvKeys.join(", ")
+    });
+  }
+  return risks;
+}
+function inspectLocalCommand(input) {
+  const args = normalizeArgs(input.args);
+  const env = input.env ?? {};
+  const transport = input.transport ?? "stdio";
+  const risks = inspectRisks(input.command, args, env);
+  return {
+    requiresConsent: transport === "stdio",
+    operation: input.operation ?? "launch",
+    command: input.command,
+    args,
+    displayCommand: displayCommand(input.command, args),
+    envKeys: Object.keys(env).sort(),
+    risks,
+    hasDangerousRisk: risks.some((risk) => risk.severity === "danger")
+  };
+}
+function formatLocalCommandReview(review) {
+  const lines = [
+    `Command: ${review.displayCommand}`,
+    review.envKeys.length > 0 ? `Env keys: ${review.envKeys.join(", ")}` : "Env keys: <none>"
+  ];
+  if (review.risks.length > 0) {
+    lines.push("Risks:");
+    for (const risk of review.risks) {
+      lines.push(`- ${risk.severity}: ${risk.code} - ${risk.message}${risk.evidence ? ` (${risk.evidence})` : ""}`);
+    }
+  } else {
+    lines.push("Risks: none detected");
+  }
+  return lines.join(`
+`);
+}
+function assertLocalCommandConsent(input, consent = {}) {
+  const review = inspectLocalCommand(input);
+  if (!review.requiresConsent)
+    return review;
+  if (consent.approved !== true) {
+    throw new LocalCommandConsentError(`local stdio command approval is required before ${review.operation}.
+${formatLocalCommandReview(review)}`, review);
+  }
+  if (review.hasDangerousRisk && consent.allowRisky !== true) {
+    throw new LocalCommandConsentError(`risky command approval is required before ${review.operation}.
+${formatLocalCommandReview(review)}`, review);
+  }
+  return review;
+}
+
+// src/lib/proxy.ts
 var connections = new Map;
 var inflightConnections = new Map;
 var CONNECT_CONCURRENCY = 4;
@@ -35617,7 +35796,7 @@ function requireUrl(entry) {
     throw new Error(`Server "${entry.id}" has an invalid URL: ${entry.url}`);
   }
 }
-async function connectToServer(entry) {
+async function connectToServer(entry, options = {}) {
   if (connections.has(entry.id)) {
     return connections.get(entry.id);
   }
@@ -35633,6 +35812,13 @@ async function connectToServer(entry) {
         if (!entry.command?.trim()) {
           throw new Error(`Server "${entry.id}" is missing a command`);
         }
+        assertLocalCommandConsent({
+          command: entry.command,
+          args: entry.args,
+          env: entry.env,
+          transport: entry.transport,
+          operation: "launch"
+        }, options.localCommandConsent);
         transport = new StdioClientTransport({
           command: entry.command,
           args: entry.args,
@@ -35749,7 +35935,7 @@ async function callTool(prefixedName, args) {
     ]
   };
 }
-async function connectAllEnabled() {
+async function connectAllEnabled(options = {}) {
   const servers = listServers().filter((s) => s.enabled);
   const results = [];
   let index = 0;
@@ -35761,7 +35947,7 @@ async function connectAllEnabled() {
         return;
       const server = servers[current];
       try {
-        const conn = await connectToServer(server);
+        const conn = await connectToServer(server, options);
         results.push(conn);
       } catch (err) {
         console.error(`Failed to connect to ${server.name}: ${err.message}`);
@@ -35773,13 +35959,28 @@ async function connectAllEnabled() {
 }
 
 // src/lib/doctor.ts
-async function diagnoseServer(server) {
+async function diagnoseServer(server, options = {}) {
   const checks4 = [];
+  let hasLocalConsent = true;
   if (server.transport === "stdio") {
+    try {
+      assertLocalCommandConsent({
+        command: server.command,
+        args: server.args,
+        env: server.env,
+        transport: server.transport,
+        operation: "diagnose"
+      }, options.localCommandConsent);
+    } catch (err) {
+      hasLocalConsent = false;
+      checks4.push({ name: "local command consent", pass: false, message: err.message });
+    }
     try {
       const path = execFileSync("which", [server.command], { stdio: "pipe" }).toString().trim();
       let version2 = "";
       try {
+        if (!hasLocalConsent)
+          throw new Error("local stdio command approval is required before version probing");
         version2 = execFileSync(server.command, ["--version"], { stdio: "pipe" }).toString().trim().split(`
 `)[0];
       } catch {}
@@ -35810,10 +36011,10 @@ async function diagnoseServer(server) {
       checks4.push({ name: "URL reachable", pass: false, message: `unreachable: ${err.message}` });
     }
   }
-  if (server.enabled) {
+  if (server.enabled && hasLocalConsent) {
     try {
       await Promise.race([
-        connectToServer(server),
+        connectToServer(server, { localCommandConsent: options.localCommandConsent }),
         new Promise((_, reject) => setTimeout(() => reject(new Error("timeout after 10s")), 1e4))
       ]);
       await disconnectServer(server.id);
@@ -35821,8 +36022,10 @@ async function diagnoseServer(server) {
     } catch (err) {
       checks4.push({ name: "connect & list tools", pass: false, message: err.message });
     }
-  } else {
+  } else if (!server.enabled) {
     checks4.push({ name: "connect & list tools", pass: true, message: "skipped (server disabled)" });
+  } else {
+    checks4.push({ name: "connect & list tools", pass: false, message: "skipped until local stdio command is approved" });
   }
   return {
     server,
@@ -35863,7 +36066,7 @@ async function getRegistryServer(id) {
   const all = entries.map(parseRegistryEntry);
   return all.find((s) => s.id === id) || null;
 }
-async function installFromRegistry(id) {
+async function installFromRegistry(id, options = {}) {
   const server = await getRegistryServer(id);
   if (!server) {
     throw new Error(`Server "${id}" not found in registry`);
@@ -35883,6 +36086,13 @@ async function installFromRegistry(id) {
       transport = pkg.transport.type;
     }
   }
+  assertLocalCommandConsent({
+    command,
+    args,
+    transport,
+    env: {},
+    operation: "register"
+  }, options.localCommandConsent);
   return addServer({
     name: server.name,
     description: server.description,
@@ -35977,7 +36187,22 @@ function installToGemini(entry) {
     return { agent: "gemini", success: false, error: err.message };
   }
 }
-function installToAgents(entry, targets = ["claude", "codex", "gemini"]) {
+function installToAgents(entry, targets = ["claude", "codex", "gemini"], options = {}) {
+  try {
+    assertLocalCommandConsent({
+      command: entry.command,
+      args: entry.args,
+      env: entry.env,
+      transport: entry.transport,
+      operation: "install"
+    }, options.localCommandConsent);
+  } catch (err) {
+    return targets.map((target) => ({
+      agent: target,
+      success: false,
+      error: err.message
+    }));
+  }
   return targets.map((target) => {
     if (target === "claude")
       return installToClaude(entry);
@@ -36978,11 +37203,19 @@ function installProviderProfile(id, options = {}) {
   if (!command) {
     throw new Error(`Provider profile "${id}" does not define an install fallback command`);
   }
+  assertLocalCommandConsent({
+    command,
+    args,
+    env: fallback?.env ?? {},
+    transport: useFallback ? "stdio" : profile.transport,
+    operation: "register"
+  }, options.localCommandConsent);
   return addServer({
     name: options.name ?? profile.displayName,
     description: profile.description ?? undefined,
     command,
     args,
+    env: fallback?.env,
     transport: useFallback ? "stdio" : profile.transport,
     url: useFallback ? fallback?.url : profile.endpoint ?? undefined,
     source: "provider-profile"
@@ -38257,6 +38490,13 @@ function jsonContent(value) {
 function errorContent(text) {
   return { ...textContent(text), isError: true };
 }
+function localConsent(input) {
+  return {
+    approved: input.allow_local_stdio === true,
+    allowRisky: input.allow_risky_command === true,
+    source: "mcp"
+  };
+}
 function buildMcpTools() {
   const definitions = [
     {
@@ -38281,23 +38521,46 @@ function buildMcpTools() {
         description: exports_external2.string().optional().describe("Description"),
         transport: exports_external2.enum(["stdio", "sse", "streamable-http"]).optional().describe("Transport type"),
         url: exports_external2.string().optional().describe("URL for remote transports"),
-        env: exports_external2.record(exports_external2.string()).optional().describe("Environment variables")
+        env: exports_external2.record(exports_external2.string()).optional().describe("Environment variables"),
+        allow_local_stdio: exports_external2.boolean().optional().describe("Approve registering this local stdio command"),
+        allow_risky_command: exports_external2.boolean().optional().describe("Approve registering risky local command patterns")
       },
-      run: ({ command, args, name, description, transport, url: url2, env }) => jsonContent(addServer({
-        command: String(command),
-        args: Array.isArray(args) ? args.map(String) : [],
-        name: typeof name === "string" ? name : undefined,
-        description: typeof description === "string" ? description : undefined,
-        transport,
-        url: typeof url2 === "string" ? url2 : undefined,
-        env: isRecordOfStrings(env) ? env : {}
-      }))
+      run: (input) => {
+        const command = String(input.command);
+        const args = Array.isArray(input.args) ? input.args.map(String) : [];
+        const env = isRecordOfStrings(input.env) ? input.env : {};
+        const transport = input.transport;
+        try {
+          assertLocalCommandConsent({ command, args, env, transport, operation: "register" }, localConsent(input));
+          return jsonContent(addServer({
+            command,
+            args,
+            name: typeof input.name === "string" ? input.name : undefined,
+            description: typeof input.description === "string" ? input.description : undefined,
+            transport,
+            url: typeof input.url === "string" ? input.url : undefined,
+            env
+          }));
+        } catch (err) {
+          return errorContent(err.message);
+        }
+      }
     },
     {
       name: "install_from_registry",
       description: "Install an MCP server from the official registry",
-      paramsSchema: { id: exports_external2.string().describe("Registry server ID") },
-      run: async ({ id }) => jsonContent(await installFromRegistry(String(id)))
+      paramsSchema: {
+        id: exports_external2.string().describe("Registry server ID"),
+        allow_local_stdio: exports_external2.boolean().optional().describe("Approve registering registry stdio commands"),
+        allow_risky_command: exports_external2.boolean().optional().describe("Approve registering risky local command patterns")
+      },
+      run: async (input) => {
+        try {
+          return jsonContent(await installFromRegistry(String(input.id), { localCommandConsent: localConsent(input) }));
+        } catch (err) {
+          return errorContent(err.message);
+        }
+      }
     },
     {
       name: "remove_server",
@@ -38343,26 +38606,41 @@ function buildMcpTools() {
         command: exports_external2.string().optional().describe("New command"),
         args: exports_external2.array(exports_external2.string()).optional().describe("New args list"),
         transport: exports_external2.enum(["stdio", "sse", "streamable-http"]).optional().describe("New transport type"),
-        url: exports_external2.string().optional().describe("New URL for remote transports")
+        url: exports_external2.string().optional().describe("New URL for remote transports"),
+        allow_local_stdio: exports_external2.boolean().optional().describe("Approve updating this local stdio command"),
+        allow_risky_command: exports_external2.boolean().optional().describe("Approve risky local command patterns")
       },
-      run: ({ id, name, description, command, args, transport, url: url2 }) => {
-        const serverId = String(id);
+      run: (input) => {
+        const serverId = String(input.id);
         const existing = getServer(serverId);
         if (!existing)
           return errorContent(`Server "${serverId}" not found.`);
         const fields = {};
-        if (typeof name === "string")
-          fields.name = name;
-        if (typeof description === "string")
-          fields.description = description;
-        if (typeof command === "string")
-          fields.command = command;
-        if (Array.isArray(args))
-          fields.args = args.map(String);
-        if (transport === "stdio" || transport === "sse" || transport === "streamable-http")
-          fields.transport = transport;
-        if (typeof url2 === "string")
-          fields.url = url2;
+        if (typeof input.name === "string")
+          fields.name = input.name;
+        if (typeof input.description === "string")
+          fields.description = input.description;
+        if (typeof input.command === "string")
+          fields.command = input.command;
+        if (Array.isArray(input.args))
+          fields.args = input.args.map(String);
+        if (input.transport === "stdio" || input.transport === "sse" || input.transport === "streamable-http")
+          fields.transport = input.transport;
+        if (typeof input.url === "string")
+          fields.url = input.url;
+        if (fields.command !== undefined || fields.args !== undefined || fields.transport !== undefined) {
+          try {
+            assertLocalCommandConsent({
+              command: fields.command ?? existing.command,
+              args: fields.args ?? existing.args,
+              env: existing.env,
+              transport: fields.transport ?? existing.transport,
+              operation: "register"
+            }, localConsent(input));
+          } catch (err) {
+            return errorContent(err.message);
+          }
+        }
         return jsonContent(redactServerEnv(updateServer(serverId, fields)));
       }
     },
@@ -38444,13 +38722,16 @@ function buildMcpTools() {
       paramsSchema: {
         id: exports_external2.string().describe("Provider profile ID"),
         name: exports_external2.string().optional().describe("Override registered server name"),
-        use_fallback: exports_external2.boolean().optional().describe("Install the stdio fallback command instead of the direct remote transport")
+        use_fallback: exports_external2.boolean().optional().describe("Install the stdio fallback command instead of the direct remote transport"),
+        allow_local_stdio: exports_external2.boolean().optional().describe("Approve registering provider stdio fallback commands"),
+        allow_risky_command: exports_external2.boolean().optional().describe("Approve risky local command patterns")
       },
-      run: ({ id, name, use_fallback }) => {
+      run: (input) => {
         try {
-          return jsonContent(redactServerEnv(installProviderProfile(String(id), {
-            name: typeof name === "string" ? name : undefined,
-            useFallback: use_fallback === true
+          return jsonContent(redactServerEnv(installProviderProfile(String(input.id), {
+            name: typeof input.name === "string" ? input.name : undefined,
+            useFallback: input.use_fallback === true,
+            localCommandConsent: localConsent(input)
           })));
         } catch (err) {
           return errorContent(err.message);
@@ -38523,15 +38804,19 @@ function buildMcpTools() {
       description: "Install a registered MCP server into Claude Code, Codex, and/or Gemini",
       paramsSchema: {
         id: exports_external2.string().describe("Server ID to install (from list_servers)"),
-        targets: exports_external2.array(exports_external2.enum(["claude", "codex", "gemini"])).optional().describe("Target agents to install into (default: all)")
+        targets: exports_external2.array(exports_external2.enum(["claude", "codex", "gemini"])).optional().describe("Target agents to install into (default: all)"),
+        allow_local_stdio: exports_external2.boolean().optional().describe("Approve installing local stdio commands into local agent configs"),
+        allow_risky_command: exports_external2.boolean().optional().describe("Approve installing risky local command patterns")
       },
-      run: ({ id, targets }) => {
-        const serverId = String(id);
+      run: (input) => {
+        const serverId = String(input.id);
         const entry = getServer(serverId);
         if (!entry)
           return errorContent(`Server "${serverId}" not found.`);
-        const agentTargets = Array.isArray(targets) ? targets : undefined;
-        return jsonContent(installToAgents(entry, agentTargets ?? ["claude", "codex", "gemini"]));
+        const agentTargets = Array.isArray(input.targets) ? input.targets : undefined;
+        return jsonContent(installToAgents(entry, agentTargets ?? ["claude", "codex", "gemini"], {
+          localCommandConsent: localConsent(input)
+        }));
       }
     },
     {
@@ -38543,11 +38828,14 @@ function buildMcpTools() {
     {
       name: "connect_and_list_tools",
       description: "Connect to all enabled MCP servers and list their available tools",
-      paramsSchema: {},
-      run: async () => {
+      paramsSchema: {
+        allow_local_stdio: exports_external2.boolean().optional().describe("Approve launching enabled local stdio commands"),
+        allow_risky_command: exports_external2.boolean().optional().describe("Approve launching risky local command patterns")
+      },
+      run: async (input) => {
         let liveTools = [];
         try {
-          await connectAllEnabled();
+          await connectAllEnabled({ localCommandConsent: localConsent(input) });
           liveTools = listAllTools();
         } finally {
           await disconnectAll().catch(() => {
@@ -38562,11 +38850,13 @@ function buildMcpTools() {
       description: `Call a tool on a connected upstream MCP server. Tool name format: server_id${TOOL_PREFIX_SEPARATOR}tool_name`,
       paramsSchema: {
         tool_name: exports_external2.string().describe(`Prefixed tool name (server_id${TOOL_PREFIX_SEPARATOR}tool_name)`),
-        arguments: exports_external2.record(exports_external2.unknown()).optional().describe("Tool arguments as key-value pairs")
+        arguments: exports_external2.record(exports_external2.unknown()).optional().describe("Tool arguments as key-value pairs"),
+        allow_local_stdio: exports_external2.boolean().optional().describe("Approve launching this local stdio command"),
+        allow_risky_command: exports_external2.boolean().optional().describe("Approve launching risky local command patterns")
       },
-      run: async ({ tool_name, arguments: args }) => {
+      run: async (input) => {
         try {
-          const toolName = String(tool_name);
+          const toolName = String(input.tool_name);
           const sepIdx = toolName.indexOf(TOOL_PREFIX_SEPARATOR);
           if (sepIdx === -1)
             return errorContent(`Error: Invalid tool name "${toolName}"`);
@@ -38576,8 +38866,8 @@ function buildMcpTools() {
             return errorContent(`Error: Server "${serverId}" not found.`);
           if (!entry.enabled)
             return errorContent(`Error: Server "${serverId}" is disabled.`);
-          await connectToServer(entry);
-          const result = await callTool(toolName, readRecord(args));
+          await connectToServer(entry, { localCommandConsent: localConsent(input) });
+          const result = await callTool(toolName, readRecord(input.arguments));
           return { content: result.content };
         } catch (error2) {
           return errorContent(`Error: ${error2.message}`);
@@ -38587,13 +38877,17 @@ function buildMcpTools() {
     {
       name: "diagnose_server",
       description: "Run health checks on a registered MCP server",
-      paramsSchema: { id: exports_external2.string().describe("Server ID") },
-      run: async ({ id }) => {
-        const serverId = String(id);
+      paramsSchema: {
+        id: exports_external2.string().describe("Server ID"),
+        allow_local_stdio: exports_external2.boolean().optional().describe("Approve launching local stdio diagnostics"),
+        allow_risky_command: exports_external2.boolean().optional().describe("Approve diagnosing risky local command patterns")
+      },
+      run: async (input) => {
+        const serverId = String(input.id);
         const entry = getServer(serverId);
         if (!entry)
           return errorContent(`Server "${serverId}" not found.`);
-        return jsonContent(await diagnoseServer(entry));
+        return jsonContent(await diagnoseServer(entry, { localCommandConsent: localConsent(input) }));
       }
     },
     {
@@ -38962,6 +39256,20 @@ function isValidId(id) {
   return /^[a-z0-9-]+$/.test(id);
 }
 var MAX_BODY_SIZE = 1024 * 1024;
+function consentFromInput(input) {
+  return {
+    approved: input.allow_local_stdio === true || input.allowLocalStdio === true,
+    allowRisky: input.allow_risky_command === true || input.allowRiskyCommand === true,
+    source: "api"
+  };
+}
+function consentFromSearchParams(params) {
+  return {
+    approved: params.get("allow_local_stdio") === "1" || params.get("allow_local_stdio") === "true",
+    allowRisky: params.get("allow_risky_command") === "1" || params.get("allow_risky_command") === "true",
+    source: "api"
+  };
+}
 function isLoopbackHost(hostname3) {
   return hostname3 === "127.0.0.1" || hostname3 === "localhost" || hostname3 === "::1";
 }
@@ -39108,6 +39416,11 @@ Dashboard not found at: ${dashboardDir}`);
             return json({ error: "Invalid 'args' format" }, 400, port);
           }
           const args = body.args || [];
+          try {
+            assertLocalCommandConsent({ command, args, env: {}, transport, operation: "register" }, consentFromInput(body));
+          } catch (err) {
+            return json({ error: err.message }, 400, port);
+          }
           const entry = addServer({
             name: body.name,
             command,
@@ -39206,6 +39519,19 @@ Dashboard not found at: ${dashboardDir}`);
             }
             fields.args = body.args;
           }
+          if (fields.command !== undefined || fields.args !== undefined || fields.transport !== undefined) {
+            try {
+              assertLocalCommandConsent({
+                command: fields.command ?? existing.command,
+                args: fields.args ?? existing.args,
+                env: existing.env,
+                transport: fields.transport ?? existing.transport,
+                operation: "register"
+              }, consentFromInput(body));
+            } catch (err) {
+              return json({ error: err.message }, 400, port);
+            }
+          }
           const updated = updateServer(id, fields);
           return json(redactServer(updated), 200, port);
         } catch (e) {
@@ -39281,7 +39607,7 @@ Dashboard not found at: ${dashboardDir}`);
           }
           if (!body.tool || typeof body.tool !== "string")
             return json({ error: "Missing 'tool'" }, 400, port);
-          await connectToServer(entry);
+          await connectToServer(entry, { localCommandConsent: consentFromInput(body) });
           const toolName = `${id}__${body.tool}`;
           const result = await callTool(toolName, body.args || {});
           await disconnectServer(id).catch(() => {
@@ -39292,6 +39618,9 @@ Dashboard not found at: ${dashboardDir}`);
           await disconnectServer(id).catch(() => {
             return;
           });
+          if (e instanceof LocalCommandConsentError) {
+            return json({ error: e.message }, 400, port);
+          }
           return json({ error: e instanceof Error ? e.message : "Failed to call tool" }, 500, port);
         }
       }
@@ -39304,7 +39633,7 @@ Dashboard not found at: ${dashboardDir}`);
         if (!entry)
           return json({ error: `Server '${id}' not found` }, 404, port);
         try {
-          const report = await diagnoseServer(entry);
+          const report = await diagnoseServer(entry, { localCommandConsent: consentFromSearchParams(url2.searchParams) });
           return json(report, 200, port);
         } catch (e) {
           return json({ error: e instanceof Error ? e.message : "Failed to diagnose server" }, 500, port);
@@ -39959,6 +40288,13 @@ function ServerDetail({ server, onSelectTool, onBack }) {
   const [tools2, setTools] = useState3([]);
   const [loading, setLoading] = useState3(false);
   const [error2, setError] = useState3(null);
+  const commandReview = inspectLocalCommand({
+    command: server.command,
+    args: server.args,
+    env: server.env,
+    transport: server.transport,
+    operation: "launch"
+  });
   const cachedTools = getCachedTools(server.id);
   const cachedKey = cachedTools.map((t) => `${t.name}|${t.description}|${JSON.stringify(t.input_schema)}`).join(";");
   useEffect3(() => {
@@ -39979,7 +40315,9 @@ function ServerDetail({ server, onSelectTool, onBack }) {
     setLoading(true);
     setError(null);
     try {
-      const conn = await connectToServer(server);
+      const conn = await connectToServer(server, {
+        localCommandConsent: { approved: true, source: "tui" }
+      });
       setTools(conn.tools);
     } catch (err) {
       setError(err.message);
@@ -40038,6 +40376,21 @@ function ServerDetail({ server, onSelectTool, onBack }) {
           server.args.join(" ")
         ]
       }, undefined, true, undefined, this),
+      commandReview.requiresConsent && /* @__PURE__ */ jsxDEV2(Box4, {
+        marginTop: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxDEV2(Text5, {
+            color: commandReview.hasDangerousRisk ? "red" : "yellow",
+            children: "Local stdio command review"
+          }, undefined, false, undefined, this),
+          formatLocalCommandReview(commandReview).split(`
+`).map((line, index) => /* @__PURE__ */ jsxDEV2(Text5, {
+            dimColor: true,
+            children: line
+          }, `${index}:${line}`, false, undefined, this))
+        ]
+      }, undefined, true, undefined, this),
       server.description && /* @__PURE__ */ jsxDEV2(Text5, {
         dimColor: true,
         children: server.description
@@ -40206,7 +40559,9 @@ function SearchView({ onBack }) {
     setInstalling(item.value);
     setMessage(null);
     try {
-      const server = await installFromRegistry(item.value);
+      const server = await installFromRegistry(item.value, {
+        localCommandConsent: { approved: true, source: "tui" }
+      });
       setMessage(`Installed: ${server.name} [${server.id}]`);
     } catch (err) {
       setMessage(`Install failed: ${err.message}`);
@@ -40317,7 +40672,9 @@ function ToolCall({ server, tool, onBack }) {
     setError(null);
     setResult(null);
     try {
-      await connectToServer(server);
+      await connectToServer(server, {
+        localCommandConsent: { approved: true, source: "tui" }
+      });
       const prefixed = `${server.id}${TOOL_PREFIX_SEPARATOR}${tool.name}`;
       const res = await callTool(prefixed, args);
       const text = res.content.map((c) => c.text).join(`
@@ -40537,6 +40894,28 @@ var MACHINE_PLATFORMS = ["linux", "darwin", "unknown"];
 var MACHINE_ARCHES = ["arm64", "x64", "unknown"];
 var MACHINE_INSTALLERS = ["auto", "bun", "npm"];
 var FLEET_INSTALL_MODES = ["missing", "missing-or-outdated", "all"];
+function localConsentFromOptions(opts, approved = false) {
+  return {
+    approved: approved || opts.yes === true || opts.allowLocalStdio === true,
+    allowRisky: opts.allowRiskyCommand === true,
+    source: "cli"
+  };
+}
+function printLocalCommandReviewIfNeeded(input) {
+  const review = inspectLocalCommand(input);
+  if (!review.requiresConsent)
+    return;
+  console.log(chalk2.dim(formatLocalCommandReview(review)));
+}
+function assertCliLocalCommandConsent(input, opts, approved = false) {
+  const consent = localConsentFromOptions(opts, approved);
+  const review = inspectLocalCommand(input);
+  if (review.requiresConsent && consent.approved === true && (!review.hasDangerousRisk || consent.allowRisky === true)) {
+    console.log(chalk2.dim(formatLocalCommandReview(review)));
+  }
+  assertLocalCommandConsent(input, consent);
+  return consent;
+}
 function printProviderProfile(profile) {
   const status = profile.enabled ? chalk2.green("enabled") : chalk2.red("disabled");
   console.log(`  ${chalk2.bold(profile.displayName)} ${chalk2.dim(`[${profile.id}]`)} \u2014 ${chalk2.dim(profile.transport)} \u2014 ${status}`);
@@ -40785,11 +41164,12 @@ providersCmd.command("info").argument("<id>", "Provider profile ID").description
     console.log(`    Docs: ${chalk2.cyan(profile.docsUrl)}`);
   closeDb();
 });
-providersCmd.command("install").argument("<id>", "Provider profile ID").description("Register a curated provider profile as an MCP server").option("--name <name>", "Override registered server name").option("--fallback", "Install the stdio fallback command instead of direct remote transport").option("--json", "Output as JSON").action((id, opts) => {
+providersCmd.command("install").argument("<id>", "Provider profile ID").description("Register a curated provider profile as an MCP server").option("--name <name>", "Override registered server name").option("--fallback", "Install the stdio fallback command instead of direct remote transport").option("--yes", "Approve local stdio fallback commands").option("--allow-local-stdio", "Approve local stdio fallback commands").option("--allow-risky-command", "Approve high-risk local command patterns").option("--json", "Output as JSON").action((id, opts) => {
   try {
     const server = installProviderProfile(id, {
       name: opts.name,
-      useFallback: opts.fallback === true
+      useFallback: opts.fallback === true,
+      localCommandConsent: localConsentFromOptions(opts)
     });
     if (opts.json) {
       printJson(server);
@@ -40820,11 +41200,13 @@ function detectSourceType(url2) {
     return "mcp-registry";
   return null;
 }
-program2.command("add").passThroughOptions().argument("[command]", "Command to run the MCP server").argument("[args...]", "Arguments for the command").option("--name <name>", "Display name for the server").option("--description <desc>", "Description").option("--from-registry <id>", "Install from official registry by ID").option("--transport <type>", "Transport type: stdio, sse, streamable-http", "stdio").option("--url <url>", "URL for remote transports").option("--env <pairs...>", "Environment variables as KEY=VALUE pairs").option("--wizard", "Interactive setup wizard").option("--force", "Register even if duplicate command exists").description("Add a local MCP server").action(async (command, args, opts) => {
+program2.command("add").passThroughOptions().argument("[command]", "Command to run the MCP server").argument("[args...]", "Arguments for the command").option("--name <name>", "Display name for the server").option("--description <desc>", "Description").option("--from-registry <id>", "Install from official registry by ID").option("--transport <type>", "Transport type: stdio, sse, streamable-http", "stdio").option("--url <url>", "URL for remote transports").option("--env <pairs...>", "Environment variables as KEY=VALUE pairs").option("--wizard", "Interactive setup wizard").option("--force", "Register even if duplicate command exists").option("--yes", "Approve registering local stdio commands").option("--allow-local-stdio", "Approve registering local stdio commands").option("--allow-risky-command", "Approve high-risk local command patterns").description("Add a local MCP server").action(async (command, args, opts) => {
   try {
     if (opts.fromRegistry) {
       console.log(chalk2.dim(`Installing "${opts.fromRegistry}" from registry...`));
-      const server2 = await installFromRegistry(opts.fromRegistry);
+      const server2 = await installFromRegistry(opts.fromRegistry, {
+        localCommandConsent: localConsentFromOptions(opts)
+      });
       console.log(chalk2.green(`Added server: ${server2.name} [${server2.id}]`));
       console.log(chalk2.dim(`  ${server2.command} ${server2.args.join(" ")}`));
       closeDb();
@@ -40863,6 +41245,13 @@ Server to add:`));
         console.log(`  Name:      ${wizardName}`);
       if (Object.keys(env).length)
         console.log(`  Env:       ${Object.keys(env).join(", ")}`);
+      printLocalCommandReviewIfNeeded({
+        command: wizardCommand,
+        args: wizardArgs,
+        env,
+        transport,
+        operation: "register"
+      });
       const confirm = await new Promise((resolve2) => {
         const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
         rl2.question(chalk2.bold("Add this server? [Y/n]: "), (ans) => {
@@ -40875,6 +41264,13 @@ Server to add:`));
         closeDb();
         return;
       }
+      assertLocalCommandConsent({
+        command: wizardCommand,
+        args: wizardArgs,
+        env,
+        transport,
+        operation: "register"
+      }, localConsentFromOptions(opts, true));
       const server2 = addServer({
         command: wizardCommand,
         args: wizardArgs,
@@ -40911,6 +41307,13 @@ Server to add:`));
         envMap[key] = rest.join("=");
       }
     }
+    assertCliLocalCommandConsent({
+      command,
+      args,
+      env: envMap,
+      transport: opts.transport,
+      operation: "register"
+    }, opts);
     const server = addServer({
       name: opts.name,
       description: opts.description,
@@ -40933,29 +41336,44 @@ Server to add:`));
   }
   closeDb();
 });
-program2.command("update-server").argument("<id>", "Server ID to update").description("Update fields of a registered server").option("--name <name>", "New display name").option("--description <desc>", "New description").option("--command <cmd>", "New command").option("--args <args...>", "New args list").option("--transport <type>", "New transport type").option("--url <url>", "New URL").action((id, opts) => {
-  const server = getServer(id);
-  if (!server) {
-    console.error(chalk2.red(`Server "${id}" not found.`));
+program2.command("update-server").argument("<id>", "Server ID to update").description("Update fields of a registered server").option("--name <name>", "New display name").option("--description <desc>", "New description").option("--command <cmd>", "New command").option("--args <args...>", "New args list").option("--transport <type>", "New transport type").option("--url <url>", "New URL").option("--yes", "Approve updated local stdio commands").option("--allow-local-stdio", "Approve updated local stdio commands").option("--allow-risky-command", "Approve high-risk local command patterns").action((id, opts) => {
+  try {
+    const server = getServer(id);
+    if (!server) {
+      console.error(chalk2.red(`Server "${id}" not found.`));
+      closeDb();
+      process.exit(1);
+    }
+    const fields = {};
+    if (opts.name !== undefined)
+      fields.name = opts.name;
+    if (opts.description !== undefined)
+      fields.description = opts.description;
+    if (opts.command !== undefined)
+      fields.command = opts.command;
+    if (opts.args !== undefined)
+      fields.args = opts.args;
+    if (opts.transport !== undefined)
+      fields.transport = opts.transport;
+    if (opts.url !== undefined)
+      fields.url = opts.url;
+    if (fields.command !== undefined || fields.args !== undefined || fields.transport !== undefined) {
+      assertCliLocalCommandConsent({
+        command: fields.command ?? server.command,
+        args: fields.args ?? server.args,
+        env: server.env,
+        transport: fields.transport ?? server.transport,
+        operation: "register"
+      }, opts);
+    }
+    const updated = updateServer(id, fields);
+    console.log(chalk2.green(`Updated server: ${updated.name} [${updated.id}]`));
+    closeDb();
+  } catch (err) {
+    console.error(chalk2.red(`Failed to update server: ${err.message}`));
     closeDb();
     process.exit(1);
   }
-  const fields = {};
-  if (opts.name !== undefined)
-    fields.name = opts.name;
-  if (opts.description !== undefined)
-    fields.description = opts.description;
-  if (opts.command !== undefined)
-    fields.command = opts.command;
-  if (opts.args !== undefined)
-    fields.args = opts.args;
-  if (opts.transport !== undefined)
-    fields.transport = opts.transport;
-  if (opts.url !== undefined)
-    fields.url = opts.url;
-  const updated = updateServer(id, fields);
-  console.log(chalk2.green(`Updated server: ${updated.name} [${updated.id}]`));
-  closeDb();
 });
 program2.command("clone").argument("<id>", "Server ID to clone").argument("<new-name>", "Name for the cloned server").description("Clone a server with a new name").action((id, newName) => {
   try {
@@ -41002,10 +41420,10 @@ program2.command("disable").argument("<id>", "Server ID to disable").description
   console.log(chalk2.yellow(`Disabled server: ${server.name}`));
   closeDb();
 });
-program2.command("tools").argument("[server-id]", "Optional server ID to filter by").description("List tools (all or per server)").option("--connect", "Connect to servers to fetch live tools").action(async (serverId, opts) => {
+program2.command("tools").argument("[server-id]", "Optional server ID to filter by").description("List tools (all or per server)").option("--connect", "Connect to servers to fetch live tools").option("--yes", "Approve launching local stdio commands when --connect is used").option("--allow-local-stdio", "Approve launching local stdio commands when --connect is used").option("--allow-risky-command", "Approve high-risk local command patterns").action(async (serverId, opts) => {
   if (opts.connect) {
     console.log(chalk2.dim("Connecting to enabled servers..."));
-    await connectAllEnabled();
+    await connectAllEnabled({ localCommandConsent: localConsentFromOptions(opts) });
     const tools2 = listAllTools();
     if (tools2.length === 0) {
       console.log(chalk2.dim("No tools available."));
@@ -41055,7 +41473,7 @@ ${total} tool(s) total.`));
   }
   closeDb();
 });
-program2.command("call").argument("<tool>", "Tool name (server_id__tool_name)").option("--arg <pairs...>", "Arguments as key=value pairs").option("--json <json>", "Arguments as JSON string").description("Call a tool directly").action(async (tool, opts) => {
+program2.command("call").argument("<tool>", "Tool name (server_id__tool_name)").option("--arg <pairs...>", "Arguments as key=value pairs").option("--json <json>", "Arguments as JSON string").option("--yes", "Approve launching local stdio commands").option("--allow-local-stdio", "Approve launching local stdio commands").option("--allow-risky-command", "Approve high-risk local command patterns").description("Call a tool directly").action(async (tool, opts) => {
   let args = {};
   if (opts.json) {
     try {
@@ -41078,7 +41496,7 @@ program2.command("call").argument("<tool>", "Tool name (server_id__tool_name)").
   let exitCode = 0;
   try {
     console.log(chalk2.dim(`Connecting to servers...`));
-    await connectAllEnabled();
+    await connectAllEnabled({ localCommandConsent: localConsentFromOptions(opts) });
     console.log(chalk2.dim(`Calling ${tool}...`));
     const result = await callTool(tool, args);
     for (const c of result.content) {
@@ -41146,7 +41564,7 @@ program2.command("status").description("Show registry stats").option("--json", "
   console.log(`  Tools:    ${totalTools} (cached)`);
   closeDb();
 });
-program2.command("doctor").argument("[id]", "Server ID to check (omit to check all)").description("Diagnose server health \u2014 checks PATH, env vars, connectivity").option("--fix", "Attempt to fix issues automatically").action(async (id, opts) => {
+program2.command("doctor").argument("[id]", "Server ID to check (omit to check all)").description("Diagnose server health \u2014 checks PATH, env vars, connectivity").option("--fix", "Attempt to fix issues automatically").option("--yes", "Approve probing and launching local stdio commands").option("--allow-local-stdio", "Approve probing and launching local stdio commands").option("--allow-risky-command", "Approve high-risk local command patterns").action(async (id, opts) => {
   const { execFileSync: execFileSync22 } = await import("child_process");
   const servers = id ? [getServer(id)].filter(Boolean) : listServers();
   if (servers.length === 0) {
@@ -41158,7 +41576,7 @@ program2.command("doctor").argument("[id]", "Server ID to check (omit to check a
   for (const server of servers) {
     console.log(chalk2.bold(`
 ${server.name} [${server.id}]`));
-    const report = await diagnoseServer(server);
+    const report = await diagnoseServer(server, { localCommandConsent: localConsentFromOptions(opts) });
     for (const check2 of report.checks) {
       const icon = check2.pass ? chalk2.green("\u2713") : chalk2.red("\u2717");
       console.log(`  ${icon} ${check2.name}: ${chalk2.dim(check2.message)}`);
@@ -41244,7 +41662,7 @@ program2.command("update").description("Update mcps to the latest version").acti
     process.exit(1);
   }
 });
-program2.command("find").argument("[query]", "Search query (omit to list all from awesome list)").description("Find MCP servers across npm, GitHub, official registry, and awesome lists").option("--source <sources...>", "Source IDs to search (see `mcps sources list`)").option("--limit <n>", "Max results per source", "20").option("--awesome", "List curated servers from punkpeye/awesome-mcp-servers").option("--json", "Output as JSON").option("--install", "After showing results, prompt to select one and install it").option("--yes", "Auto-install without prompting (only when there is exactly 1 result)").option("--no-cache", "Bypass source cache and fetch fresh results").action(async (query, opts) => {
+program2.command("find").argument("[query]", "Search query (omit to list all from awesome list)").description("Find MCP servers across npm, GitHub, official registry, and awesome lists").option("--source <sources...>", "Source IDs to search (see `mcps sources list`)").option("--limit <n>", "Max results per source", "20").option("--awesome", "List curated servers from punkpeye/awesome-mcp-servers").option("--json", "Output as JSON").option("--install", "After showing results, prompt to select one and install it").option("--yes", "Auto-install without prompting (only when there is exactly 1 result)").option("--allow-risky-command", "Approve high-risk local command patterns").option("--no-cache", "Bypass source cache and fetch fresh results").action(async (query, opts) => {
   try {
     if (opts.awesome) {
       console.log(chalk2.dim("Fetching curated awesome-mcp-servers list..."));
@@ -41354,6 +41772,14 @@ Enter number to install (1-${results.length}), or 0 to cancel: `), resolve2);
         return;
       }
       console.log(chalk2.dim(`Installing ${chosen.name}...`));
+      const localCommandInput = {
+        command: "npx",
+        args: ["-y", pkg],
+        env: {},
+        transport: "stdio",
+        operation: "install"
+      };
+      const localCommandConsent = assertCliLocalCommandConsent(localCommandInput, opts, true);
       const server = addServer({
         command: "npx",
         args: ["-y", pkg],
@@ -41361,7 +41787,7 @@ Enter number to install (1-${results.length}), or 0 to cancel: `), resolve2);
         description: chosen.description,
         transport: "stdio"
       });
-      const results2 = installToAgents(server, ["claude", "codex", "gemini"]);
+      const results2 = installToAgents(server, ["claude", "codex", "gemini"], { localCommandConsent });
       for (const r of results2) {
         if (r.success) {
           console.log(chalk2.green(`  \u2713 ${r.agent}`));
@@ -41506,7 +41932,7 @@ sourcesCmd.command("test").argument("<id>", "Source ID to test").description("Te
   }
   closeDb();
 });
-program2.command("install").argument("[id]", "Server ID (from `mcps list`) to install into AI agents").description("Install a registered MCP server into Claude Code, Codex, and/or Gemini").option("--claude", "Install to Claude Code").option("--codex", "Install to Codex").option("--gemini", "Install to Gemini").option("--all", "Install to all agents (default if none specified)").option("--to <agents...>", "Agents to install to: claude, codex, gemini").option("--from-registry <id>", "Add from official registry and install in one step").option("--npm <package>", "Add an npm package as a server and install in one step").action(async (id, opts) => {
+program2.command("install").argument("[id]", "Server ID (from `mcps list`) to install into AI agents").description("Install a registered MCP server into Claude Code, Codex, and/or Gemini").option("--claude", "Install to Claude Code").option("--codex", "Install to Codex").option("--gemini", "Install to Gemini").option("--all", "Install to all agents (default if none specified)").option("--to <agents...>", "Agents to install to: claude, codex, gemini").option("--from-registry <id>", "Add from official registry and install in one step").option("--npm <package>", "Add an npm package as a server and install in one step").option("--yes", "Approve installing local stdio commands into agents").option("--allow-local-stdio", "Approve installing local stdio commands into agents").option("--allow-risky-command", "Approve high-risk local command patterns").action(async (id, opts) => {
   const targets = [];
   if (opts.to) {
     for (const t of opts.to) {
@@ -41532,7 +41958,9 @@ program2.command("install").argument("[id]", "Server ID (from `mcps list`) to in
   if (opts.fromRegistry) {
     console.log(chalk2.dim(`Installing "${opts.fromRegistry}" from registry...`));
     try {
-      server = await installFromRegistry(opts.fromRegistry);
+      server = await installFromRegistry(opts.fromRegistry, {
+        localCommandConsent: localConsentFromOptions(opts)
+      });
       console.log(chalk2.green(`Added server: ${server.name} [${server.id}]`));
     } catch (err) {
       console.error(chalk2.red(`Failed to install from registry: ${err.message}`));
@@ -41541,6 +41969,13 @@ program2.command("install").argument("[id]", "Server ID (from `mcps list`) to in
     }
   } else if (opts.npm) {
     const pkg = opts.npm;
+    assertCliLocalCommandConsent({
+      command: "npx",
+      args: ["-y", pkg],
+      env: {},
+      transport: "stdio",
+      operation: "install"
+    }, opts);
     server = addServer({ command: "npx", args: ["-y", pkg], name: pkg, transport: "stdio" });
     console.log(chalk2.green(`Added server: ${server.name} [${server.id}]`));
   } else {
@@ -41557,7 +41992,7 @@ program2.command("install").argument("[id]", "Server ID (from `mcps list`) to in
     }
   }
   console.log(chalk2.dim(`Installing "${server.name}" to: ${targets.join(", ")}...`));
-  const results = installToAgents(server, targets);
+  const results = installToAgents(server, targets, { localCommandConsent: localConsentFromOptions(opts) });
   for (const r of results) {
     if (r.success) {
       console.log(chalk2.green(`  \u2713 ${r.agent}`));