@hasna/mcps 0.0.14 → 0.0.16

package/dist/mcp/index.js

@@ -16673,6 +16673,7 @@ function getDb() {
       command TEXT NOT NULL,
       args TEXT NOT NULL DEFAULT '[]',
       env TEXT NOT NULL DEFAULT '{}',
+      credential_refs TEXT NOT NULL DEFAULT '{}',
       transport TEXT NOT NULL DEFAULT 'stdio',
       url TEXT,
       source TEXT NOT NULL DEFAULT 'local',
@@ -16699,6 +16700,9 @@ function getDb() {
   try {
     db.exec("ALTER TABLE servers ADD COLUMN last_error TEXT");
   } catch {}
+  try {
+    db.exec("ALTER TABLE servers ADD COLUMN credential_refs TEXT NOT NULL DEFAULT '{}'");
+  } catch {}
   db.exec(`
     CREATE TABLE IF NOT EXISTS sources (
       id TEXT PRIMARY KEY,
@@ -16824,17 +16828,17 @@ __export(exports_sources, {
   clearCache: () => clearCache,
   addSource: () => addSource
 });
-import { mkdirSync as mkdirSync6, existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync2, readdirSync as readdirSync3, unlinkSync } from "fs";
-import { join as join8 } from "path";
+import { mkdirSync as mkdirSync6, existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync2, readdirSync as readdirSync3, unlinkSync } from "fs";
+import { join as join9 } from "path";
 function getCacheFile(sourceId) {
-  return join8(CACHE_DIR, `${sourceId}.json`);
+  return join9(CACHE_DIR, `${sourceId}.json`);
 }
 function readCache(sourceId) {
   try {
     const file = getCacheFile(sourceId);
-    if (!existsSync7(file))
+    if (!existsSync8(file))
       return null;
-    const data = JSON.parse(readFileSync3(file, "utf-8"));
+    const data = JSON.parse(readFileSync4(file, "utf-8"));
     return data;
   } catch {
     return null;
@@ -16848,7 +16852,7 @@ function writeCache(sourceId, results) {
 }
 function clearCache(sourceId) {
   try {
-    if (!existsSync7(CACHE_DIR))
+    if (!existsSync8(CACHE_DIR))
       return;
     const files = readdirSync3(CACHE_DIR);
     for (const file of files) {
@@ -16856,7 +16860,7 @@ function clearCache(sourceId) {
         continue;
       if (!sourceId || file.startsWith(`${sourceId}.`)) {
         try {
-          unlinkSync(join8(CACHE_DIR, file));
+          unlinkSync(join9(CACHE_DIR, file));
         } catch {}
       }
     }
@@ -17102,7 +17106,7 @@ var CACHE_DIR, DEFAULT_TTL_MS;
 var init_sources = __esm(() => {
   init_db();
   init_config2();
-  CACHE_DIR = join8(MCPS_DIR, "cache");
+  CACHE_DIR = join9(MCPS_DIR, "cache");
   DEFAULT_TTL_MS = 10 * 60 * 1000;
 });
 
@@ -30660,6 +30664,146 @@ function readPackageVersion(moduleUrl, fallback = FALLBACK_VERSION) {
 
 // src/lib/registry.ts
 init_db();
+
+// src/lib/credentials.ts
+init_config2();
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
+import { join as join8 } from "path";
+
+class CredentialReferenceError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CredentialReferenceError";
+  }
+}
+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 REDACTED_CREDENTIAL_VALUE = "<redacted>";
+function normalizeKey(key) {
+  return key.trim();
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSecretLikeEnvKey(key) {
+  return SECRET_KEY_PATTERN.test(key);
+}
+function isSecretLikeValue(value) {
+  return SECRET_VALUE_PATTERN.test(value.trim());
+}
+function normalizeCredentialRef(ref) {
+  const source = ref.source;
+  if (source !== "env" && source !== "local-vault" && source !== "hosted") {
+    throw new CredentialReferenceError(`Unsupported credential reference source: ${String(source)}`);
+  }
+  const name = ref.name?.trim();
+  if (!name) {
+    throw new CredentialReferenceError("Credential reference name is required");
+  }
+  return {
+    source,
+    name,
+    required: ref.required !== false,
+    ...ref.description ? { description: ref.description } : {}
+  };
+}
+function normalizeCredentialRefs(refs) {
+  const normalized = {};
+  for (const [rawKey, ref] of Object.entries(refs ?? {})) {
+    const key = normalizeKey(rawKey);
+    if (!key)
+      throw new CredentialReferenceError("Credential reference env key is required");
+    normalized[key] = normalizeCredentialRef(ref);
+  }
+  return normalized;
+}
+function parseCredentialRefs(value) {
+  if (!isRecord(value))
+    return {};
+  const refs = {};
+  for (const [key, ref] of Object.entries(value)) {
+    if (!isRecord(ref))
+      continue;
+    const source = ref.source;
+    const name = ref.name;
+    if ((source === "env" || source === "local-vault" || source === "hosted") && typeof name === "string" && name.trim()) {
+      refs[key] = normalizeCredentialRef({
+        source,
+        name,
+        required: typeof ref.required === "boolean" ? ref.required : true,
+        description: typeof ref.description === "string" ? ref.description : undefined
+      });
+    }
+  }
+  return refs;
+}
+function normalizeLiteralEnv(env) {
+  const normalized = {};
+  for (const [rawKey, rawValue] of Object.entries(env ?? {})) {
+    const key = normalizeKey(rawKey);
+    if (!key)
+      continue;
+    const value = String(rawValue);
+    if (isSecretLikeEnvKey(key) || isSecretLikeValue(value)) {
+      throw new CredentialReferenceError(`Refusing to store raw secret-like env value for "${key}". Use a credential reference instead.`);
+    }
+    normalized[key] = value;
+  }
+  return normalized;
+}
+function readLocalVault() {
+  const path = process.env.HASNA_MCPS_CREDENTIAL_VAULT_PATH ?? join8(MCPS_DIR, "credentials.local.json");
+  if (!existsSync7(path))
+    return {};
+  const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+  if (!isRecord(parsed))
+    return {};
+  const values = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value === "string")
+      values[key] = value;
+  }
+  return values;
+}
+function resolveCredentialRef(envKey, ref) {
+  if (ref.source === "env") {
+    const value = process.env[ref.name];
+    if (value === undefined && ref.required !== false) {
+      throw new CredentialReferenceError(`Missing required environment credential "${ref.name}" for "${envKey}"`);
+    }
+    return value;
+  }
+  if (ref.source === "local-vault") {
+    const value = readLocalVault()[ref.name];
+    if (value === undefined && ref.required !== false) {
+      throw new CredentialReferenceError(`Missing required local vault credential "${ref.name}" for "${envKey}"`);
+    }
+    return value;
+  }
+  if (ref.required !== false) {
+    throw new CredentialReferenceError(`Hosted credential "${ref.name}" for "${envKey}" cannot be resolved by the local runtime`);
+  }
+  return;
+}
+function resolveServerEnv(server) {
+  const resolved = { ...server.env };
+  const refs = normalizeCredentialRefs(server.credentialRefs);
+  for (const [envKey, ref] of Object.entries(refs)) {
+    const value = resolveCredentialRef(envKey, ref);
+    if (value !== undefined)
+      resolved[envKey] = value;
+  }
+  return resolved;
+}
+function credentialRefPlaceholders(refs) {
+  const placeholders = {};
+  for (const key of Object.keys(refs ?? {})) {
+    placeholders[key] = REDACTED_CREDENTIAL_VALUE;
+  }
+  return placeholders;
+}
+
+// src/lib/registry.ts
 function parseRow(row) {
   return {
     id: row.id,
@@ -30668,6 +30812,7 @@ function parseRow(row) {
     command: row.command,
     args: safeJsonParse(row.args, []),
     env: safeJsonParse(row.env, {}),
+    credentialRefs: parseCredentialRefs(safeJsonParse(row.credential_refs, {})),
     transport: row.transport,
     url: row.url || null,
     source: row.source,
@@ -30735,9 +30880,9 @@ function addServer(opts) {
   if (!id) {
     throw new Error("Unable to generate a valid server ID");
   }
-  const row = db2.prepare(`INSERT INTO servers (id, name, description, command, args, env, transport, url, source)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-       RETURNING *`).get(id, name, opts.description || null, command, JSON.stringify(opts.args || []), JSON.stringify(opts.env || {}), opts.transport || "stdio", opts.url || null, opts.source || "local");
+  const row = db2.prepare(`INSERT INTO servers (id, name, description, command, args, env, credential_refs, transport, url, source)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       RETURNING *`).get(id, name, opts.description || null, command, JSON.stringify(opts.args || []), JSON.stringify(normalizeLiteralEnv(opts.env)), JSON.stringify(normalizeCredentialRefs(opts.credentialRefs)), opts.transport || "stdio", opts.url || null, opts.source || "local");
   return parseRow(row);
 }
 function removeServer(id) {
@@ -30776,7 +30921,11 @@ function updateServer(id, updates) {
   }
   if (updates.env !== undefined) {
     sets.push("env = ?");
-    values.push(JSON.stringify(updates.env));
+    values.push(JSON.stringify(normalizeLiteralEnv(updates.env)));
+  }
+  if (updates.credentialRefs !== undefined) {
+    sets.push("credential_refs = ?");
+    values.push(JSON.stringify(normalizeCredentialRefs(updates.credentialRefs)));
   }
   if (updates.transport !== undefined) {
     sets.push("transport = ?");
@@ -30840,6 +30989,185 @@ function getCachedTools(serverId) {
 
 // src/lib/remote.ts
 init_config2();
+
+// 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_PATTERN2 = /(?:^|[_-])(api[_-]?key|token|secret|password|passwd|credential|auth|private[_-]?key)(?:$|[_-])/i;
+var SECRET_VALUE_PATTERN2 = /^(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_PATTERN2.test(key) || SECRET_FLAG_PATTERN.test(key);
+}
+function isSecretValue(value) {
+  return SECRET_VALUE_PATTERN2.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/remote.ts
 function parseRegistryEntry(entry) {
   const s = entry.server;
   return {
@@ -30870,7 +31198,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`);
@@ -30890,6 +31218,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,
@@ -30915,8 +31250,8 @@ init_sources();
 
 // src/lib/install.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync7 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync7 } from "fs";
+import { join as join10 } from "path";
 import { homedir as homedir8 } from "os";
 function installToClaude(entry) {
   try {
@@ -30928,7 +31263,7 @@ function installToClaude(entry) {
       "--scope",
       "user"
     ];
-    for (const [k, v] of Object.entries(entry.env)) {
+    for (const [k, v] of Object.entries(assertAgentInstallEnv(entry))) {
       args.push("--env", `${k}=${v}`);
     }
     args.push(entry.id, "--", entry.command, ...entry.args);
@@ -30940,9 +31275,9 @@ function installToClaude(entry) {
 }
 function installToCodex(entry) {
   try {
-    const configDir = join9(homedir8(), ".codex");
-    const configPath = join9(configDir, "config.toml");
-    if (!existsSync8(configDir)) {
+    const configDir = join10(homedir8(), ".codex");
+    const configPath = join10(configDir, "config.toml");
+    if (!existsSync9(configDir)) {
       mkdirSync7(configDir, { recursive: true });
     }
     const block = `
@@ -30950,7 +31285,7 @@ function installToCodex(entry) {
 ` + `command = ${JSON.stringify(entry.command)}
 ` + `args = [${entry.args.map((a) => JSON.stringify(a)).join(", ")}]
 `;
-    const existing = existsSync8(configPath) ? readFileSync4(configPath, "utf-8") : "";
+    const existing = existsSync9(configPath) ? readFileSync5(configPath, "utf-8") : "";
     if (existing.includes(`[mcp_servers.${entry.id}]`)) {
       return { agent: "codex", success: true };
     }
@@ -30962,21 +31297,22 @@ function installToCodex(entry) {
 }
 function installToGemini(entry) {
   try {
-    const configDir = join9(homedir8(), ".gemini");
-    const configPath = join9(configDir, "settings.json");
-    if (!existsSync8(configDir)) {
+    const configDir = join10(homedir8(), ".gemini");
+    const configPath = join10(configDir, "settings.json");
+    if (!existsSync9(configDir)) {
       mkdirSync7(configDir, { recursive: true });
     }
     let settings = {};
-    if (existsSync8(configPath)) {
-      settings = JSON.parse(readFileSync4(configPath, "utf-8"));
+    if (existsSync9(configPath)) {
+      settings = JSON.parse(readFileSync5(configPath, "utf-8"));
     }
     if (!settings.mcpServers)
       settings.mcpServers = {};
+    const env = assertAgentInstallEnv(entry);
     settings.mcpServers[entry.id] = {
       command: entry.command,
       args: entry.args,
-      ...Object.keys(entry.env).length > 0 ? { env: entry.env } : {}
+      ...Object.keys(env).length > 0 ? { env } : {}
     };
     writeFileSync3(configPath, JSON.stringify(settings, null, 2), "utf-8");
     return { agent: "gemini", success: true };
@@ -30984,7 +31320,43 @@ function installToGemini(entry) {
     return { agent: "gemini", success: false, error: err.message };
   }
 }
-function installToAgents(entry, targets = ["claude", "codex", "gemini"]) {
+function assertAgentInstallEnv(entry) {
+  const refs = entry.credentialRefs ?? {};
+  if (Object.keys(refs).length > 0) {
+    throw new CredentialReferenceError(`Server "${entry.id}" uses credential references; refusing to materialize secrets into local agent config files`);
+  }
+  for (const [key, value] of Object.entries(entry.env)) {
+    if (isSecretLikeEnvKey(key) || isSecretLikeValue(value)) {
+      throw new CredentialReferenceError(`Server "${entry.id}" has legacy raw secret-like env "${key}"; move it to a credential reference before installing to agents`);
+    }
+  }
+  return entry.env;
+}
+function installToAgents(entry, targets = ["claude", "codex", "gemini"], options = {}) {
+  try {
+    assertLocalCommandConsent({
+      command: entry.command,
+      args: entry.args,
+      env: { ...entry.env, ...credentialRefPlaceholders(entry.credentialRefs) },
+      transport: entry.transport,
+      operation: "install"
+    }, options.localCommandConsent);
+  } catch (err) {
+    return targets.map((target) => ({
+      agent: target,
+      success: false,
+      error: err.message
+    }));
+  }
+  try {
+    assertAgentInstallEnv(entry);
+  } catch (err) {
+    return targets.map((target) => ({
+      agent: target,
+      success: false,
+      error: err.message
+    }));
+  }
   return targets.map((target) => {
     if (target === "claude")
       return installToClaude(entry);
@@ -33401,7 +33773,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);
   }
@@ -33417,10 +33789,17 @@ 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, ...credentialRefPlaceholders(entry.credentialRefs) },
+          transport: entry.transport,
+          operation: "launch"
+        }, options.localCommandConsent);
         transport = new StdioClientTransport({
           command: entry.command,
           args: entry.args,
-          env: buildEnv(entry.env)
+          env: buildEnv(resolveServerEnv(entry))
         });
       } else if (entry.transport === "sse") {
         transport = new SSEClientTransport(requireUrl(entry));
@@ -33533,7 +33912,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;
@@ -33545,7 +33924,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}`);
@@ -33558,13 +33937,28 @@ async function connectAllEnabled() {
 
 // src/lib/doctor.ts
 import { execFileSync as execFileSync2 } from "child_process";
-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, ...credentialRefPlaceholders(server.credentialRefs) },
+        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 = execFileSync2("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 = execFileSync2(server.command, ["--version"], { stdio: "pipe" }).toString().trim().split(`
 `)[0];
       } catch {}
@@ -33580,12 +33974,29 @@ async function diagnoseServer(server) {
     }
   }
   const missingEnv = Object.entries(server.env).filter(([, v]) => !v);
-  if (Object.keys(server.env).length === 0) {
-    checks4.push({ name: "env vars", pass: true, message: "no env vars required" });
-  } else if (missingEnv.length > 0) {
-    checks4.push({ name: "env vars", pass: false, message: `missing values for: ${missingEnv.map(([k]) => k).join(", ")}` });
+  const credentialRefCount = Object.keys(server.credentialRefs ?? {}).length;
+  let credentialError = null;
+  try {
+    resolveServerEnv(server);
+  } catch (err) {
+    credentialError = err.message;
+  }
+  if (Object.keys(server.env).length === 0 && credentialRefCount === 0) {
+    checks4.push({ name: "env vars", pass: true, message: "no env vars or credential refs required" });
+  } else if (missingEnv.length > 0 || credentialError) {
+    const parts = [];
+    if (missingEnv.length > 0)
+      parts.push(`missing literal values for: ${missingEnv.map(([k]) => k).join(", ")}`);
+    if (credentialError)
+      parts.push(credentialError);
+    checks4.push({ name: "env vars", pass: false, message: parts.join("; ") });
   } else {
-    checks4.push({ name: "env vars", pass: true, message: `${Object.keys(server.env).length} env var(s) set` });
+    const literalCount = Object.keys(server.env).length;
+    checks4.push({
+      name: "env vars",
+      pass: true,
+      message: `${literalCount} literal env var(s), ${credentialRefCount} credential ref(s) available`
+    });
   }
   if (server.transport !== "stdio" && server.url) {
     try {
@@ -33595,10 +34006,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);
@@ -33606,8 +34017,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,
@@ -33820,11 +34233,11 @@ function seedDefaultMachines() {
 // src/lib/fleet.ts
 init_config2();
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join11 } from "path";
 var NPM_SEARCH_URL = "https://registry.npmjs.org/-/v1/search";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
-var CATALOG_CACHE_PATH = join10(MCPS_DIR, "cache", "hasna-catalog.json");
+var CATALOG_CACHE_PATH = join11(MCPS_DIR, "cache", "hasna-catalog.json");
 var DEFAULT_CATALOG_CACHE_TTL_MS = 60 * 60 * 1000;
 var DEFAULT_REMOTE_TIMEOUT_MS = 180000;
 var DEFAULT_HANDSHAKE_TIMEOUT_MS = 2500;
@@ -33834,9 +34247,9 @@ function normalizeQueryList(values) {
 }
 function readCatalogCache(maxAgeMs) {
   try {
-    if (!existsSync9(CATALOG_CACHE_PATH))
+    if (!existsSync10(CATALOG_CACHE_PATH))
       return null;
-    const parsed = JSON.parse(readFileSync5(CATALOG_CACHE_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(CATALOG_CACHE_PATH, "utf-8"));
     if (!parsed.cachedAt || !Array.isArray(parsed.entries))
       return null;
     if (Date.now() - parsed.cachedAt > maxAgeMs)
@@ -33848,7 +34261,7 @@ function readCatalogCache(maxAgeMs) {
 }
 function writeCatalogCache(entries) {
   try {
-    mkdirSync8(join10(MCPS_DIR, "cache"), { recursive: true });
+    mkdirSync8(join11(MCPS_DIR, "cache"), { recursive: true });
     writeFileSync4(CATALOG_CACHE_PATH, JSON.stringify({ cachedAt: Date.now(), entries }, null, 2), "utf-8");
   } catch {}
 }
@@ -34606,11 +35019,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"
@@ -34632,6 +35053,16 @@ 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 readCredentialRefs(input) {
+  return normalizeCredentialRefs(input.credential_refs ?? input.credentialRefs);
+}
 function buildMcpTools() {
   const definitions = [
     {
@@ -34656,23 +35087,60 @@ 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"),
+        credential_refs: exports_external2.record(exports_external2.object({
+          source: exports_external2.enum(["env", "local-vault", "hosted"]),
+          name: exports_external2.string(),
+          required: exports_external2.boolean().optional(),
+          description: exports_external2.string().optional()
+        })).optional().describe("Credential references by server env key"),
+        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 credentialRefs = readCredentialRefs(input);
+        const transport = input.transport;
+        try {
+          assertLocalCommandConsent({
+            command,
+            args,
+            env: { ...env, ...Object.fromEntries(Object.keys(credentialRefs).map((key) => [key, "<credential-ref>"])) },
+            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,
+            credentialRefs
+          }));
+        } 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",
@@ -34718,26 +35186,52 @@ 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"),
+        credential_refs: exports_external2.record(exports_external2.object({
+          source: exports_external2.enum(["env", "local-vault", "hosted"]),
+          name: exports_external2.string(),
+          required: exports_external2.boolean().optional(),
+          description: exports_external2.string().optional()
+        })).optional().describe("Credential references by server env key"),
+        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.credential_refs !== undefined || input.credentialRefs !== undefined)
+          fields.credentialRefs = readCredentialRefs(input);
+        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,
+                ...Object.fromEntries(Object.keys(fields.credentialRefs ?? existing.credentialRefs ?? {}).map((key) => [key, "<credential-ref>"]))
+              },
+              transport: fields.transport ?? existing.transport,
+              operation: "register"
+            }, localConsent(input));
+          } catch (err) {
+            return errorContent(err.message);
+          }
+        }
         return jsonContent(redactServerEnv(updateServer(serverId, fields)));
       }
     },
@@ -34819,13 +35313,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);
@@ -34898,15 +35395,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)
+        }));
       }
     },
     {
@@ -34918,11 +35419,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(() => {
@@ -34937,11 +35441,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}"`);
@@ -34951,8 +35457,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}`);
@@ -34962,13 +35468,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) }));
       }
     },
     {