run-mcp 1.6.3 → 1.7.1

package/dist/index.js

@@ -3,15 +3,15 @@
 // src/index.ts
 import { program } from "commander";
 import { createConnection, createServer } from "net";
-import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir2, readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
-import { join as join2, resolve } from "path";
-import { tmpdir as tmpdir2 } from "os";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir3, readFile as readFile5, rm, writeFile as writeFile3 } from "fs/promises";
+import { join as join6, resolve as resolve2 } from "path";
+import { tmpdir as tmpdir3 } from "os";
 import { spawn } from "child_process";
 
 // src/config-scanner.ts
 import { existsSync } from "fs";
-import { readFile } from "fs/promises";
+import { readFile, readdir } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
 import process2 from "process";
@@ -57,10 +57,14 @@ function getConfigPaths() {
     { source: "Gemini CLI (Project)", file: path.join(cwd, ".gemini", "settings.json") },
     { source: "Claude Code (Global)", file: path.join(home, ".claude.json") },
     { source: "Claude Code (Project)", file: path.join(cwd, ".mcp.json") },
-    { source: "Antigravity", file: path.join(home, ".gemini", "antigravity", "mcp_config.json") }
+    { source: "Antigravity", file: path.join(home, ".gemini", "antigravity", "mcp_config.json") },
+    {
+      source: "Gemini App (Global)",
+      file: path.join(home, ".gemini", "config", "mcp_config.json")
+    }
   ];
 }
-async function discoverServers() {
+async function discoverServers(options) {
   const servers = [];
   const paths = getConfigPaths();
   for (const { source, file } of paths) {
@@ -86,10 +90,52 @@ async function discoverServers() {
     } catch {
     }
   }
+  if (options?.scan) {
+    try {
+      let currentDir = process2.cwd();
+      const visited = /* @__PURE__ */ new Set();
+      while (currentDir && !visited.has(currentDir)) {
+        visited.add(currentDir);
+        if (existsSync(currentDir)) {
+          const files = await readdir(currentDir, { withFileTypes: true });
+          for (const file of files) {
+            if (file.isFile() && file.name.endsWith(".json")) {
+              if (file.name === "package-lock.json" || file.name === "package.json" || file.name === "tsconfig.json") {
+                continue;
+              }
+              const filePath = path.join(currentDir, file.name);
+              try {
+                const content = await readFile(filePath, "utf8");
+                if (content.includes("mcpServers")) {
+                  const json = JSON.parse(content);
+                  if (json.mcpServers && typeof json.mcpServers === "object") {
+                    for (const [name, config] of Object.entries(json.mcpServers)) {
+                      if (config && typeof config === "object" && config.command) {
+                        servers.push({
+                          name,
+                          config,
+                          source: `Local Workspace (${file.name})`
+                        });
+                      }
+                    }
+                  }
+                }
+              } catch {
+              }
+            }
+          }
+        }
+        const parent = path.dirname(currentDir);
+        if (parent === currentDir) break;
+        currentDir = parent;
+      }
+    } catch {
+    }
+  }
   return servers;
 }
-async function pickDiscoveredServer() {
-  const servers = await discoverServers();
+async function pickDiscoveredServer(options) {
+  const servers = await discoverServers(options);
   if (servers.length === 0) {
     return null;
   }
@@ -99,7 +145,7 @@ async function pickDiscoveredServer() {
     if (!uniqueServers.has(key)) {
       uniqueServers.set(key, s);
     } else {
-      if (s.source.includes("Project")) {
+      if (s.source.includes("Project") || s.source.includes("Local Workspace")) {
         uniqueServers.set(key, s);
       }
     }
@@ -143,6 +189,7 @@ async function pickDiscoveredServer() {
 import { mkdir, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
+import { exec } from "child_process";
 var BASE64_PATTERN = /^[A-Za-z0-9+/]{1000,}={0,2}$/;
 var DEFAULT_TIMEOUT_MS = 3e5;
 var DEFAULT_MAX_TEXT_LENGTH = 5e4;
@@ -151,12 +198,14 @@ var ResponseInterceptor = class {
   defaultTimeoutMs;
   maxTextLength;
   mediaThresholdKb;
+  openMedia;
   fileCounter = 0;
   constructor(opts = {}) {
     this.outDir = opts.outDir ?? join(tmpdir(), "run-mcp");
     this.defaultTimeoutMs = opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.maxTextLength = opts.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH;
     this.mediaThresholdKb = opts.mediaThresholdKb ?? 0;
+    this.openMedia = opts.openMedia ?? false;
   }
   /**
    * Call a tool on the target, applying timeout, media extraction, and truncation.
@@ -373,6 +422,13 @@ var ResponseInterceptor = class {
     const filepath = join(this.outDir, filename);
     const buffer = Buffer.from(base64Data, "base64");
     await writeFile(filepath, buffer);
+    if (this.openMedia) {
+      const isMac = process.platform === "darwin";
+      const isWin = process.platform === "win32";
+      const cmd = isMac ? "open" : isWin ? "start" : "xdg-open";
+      exec(`${cmd} "${filepath}"`, () => {
+      });
+    }
     const sizeKB = (buffer.length / 1024).toFixed(1);
     const label = mediaType === "audio" ? "Audio" : "Image";
     return {
@@ -423,8 +479,41 @@ var ResponseInterceptor = class {
   }
 };
 
-// src/parsing.ts
+// src/colors.ts
 import pc from "picocolors";
+function shouldEnableColor() {
+  const dashDashIdx = process.argv.indexOf("--");
+  const argsToCheck = dashDashIdx === -1 ? process.argv : process.argv.slice(0, dashDashIdx);
+  for (let i = 0; i < argsToCheck.length; i++) {
+    const arg = argsToCheck[i];
+    if (arg.startsWith("--color=")) {
+      const val = arg.split("=")[1];
+      if (val === "always") return true;
+      if (val === "never") return false;
+    } else if (arg === "--color") {
+      const val = argsToCheck[i + 1];
+      if (val === "always") return true;
+      if (val === "never") return false;
+    }
+  }
+  if (process.env.CLICOLOR_FORCE !== void 0 && process.env.CLICOLOR_FORCE !== "0") {
+    return true;
+  }
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  if (process.env.CLICOLOR === "0") {
+    return false;
+  }
+  const isatty = !!(process.stdout?.isTTY || process.stderr?.isTTY);
+  if (!isatty) {
+    return false;
+  }
+  return true;
+}
+var colors = pc.createColors(shouldEnableColor());
+
+// src/parsing.ts
 function parseCommandLine(input3) {
   const spaceIdx = input3.indexOf(" ");
   if (spaceIdx === -1) {
@@ -466,10 +555,10 @@ function colorizeJson(json) {
     if (ch === '"') {
       const str = consumeString(json, i);
       if (expectingValue) {
-        result.push(pc.green(str));
+        result.push(colors.green(str));
         expectingValue = false;
       } else {
-        result.push(pc.cyan(str));
+        result.push(colors.cyan(str));
       }
       i += str.length;
       continue;
@@ -493,19 +582,19 @@ function colorizeJson(json) {
       continue;
     }
     if (json.startsWith("true", i)) {
-      result.push(pc.magenta("true"));
+      result.push(colors.magenta("true"));
       expectingValue = false;
       i += 4;
       continue;
     }
     if (json.startsWith("false", i)) {
-      result.push(pc.magenta("false"));
+      result.push(colors.magenta("false"));
       expectingValue = false;
       i += 5;
       continue;
     }
     if (json.startsWith("null", i)) {
-      result.push(pc.dim("null"));
+      result.push(colors.dim("null"));
       expectingValue = false;
       i += 4;
       continue;
@@ -516,7 +605,7 @@ function colorizeJson(json) {
         num += json[i];
         i++;
       }
-      result.push(pc.yellow(num));
+      result.push(colors.yellow(num));
       expectingValue = false;
       continue;
     }
@@ -834,7 +923,425 @@ function interpolateString(input3, context) {
 
 // src/target-manager.ts
 import { EventEmitter } from "events";
+import { execSync } from "child_process";
+import { writeFileSync, rmSync, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 import treeKill from "tree-kill";
+
+// src/settings.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname, join as join2, resolve, isAbsolute } from "path";
+import { homedir as homedir2 } from "os";
+function resolvePath(p, settingsFileDir) {
+  if (p.startsWith("~")) {
+    return resolve(homedir2(), p.slice(1).replace(/^[/\\]/, ""));
+  }
+  if (p.startsWith("$HOME")) {
+    return resolve(homedir2(), p.slice(5).replace(/^[/\\]/, ""));
+  }
+  if (isAbsolute(p)) {
+    return resolve(p);
+  }
+  return resolve(settingsFileDir, p);
+}
+function matchDomain(host, pattern) {
+  if (pattern === "*") return true;
+  const [hostName, hostPort] = host.split(":");
+  const [patternName, patternPort] = pattern.split(":");
+  if (patternPort && patternPort !== "*") {
+    if (hostPort !== patternPort) return false;
+  }
+  const regexPattern = patternName.replace(/\./g, "\\.").replace(/\*/g, ".*");
+  const regex = new RegExp(`^${regexPattern}$`, "i");
+  return regex.test(hostName);
+}
+var SandboxPolicy = class {
+  // Allowlists (Absolute paths or patterns)
+  fileReadAllow = /* @__PURE__ */ new Set();
+  fileWriteAllow = /* @__PURE__ */ new Set();
+  networkAllow = /* @__PURE__ */ new Set();
+  // Denylists (Absolute paths or patterns)
+  fileReadDeny = /* @__PURE__ */ new Set();
+  fileWriteDeny = /* @__PURE__ */ new Set();
+  networkDeny = /* @__PURE__ */ new Set();
+  constructor() {
+  }
+  /**
+   * Merge a SandboxConfig block into the policy.
+   * Path rules are resolved relative to the settingsFileDir.
+   */
+  mergeConfig(config, settingsFileDir) {
+    if (config.file?.allow?.read) {
+      for (const p of config.file.allow.read) {
+        this.fileReadAllow.add(resolvePath(p, settingsFileDir));
+      }
+    }
+    if (config.file?.allow?.write) {
+      for (const p of config.file.allow.write) {
+        this.fileWriteAllow.add(resolvePath(p, settingsFileDir));
+      }
+    }
+    if (config.file?.deny?.read) {
+      for (const p of config.file.deny.read) {
+        this.fileReadDeny.add(resolvePath(p, settingsFileDir));
+      }
+    }
+    if (config.file?.deny?.write) {
+      for (const p of config.file.deny.write) {
+        this.fileWriteDeny.add(resolvePath(p, settingsFileDir));
+      }
+    }
+    if (config.network?.allow) {
+      for (const host of config.network.allow) {
+        this.networkAllow.add(host);
+      }
+    }
+    if (config.network?.deny) {
+      for (const host of config.network.deny) {
+        this.networkDeny.add(host);
+      }
+    }
+  }
+  /**
+   * Merge raw command line overrides.
+   * CLI overrides are resolved relative to the process CWD.
+   */
+  mergeCliOverrides(options) {
+    const cwd = process.cwd();
+    if (options.allowRead) {
+      for (const p of options.allowRead) this.fileReadAllow.add(resolvePath(p, cwd));
+    }
+    if (options.allowWrite) {
+      for (const p of options.allowWrite) this.fileWriteAllow.add(resolvePath(p, cwd));
+    }
+    if (options.allowNet) {
+      for (const host of options.allowNet) this.networkAllow.add(host);
+    }
+    if (options.denyRead) {
+      for (const p of options.denyRead) this.fileReadDeny.add(resolvePath(p, cwd));
+    }
+    if (options.denyWrite) {
+      for (const p of options.denyWrite) this.fileWriteDeny.add(resolvePath(p, cwd));
+    }
+    if (options.denyNet) {
+      for (const host of options.denyNet) this.networkDeny.add(host);
+    }
+  }
+  /**
+   * Automatically deny reading sensitive credential directories if network outbound is allowed.
+   */
+  applyCredentialProtections() {
+    if (this.networkAllow.size > 0 && !this.networkDeny.has("*")) {
+      const sensitivePatterns = [
+        "~/.ssh",
+        "~/.aws",
+        "~/.kube",
+        "~/.config/gcloud",
+        "~/.netrc",
+        "~/.npmrc"
+      ];
+      const cwd = process.cwd();
+      for (const pattern of sensitivePatterns) {
+        const resolved = resolvePath(pattern, cwd);
+        if (!this.fileReadAllow.has(resolved)) {
+          this.fileReadDeny.add(resolved);
+        }
+      }
+    }
+  }
+  /**
+   * Evaluates if a file read path is allowed, under Deny-Wins precedence.
+   */
+  isFileReadAllowed(p) {
+    const absPath = resolve(p);
+    for (const denyPath of this.fileReadDeny) {
+      if (absPath === denyPath || absPath.startsWith(denyPath + "/")) {
+        return false;
+      }
+    }
+    for (const allowPath of this.fileReadAllow) {
+      if (absPath === allowPath || absPath.startsWith(allowPath + "/")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Evaluates if a file write path is allowed, under Deny-Wins precedence.
+   */
+  isFileWriteAllowed(p) {
+    const absPath = resolve(p);
+    for (const denyPath of this.fileWriteDeny) {
+      if (absPath === denyPath || absPath.startsWith(denyPath + "/")) {
+        return false;
+      }
+    }
+    for (const allowPath of this.fileWriteAllow) {
+      if (absPath === allowPath || absPath.startsWith(allowPath + "/")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Evaluates if network access to a host (hostname:port or hostname) is allowed.
+   */
+  isNetworkAllowed(host) {
+    for (const denyPattern of this.networkDeny) {
+      if (matchDomain(host, denyPattern)) {
+        return false;
+      }
+    }
+    for (const allowPattern of this.networkAllow) {
+      if (matchDomain(host, allowPattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Generate Scheme-based macOS Seatbelt profile.
+   */
+  getSeatbeltProfile(options) {
+    if (options.audit) {
+      return `(version 1)
+(allow default)
+(deny network*)
+(deny file-write*)
+(deny process-fork)
+(deny process-exec*)
+(allow process-exec*
+  (subpath "/System")
+  (subpath "/usr")
+  (subpath "/bin")
+  (subpath "${options.nodeBinDir}")
+)
+(deny file-read*)
+(allow file-read*
+  (literal "/")
+  (subpath "/System")
+  (subpath "/usr")
+  (subpath "/dev")
+  (subpath "/private/var")
+  (subpath "/var")
+  (subpath "/private/etc")
+  (subpath "/etc")
+  (subpath "${options.nodeBinDir}")
+  (subpath "${options.nodeInstallDir}")
+  (subpath "${options.cwd}")
+  (path-ancestors "${options.cwd}")
+  (path-ancestors "${options.nodeBinDir}")
+)
+`;
+    }
+    const readDirectives = Array.from(this.fileReadAllow).map((p) => `  (subpath "${p}")`).join("\n");
+    const writeDirectives = Array.from(this.fileWriteAllow).map((p) => `  (subpath "${p}")`).join("\n");
+    const readDenyDirectives = Array.from(this.fileReadDeny).map((p) => `  (subpath "${p}")`).join("\n");
+    const writeDenyDirectives = Array.from(this.fileWriteDeny).map((p) => `  (subpath "${p}")`).join("\n");
+    let netRules;
+    if (this.networkAllow.size > 0 && !this.networkDeny.has("*")) {
+      netRules = `(allow network-outbound)
+`;
+      if (this.networkDeny.size > 0) {
+        for (const pattern of this.networkDeny) {
+          if (pattern !== "*") {
+            netRules += `(deny network-outbound (remote ip "${pattern}"))
+`;
+          }
+        }
+      }
+    } else {
+      netRules = `(deny network*)
+`;
+    }
+    return `(version 1)
+(allow default)
+${netRules}
+(deny file-write*)
+(allow file-write*
+  (subpath "${options.tmp}")
+  (subpath "/private/tmp")
+  (subpath "/tmp")
+${writeDirectives}
+)
+${writeDenyDirectives ? `(deny file-write*
+${writeDenyDirectives}
+)
+` : ""}
+(deny file-read*)
+(allow file-read*
+  (literal "/")
+  (subpath "/System")
+  (subpath "/usr")
+  (subpath "/dev")
+  (subpath "/private/var")
+  (subpath "/var")
+  (subpath "/private/etc")
+  (subpath "/etc")
+  (subpath "/private/tmp")
+  (subpath "/tmp")
+  (subpath "${options.nodeBinDir}")
+  (subpath "${options.nodeInstallDir}")
+  (subpath "${options.cwd}")
+  (subpath "${options.tmp}")
+  (path-ancestors "${options.cwd}")
+  (path-ancestors "${options.nodeBinDir}")
+${readDirectives}
+)
+${readDenyDirectives ? `(deny file-read*
+${readDenyDirectives}
+)
+` : ""}
+`;
+  }
+};
+function loadSettings(cwd = process.cwd()) {
+  const settings = { sandbox: {} };
+  const loadedConfigs = [];
+  let managedPath;
+  if (process.platform === "darwin") {
+    managedPath = "/Library/Application Support/run-mcp/settings.json";
+  } else if (process.platform === "win32") {
+    managedPath = join2(process.env.ProgramFiles || "C:\\Program Files", "run-mcp", "settings.json");
+  } else {
+    managedPath = "/etc/run-mcp/settings.json";
+  }
+  if (existsSync2(managedPath)) {
+    try {
+      const config = JSON.parse(readFileSync(managedPath, "utf8"));
+      if (config.sandbox) loadedConfigs.push({ config: config.sandbox, dir: dirname(managedPath) });
+    } catch {
+    }
+  }
+  const userPath = join2(homedir2(), ".run-mcp", "settings.json");
+  if (existsSync2(userPath)) {
+    try {
+      const config = JSON.parse(readFileSync(userPath, "utf8"));
+      if (config.sandbox) loadedConfigs.push({ config: config.sandbox, dir: dirname(userPath) });
+    } catch {
+    }
+  }
+  const projectPath = join2(cwd, ".run-mcp", "settings.json");
+  if (existsSync2(projectPath)) {
+    try {
+      const config = JSON.parse(readFileSync(projectPath, "utf8"));
+      if (config.sandbox) loadedConfigs.push({ config: config.sandbox, dir: dirname(projectPath) });
+    } catch {
+    }
+  }
+  const localPath = join2(cwd, ".run-mcp", "settings.local.json");
+  if (existsSync2(localPath)) {
+    try {
+      const config = JSON.parse(readFileSync(localPath, "utf8"));
+      if (config.sandbox) loadedConfigs.push({ config: config.sandbox, dir: dirname(localPath) });
+    } catch {
+    }
+  }
+  const policy = new SandboxPolicy();
+  for (const item of loadedConfigs) {
+    policy.mergeConfig(item.config, item.dir);
+  }
+  settings.sandbox = {
+    file: {
+      allow: {
+        read: Array.from(policy.fileReadAllow),
+        write: Array.from(policy.fileWriteAllow)
+      },
+      deny: {
+        read: Array.from(policy.fileReadDeny),
+        write: Array.from(policy.fileWriteDeny)
+      }
+    },
+    network: {
+      allow: Array.from(policy.networkAllow),
+      deny: Array.from(policy.networkDeny)
+    }
+  };
+  return settings;
+}
+
+// src/proxy-audit.ts
+import http from "http";
+import net from "net";
+var NetworkAuditProxy = class {
+  server;
+  port = 0;
+  constructor() {
+    this.server = http.createServer((req, res) => {
+      const url = req.url || "";
+      console.error(`\x1B[36m\u{1F310} [NETWORK AUDIT] HTTP request to: ${url}\x1B[0m`);
+      try {
+        const parsedUrl = new URL(url);
+        const options = {
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port || 80,
+          path: parsedUrl.pathname + parsedUrl.search,
+          method: req.method,
+          headers: req.headers
+        };
+        const proxyReq = http.request(options, (proxyRes) => {
+          res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+          proxyRes.pipe(res);
+        });
+        proxyReq.on("error", (err) => {
+          res.writeHead(502);
+          res.end(`Proxy Error: ${err.message}`);
+        });
+        req.pipe(proxyReq);
+      } catch (err) {
+        res.writeHead(400);
+        res.end(`Invalid URL: ${err.message}`);
+      }
+    });
+    this.server.on("connect", (req, clientSocket, head) => {
+      const parts = req.url ? req.url.split(":") : [];
+      const hostname = parts[0];
+      const port = parts[1] ? Number.parseInt(parts[1], 10) : 443;
+      console.error(
+        `\x1B[36m\u{1F310} [NETWORK AUDIT] HTTPS connection established to: ${hostname}:${port}\x1B[0m`
+      );
+      const serverSocket = net.connect(port, hostname, () => {
+        clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+        serverSocket.write(head);
+        serverSocket.pipe(clientSocket);
+        clientSocket.pipe(serverSocket);
+      });
+      serverSocket.on("error", (err) => {
+        clientSocket.end(`HTTP/1.1 502 Bad Gateway\r
+\r
+Proxy Connection Error: ${err.message}`);
+      });
+      clientSocket.on("error", () => {
+        serverSocket.end();
+      });
+    });
+  }
+  async start() {
+    return new Promise((resolve3, reject) => {
+      this.server.on("error", (err) => {
+        reject(err);
+      });
+      this.server.listen(0, "127.0.0.1", () => {
+        const addr = this.server.address();
+        if (addr && typeof addr === "object") {
+          this.port = addr.port;
+        }
+        resolve3(this.port);
+      });
+    });
+  }
+  async close() {
+    return new Promise((resolve3) => {
+      this.server.close(() => resolve3());
+    });
+  }
+  getPort() {
+    return this.port;
+  }
+};
+
+// src/target-manager.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -852,11 +1359,29 @@ var MIN_UPTIME_FOR_RESTART_MS = 5e3;
 var MAX_RECONNECT_ATTEMPTS = 3;
 var STABLE_CONNECTION_RESET_MS = 6e4;
 var MAX_HISTORY = 100;
+function isCommandAvailable(cmd) {
+  try {
+    const checkCmd = process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`;
+    execSync(checkCmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 var TargetManager = class _TargetManager extends EventEmitter {
-  constructor(command, args) {
+  constructor(command, args, options = {}) {
     super();
     this.command = command;
     this.args = args;
+    this.sandboxMode = options.sandbox ?? "none";
+    this.sandboxOptions = {
+      allowRead: options.allowRead,
+      allowWrite: options.allowWrite,
+      allowNet: options.allowNet,
+      denyRead: options.denyRead,
+      denyWrite: options.denyWrite,
+      denyNet: options.denyNet
+    };
   }
   client = null;
   transport = null;
@@ -883,6 +1408,12 @@ var TargetManager = class _TargetManager extends EventEmitter {
   static MAX_NOTIFICATIONS = 200;
   // Roots
   _roots = [];
+  _proxy = null;
+  _proxyPort = 0;
+  sandboxMode;
+  _tempSbPath = null;
+  _useWindowsMxc = false;
+  sandboxOptions;
   /**
    * Enable auto-reconnect behavior.
    * Only applies to interactive REPL mode — proxy mode manages its own lifecycle.
@@ -901,11 +1432,27 @@ var TargetManager = class _TargetManager extends EventEmitter {
       if (this.command.startsWith("http://") || this.command.startsWith("https://")) {
         this.transport = new SSEClientTransport(new URL(this.command));
       } else {
+        const policy = new SandboxPolicy();
+        const fileSettings = loadSettings();
+        if (fileSettings.sandbox) {
+          policy.mergeConfig(fileSettings.sandbox, process.cwd());
+        }
+        policy.mergeCliOverrides(this.sandboxOptions);
+        policy.applyCredentialProtections();
+        if (this.sandboxMode !== "none" && this.sandboxMode !== "audit" && policy.networkAllow.size > 0 && !policy.networkDeny.has("*")) {
+          this._proxy = new NetworkAuditProxy();
+          this._proxyPort = await this._proxy.start();
+        }
+        const { command: finalCommand, args: finalArgs } = await this._maybeWrapCommand(policy);
         const stdioTransport = new StdioClientTransport({
-          command: this.command,
-          args: this.args,
-          stderr: "pipe"
+          command: finalCommand,
+          args: finalArgs,
+          stderr: "pipe",
+          env: this._getDefaultEnvironment()
         });
+        if (this._useWindowsMxc) {
+          await this._applyWindowsMxcOverride(stdioTransport, finalCommand, finalArgs, policy);
+        }
         stdioTransport.stderr?.on("data", (chunk) => {
           const text = chunk.toString().trimEnd();
           if (text) {
@@ -915,13 +1462,21 @@ var TargetManager = class _TargetManager extends EventEmitter {
             if (this._stderrLines.length > _TargetManager.MAX_STDERR_LINES) {
               this._stderrLines = this._stderrLines.slice(-_TargetManager.MAX_STDERR_LINES);
             }
+            if (this.sandboxMode === "audit") {
+              const lowerText = text.toLowerCase();
+              if (lowerText.includes("eperm") || lowerText.includes("eacces") || lowerText.includes("permission denied") || lowerText.includes("operation not permitted") || lowerText.includes("enotfound") || lowerText.includes("command not found") || lowerText.includes("cannot execute")) {
+                console.error(
+                  `\x1B[31m\u26A0\uFE0F  [SANDBOX AUDIT] Blocked unauthorized side-effect: ${text}\x1B[0m`
+                );
+              }
+            }
             this.emit("stderr", text);
           }
         });
         this.transport = stdioTransport;
       }
       this.client = new Client(
-        { name: "run-mcp", version: "1.6.3" },
+        { name: "run-mcp", version: "1.7.1" },
         {
           capabilities: {
             roots: { listChanged: true },
@@ -979,7 +1534,7 @@ var TargetManager = class _TargetManager extends EventEmitter {
         this.emit("notification", record);
       });
       this.client.setRequestHandler(CreateMessageRequestSchema, async (request) => {
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve3, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("Sampling request timed out (no response from user in 5 minutes)"));
           }, 3e5);
@@ -987,7 +1542,7 @@ var TargetManager = class _TargetManager extends EventEmitter {
             request: request.params,
             respond: (result) => {
               clearTimeout(timeout);
-              resolve2(result);
+              resolve3(result);
             },
             reject: (err) => {
               clearTimeout(timeout);
@@ -997,7 +1552,7 @@ var TargetManager = class _TargetManager extends EventEmitter {
         });
       });
       this.client.setRequestHandler(ElicitRequestSchema, async (request) => {
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve3, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("Elicitation request timed out (no response from user in 5 minutes)"));
           }, 3e5);
@@ -1005,7 +1560,7 @@ var TargetManager = class _TargetManager extends EventEmitter {
             request: request.params,
             respond: (result) => {
               clearTimeout(timeout);
-              resolve2(result);
+              resolve3(result);
             },
             reject: (err) => {
               clearTimeout(timeout);
@@ -1343,7 +1898,8 @@ var TargetManager = class _TargetManager extends EventEmitter {
       lastResponseTime: this._lastResponseTime,
       stderrLineCount: this._stderrLineCount,
       reconnectAttempts: this._reconnectAttempts,
-      maxReconnectAttempts: MAX_RECONNECT_ATTEMPTS
+      maxReconnectAttempts: MAX_RECONNECT_ATTEMPTS,
+      sandbox: this.sandboxMode
     };
   }
   /**
@@ -1368,10 +1924,25 @@ var TargetManager = class _TargetManager extends EventEmitter {
       this.transport = null;
     }
     if (pidToKill) {
-      await new Promise((resolve2) => {
-        treeKill(pidToKill, "SIGKILL", () => resolve2());
+      await new Promise((resolve3) => {
+        treeKill(pidToKill, "SIGKILL", () => resolve3());
       });
     }
+    if (this._tempSbPath && existsSync3(this._tempSbPath)) {
+      try {
+        rmSync(this._tempSbPath, { force: true });
+      } catch {
+      }
+      this._tempSbPath = null;
+    }
+    if (this._proxy) {
+      try {
+        await this._proxy.close();
+      } catch {
+      }
+      this._proxy = null;
+      this._proxyPort = 0;
+    }
     this._connected = false;
     this.childPid = null;
   }
@@ -1443,6 +2014,264 @@ var TargetManager = class _TargetManager extends EventEmitter {
     }
   }
   // ─── Internal helpers ──────────────────────────────────────────────────────
+  async _maybeWrapCommand(policy) {
+    let command = this.command;
+    let args = [...this.args];
+    let modeToUse = this.sandboxMode;
+    if (modeToUse === "auto") {
+      if (process.platform === "darwin") {
+        if (isCommandAvailable("sandbox-exec")) {
+          modeToUse = "native";
+        } else {
+          process.stderr.write("Warning: sandbox-exec is not available. Sandboxing disabled.\n");
+          modeToUse = "none";
+        }
+      } else if (process.platform === "linux") {
+        if (isCommandAvailable("bwrap")) {
+          modeToUse = "native";
+        } else {
+          process.stderr.write("Warning: bwrap is not available. Sandboxing disabled.\n");
+          modeToUse = "none";
+        }
+      } else if (process.platform === "win32") {
+        let hasMxc = false;
+        try {
+          const mxcModule = "@microsoft/mxc-sdk";
+          await import(mxcModule);
+          hasMxc = true;
+        } catch {
+        }
+        if (hasMxc) {
+          modeToUse = "native";
+        } else {
+          process.stderr.write(
+            "Warning: @microsoft/mxc-sdk is not available. Sandboxing disabled.\n"
+          );
+          modeToUse = "none";
+        }
+      } else {
+        process.stderr.write(
+          `Warning: Sandboxing not supported on platform "${process.platform}". Sandboxing disabled.
+`
+        );
+        modeToUse = "none";
+      }
+    }
+    if (modeToUse === "docker") {
+      let image = "node:20";
+      if (command.includes("python")) {
+        image = "python:3";
+      }
+      const cwd = process.cwd();
+      args = [
+        "run",
+        "-i",
+        "--rm",
+        "--net=none",
+        "-v",
+        `${cwd}:/workspace`,
+        "-w",
+        "/workspace",
+        image,
+        command,
+        ...args
+      ];
+      command = "docker";
+    } else if (modeToUse === "native" || modeToUse === "audit") {
+      const isAudit = modeToUse === "audit";
+      if (process.platform === "darwin") {
+        if (!isCommandAvailable("sandbox-exec")) {
+          throw new Error(
+            "sandbox-exec not found. Native sandboxing is not available on this macOS host."
+          );
+        }
+        const cwd = process.cwd();
+        const tmp = tmpdir2();
+        const nodeBinDir = join3(process.execPath, "..");
+        const nodeInstallDir = join3(nodeBinDir, "..");
+        const profile = policy.getSeatbeltProfile({
+          tmp,
+          cwd,
+          nodeBinDir,
+          nodeInstallDir,
+          audit: isAudit
+        });
+        const tempSbPath = join3(
+          tmp,
+          `run-mcp-sandbox-${Date.now()}-${Math.random().toString(36).slice(2)}.sb`
+        );
+        writeFileSync(tempSbPath, profile, "utf8");
+        this._tempSbPath = tempSbPath;
+        args = ["-f", tempSbPath, command, ...args];
+        command = "sandbox-exec";
+      } else if (process.platform === "linux") {
+        if (!isCommandAvailable("bwrap")) {
+          throw new Error(
+            "bwrap not found. Native sandboxing is not available on this Linux host."
+          );
+        }
+        const cwd = process.cwd();
+        const tmp = tmpdir2();
+        const bwrapArgs = [
+          "--ro-bind",
+          "/usr",
+          "/usr",
+          "--ro-bind",
+          "/lib",
+          "/lib",
+          "--ro-bind-try",
+          "/lib64",
+          "/lib64",
+          "--ro-bind-try",
+          "/bin",
+          "/bin",
+          "--ro-bind-try",
+          "/sbin",
+          "/sbin",
+          "--ro-bind-try",
+          "/etc",
+          "/etc",
+          "--ro-bind",
+          cwd,
+          cwd,
+          "--dev",
+          "/dev",
+          "--proc",
+          "/proc",
+          "--unshare-pid",
+          "--unshare-user",
+          "--unshare-ipc"
+        ];
+        if (isAudit) {
+          bwrapArgs.push("--unshare-net");
+          bwrapArgs.push("--ro-bind", tmp, tmp);
+        } else {
+          bwrapArgs.push("--bind", tmp, tmp);
+          if (policy.networkAllow.size === 0 || policy.networkDeny.has("*")) {
+            bwrapArgs.push("--unshare-net");
+          }
+          for (const p of policy.fileReadAllow) {
+            if (existsSync3(p)) {
+              bwrapArgs.push("--ro-bind", p, p);
+            }
+          }
+          for (const p of policy.fileWriteAllow) {
+            if (existsSync3(p)) {
+              bwrapArgs.push("--bind", p, p);
+            }
+          }
+        }
+        args = [...bwrapArgs, command, ...args];
+        command = "bwrap";
+      } else if (process.platform === "win32") {
+        let hasMxc = false;
+        try {
+          const mxcModule = "@microsoft/mxc-sdk";
+          await import(mxcModule);
+          hasMxc = true;
+        } catch {
+        }
+        if (!hasMxc) {
+          throw new Error(
+            "@microsoft/mxc-sdk not found. Native sandboxing is not available on this Windows host."
+          );
+        }
+        this._useWindowsMxc = true;
+      } else {
+        throw new Error(`Native sandboxing not supported on platform "${process.platform}"`);
+      }
+    }
+    return { command, args };
+  }
+  async _applyWindowsMxcOverride(transport, command, args, policyObj) {
+    const mxcModule = "@microsoft/mxc-sdk";
+    const mxcSdk = await import(mxcModule);
+    const isAudit = this.sandboxMode === "audit";
+    const readPaths = isAudit ? [process.cwd()] : [process.cwd(), tmpdir2(), ...Array.from(policyObj.fileReadAllow)];
+    const writePaths = isAudit ? [] : [tmpdir2(), ...Array.from(policyObj.fileWriteAllow)];
+    const policy = {
+      filesystem: {
+        read: readPaths,
+        write: writePaths
+      },
+      network: {
+        outbound: isAudit ? "block" : policyObj.networkAllow.size > 0 ? "allow" : "block"
+      }
+    };
+    const config = mxcSdk.createConfigFromPolicy(policy);
+    transport.start = async () => {
+      if (transport._process) {
+        throw new Error("StdioClientTransport already started!");
+      }
+      return new Promise((resolve3, reject) => {
+        try {
+          const env = {
+            ...this._getDefaultEnvironment(),
+            ...transport._serverParams.env
+          };
+          transport._process = mxcSdk.spawnSandboxFromConfig(config, command, args, {
+            env,
+            stdio: ["pipe", "pipe", transport._serverParams.stderr ?? "inherit"],
+            cwd: transport._serverParams.cwd
+          });
+          transport._process.on("error", (error) => {
+            reject(error);
+            transport.onerror?.(error);
+          });
+          transport._process.on("spawn", () => {
+            resolve3();
+          });
+          transport._process.on("close", () => {
+            transport._process = void 0;
+            transport.onclose?.();
+          });
+          transport._process.stdin?.on("error", (error) => {
+            transport.onerror?.(error);
+          });
+          transport._process.stdout?.on("data", (chunk) => {
+            transport._readBuffer.append(chunk);
+            transport.processReadBuffer();
+          });
+          transport._process.stdout?.on("error", (error) => {
+            transport.onerror?.(error);
+          });
+          if (transport._stderrStream && transport._process.stderr) {
+            transport._process.stderr.pipe(transport._stderrStream);
+          }
+        } catch (err) {
+          reject(err);
+        }
+      });
+    };
+  }
+  _getDefaultEnvironment() {
+    const env = {};
+    const safeVars = process.platform === "win32" ? [
+      "APPDATA",
+      "HOMEDRIVE",
+      "HOMEPATH",
+      "LOCALAPPDATA",
+      "PATH",
+      "TEMP",
+      "USERPROFILE",
+      "SYSTEMROOT"
+    ] : ["HOME", "PATH", "SHELL", "USER"];
+    for (const key of safeVars) {
+      if (process.env[key]) {
+        env[key] = process.env[key];
+      }
+    }
+    if (this._proxyPort) {
+      const proxyUrl = `http://127.0.0.1:${this._proxyPort}`;
+      env["http_proxy"] = proxyUrl;
+      env["https_proxy"] = proxyUrl;
+      env["HTTP_PROXY"] = proxyUrl;
+      env["HTTPS_PROXY"] = proxyUrl;
+      env["all_proxy"] = proxyUrl;
+      env["ALL_PROXY"] = proxyUrl;
+    }
+    return env;
+  }
   _assertConnected() {
     if (!this._connected || !this.client) {
       throw new Error("Not connected to target MCP server");
@@ -1476,7 +2305,15 @@ var TargetManager = class _TargetManager extends EventEmitter {
 var DEFAULT_HEADLESS_TIMEOUT_MS = 3e4;
 async function runHeadless(targetCommand, operation, opts = {}) {
   const [command, ...args] = targetCommand;
-  const target = new TargetManager(command, args);
+  const target = new TargetManager(command, args, {
+    sandbox: opts.sandbox,
+    allowRead: opts.allowRead,
+    allowWrite: opts.allowWrite,
+    allowNet: opts.allowNet,
+    denyRead: opts.denyRead,
+    denyWrite: opts.denyWrite,
+    denyNet: opts.denyNet
+  });
   const interceptor = new ResponseInterceptor({
     outDir: opts.outDir,
     defaultTimeoutMs: opts.timeoutMs ?? DEFAULT_HEADLESS_TIMEOUT_MS
@@ -1504,21 +2341,21 @@ async function runHeadless(targetCommand, operation, opts = {}) {
     process.exit(hasError ? 1 : 0);
   } catch (err) {
     const msg = err.message ?? String(err);
+    let exitCode;
     if (msg.includes("ENOENT") || msg.includes("spawn")) {
       process.stderr.write(
         `Error: command "${command}" not found. Check that it is installed and in your PATH.
 `
       );
-    } else if (msg.includes("timed out")) {
-      process.stderr.write(`Error: ${msg}
-`);
+      exitCode = 66;
     } else {
       process.stderr.write(`Error: ${msg}
 `);
+      exitCode = 69;
     }
     await target.close().catch(() => {
     });
-    process.exit(1);
+    process.exit(exitCode);
   }
 }
 async function executeOperation(target, interceptor, operation, opts) {
@@ -1535,7 +2372,7 @@ async function executeOperation(target, interceptor, operation, opts) {
 `);
             process.stderr.write(`  Received: ${operation.args}
 `);
-            process.exit(2);
+            process.exit(65);
           }
         } else {
           parsedArgs = parseHttpieArgs(trimmed);
@@ -1583,7 +2420,7 @@ async function executeOperation(target, interceptor, operation, opts) {
 Available tools: ${available}
 `
         );
-        process.exit(1);
+        process.exit(64);
       }
       return { result: tool, hasError: false };
     }
@@ -1599,7 +2436,7 @@ Available tools: ${available}
 `);
             process.stderr.write(`  Received: ${operation.args}
 `);
-            process.exit(2);
+            process.exit(65);
           }
         } else {
           parsedArgs = parseHttpieArgs(trimmed);
@@ -1614,15 +2451,16 @@ Available tools: ${available}
   }
 }
 
-// src/repl.ts
-import { readFile as readFile2 } from "fs/promises";
+// src/repl/index.ts
+import { readFile as readFile4 } from "fs/promises";
 import { createInterface } from "readline";
-import { checkbox, confirm, input as input2, search } from "@inquirer/prompts";
-import pc2 from "picocolors";
+
+// src/repl/state.ts
 var KNOWN_COMMANDS = [
   "menu",
   "explore",
   "interactive",
+  "view",
   "tools/list",
   "tools/describe",
   "tools/call",
@@ -1664,48 +2502,259 @@ var KNOWN_COMMANDS = [
   "pl",
   "pg"
 ];
+var activeRl = null;
+function setActiveRl(rl) {
+  activeRl = rl;
+}
+var closed = false;
+function setClosed(val) {
+  closed = val;
+}
+var isScriptMode = false;
+function setIsScriptMode(val) {
+  isScriptMode = val;
+}
+var globalPauseReadlineClose = false;
+function setGlobalPauseReadlineClose(val) {
+  globalPauseReadlineClose = val;
+}
+var deferNextPrompt = false;
+function setDeferNextPrompt(val) {
+  deferNextPrompt = val;
+}
 var cachedToolNames = [];
+function setCachedToolNames(names) {
+  cachedToolNames = names;
+}
 var cachedResourceUris = [];
+function setCachedResourceUris(uris) {
+  cachedResourceUris = uris;
+}
 var cachedPromptNames = [];
+function setCachedPromptNames(names) {
+  cachedPromptNames = names;
+}
 var activeCapabilities = null;
-function getActiveCommands() {
-  let commands = [...KNOWN_COMMANDS];
-  if (!activeCapabilities?.resources) {
-    commands = commands.filter(
-      (c) => !c.startsWith("resources/") && !["rl", "rr", "rt", "rs", "ru"].includes(c)
-    );
-  }
-  if (!activeCapabilities?.prompts) {
-    commands = commands.filter((c) => !c.startsWith("prompts/") && !["pl", "pg"].includes(c));
-  }
-  return commands;
-}
-async function refreshCaches(target) {
-  const caps = target.getServerCapabilities() ?? {};
+function setActiveCapabilities(caps) {
   activeCapabilities = caps;
+}
+var tabCycleState = null;
+function setTabCycleState(state) {
+  tabCycleState = state;
+}
+var callHistory = [];
+var lastToolArgsMap = /* @__PURE__ */ new Map();
+
+// src/repl/history.ts
+import { readFile as readFile2, mkdir as mkdir2, appendFile } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+var RUN_MCP_DIR = join4(homedir3(), ".run-mcp");
+var HISTORY_FILE = join4(RUN_MCP_DIR, "history");
+var replHistory = [];
+async function ensureRunMcpDir() {
   try {
-    const { tools } = await target.listTools();
-    cachedToolNames = tools.map((t) => t.name);
+    await mkdir2(RUN_MCP_DIR, { recursive: true });
   } catch {
   }
-  if (caps.resources) {
+}
+async function loadHistory() {
+  await ensureRunMcpDir();
+  if (existsSync4(HISTORY_FILE)) {
     try {
-      const { resources } = await target.listResources();
-      cachedResourceUris = resources.map((r) => r.uri);
+      const content = await readFile2(HISTORY_FILE, "utf8");
+      const lines = content.split("\n").map((l) => l.trim()).filter(Boolean);
+      replHistory.length = 0;
+      replHistory.push(...lines);
     } catch {
     }
   }
-  if (caps.prompts) {
+}
+async function appendToHistoryFile(line) {
+  await ensureRunMcpDir();
+  try {
+    await appendFile(HISTORY_FILE, line + "\n", "utf8");
+  } catch {
+  }
+}
+
+// src/repl/wizard.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+var WIZARD_DEFAULTS_FILE = join5(RUN_MCP_DIR, "wizard_defaults.json");
+async function loadWizardDefaults() {
+  await ensureRunMcpDir();
+  if (existsSync5(WIZARD_DEFAULTS_FILE)) {
     try {
-      const { prompts } = await target.listPrompts();
-      cachedPromptNames = prompts.map((p) => p.name);
+      const content = await readFile3(WIZARD_DEFAULTS_FILE, "utf8");
+      const parsed = JSON.parse(content);
+      lastToolArgsMap.clear();
+      for (const [key, val] of Object.entries(parsed)) {
+        lastToolArgsMap.set(key, val);
+      }
     } catch {
     }
   }
 }
-var tabCycleState = null;
+async function saveWizardDefaults() {
+  await ensureRunMcpDir();
+  try {
+    const obj = Object.fromEntries(lastToolArgsMap.entries());
+    await writeFile2(WIZARD_DEFAULTS_FILE, JSON.stringify(obj, null, 2), "utf8");
+  } catch {
+  }
+}
+
+// src/repl/ui.ts
+function printResultBlock(opts) {
+  const colorFn = colors[opts.labelColor];
+  const elapsedStr = opts.elapsed < 1e3 ? `${opts.elapsed}ms` : `${(opts.elapsed / 1e3).toFixed(1)}s`;
+  const detail = opts.detail ?? opts.toolName ?? "";
+  console.log(`  ${colorFn(opts.label)}  ${colors.dim(detail)}  ${colors.dim(`(${elapsedStr})`)}`);
+  console.log(colors.dim(`  ${"\u2500".repeat(60)}`));
+}
+function printShortHelp() {
+  const hasTools = !!activeCapabilities?.tools;
+  const hasResources = !!activeCapabilities?.resources;
+  const hasPrompts = !!activeCapabilities?.prompts;
+  const tC = hasTools ? colors.green : colors.dim;
+  const rC = hasResources ? colors.green : colors.dim;
+  const pC = hasPrompts ? colors.green : colors.dim;
+  console.log(`
+${colors.bold("Quick Reference:")}
+
+  ${tC("tl")}  ${tC("tools/list")}        ${rC("rl")}  ${rC("resources/list")}     ${pC("pl")}  ${pC("prompts/list")}
+  ${tC("td")}  ${tC("tools/describe")}    ${rC("rr")}  ${rC("resources/read")}     ${pC("pg")}  ${pC("prompts/get")}
+  ${tC("tc")}  ${tC("tools/call")}        ${rC("rt")}  ${rC("resources/templates")}
+  ${tC("ts")}  ${tC("tools/scaffold")}    ${rC("rs")}  ${rC("resources/subscribe")}
+                          ${rC("ru")}  ${rC("resources/unsubscribe")}
+
+  ${colors.green("ping")}  ${colors.green("status")}  ${colors.green("timing")}  ${colors.green("history")}  ${colors.green("!!")}  ${colors.green("explore")}  ${colors.green("reconnect")}
+
+${colors.dim("Type 'help' for full command reference.")}
+`);
+}
+function printHelp() {
+  const hasTools = !!activeCapabilities?.tools;
+  const hasResources = !!activeCapabilities?.resources;
+  const hasPrompts = !!activeCapabilities?.prompts;
+  const hasLogging = !!activeCapabilities?.logging;
+  const tC = hasTools ? colors.green : colors.dim;
+  const rC = hasResources ? colors.green : colors.dim;
+  const pC = hasPrompts ? colors.green : colors.dim;
+  const lC = hasLogging ? colors.green : colors.dim;
+  const tD = hasTools ? (s) => s : colors.dim;
+  const rD = hasResources ? (s) => s : colors.dim;
+  const pD = hasPrompts ? (s) => s : colors.dim;
+  const lD = hasLogging ? (s) => s : colors.dim;
+  const tH = hasTools ? colors.bold("Tool Commands:") : colors.dim(colors.bold("Tool Commands:")) + colors.dim("  (Unsupported)");
+  const rH = hasResources ? colors.bold("Resource Commands:") : colors.dim(colors.bold("Resource Commands:")) + colors.dim("  (Unsupported)");
+  const pH = hasPrompts ? colors.bold("Prompt Commands:") : colors.dim(colors.bold("Prompt Commands:")) + colors.dim("  (Unsupported)");
+  console.log(`
+${tH}
+
+  ${tC("tools/list")}                         ${tD("List all available tools")}
+  ${tC("tools/describe")} <name>              ${tD("Show a tool's input schema")}
+  ${tC("tools/call")} <name> [json] [opts]    ${tD("Call a tool (interactive if no json)")}
+    ${tD("Options:")} ${colors.dim("--timeout <ms>")}            ${tD("Override default timeout (60s)")}
+             ${colors.dim("--clear")}                  ${tD("Ignore remembered argument defaults")}
+  ${tC("tools/scaffold")} <name>              ${tD("Generate a template for a tool's arguments")}
+  ${tC("tools/forget")} [name]                ${tD("Clear remembered interactive defaults")}
+
+${rH}
+
+  ${rC("resources/list")}                     ${rD("List all available resources")}
+  ${rC("resources/read")} <uri>               ${rD("Read a resource by URI")}
+  ${rC("resources/templates")}                ${rD("List resource templates")}
+  ${rC("resources/subscribe")} <uri>          ${rD("Subscribe to resource changes")}
+  ${rC("resources/unsubscribe")} <uri>        ${rD("Unsubscribe from resource changes")}
+
+${pH}
+
+  ${pC("prompts/list")}                       ${pD("List all available prompts")}
+  ${pC("prompts/get")} <name> [json_args]    ${pD("Get a prompt with arguments")}
+
+${colors.bold("Protocol Commands:")}
+
+  ${colors.green("ping")}                               Verify connection, show round-trip time
+  ${lC("log-level")} <level>                  ${lD("Set server logging verbosity")}${hasLogging ? "" : colors.dim("  (Unsupported)")}
+  ${colors.green("history")} [count|clear]              Show request/response history
+  ${colors.green("notifications")} [count|clear]        Show server notifications
+
+${colors.bold("Roots Management:")}
+
+  ${colors.green("roots/list")}                         Show configured client roots
+  ${colors.green("roots/add")} <uri> [name]             Add a root directory
+  ${colors.green("roots/remove")} <uri>                 Remove a root directory
+
+${colors.bold("Session Commands:")}
+
+  ${colors.green("!!")} / ${colors.green("last")}                           Re-run the last command
+  ${colors.green("reconnect")}                          Disconnect and reconnect to the server
+  ${colors.green("timing")}                             Show tool call performance stats
+  ${colors.green("status")}                             Show target server status
+  ${colors.green("help")}                               Show this help
+  ${colors.green("exit")} / ${colors.green("quit")}                         Disconnect and exit
+
+${colors.bold("Shortcuts:")}
+
+  ${tC("tl")}  ${tC("tools/list")}          ${rC("rl")}  ${rC("resources/list")}     ${pC("pl")}  ${pC("prompts/list")}
+  ${tC("td")}  ${tC("tools/describe")}      ${rC("rr")}  ${rC("resources/read")}     ${pC("pg")}  ${pC("prompts/get")}
+  ${tC("tc")}  ${tC("tools/call")}          ${rC("rt")}  ${rC("resources/templates")}
+  ${tC("ts")}  ${tC("tools/scaffold")}      ${rC("rs")}  ${rC("resources/subscribe")}
+                          ${rC("ru")}  ${rC("resources/unsubscribe")}
+
+${colors.dim("Lines starting with # are treated as comments.")}
+${colors.dim('JSON arguments can contain spaces: tools/call say {"message": "hello world"}')}
+${colors.dim("Run tools/call <name> without JSON for interactive argument prompting.")}
+${colors.dim("Use tools/call <name> --clear to ignore remembered defaults.")}
+`);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1B\[\d+m/g, "");
+}
+var BOX_WIDTH = 58;
+function padLine(content) {
+  const clean = stripAnsi(content);
+  const padding = Math.max(0, BOX_WIDTH - clean.length);
+  return `${colors.cyan("  \u2502")}${content}${"".padEnd(padding)}${colors.cyan("\u2502")}`;
+}
+function printBanner(serverName, serverVersion, toolCount, resourceCount, promptCount, harnessMode) {
+  const parts = [];
+  parts.push(`${colors.bold(toolCount.toString())} tools`);
+  if (resourceCount > 0) parts.push(`${colors.bold(resourceCount.toString())} resources`);
+  if (promptCount > 0) parts.push(`${colors.bold(promptCount.toString())} prompts`);
+  const baseTitle = serverVersion ? `${serverName} ${colors.dim(`v${serverVersion}`)}` : serverName;
+  const title = harnessMode ? `${baseTitle} ${colors.bgBlue(colors.white(" AGENT HARNESS "))}` : baseTitle;
+  console.log(colors.cyan(`  \u250C${"\u2500".repeat(BOX_WIDTH)}\u2510`));
+  console.log(padLine(`  Connected to ${title}`));
+  console.log(padLine(`  Discovered ${parts.join(", ")}`));
+  console.log(colors.cyan(`  \u251C${"\u2500".repeat(BOX_WIDTH)}\u2524`));
+  console.log(padLine(`    ${colors.green("tools/list")}                  See all tools`));
+  console.log(padLine(`    ${colors.green("tools/call")} ${colors.dim("<name>")}           Call a tool`));
+  console.log(padLine(`    ${colors.green("help")}                        All commands`));
+  console.log(padLine(""));
+  console.log(padLine(colors.dim("  Tab completion is active. Start typing to explore.")));
+  console.log(colors.cyan(`  \u2514${"\u2500".repeat(BOX_WIDTH)}\u2518`));
+}
+
+// src/repl/completer.ts
 function resetTabCycle() {
-  tabCycleState = null;
+  setTabCycleState(null);
+}
+function getActiveCommands() {
+  let commands = [...KNOWN_COMMANDS];
+  if (!activeCapabilities?.resources) {
+    commands = commands.filter(
+      (c) => !c.startsWith("resources/") && !["rl", "rr", "rt", "rs", "ru"].includes(c)
+    );
+  }
+  if (!activeCapabilities?.prompts) {
+    commands = commands.filter((c) => !c.startsWith("prompts/") && !["pl", "pg"].includes(c));
+  }
+  return commands;
 }
 function computeMatches(line) {
   const expanded = resolveAlias(line);
@@ -1734,8 +2783,12 @@ var completer = (line) => {
   if (tabCycleState) {
     const inCycle = line === tabCycleState.original || tabCycleState.matches.includes(line);
     if (inCycle) {
-      tabCycleState.index = (tabCycleState.index + 1) % tabCycleState.matches.length;
-      const next = tabCycleState.matches[tabCycleState.index];
+      const nextIndex = (tabCycleState.index + 1) % tabCycleState.matches.length;
+      setTabCycleState({
+        ...tabCycleState,
+        index: nextIndex
+      });
+      const next = tabCycleState.matches[nextIndex];
       setImmediate(() => {
         if (activeRl) {
           activeRl.line = next;
@@ -1745,421 +2798,70 @@ var completer = (line) => {
       });
       return [[], ""];
     }
-    tabCycleState = null;
+    setTabCycleState(null);
   }
   const [matches, matchLine] = computeMatches(line);
   if (matches.length > 1) {
-    tabCycleState = { matches, index: -1, original: line };
+    setTabCycleState({ matches, index: -1, original: line });
   }
   return [matches, matchLine];
-};
-var callHistory = [];
-var lastToolArgsMap = /* @__PURE__ */ new Map();
-var replHistory = [];
-var lastCommand = null;
-var AbortFlowError = class extends Error {
-  constructor() {
-    super("Aborted by user.");
-    this.name = "AbortFlowError";
-  }
-};
-function isAbortError(err) {
-  if (!err) return false;
-  return err.name === "ExitPromptError" || err.name === "AbortError" || err.message === "Prompt was aborted" || typeof err.message === "string" && err.message.includes("User force closed");
-}
-var activeRl = null;
-var isScriptMode = false;
-var globalPauseReadlineClose = false;
-var deferNextPrompt = false;
-async function withSuspendedReadline(target, interceptor, fn) {
-  const wasActive = !!activeRl;
-  if (wasActive) {
-    globalPauseReadlineClose = true;
-    activeRl.close();
-    activeRl = null;
-  }
-  try {
-    return await fn();
-  } finally {
-    if (wasActive) {
-      globalPauseReadlineClose = false;
-      if (!isScriptMode) {
-        deferNextPrompt = true;
-        startReadlineLoop(target, interceptor);
-      }
-    }
-  }
-}
-function getPrompt(target) {
-  if (target.connected) return `${pc2.green("\u2713")}${pc2.cyan("> ")}`;
-  return `${pc2.red("\u2717")}${pc2.cyan("> ")}`;
-}
-function printBanner(serverName, serverVersion, toolCount, resourceCount, promptCount) {
-  const parts = [];
-  parts.push(`${pc2.bold(toolCount.toString())} tools`);
-  if (resourceCount > 0) parts.push(`${pc2.bold(resourceCount.toString())} resources`);
-  if (promptCount > 0) parts.push(`${pc2.bold(promptCount.toString())} prompts`);
-  const baseTitle = serverVersion ? `${serverName} ${pc2.dim(`v${serverVersion}`)}` : serverName;
-  const isAgentHarness = serverName === "run-mcp";
-  const title = isAgentHarness ? `${baseTitle} ${pc2.bgBlue(pc2.white(" AGENT HARNESS "))}` : baseTitle;
-  const BOX_WIDTH = 53;
-  const padLine = (content) => {
-    const visible = stripAnsi(content).length;
-    const padding = Math.max(0, BOX_WIDTH - visible);
-    return `${pc2.cyan("  \u2502")}${content}${"".padEnd(padding)}${pc2.cyan("\u2502")}`;
-  };
-  const partsStr = `  ${parts.join(" \u2022 ")}`;
-  console.log();
-  console.log(pc2.cyan(`  \u250C${"\u2500".repeat(BOX_WIDTH)}\u2510`));
-  console.log(padLine(`  ${title}`));
-  console.log(padLine(partsStr));
-  console.log(pc2.cyan(`  \u251C${"\u2500".repeat(BOX_WIDTH)}\u2524`));
-  console.log(padLine("  Quick start:"));
-  console.log(padLine(`    ${pc2.green("tools/list")}                  See all tools`));
-  console.log(padLine(`    ${pc2.green("tools/call")} ${pc2.dim("<name>")}           Call a tool`));
-  console.log(padLine(`    ${pc2.green("help")}                        All commands`));
-  console.log(padLine(""));
-  console.log(padLine(pc2.dim("  Tab completion is active. Start typing to explore.")));
-  console.log(pc2.cyan(`  \u2514${"\u2500".repeat(BOX_WIDTH)}\u2518`));
-  console.log();
-}
-function stripAnsi(str) {
-  return str.replace(/\x1b\[[0-9;]*m/g, "");
-}
-async function startRepl(targetCommand, opts) {
-  const [command, ...args] = targetCommand;
-  const target = new TargetManager(command, args);
-  const interceptor = new ResponseInterceptor({
-    outDir: opts.outDir,
-    mediaThresholdKb: opts.mediaThresholdKb
-  });
-  isScriptMode = !!opts.script;
-  target.on("stderr", (text) => {
-    for (const line of text.split("\n")) {
-      console.error(pc2.dim(`[server] ${line}`));
-    }
-  });
-  console.log(pc2.cyan("\u27F3 Connecting to target MCP server..."));
-  console.log(pc2.dim(`  Command: ${targetCommand.join(" ")}`));
-  try {
-    await target.connect();
-  } catch (err) {
-    const msg = err.message ?? String(err);
-    if (msg.includes("ENOENT") || msg.includes("spawn")) {
-      console.error(pc2.red(`\u2717 Failed to start server: command "${command}" not found.`));
-      console.error(pc2.dim(`  Check that "${command}" is installed and in your PATH.`));
-    } else {
-      console.error(pc2.red(`\u2717 Failed to connect: ${msg}`));
-      console.error(pc2.dim(`  Check that the target command starts a valid MCP server on stdio.`));
-    }
-    process.exit(1);
-  }
-  const status = target.getStatus();
-  console.log(pc2.green(`\u2713 Connected (PID: ${status.pid})`));
-  if (!isScriptMode) {
-    target.enableAutoReconnect();
-    target.on(
-      "reconnecting",
-      ({ attempt, maxAttempts }) => {
-        console.log(
-          pc2.yellow(`
-\u27F3 Server disconnected. Reconnecting (${attempt}/${maxAttempts})...`)
-        );
-      }
-    );
-    target.on("reconnected", async ({ attempt }) => {
-      const s = target.getStatus();
-      console.log(pc2.green(`\u2713 Reconnected (PID: ${s.pid}, attempt ${attempt})`));
-      await refreshCaches(target);
-    });
-    target.on("reconnect_failed", ({ reason, message }) => {
-      console.error(pc2.red(`\u2717 ${message}`));
-      if (reason === "max_retries") {
-        console.log(
-          pc2.dim("  Use 'exit' to quit or wait for the server to be fixed and restart manually.")
-        );
-      }
-    });
-    target.on("notification", (notification) => {
-      const method = notification.method;
-      if (method === "notifications/message") {
-        const lvl = notification.params?.level ?? "info";
-        const data = notification.params?.data ?? "";
-        const text = typeof data === "string" ? data : JSON.stringify(data);
-        console.log(pc2.dim(`
-  [${lvl}] ${text}`));
-      } else if (method === "notifications/tools/list_changed") {
-        console.log(pc2.yellow("\n  \u27F3 Server tools changed. Run tools/list to see updates."));
-        refreshCaches(target).catch(() => {
-        });
-      } else if (method === "notifications/resources/list_changed") {
-        console.log(pc2.yellow("\n  \u27F3 Server resources changed. Run resources/list to see."));
-        refreshCaches(target).catch(() => {
-        });
-      } else if (method === "notifications/resources/updated") {
-        const uri = notification.params?.uri ?? "unknown";
-        console.log(pc2.yellow(`
-  \u27F3 Resource updated: ${uri}`));
-      } else if (method === "notifications/prompts/list_changed") {
-        console.log(pc2.yellow("\n  \u27F3 Server prompts changed. Run prompts/list to see."));
-        refreshCaches(target).catch(() => {
-        });
-      }
-    });
-    target.on("sampling_request", async ({ request, respond, reject: rejectFn }) => {
-      console.log(pc2.magenta("\n  \u2554\u2550\u2550 Sampling Request \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
-      const messages = request?.messages ?? [];
-      for (const msg of messages) {
-        const role = msg.role === "user" ? pc2.blue("user") : pc2.magenta("assistant");
-        const text = msg.content?.text ?? JSON.stringify(msg.content);
-        console.log(pc2.magenta(`  \u2551 ${role}: ${text}`));
-      }
-      console.log(pc2.magenta("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
-      if (activeRl) {
-        try {
-          const answer = await question(activeRl, `  ${pc2.bold("Approve? [y/N/text]:")} `);
-          const trimmed = answer.trim().toLowerCase();
-          if (trimmed === "y" || trimmed === "yes") {
-            respond({
-              model: "user-approved",
-              role: "assistant",
-              content: { type: "text", text: "Approved by user." }
-            });
-          } else if (trimmed === "n" || trimmed === "no" || trimmed === "") {
-            rejectFn(new Error("Sampling request rejected by user"));
-          } else {
-            respond({
-              model: "user-provided",
-              role: "assistant",
-              content: { type: "text", text: answer.trim() }
-            });
-          }
-        } catch (err) {
-          if (err instanceof AbortFlowError) {
-            rejectFn(new Error("Sampling request rejected by user"));
-          } else {
-            throw err;
-          }
-        }
-      } else {
-        rejectFn(new Error("No interactive terminal available for sampling approval"));
-      }
-    });
-    target.on("elicitation_request", async ({ request, respond, reject: rejectFn }) => {
-      console.log(pc2.cyan("\n  \u2554\u2550\u2550 Elicitation Request \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
-      console.log(pc2.cyan(`  \u2551 ${request?.message ?? "Server requests input"}`));
-      console.log(pc2.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
-      if (activeRl) {
-        try {
-          const answer = await question(
-            activeRl,
-            `  ${pc2.bold("Your response (empty to decline):")} `
-          );
-          if (answer.trim() === "") {
-            respond({ action: "decline" });
-          } else {
-            try {
-              const parsed = JSON.parse(answer.trim());
-              respond({ action: "accept", content: parsed });
-            } catch {
-              respond({ action: "accept", content: { value: answer.trim() } });
-            }
-          }
-        } catch (err) {
-          if (err instanceof AbortFlowError) {
-            respond({ action: "decline" });
-          } else {
-            throw err;
-          }
-        }
-      } else {
-        rejectFn(new Error("No interactive terminal available for elicitation"));
-      }
-    });
-  }
-  let toolCount;
-  let resourceCount = 0;
-  let promptCount = 0;
-  try {
-    const { tools } = await target.listTools();
-    toolCount = tools.length;
-    const caps = target.getServerCapabilities() ?? {};
-    if (caps.resources) {
-      try {
-        const { resources } = await target.listResources();
-        resourceCount = resources.length;
-      } catch {
-      }
-    }
-    if (caps.prompts) {
-      try {
-        const { prompts } = await target.listPrompts();
-        promptCount = prompts.length;
-      } catch {
-      }
-    }
-    const serverInfo = target.getServerVersion();
-    const serverName = serverInfo?.name ?? "MCP Server";
-    const serverVersion = serverInfo?.version ?? "";
-    printBanner(serverName, serverVersion, toolCount, resourceCount, promptCount);
-    if (toolCount >= 10) {
-      const groups = groupToolsByPrefix(
-        cachedToolNames.length > 0 ? cachedToolNames : tools.map((t) => t.name)
-      );
-      if (!groups.has("All")) {
-        for (const [label, members] of groups) {
-          console.log(`  ${pc2.bold(label.padEnd(16))} ${pc2.dim(members.join(", "))}`);
-        }
-        console.log();
-      }
+};
+async function refreshCaches(target) {
+  const caps = target.getServerCapabilities() ?? {};
+  setActiveCapabilities(caps);
+  try {
+    const { tools } = await target.listTools();
+    setCachedToolNames(tools.map((t) => t.name));
+  } catch {
+  }
+  if (caps.resources) {
+    try {
+      const { resources } = await target.listResources();
+      setCachedResourceUris(resources.map((r) => r.uri));
+    } catch {
     }
-  } catch (err) {
-    console.log(pc2.yellow(`  Warning: Could not list tools: ${err.message}
-`));
   }
-  await refreshCaches(target);
-  if (isScriptMode) {
-    const lines = await readScriptLines(opts.script);
-    const scriptContext = {};
-    let expectError = false;
-    for (const line of lines) {
-      let trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) {
-        if (trimmed === "# @expect-error") {
-          expectError = true;
-        }
-        continue;
-      }
-      if (trimmed.endsWith("# @expect-error")) {
-        expectError = true;
-        trimmed = trimmed.replace(/\s*#\s*@expect-error$/, "");
-      }
-      const interpolated = interpolateString(trimmed, scriptContext);
-      try {
-        const res = await handleCommand(interpolated, target, interceptor);
-        if (res !== void 0) {
-          scriptContext.LAST = res;
-        }
-        const isErrorRes = res && typeof res === "object" && res.isError === true;
-        if (expectError && !isErrorRes) {
-          console.error(pc2.red(`\u2717 Expected an error but the command succeeded.`));
-          await target.close();
-          process.exit(1);
-        }
-        if (!expectError && isErrorRes) {
-          console.error(pc2.red(`\u2717 Command failed unexpectedly.`));
-          await target.close();
-          process.exit(1);
-        }
-        if (expectError && isErrorRes) {
-          console.log(pc2.yellow(`  \u2713 Expected error caught: tool returned isError: true`));
-        }
-      } catch (err) {
-        if (expectError) {
-          console.log(pc2.yellow(`  \u2713 Expected error caught: ${err.message}`));
-        } else {
-          if (err?.message?.includes("-32601") || err?.code === -32601) {
-            let msg = "Server does not support this feature (Method not found)";
-            if (trimmed.startsWith("prompts/")) msg = "This server does not have any prompts.";
-            else if (trimmed.startsWith("resources/"))
-              msg = "This server does not have any resources.";
-            else if (trimmed.startsWith("tools/")) msg = "This server does not have any tools.";
-            console.log(pc2.yellow(`  ${msg}`));
-          } else {
-            console.error(pc2.red(`\u2717 Error: ${err.message}`));
-          }
-          console.log(pc2.dim("\nShutting down..."));
-          await target.close();
-          process.exit(1);
-        }
-      }
-      expectError = false;
+  if (caps.prompts) {
+    try {
+      const { prompts } = await target.listPrompts();
+      setCachedPromptNames(prompts.map((p) => p.name));
+    } catch {
     }
-    console.log(pc2.dim("\nShutting down..."));
-    await target.close();
-    process.exit(0);
-  } else {
-    mainMenuLoop(target, interceptor);
   }
 }
-function startReadlineLoop(target, interceptor) {
-  if (isScriptMode || activeRl) return;
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: getPrompt(target),
-    terminal: true,
-    completer,
-    history: [...replHistory].reverse()
-    // Node's readline history expects newest first
-  });
-  activeRl = rl;
-  if (process.stdin.isTTY) {
-    process.stdin.on("keypress", (_str, key) => {
-      if (!key || key.name !== "tab") {
-        resetTabCycle();
-      }
-    });
+
+// src/repl/commands.ts
+import { exec as exec2 } from "child_process";
+import { checkbox, confirm, input as input2, search } from "@inquirer/prompts";
+var lastCommand = null;
+var AbortFlowError = class extends Error {
+  constructor() {
+    super("Aborted by user.");
+    this.name = "AbortFlowError";
   }
-  if (!deferNextPrompt) {
-    rl.prompt();
+};
+function isAbortError(err) {
+  if (!err) return false;
+  return err.name === "ExitPromptError" || err.name === "AbortError" || err.message === "Prompt was aborted" || typeof err.message === "string" && err.message.includes("User force closed");
+}
+async function withSuspendedReadline(target, interceptor, fn) {
+  const wasActive = !!activeRl;
+  if (wasActive) {
+    setGlobalPauseReadlineClose(true);
+    activeRl.close();
+    setActiveRl(null);
   }
-  deferNextPrompt = false;
-  let processing = false;
-  let closed = false;
-  const queue = [];
-  const processQueue = async () => {
-    if (processing) return;
-    processing = true;
-    while (queue.length > 0) {
-      const trimmed = queue.shift();
-      try {
-        await handleCommand(trimmed, target, interceptor);
-      } catch (err) {
-        if (err instanceof AbortFlowError) {
-          console.log(pc2.yellow("  Aborted."));
-        } else if (err?.message?.includes("-32601") || err?.code === -32601) {
-          let msg = "Server does not support this feature (Method not found)";
-          if (trimmed.startsWith("prompts/")) msg = "This server does not have any prompts.";
-          else if (trimmed.startsWith("resources/"))
-            msg = "This server does not have any resources.";
-          else if (trimmed.startsWith("tools/")) msg = "This server does not have any tools.";
-          console.log(pc2.yellow(`  ${msg}`));
-        } else {
-          console.error(pc2.red(`\u2717 Error: ${err.message}`));
-        }
-      }
-      if (activeRl) {
-        setImmediate(() => {
-          if (activeRl) {
-            console.log();
-            activeRl.setPrompt(getPrompt(target));
-            activeRl.prompt();
-          }
-        });
+  try {
+    return await fn();
+  } finally {
+    if (wasActive) {
+      setGlobalPauseReadlineClose(false);
+      if (!isScriptMode) {
+        setDeferNextPrompt(true);
+        startReadlineLoop(target, interceptor);
       }
     }
-    processing = false;
-  };
-  rl.on("line", (line) => {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      if (!closed && activeRl) activeRl.prompt();
-      return;
-    }
-    replHistory.push(trimmed);
-    queue.push(trimmed);
-    processQueue();
-  });
-  rl.on("close", async () => {
-    closed = true;
-    activeRl = null;
-    if (!globalPauseReadlineClose) {
-      console.log(pc2.dim("\nShutting down..."));
-      await target.close();
-      process.exit(0);
-    }
-  });
+  }
 }
 async function handleCommand(input3, target, interceptor) {
   const expanded = resolveAlias(input3);
@@ -2175,14 +2877,32 @@ async function handleCommand(input3, target, interceptor) {
     case "?":
       printShortHelp();
       return;
+    case "view": {
+      const filepath = rest.trim();
+      if (!filepath) {
+        console.error(colors.red("Error: Please specify a file path to view."));
+        return;
+      }
+      const isMac = process.platform === "darwin";
+      const isWin = process.platform === "win32";
+      const cmdToRun = isMac ? "open" : isWin ? "start" : "xdg-open";
+      exec2(`${cmdToRun} "${filepath}"`, (err) => {
+        if (err) {
+          console.error(colors.red(`Error opening file: ${err.message}`));
+        } else {
+          console.log(colors.green(`Opened ${filepath}`));
+        }
+      });
+      return;
+    }
     case "menu":
     case "explore":
     case "interactive":
       if (activeRl) {
-        globalPauseReadlineClose = true;
+        setGlobalPauseReadlineClose(true);
         activeRl.close();
-        activeRl = null;
-        globalPauseReadlineClose = false;
+        setActiveRl(null);
+        setGlobalPauseReadlineClose(false);
       }
       mainMenuLoop(target, interceptor);
       return;
@@ -2249,10 +2969,10 @@ async function handleCommand(input3, target, interceptor) {
     case "!!":
     case "last":
       if (lastCommand) {
-        console.log(pc2.dim(`  Re-running: ${lastCommand}`));
+        console.log(colors.dim(`  Re-running: ${lastCommand}`));
         return await handleCommand(lastCommand, target, interceptor);
       } else {
-        console.log(pc2.yellow("No previous command to re-run."));
+        console.log(colors.yellow("No previous command to re-run."));
       }
       return;
     case "status":
@@ -2260,7 +2980,7 @@ async function handleCommand(input3, target, interceptor) {
       return;
     case "exit":
     case "quit": {
-      console.log(pc2.dim("Shutting down..."));
+      console.log(colors.dim("Shutting down..."));
       await target.close();
       process.exit(0);
       return;
@@ -2271,11 +2991,11 @@ async function handleCommand(input3, target, interceptor) {
       }
       const suggestion = suggestCommand(cmd, getActiveCommands());
       if (suggestion) {
-        console.log(pc2.yellow(`Unknown command: ${cmd}.`));
+        console.log(colors.yellow(`Unknown command: ${cmd}.`));
         try {
           await withSuspendedReadline(target, interceptor, async () => {
             const runIt = await confirm({
-              message: `Did you mean ${pc2.bold(suggestion)}?`,
+              message: `Did you mean ${colors.bold(suggestion)}?`,
               default: true
             });
             if (runIt) {
@@ -2288,7 +3008,7 @@ async function handleCommand(input3, target, interceptor) {
           throw new AbortFlowError();
         }
       } else {
-        console.log(pc2.yellow(`Unknown command: ${cmd}. Type ${pc2.bold("help")} for usage.`));
+        console.log(colors.yellow(`Unknown command: ${cmd}. Type ${colors.bold("help")} for usage.`));
       }
     }
   }
@@ -2296,25 +3016,25 @@ async function handleCommand(input3, target, interceptor) {
 async function cmdToolsList(target) {
   const { tools } = await target.listTools();
   if (tools.length === 0) {
-    console.log(pc2.dim("  No tools available."));
+    console.log(colors.dim("  No tools available."));
     return;
   }
   const nameWidth = Math.max(8, ...tools.map((t) => t.name.length));
-  console.log(pc2.bold(`  ${"Name".padEnd(nameWidth)}  Description`));
-  console.log(pc2.dim(`  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(50)}`));
+  console.log(colors.bold(`  ${"Name".padEnd(nameWidth)}  Description`));
+  console.log(colors.dim(`  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(50)}`));
   for (const tool of tools) {
-    const desc = tool.description ? tool.description.length > 60 ? `${tool.description.slice(0, 57)}...` : tool.description : pc2.dim("(no description)");
-    console.log(`  ${pc2.green(tool.name.padEnd(nameWidth))}  ${desc}`);
+    const desc = tool.description ? tool.description.length > 60 ? `${tool.description.slice(0, 57)}...` : tool.description : colors.dim("(no description)");
+    console.log(`  ${colors.green(tool.name.padEnd(nameWidth))}  ${desc}`);
   }
-  console.log(pc2.dim(`
+  console.log(colors.dim(`
   ${tools.length} tool(s) total.`));
   if (tools.length >= 10) {
     const groups = groupToolsByPrefix(tools.map((t) => t.name));
     if (!groups.has("All")) {
       console.log();
-      console.log(pc2.bold("  Groups:"));
+      console.log(colors.bold("  Groups:"));
       for (const [label, members] of groups) {
-        console.log(`    ${pc2.cyan(label.padEnd(16))} ${pc2.dim(members.join(", "))}`);
+        console.log(`    ${colors.cyan(label.padEnd(16))} ${colors.dim(members.join(", "))}`);
       }
     }
   }
@@ -2322,28 +3042,28 @@ async function cmdToolsList(target) {
 async function cmdToolsDescribe(target, rest) {
   const name = rest.trim();
   if (!name) {
-    console.log(pc2.yellow("  Usage: tools/describe <name>"));
+    console.log(colors.yellow("  Usage: tools/describe <name>"));
     if (cachedToolNames.length > 0) {
       const preview = cachedToolNames.slice(0, 6);
       const more = cachedToolNames.length > 6 ? `, ... (${cachedToolNames.length} total)` : "";
-      console.log(pc2.dim(`
+      console.log(colors.dim(`
   Available tools: ${preview.join(", ")}${more}`));
-      console.log(pc2.dim(`  Type ${pc2.bold("tools/list")} for all.`));
+      console.log(colors.dim(`  Type ${colors.bold("tools/list")} for all.`));
     }
     return;
   }
   const { tools } = await target.listTools();
   const tool = tools.find((t) => t.name === name);
   if (!tool) {
-    console.log(pc2.red(`Tool "${name}" not found.`));
+    console.log(colors.red(`Tool "${name}" not found.`));
     const suggestion = suggestCommand(
       name,
       tools.map((t) => t.name)
     );
     if (suggestion) {
-      console.log(pc2.yellow(`Did you mean ${pc2.bold(suggestion)}?`));
+      console.log(colors.yellow(`Did you mean ${colors.bold(suggestion)}?`));
     } else {
-      console.log(pc2.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
+      console.log(colors.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
     }
     return;
   }
@@ -2374,14 +3094,14 @@ async function cmdToolsCall(target, interceptor, rest) {
       if (!picked) return;
       return cmdToolsCall(target, interceptor, picked);
     }
-    console.log(pc2.yellow("  Usage: tools/call <name> [json_args] [--timeout <ms>]"));
+    console.log(colors.yellow("  Usage: tools/call <name> [json_args] [--timeout <ms>]"));
     if (cachedToolNames.length > 0) {
       const preview = cachedToolNames.slice(0, 6);
       const more = cachedToolNames.length > 6 ? `, ... (${cachedToolNames.length} total)` : "";
-      console.log(pc2.dim(`
+      console.log(colors.dim(`
   Available tools: ${preview.join(", ")}${more}`));
       console.log(
-        pc2.dim(`  Run without args for ${pc2.bold("interactive mode")}: tools/call <name>`)
+        colors.dim(`  Run without args for ${colors.bold("interactive mode")}: tools/call <name>`)
       );
     }
     return;
@@ -2393,31 +3113,31 @@ async function cmdToolsCall(target, interceptor, rest) {
       try {
         args = JSON.parse(trimmed);
       } catch (err) {
-        console.error(pc2.red(`Invalid JSON: ${err.message}`));
-        console.log(pc2.dim(`  Received: ${jsonArgs}`));
+        console.error(colors.red(`Invalid JSON: ${err.message}`));
+        console.log(colors.dim(`  Received: ${jsonArgs}`));
         return;
       }
     } else {
       try {
         args = parseHttpieArgs(trimmed);
       } catch (err) {
-        console.error(pc2.red(`Invalid shorthand arguments: ${err.message}`));
+        console.error(colors.red(`Invalid shorthand arguments: ${err.message}`));
         return;
       }
     }
     const { tools } = await target.listTools();
     const tool = tools.find((t) => t.name === toolName);
     if (!tool) {
-      console.log(pc2.red(`
+      console.log(colors.red(`
   \u2717 Tool "${toolName}" not found.`));
       const toolNames = tools.map((t) => t.name);
       const suggestion = suggestCommand(toolName, toolNames);
       if (suggestion) {
-        console.log(pc2.yellow(`  \u{1F4A1} Did you mean "${suggestion}"?`));
+        console.log(colors.yellow(`  \u{1F4A1} Did you mean "${suggestion}"?`));
       } else {
         const preview = toolNames.slice(0, 6);
         const more = toolNames.length > 6 ? `, ... (${toolNames.length} total)` : "";
-        console.log(pc2.dim(`  Available tools: ${preview.join(", ")}${more}`));
+        console.log(colors.dim(`  Available tools: ${preview.join(", ")}${more}`));
       }
       return { isError: true, content: [{ type: "text", text: `Tool not found: ${toolName}` }] };
     }
@@ -2425,14 +3145,14 @@ async function cmdToolsCall(target, interceptor, rest) {
     const required = schema.required ?? [];
     const missing = required.filter((r) => !(r in args));
     if (missing.length > 0) {
-      console.log(pc2.yellow(`
+      console.log(colors.yellow(`
   Missing required arguments: ${missing.join(", ")}`));
       console.log();
       const scaffolded = scaffoldArgs(schema);
-      console.log(pc2.dim("  Try:"));
+      console.log(colors.dim("  Try:"));
       console.log(`    tools/call ${toolName} ${scaffolded}`);
       console.log();
-      console.log(pc2.dim("  Or run without args for interactive mode:"));
+      console.log(colors.dim("  Or run without args for interactive mode:"));
       console.log(`    tools/call ${toolName}`);
       console.log();
       return;
@@ -2444,17 +3164,21 @@ async function cmdToolsCall(target, interceptor, rest) {
     if (!isScriptMode) {
       const fullCmd = `tools/call ${toolName} ${JSON.stringify(args)}`;
       replHistory.push(fullCmd);
+      appendToHistoryFile(fullCmd).catch(() => {
+      });
       if (activeRl) {
         activeRl.history.unshift(fullCmd);
       }
     }
   }
-  console.log(pc2.dim(`  Calling ${toolName}...`));
+  console.log(colors.dim(`  Calling ${toolName}...`));
   const startTime = Date.now();
   const result = await interceptor.callTool(target, toolName, args, timeoutMs);
   const elapsed = Date.now() - startTime;
   callHistory.push({ toolName, durationMs: elapsed, timestamp: startTime });
   lastToolArgsMap.set(toolName, { ...args });
+  saveWizardDefaults().catch(() => {
+  });
   const isError = result.isError === true;
   console.log();
   printResultBlock({
@@ -2468,17 +3192,17 @@ async function cmdToolsCall(target, interceptor, rest) {
     for (const item of content) {
       if (item.type === "text") {
         if (isError) {
-          console.log(pc2.red(`  \u2717 ${item.text}`));
+          console.log(colors.red(`  \u2717 ${item.text}`));
         } else {
           try {
             const parsed = JSON.parse(item.text);
             if (typeof parsed === "object" && parsed !== null) {
               console.log(formatJson(parsed, 2, true));
             } else {
-              console.log(pc2.yellow(`  ${item.text}`));
+              console.log(colors.yellow(`  ${item.text}`));
             }
           } catch {
-            console.log(pc2.yellow(`  ${item.text}`));
+            console.log(colors.yellow(`  ${item.text}`));
           }
         }
       } else {
@@ -2492,7 +3216,7 @@ async function cmdToolsCall(target, interceptor, rest) {
     const errText = Array.isArray(content) ? content.map((c) => c.text || "").join(" ").toLowerCase() : typeof content === "object" ? (content.text || "").toLowerCase() : "";
     if (errText.includes("argument") || errText.includes("validation") || errText.includes("schema") || errText.includes("missing") || errText.includes("invalid")) {
       console.log(
-        pc2.yellow(
+        colors.yellow(
           `  \u{1F4A1} Tip: Check the tool arguments via 'tools/describe ${toolName}' 
           or view the raw server stderr above.`
         )
@@ -2506,15 +3230,15 @@ async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious
   const { tools } = await target.listTools();
   const tool = tools.find((t) => t.name === toolName);
   if (!tool) {
-    console.log(pc2.red(`Tool "${toolName}" not found.`));
+    console.log(colors.red(`Tool "${toolName}" not found.`));
     const suggestion = suggestCommand(
       toolName,
       tools.map((t) => t.name)
     );
     if (suggestion) {
-      console.log(pc2.yellow(`Did you mean ${pc2.bold(suggestion)}?`));
+      console.log(colors.yellow(`Did you mean ${colors.bold(suggestion)}?`));
     } else {
-      console.log(pc2.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
+      console.log(colors.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
     }
     return null;
   }
@@ -2524,9 +3248,9 @@ async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious
     return {};
   }
   if (isScriptMode) {
-    console.log(pc2.yellow(`  Tool "${toolName}" requires arguments.`));
+    console.log(colors.yellow(`  Tool "${toolName}" requires arguments.`));
     const scaffolded = scaffoldArgs(schema);
-    console.log(pc2.dim(`  Usage: tools/call ${toolName} ${scaffolded}`));
+    console.log(colors.dim(`  Usage: tools/call ${toolName} ${scaffolded}`));
     return null;
   }
   const required = schema.required ?? [];
@@ -2535,10 +3259,10 @@ async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious
   const optionalProps = allProps.filter(([name]) => !required.includes(name));
   const previousArgs = clearPrevious ? void 0 : lastToolArgsMap.get(toolName);
   console.log();
-  console.log(`  ${pc2.bold(tool.name)}${tool.description ? pc2.dim(` \u2014 ${tool.description}`) : ""}`);
+  console.log(`  ${colors.bold(tool.name)}${tool.description ? colors.dim(` \u2014 ${tool.description}`) : ""}`);
   if (previousArgs) {
-    console.log(pc2.dim(`  Previous: ${JSON.stringify(previousArgs)}`));
-    console.log(pc2.dim("  Press Enter to reuse values, or type to override."));
+    console.log(colors.dim(`  Previous: ${JSON.stringify(previousArgs)}`));
+    console.log(colors.dim("  Press Enter to reuse values, or type to override."));
   }
   console.log();
   const collectedArgs = {};
@@ -2556,7 +3280,7 @@ async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious
         const typeStr = prop.type ?? "any";
         const desc = prop.description ?? "";
         const prevVal = previousArgs?.[name];
-        const label = desc ? `${name} ${pc2.dim(`(${typeStr})`)} ${pc2.dim(desc)}` : `${name} ${pc2.dim(`(${typeStr})`)}`;
+        const label = desc ? `${name} ${colors.dim(`(${typeStr})`)} ${colors.dim(desc)}` : `${name} ${colors.dim(`(${typeStr})`)}`;
         const answerStr = await input2(
           {
             message: label,
@@ -2598,7 +3322,7 @@ async function interactiveArgPrompt(target, interceptor, toolName, clearPrevious
           const typeStr = prop.type ?? "any";
           const desc = prop.description ?? "";
           const prevVal = previousArgs?.[name];
-          const label = desc ? `${name} ${pc2.dim(`(${typeStr})`)} ${pc2.dim(desc)}` : `${name} ${pc2.dim(`(${typeStr})`)}`;
+          const label = desc ? `${name} ${colors.dim(`(${typeStr})`)} ${colors.dim(desc)}` : `${name} ${colors.dim(`(${typeStr})`)}`;
           const answerStr = await input2(
             {
               message: label,
@@ -2637,14 +3361,14 @@ function printJsonTemplate(filled, allProps, currentProp) {
   const parts = [];
   for (const [name] of allProps) {
     if (name in filled) {
-      parts.push(`"${name}": ${pc2.green(JSON.stringify(filled[name]))}`);
+      parts.push(`"${name}": ${colors.green(JSON.stringify(filled[name]))}`);
     } else if (name === currentProp) {
-      parts.push(`"${name}": ${pc2.yellow("\u2592")}`);
+      parts.push(`"${name}": ${colors.yellow("\u2592")}`);
     } else {
-      parts.push(`"${name}": ${pc2.dim("\u2592")}`);
+      parts.push(`"${name}": ${colors.dim("\u2592")}`);
     }
   }
-  console.log(pc2.dim("  { ") + parts.join(pc2.dim(", ")) + pc2.dim(" }"));
+  console.log(colors.dim("  { ") + parts.join(colors.dim(", ")) + colors.dim(" }"));
   console.log();
 }
 function coerceValue(input3, type) {
@@ -2661,7 +3385,7 @@ function coerceValue(input3, type) {
   }
 }
 function question(rl, prompt) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let aborted = false;
     const onKeypress = (_str, key) => {
       if (key && key.name === "escape") {
@@ -2685,7 +3409,7 @@ function question(rl, prompt) {
       if (aborted) {
         reject(new AbortFlowError());
       } else {
-        resolve2(answer);
+        resolve3(answer);
       }
     });
   });
@@ -2693,11 +3417,11 @@ function question(rl, prompt) {
 async function cmdToolsScaffold(target, rest) {
   const name = rest.trim();
   if (!name) {
-    console.log(pc2.yellow("  Usage: tools/scaffold <name>"));
+    console.log(colors.yellow("  Usage: tools/scaffold <name>"));
     if (cachedToolNames.length > 0) {
       const preview = cachedToolNames.slice(0, 6);
       const more = cachedToolNames.length > 6 ? `, ... (${cachedToolNames.length} total)` : "";
-      console.log(pc2.dim(`
+      console.log(colors.dim(`
   Available tools: ${preview.join(", ")}${more}`));
     }
     return;
@@ -2705,38 +3429,38 @@ async function cmdToolsScaffold(target, rest) {
   const { tools } = await target.listTools();
   const tool = tools.find((t) => t.name === name);
   if (!tool) {
-    console.log(pc2.red(`Tool "${name}" not found.`));
+    console.log(colors.red(`Tool "${name}" not found.`));
     const suggestion = suggestCommand(
       name,
       tools.map((t) => t.name)
     );
     if (suggestion) {
-      console.log(pc2.yellow(`Did you mean ${pc2.bold(suggestion)}?`));
+      console.log(colors.yellow(`Did you mean ${colors.bold(suggestion)}?`));
     } else {
-      console.log(pc2.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
+      console.log(colors.dim(`Available: ${tools.map((t) => t.name).join(", ")}`));
     }
     return;
   }
   const scaffolded = scaffoldArgs(tool.inputSchema);
-  console.log(pc2.cyan("\n  Ready-to-paste command:"));
+  console.log(colors.cyan("\n  Ready-to-paste command:"));
   console.log(`  tools/call ${name} ${scaffolded}
 `);
 }
 async function cmdResourcesList(target) {
   const { resources } = await target.listResources();
   if (resources.length === 0) {
-    console.log(pc2.dim("  No resources available."));
+    console.log(colors.dim("  No resources available."));
     return;
   }
   const uriWidth = Math.max(6, ...resources.map((r) => r.uri.length));
-  console.log(pc2.bold(`  ${"URI".padEnd(uriWidth)}  Name`));
-  console.log(pc2.dim(`  ${"\u2500".repeat(uriWidth)}  ${"\u2500".repeat(40)}`));
+  console.log(colors.bold(`  ${"URI".padEnd(uriWidth)}  Name`));
+  console.log(colors.dim(`  ${"\u2500".repeat(uriWidth)}  ${"\u2500".repeat(40)}`));
   for (const r of resources) {
     const uri = r.uri;
-    const name = r.name ?? pc2.dim("(unnamed)");
-    console.log(`  ${pc2.green(uri.padEnd(uriWidth))}  ${name}`);
+    const name = r.name ?? colors.dim("(unnamed)");
+    console.log(`  ${colors.green(uri.padEnd(uriWidth))}  ${name}`);
   }
-  console.log(pc2.dim(`
+  console.log(colors.dim(`
   ${resources.length} resource(s) total.`));
 }
 async function cmdResourcesRead(target, rest, interceptor) {
@@ -2756,11 +3480,11 @@ async function cmdResourcesRead(target, rest, interceptor) {
       if (!picked) return;
       return cmdResourcesRead(target, picked, interceptor);
     }
-    console.log(pc2.yellow("  Usage: resources/read <uri>"));
+    console.log(colors.yellow("  Usage: resources/read <uri>"));
     if (cachedResourceUris.length > 0) {
       const preview = cachedResourceUris.slice(0, 5);
       const more = cachedResourceUris.length > 5 ? `, ... (${cachedResourceUris.length} total)` : "";
-      console.log(pc2.dim(`
+      console.log(colors.dim(`
   Available resources: ${preview.join(", ")}${more}`));
     }
     return;
@@ -2778,15 +3502,15 @@ async function cmdResourcesRead(target, rest, interceptor) {
         if (typeof parsed === "object" && parsed !== null) {
           console.log(formatJson(parsed, 2, true));
         } else {
-          console.log(pc2.yellow(`  ${text}`));
+          console.log(colors.yellow(`  ${text}`));
         }
       } catch {
-        console.log(pc2.yellow(`  ${text}`));
+        console.log(colors.yellow(`  ${text}`));
       }
     } else if (item.blob !== void 0) {
       const mimeType = item.mimeType ?? "application/octet-stream";
       const sizeBytes = Buffer.from(item.blob, "base64").length;
-      console.log(pc2.dim(`  [Binary: ${mimeType}, ${sizeBytes} bytes]`));
+      console.log(colors.dim(`  [Binary: ${mimeType}, ${sizeBytes} bytes]`));
     } else {
       console.log(formatJson(item, 2, true));
     }
@@ -2797,37 +3521,37 @@ async function cmdResourcesRead(target, rest, interceptor) {
 async function cmdResourcesTemplates(target) {
   const { resourceTemplates } = await target.listResourceTemplates();
   if (resourceTemplates.length === 0) {
-    console.log(pc2.dim("  No resource templates available."));
+    console.log(colors.dim("  No resource templates available."));
     return;
   }
   const uriWidth = Math.max(
     12,
     ...resourceTemplates.map((t) => t.uriTemplate.length)
   );
-  console.log(pc2.bold(`  ${"URI Template".padEnd(uriWidth)}  Name`));
-  console.log(pc2.dim(`  ${"\u2500".repeat(uriWidth)}  ${"\u2500".repeat(40)}`));
+  console.log(colors.bold(`  ${"URI Template".padEnd(uriWidth)}  Name`));
+  console.log(colors.dim(`  ${"\u2500".repeat(uriWidth)}  ${"\u2500".repeat(40)}`));
   for (const t of resourceTemplates) {
     const uriTemplate = t.uriTemplate;
-    const name = t.name ?? pc2.dim("(unnamed)");
-    console.log(`  ${pc2.green(uriTemplate.padEnd(uriWidth))}  ${name}`);
+    const name = t.name ?? colors.dim("(unnamed)");
+    console.log(`  ${colors.green(uriTemplate.padEnd(uriWidth))}  ${name}`);
   }
-  console.log(pc2.dim(`
+  console.log(colors.dim(`
   ${resourceTemplates.length} template(s) total.`));
 }
 async function cmdPromptsList(target) {
   const { prompts } = await target.listPrompts();
   if (prompts.length === 0) {
-    console.log(pc2.dim("  No prompts available."));
+    console.log(colors.dim("  No prompts available."));
     return;
   }
   const nameWidth = Math.max(8, ...prompts.map((p) => p.name.length));
-  console.log(pc2.bold(`  ${"Name".padEnd(nameWidth)}  Description`));
-  console.log(pc2.dim(`  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(50)}`));
+  console.log(colors.bold(`  ${"Name".padEnd(nameWidth)}  Description`));
+  console.log(colors.dim(`  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(50)}`));
   for (const p of prompts) {
-    const desc = p.description ? p.description.length > 60 ? `${p.description.slice(0, 57)}...` : p.description : pc2.dim("(no description)");
-    console.log(`  ${pc2.green(p.name.padEnd(nameWidth))}  ${desc}`);
+    const desc = p.description ? p.description.length > 60 ? `${p.description.slice(0, 57)}...` : p.description : colors.dim("(no description)");
+    console.log(`  ${colors.green(p.name.padEnd(nameWidth))}  ${desc}`);
   }
-  console.log(pc2.dim(`
+  console.log(colors.dim(`
   ${prompts.length} prompt(s) total.`));
 }
 async function cmdPromptsGet(target, rest, interceptor) {
@@ -2844,9 +3568,9 @@ async function cmdPromptsGet(target, rest, interceptor) {
       if (!picked) return;
       return cmdPromptsGet(target, picked);
     }
-    console.log(pc2.yellow("  Usage: prompts/get <name> [json_args]"));
+    console.log(colors.yellow("  Usage: prompts/get <name> [json_args]"));
     if (cachedPromptNames.length > 0) {
-      console.log(pc2.dim(`
+      console.log(colors.dim(`
   Available prompts: ${cachedPromptNames.join(", ")}`));
     }
     return;
@@ -2858,15 +3582,15 @@ async function cmdPromptsGet(target, rest, interceptor) {
       try {
         promptArgs = JSON.parse(trimmed);
       } catch (err) {
-        console.error(pc2.red(`Invalid JSON: ${err.message}`));
-        console.log(pc2.dim(`  Received: ${jsonArgs}`));
+        console.error(colors.red(`Invalid JSON: ${err.message}`));
+        console.log(colors.dim(`  Received: ${jsonArgs}`));
         return;
       }
     } else {
       try {
         promptArgs = parseHttpieArgs(trimmed);
       } catch (err) {
-        console.error(pc2.red(`Invalid shorthand arguments: ${err.message}`));
+        console.error(colors.red(`Invalid shorthand arguments: ${err.message}`));
         return;
       }
     }
@@ -2874,14 +3598,14 @@ async function cmdPromptsGet(target, rest, interceptor) {
   const { prompts } = await target.listPrompts();
   const prompt = prompts.find((p) => p.name === promptName);
   if (!prompt) {
-    console.log(pc2.red(`
+    console.log(colors.red(`
   \u2717 Prompt "${promptName}" not found.`));
     const promptNames = prompts.map((p) => p.name);
     const suggestion = suggestCommand(promptName, promptNames);
     if (suggestion) {
-      console.log(pc2.yellow(`  \u{1F4A1} Did you mean "${suggestion}"?`));
+      console.log(colors.yellow(`  \u{1F4A1} Did you mean "${suggestion}"?`));
     } else {
-      console.log(pc2.dim(`  Available prompts: ${promptNames.join(", ")}`));
+      console.log(colors.dim(`  Available prompts: ${promptNames.join(", ")}`));
     }
     return { isError: true, content: [{ type: "text", text: `Prompt not found: ${promptName}` }] };
   }
@@ -2889,24 +3613,24 @@ async function cmdPromptsGet(target, rest, interceptor) {
   const result = await target.getPrompt({ name: promptName, arguments: promptArgs });
   const elapsed = Date.now() - startTime;
   if (result.messages.length === 0) {
-    console.log(pc2.dim("  No messages returned."));
+    console.log(colors.dim("  No messages returned."));
     return;
   }
   console.log();
   printResultBlock({ label: "Prompt", labelColor: "blue", elapsed, detail: promptName });
   for (const msg of result.messages) {
-    const role = msg.role === "user" ? pc2.blue("user") : pc2.magenta("assistant");
+    const role = msg.role === "user" ? colors.blue("user") : colors.magenta("assistant");
     const text = msg.content.text ?? JSON.stringify(msg.content);
     try {
       const parsed = JSON.parse(text);
       if (typeof parsed === "object" && parsed !== null) {
-        console.log(`  ${pc2.bold(role)}:`);
+        console.log(`  ${colors.bold(role)}:`);
         console.log(formatJson(parsed, 4, true));
       } else {
-        console.log(`  ${pc2.bold(role)}: ${pc2.yellow(text)}`);
+        console.log(`  ${colors.bold(role)}: ${colors.yellow(text)}`);
       }
     } catch {
-      console.log(`  ${pc2.bold(role)}: ${pc2.yellow(text)}`);
+      console.log(`  ${colors.bold(role)}: ${colors.yellow(text)}`);
     }
   }
   console.log();
@@ -2916,36 +3640,36 @@ async function cmdPing(target) {
   try {
     const elapsed = await target.ping();
     console.log();
-    console.log(pc2.green(`  \u2713 Pong! Round-trip: ${elapsed}ms`));
+    console.log(colors.green(`  \u2713 Pong! Round-trip: ${elapsed}ms`));
     console.log();
   } catch (err) {
     console.log();
-    console.error(pc2.red(`  \u2717 Ping failed: ${err.message}`));
+    console.error(colors.red(`  \u2717 Ping failed: ${err.message}`));
     console.log();
   }
 }
 async function cmdLogLevel(target, rest) {
   const level = rest.trim().toLowerCase();
   if (!level) {
-    console.log(pc2.yellow("  Usage: log-level <level>"));
-    console.log(pc2.dim(`  Valid levels: ${LOG_LEVELS.join(", ")}`));
+    console.log(colors.yellow("  Usage: log-level <level>"));
+    console.log(colors.dim(`  Valid levels: ${LOG_LEVELS.join(", ")}`));
     return;
   }
   if (!LOG_LEVELS.includes(level)) {
     const suggestion = suggestCommand(level, [...LOG_LEVELS]);
     const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
-    console.log(pc2.red(`  Unknown log level: "${level}".${hint}`));
-    console.log(pc2.dim(`  Valid levels: ${LOG_LEVELS.join(", ")}`));
+    console.log(colors.red(`  Unknown log level: "${level}".${hint}`));
+    console.log(colors.dim(`  Valid levels: ${LOG_LEVELS.join(", ")}`));
     return;
   }
   try {
     await target.setLoggingLevel(level);
-    console.log(pc2.green(`  \u2713 Logging level set to: ${level}`));
+    console.log(colors.green(`  \u2713 Logging level set to: ${level}`));
   } catch (err) {
-    console.error(pc2.red(`  \u2717 Failed to set log level: ${err.message}`));
+    console.error(colors.red(`  \u2717 Failed to set log level: ${err.message}`));
     const caps = target.getServerCapabilities();
     if (!caps?.logging) {
-      console.log(pc2.dim("  The server does not advertise logging support."));
+      console.log(colors.dim("  The server does not advertise logging support."));
     }
   }
 }
@@ -2953,28 +3677,28 @@ function cmdHistory(target, rest) {
   const arg = rest.trim();
   if (arg === "clear") {
     target.clearHistory();
-    console.log(pc2.dim("  History cleared."));
+    console.log(colors.dim("  History cleared."));
     return;
   }
   const count = arg ? Number.parseInt(arg, 10) : 20;
   const records = target.getHistory(Number.isNaN(count) ? 20 : count);
   if (records.length === 0) {
-    console.log(pc2.dim("  No request history yet."));
+    console.log(colors.dim("  No request history yet."));
     return;
   }
-  console.log(pc2.bold("\n  Request History"));
-  console.log(pc2.dim(`  ${"\u2500".repeat(70)}`));
+  console.log(colors.bold("\n  Request History"));
+  console.log(colors.dim(`  ${"\u2500".repeat(70)}`));
   for (const rec of records) {
     const time = new Date(rec.timestamp).toLocaleTimeString();
     const dur = `${rec.durationMs}ms`;
-    const hasError = rec.error ? pc2.red(" \u2717") : "";
+    const hasError = rec.error ? colors.red(" \u2717") : "";
     console.log(
-      `  ${pc2.dim(`#${rec.id}`)} ${pc2.dim(time)} ${pc2.green(rec.method.padEnd(30))} ${pc2.cyan(dur.padStart(8))}${hasError}`
+      `  ${colors.dim(`#${rec.id}`)} ${colors.dim(time)} ${colors.green(rec.method.padEnd(30))} ${colors.cyan(dur.padStart(8))}${hasError}`
     );
   }
   const total = target.getHistory().length;
   console.log(
-    pc2.dim(`
+    colors.dim(`
   Showing ${records.length} of ${total} total. Use "history clear" to reset.`)
   );
   console.log();
@@ -2983,26 +3707,26 @@ function cmdNotifications(target, rest) {
   const arg = rest.trim();
   if (arg === "clear") {
     target.clearNotifications();
-    console.log(pc2.dim("  Notifications cleared."));
+    console.log(colors.dim("  Notifications cleared."));
     return;
   }
   const count = arg ? Number.parseInt(arg, 10) : 20;
   const records = target.getNotifications(Number.isNaN(count) ? 20 : count);
   if (records.length === 0) {
-    console.log(pc2.dim("  No notifications received yet."));
-    console.log(pc2.dim("  Notifications appear inline as they arrive from the server."));
+    console.log(colors.dim("  No notifications received yet."));
+    console.log(colors.dim("  Notifications appear inline as they arrive from the server."));
     return;
   }
-  console.log(pc2.bold("\n  Server Notifications"));
-  console.log(pc2.dim(`  ${"\u2500".repeat(70)}`));
+  console.log(colors.bold("\n  Server Notifications"));
+  console.log(colors.dim(`  ${"\u2500".repeat(70)}`));
   for (const n of records) {
     const time = new Date(n.timestamp).toLocaleTimeString();
-    const params = n.params ? ` ${pc2.dim(JSON.stringify(n.params))}` : "";
-    console.log(`  ${pc2.dim(time)} ${pc2.yellow(n.method)}${params}`);
+    const params = n.params ? ` ${colors.dim(JSON.stringify(n.params))}` : "";
+    console.log(`  ${colors.dim(time)} ${colors.yellow(n.method)}${params}`);
   }
   const total = target.getNotifications().length;
   console.log(
-    pc2.dim(`
+    colors.dim(`
   Showing ${records.length} of ${total} total. Use "notifications clear" to reset.`)
   );
   console.log();
@@ -3010,44 +3734,44 @@ function cmdNotifications(target, rest) {
 async function cmdResourcesSubscribe(target, rest) {
   const uri = rest.trim();
   if (!uri) {
-    console.log(pc2.yellow("  Usage: resources/subscribe <uri>"));
+    console.log(colors.yellow("  Usage: resources/subscribe <uri>"));
     if (cachedResourceUris.length > 0) {
-      console.log(pc2.dim(`  Available: ${cachedResourceUris.join(", ")}`));
+      console.log(colors.dim(`  Available: ${cachedResourceUris.join(", ")}`));
     }
     return;
   }
   try {
     await target.subscribeResource({ uri });
-    console.log(pc2.green(`  \u2713 Subscribed to: ${uri}`));
-    console.log(pc2.dim("  You'll see notifications when this resource changes."));
+    console.log(colors.green(`  \u2713 Subscribed to: ${uri}`));
+    console.log(colors.dim("  You'll see notifications when this resource changes."));
   } catch (err) {
-    console.error(pc2.red(`  \u2717 Subscribe failed: ${err.message}`));
+    console.error(colors.red(`  \u2717 Subscribe failed: ${err.message}`));
   }
 }
 async function cmdResourcesUnsubscribe(target, rest) {
   const uri = rest.trim();
   if (!uri) {
-    console.log(pc2.yellow("  Usage: resources/unsubscribe <uri>"));
+    console.log(colors.yellow("  Usage: resources/unsubscribe <uri>"));
     return;
   }
   try {
     await target.unsubscribeResource({ uri });
-    console.log(pc2.green(`  \u2713 Unsubscribed from: ${uri}`));
+    console.log(colors.green(`  \u2713 Unsubscribed from: ${uri}`));
   } catch (err) {
-    console.error(pc2.red(`  \u2717 Unsubscribe failed: ${err.message}`));
+    console.error(colors.red(`  \u2717 Unsubscribe failed: ${err.message}`));
   }
 }
 function cmdRootsList(target) {
   const roots = target.getRoots();
   if (roots.length === 0) {
-    console.log(pc2.dim("  No roots configured."));
-    console.log(pc2.dim("  Use roots/add <uri> [name] to add one."));
+    console.log(colors.dim("  No roots configured."));
+    console.log(colors.dim("  Use roots/add <uri> [name] to add one."));
     return;
   }
-  console.log(pc2.bold("\n  Client Roots"));
+  console.log(colors.bold("\n  Client Roots"));
   for (const r of roots) {
     const name = r.name ? ` (${r.name})` : "";
-    console.log(`  ${pc2.green(r.uri)}${pc2.dim(name)}`);
+    console.log(`  ${colors.green(r.uri)}${colors.dim(name)}`);
   }
   console.log();
 }
@@ -3056,53 +3780,53 @@ async function cmdRootsAdd(target, rest) {
   const uri = parts[0];
   const name = parts.slice(1).join(" ") || void 0;
   if (!uri) {
-    console.log(pc2.yellow("  Usage: roots/add <uri> [name]"));
-    console.log(pc2.dim('  Example: roots/add file:///Users/me/project "My Project"'));
+    console.log(colors.yellow("  Usage: roots/add <uri> [name]"));
+    console.log(colors.dim('  Example: roots/add file:///Users/me/project "My Project"'));
     return;
   }
   await target.addRoot({ uri, name });
-  console.log(pc2.green(`  \u2713 Root added: ${uri}`));
-  console.log(pc2.dim("  Server has been notified of the change."));
+  console.log(colors.green(`  \u2713 Root added: ${uri}`));
+  console.log(colors.dim("  Server has been notified of the change."));
 }
 async function cmdRootsRemove(target, rest) {
   const uri = rest.trim();
   if (!uri) {
-    console.log(pc2.yellow("  Usage: roots/remove <uri>"));
+    console.log(colors.yellow("  Usage: roots/remove <uri>"));
     const roots = target.getRoots();
     if (roots.length > 0) {
-      console.log(pc2.dim(`  Current roots: ${roots.map((r) => r.uri).join(", ")}`));
+      console.log(colors.dim(`  Current roots: ${roots.map((r) => r.uri).join(", ")}`));
     }
     return;
   }
   const removed = await target.removeRoot(uri);
   if (removed) {
-    console.log(pc2.green(`  \u2713 Root removed: ${uri}`));
+    console.log(colors.green(`  \u2713 Root removed: ${uri}`));
   } else {
-    console.log(pc2.yellow(`  Root not found: ${uri}`));
+    console.log(colors.yellow(`  Root not found: ${uri}`));
   }
 }
 async function cmdReconnect(target) {
-  console.log(pc2.cyan("\u27F3 Disconnecting..."));
+  console.log(colors.cyan("\u27F3 Disconnecting..."));
   await target.close();
-  await new Promise((resolve2) => setTimeout(resolve2, 200));
-  console.log(pc2.cyan("\u27F3 Reconnecting..."));
+  await new Promise((resolve3) => setTimeout(resolve3, 200));
+  console.log(colors.cyan("\u27F3 Reconnecting..."));
   const { command, args } = target.getStatus();
-  console.log(pc2.dim(`  Command: ${command} ${args.join(" ")}`));
+  console.log(colors.dim(`  Command: ${command} ${args.join(" ")}`));
   try {
     await target.connect();
     const s = target.getStatus();
-    console.log(pc2.green(`\u2713 Reconnected (PID: ${s.pid})`));
+    console.log(colors.green(`\u2713 Reconnected (PID: ${s.pid})`));
     const { tools } = await target.listTools();
-    console.log(pc2.cyan(`  ${tools.length} tool(s) available.
+    console.log(colors.cyan(`  ${tools.length} tool(s) available.
 `));
     await refreshCaches(target);
   } catch (err) {
-    console.error(pc2.red(`\u2717 Failed to reconnect: ${err.message}`));
+    console.error(colors.red(`\u2717 Failed to reconnect: ${err.message}`));
   }
 }
 function cmdTiming() {
   if (callHistory.length === 0) {
-    console.log(pc2.dim("  No tool calls recorded yet."));
+    console.log(colors.dim("  No tool calls recorded yet."));
     return;
   }
   const groups = /* @__PURE__ */ new Map();
@@ -3112,172 +3836,68 @@ function cmdTiming() {
     groups.set(record.toolName, list);
   }
   const nameWidth = Math.max(8, ...[...groups.keys()].map((n) => n.length));
-  console.log(pc2.bold("\n  Tool Call Performance"));
-  console.log(pc2.dim(`  ${"\u2500".repeat(nameWidth + 50)}`));
+  console.log(colors.bold("\n  Tool Call Performance"));
+  console.log(colors.dim(`  ${"\u2500".repeat(nameWidth + 50)}`));
   let totalCalls = 0;
   let totalMs = 0;
   let slowestName = "";
   let slowestMs = 0;
   for (const [name, durations] of groups) {
     const count = durations.length;
-    totalCalls += count;
-    const sorted = [...durations].sort((a, b) => a - b);
-    const avg = Math.round(sorted.reduce((a, b) => a + b, 0) / count);
-    const p95 = sorted[Math.floor(count * 0.95)];
-    const max = sorted[sorted.length - 1];
-    totalMs += sorted.reduce((a, b) => a + b, 0);
-    if (max > slowestMs) {
-      slowestMs = max;
-      slowestName = name;
-    }
-    console.log(
-      `  ${pc2.green(name.padEnd(nameWidth))}  \xD7 ${count}  avg: ${avg}ms    p95: ${p95}ms    max: ${max}ms`
-    );
-  }
-  const overallAvg = Math.round(totalMs / totalCalls);
-  console.log(
-    pc2.dim(
-      `
-  Total: ${totalCalls} call(s), avg ${overallAvg}ms, slowest: ${slowestName} (${slowestMs}ms)`
-    )
-  );
-  console.log();
-}
-function cmdStatus(target) {
-  const s = target.getStatus();
-  const uptimeStr = s.uptime >= 60 ? `${Math.floor(s.uptime / 60)}m ${(s.uptime % 60).toFixed(0)}s` : `${s.uptime.toFixed(1)}s`;
-  const lastRespStr = s.lastResponseTime ? `${((Date.now() - s.lastResponseTime) / 1e3).toFixed(1)}s ago` : "never";
-  console.log(pc2.bold("\n  Target Server Status"));
-  console.log(`  ${pc2.dim("Connected:")}      ${s.connected ? pc2.green("yes") : pc2.red("no")}`);
-  console.log(`  ${pc2.dim("PID:")}            ${s.pid ?? "N/A"}`);
-  console.log(`  ${pc2.dim("Uptime:")}         ${uptimeStr}`);
-  console.log(`  ${pc2.dim("Last response:")}  ${lastRespStr}`);
-  console.log(`  ${pc2.dim("Stderr lines:")}   ${s.stderrLineCount.toLocaleString()}`);
-  console.log(`  ${pc2.dim("Reconnects:")}     ${s.reconnectAttempts}/${s.maxReconnectAttempts}`);
-  console.log(`  ${pc2.dim("Command:")}        ${s.command} ${s.args.join(" ")}`);
-  console.log();
-}
-function printResultBlock(opts) {
-  const colorFn = pc2[opts.labelColor];
-  const elapsedStr = opts.elapsed < 1e3 ? `${opts.elapsed}ms` : `${(opts.elapsed / 1e3).toFixed(1)}s`;
-  const detail = opts.detail ?? opts.toolName ?? "";
-  console.log(`  ${colorFn(opts.label)}  ${pc2.dim(detail)}  ${pc2.dim(`(${elapsedStr})`)}`);
-  console.log(pc2.dim(`  ${"\u2500".repeat(60)}`));
-}
-function printShortHelp() {
-  const hasTools = !!activeCapabilities?.tools;
-  const hasResources = !!activeCapabilities?.resources;
-  const hasPrompts = !!activeCapabilities?.prompts;
-  const tC = hasTools ? pc2.green : pc2.dim;
-  const rC = hasResources ? pc2.green : pc2.dim;
-  const pC = hasPrompts ? pc2.green : pc2.dim;
-  console.log(`
-${pc2.bold("Quick Reference:")}
-
-  ${tC("tl")}  ${tC("tools/list")}        ${rC("rl")}  ${rC("resources/list")}     ${pC("pl")}  ${pC("prompts/list")}
-  ${tC("td")}  ${tC("tools/describe")}    ${rC("rr")}  ${rC("resources/read")}     ${pC("pg")}  ${pC("prompts/get")}
-  ${tC("tc")}  ${tC("tools/call")}        ${rC("rt")}  ${rC("resources/templates")}
-  ${tC("ts")}  ${tC("tools/scaffold")}    ${rC("rs")}  ${rC("resources/subscribe")}
-                          ${rC("ru")}  ${rC("resources/unsubscribe")}
-
-  ${pc2.green("ping")}  ${pc2.green("status")}  ${pc2.green("timing")}  ${pc2.green("history")}  ${pc2.green("!!")}  ${pc2.green("explore")}  ${pc2.green("reconnect")}
-
-${pc2.dim("Type 'help' for full command reference.")}
-`);
-}
-function printHelp() {
-  const hasTools = !!activeCapabilities?.tools;
-  const hasResources = !!activeCapabilities?.resources;
-  const hasPrompts = !!activeCapabilities?.prompts;
-  const hasLogging = !!activeCapabilities?.logging;
-  const tC = hasTools ? pc2.green : pc2.dim;
-  const rC = hasResources ? pc2.green : pc2.dim;
-  const pC = hasPrompts ? pc2.green : pc2.dim;
-  const lC = hasLogging ? pc2.green : pc2.dim;
-  const tD = hasTools ? (s) => s : pc2.dim;
-  const rD = hasResources ? (s) => s : pc2.dim;
-  const pD = hasPrompts ? (s) => s : pc2.dim;
-  const lD = hasLogging ? (s) => s : pc2.dim;
-  const tH = hasTools ? pc2.bold("Tool Commands:") : pc2.dim(pc2.bold("Tool Commands:")) + pc2.dim("  (Unsupported)");
-  const rH = hasResources ? pc2.bold("Resource Commands:") : pc2.dim(pc2.bold("Resource Commands:")) + pc2.dim("  (Unsupported)");
-  const pH = hasPrompts ? pc2.bold("Prompt Commands:") : pc2.dim(pc2.bold("Prompt Commands:")) + pc2.dim("  (Unsupported)");
-  console.log(`
-${tH}
-
-  ${tC("tools/list")}                         ${tD("List all available tools")}
-  ${tC("tools/describe")} <name>              ${tD("Show a tool's input schema")}
-  ${tC("tools/call")} <name> [json] [opts]    ${tD("Call a tool (interactive if no json)")}
-    ${tD("Options:")} ${pc2.dim("--timeout <ms>")}            ${tD("Override default timeout (60s)")}
-             ${pc2.dim("--clear")}                  ${tD("Ignore remembered argument defaults")}
-  ${tC("tools/scaffold")} <name>              ${tD("Generate a template for a tool's arguments")}
-  ${tC("tools/forget")} [name]                ${tD("Clear remembered interactive defaults")}
-
-${rH}
-
-  ${rC("resources/list")}                     ${rD("List all available resources")}
-  ${rC("resources/read")} <uri>               ${rD("Read a resource by URI")}
-  ${rC("resources/templates")}                ${rD("List resource templates")}
-  ${rC("resources/subscribe")} <uri>          ${rD("Subscribe to resource changes")}
-  ${rC("resources/unsubscribe")} <uri>        ${rD("Unsubscribe from resource changes")}
-
-${pH}
-
-  ${pC("prompts/list")}                       ${pD("List all available prompts")}
-  ${pC("prompts/get")} <name> [json_args]    ${pD("Get a prompt with arguments")}
-
-${pc2.bold("Protocol Commands:")}
-
-  ${pc2.green("ping")}                               Verify connection, show round-trip time
-  ${lC("log-level")} <level>                  ${lD("Set server logging verbosity")}${hasLogging ? "" : pc2.dim("  (Unsupported)")}
-  ${pc2.green("history")} [count|clear]              Show request/response history
-  ${pc2.green("notifications")} [count|clear]        Show server notifications
-
-${pc2.bold("Roots Management:")}
-
-  ${pc2.green("roots/list")}                         Show configured client roots
-  ${pc2.green("roots/add")} <uri> [name]             Add a root directory
-  ${pc2.green("roots/remove")} <uri>                 Remove a root directory
-
-${pc2.bold("Session Commands:")}
-
-  ${pc2.green("!!")} / ${pc2.green("last")}                           Re-run the last command
-  ${pc2.green("reconnect")}                          Disconnect and reconnect to the server
-  ${pc2.green("timing")}                             Show tool call performance stats
-  ${pc2.green("status")}                             Show target server status
-  ${pc2.green("help")}                               Show this help
-  ${pc2.green("exit")} / ${pc2.green("quit")}                         Disconnect and exit
-
-${pc2.bold("Shortcuts:")}
-
-  ${tC("tl")}  ${tC("tools/list")}          ${rC("rl")}  ${rC("resources/list")}     ${pC("pl")}  ${pC("prompts/list")}
-  ${tC("td")}  ${tC("tools/describe")}      ${rC("rr")}  ${rC("resources/read")}     ${pC("pg")}  ${pC("prompts/get")}
-  ${tC("tc")}  ${tC("tools/call")}          ${rC("rt")}  ${rC("resources/templates")}
-  ${tC("ts")}  ${tC("tools/scaffold")}      ${rC("rs")}  ${rC("resources/subscribe")}
-                          ${rC("ru")}  ${rC("resources/unsubscribe")}
-
-${pc2.dim("Lines starting with # are treated as comments.")}
-${pc2.dim('JSON arguments can contain spaces: tools/call say {"message": "hello world"}')}
-${pc2.dim("Run tools/call <name> without JSON for interactive argument prompting.")}
-${pc2.dim("Use tools/call <name> --clear to ignore remembered defaults.")}
-`);
+    totalCalls += count;
+    const sorted = [...durations].sort((a, b) => a - b);
+    const avg = Math.round(sorted.reduce((a, b) => a + b, 0) / count);
+    const p95 = sorted[Math.floor(count * 0.95)];
+    const max = sorted[sorted.length - 1];
+    totalMs += sorted.reduce((a, b) => a + b, 0);
+    if (max > slowestMs) {
+      slowestMs = max;
+      slowestName = name;
+    }
+    console.log(
+      `  ${colors.green(name.padEnd(nameWidth))}  \xD7 ${count}  avg: ${avg}ms    p95: ${p95}ms    max: ${max}ms`
+    );
+  }
+  const overallAvg = Math.round(totalMs / totalCalls);
+  console.log(
+    colors.dim(
+      `
+  Total: ${totalCalls} call(s), avg ${overallAvg}ms, slowest: ${slowestName} (${slowestMs}ms)`
+    )
+  );
+  console.log();
 }
-async function readScriptLines(filepath) {
-  const content = await readFile2(filepath, "utf-8");
-  return content.split("\n");
+function cmdStatus(target) {
+  const s = target.getStatus();
+  const uptimeStr = s.uptime >= 60 ? `${Math.floor(s.uptime / 60)}m ${(s.uptime % 60).toFixed(0)}s` : `${s.uptime.toFixed(1)}s`;
+  const lastRespStr = s.lastResponseTime ? `${((Date.now() - s.lastResponseTime) / 1e3).toFixed(1)}s ago` : "never";
+  console.log(colors.bold("\n  Target Server Status"));
+  console.log(`  ${colors.dim("Connected:")}      ${s.connected ? colors.green("yes") : colors.red("no")}`);
+  console.log(`  ${colors.dim("PID:")}            ${s.pid ?? "N/A"}`);
+  console.log(`  ${colors.dim("Uptime:")}         ${uptimeStr}`);
+  console.log(`  ${colors.dim("Last response:")}  ${lastRespStr}`);
+  console.log(`  ${colors.dim("Stderr lines:")}   ${s.stderrLineCount.toLocaleString()}`);
+  console.log(`  ${colors.dim("Reconnects:")}     ${s.reconnectAttempts}/${s.maxReconnectAttempts}`);
+  console.log(`  ${colors.dim("Command:")}        ${s.command} ${s.args.join(" ")}`);
+  console.log();
 }
 function cmdToolsForget(rest) {
   const toolName = rest.trim();
   if (toolName) {
     if (lastToolArgsMap.has(toolName)) {
       lastToolArgsMap.delete(toolName);
-      console.log(pc2.green(`  Cleared remembered args for ${pc2.bold(toolName)}.`));
+      saveWizardDefaults().catch(() => {
+      });
+      console.log(colors.green(`  Cleared remembered args for ${colors.bold(toolName)}.`));
     } else {
-      console.log(pc2.yellow(`  No remembered args for "${toolName}".`));
+      console.log(colors.yellow(`  No remembered args for "${toolName}".`));
     }
   } else {
     const count = lastToolArgsMap.size;
     lastToolArgsMap.clear();
-    console.log(pc2.green(`  Cleared remembered args for ${count} tool${count === 1 ? "" : "s"}.`));
+    saveWizardDefaults().catch(() => {
+    });
+    console.log(colors.green(`  Cleared remembered args for ${count} tool${count === 1 ? "" : "s"}.`));
   }
 }
 async function pickInteractive(items, message) {
@@ -3377,55 +3997,416 @@ async function showMainMenu(target, interceptor) {
         );
       }
     });
-    if (answer.type === "tool") {
-      await cmdToolsCall(target, interceptor, answer.name);
-    } else if (answer.type === "resource") {
-      await cmdResourcesRead(target, answer.uri);
-    } else if (answer.type === "prompt") {
-      await cmdPromptsGet(target, answer.name);
-    } else if (answer.type === "command") {
-      if (answer.name === "status") {
-        cmdStatus(target);
-      } else if (answer.name === "reconnect") {
-        await cmdReconnect(target);
-      } else if (answer.name === "exit") {
-        console.log(pc2.dim("\nShutting down..."));
-        await target.close();
-        process.exit(0);
+    if (answer.type === "tool") {
+      await cmdToolsCall(target, interceptor, answer.name);
+    } else if (answer.type === "resource") {
+      await cmdResourcesRead(target, answer.uri);
+    } else if (answer.type === "prompt") {
+      await cmdPromptsGet(target, answer.name);
+    } else if (answer.type === "command") {
+      if (answer.name === "status") {
+        cmdStatus(target);
+      } else if (answer.name === "reconnect") {
+        await cmdReconnect(target);
+      } else if (answer.name === "exit") {
+        console.log(colors.dim("\nShutting down..."));
+        await target.close();
+        process.exit(0);
+      }
+    } else if (answer.type === "raw") {
+      return true;
+    }
+    return false;
+  } catch (err) {
+    if (isAbortError(err)) {
+      console.log(colors.dim("\nShutting down..."));
+      await target.close();
+      process.exit(0);
+    }
+    throw err;
+  }
+}
+async function mainMenuLoop(target, interceptor) {
+  if (isScriptMode || !process.stdin.isTTY) {
+    startReadlineLoop(target, interceptor);
+    return;
+  }
+  while (true) {
+    try {
+      const dropToRaw = await showMainMenu(target, interceptor);
+      if (dropToRaw) {
+        console.log(colors.dim("  Entering raw command mode. Type 'menu' to return."));
+        startReadlineLoop(target, interceptor);
+        break;
+      }
+    } catch (err) {
+      console.error(colors.red(`Error in menu: ${err.message}`));
+      startReadlineLoop(target, interceptor);
+      break;
+    }
+  }
+}
+
+// src/repl/index.ts
+function getPrompt(target) {
+  if (target.connected) return `${colors.green("\u2713")}${colors.cyan("> ")}`;
+  return `${colors.red("\u2717")}${colors.cyan("> ")}`;
+}
+function startReadlineLoop(target, interceptor) {
+  if (isScriptMode || activeRl) return;
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: getPrompt(target),
+    terminal: true,
+    completer,
+    history: [...replHistory].reverse()
+    // Node's readline history expects newest first
+  });
+  setActiveRl(rl);
+  setClosed(false);
+  if (process.stdin.isTTY) {
+    process.stdin.on("keypress", (_str, key) => {
+      if (!key || key.name !== "tab") {
+        resetTabCycle();
+      }
+    });
+  }
+  if (!deferNextPrompt) {
+    rl.prompt();
+  }
+  setDeferNextPrompt(false);
+  let processing = false;
+  const queue = [];
+  const processQueue = async () => {
+    if (processing) return;
+    processing = true;
+    while (queue.length > 0) {
+      const trimmed = queue.shift();
+      try {
+        await handleCommand(trimmed, target, interceptor);
+      } catch (err) {
+        if (err instanceof AbortFlowError) {
+          console.log(colors.yellow("  Aborted."));
+        } else if (err?.message?.includes("-32601") || err?.code === -32601) {
+          let msg = "Server does not support this feature (Method not found)";
+          if (trimmed.startsWith("prompts/")) msg = "This server does not have any prompts.";
+          else if (trimmed.startsWith("resources/"))
+            msg = "This server does not have any resources.";
+          else if (trimmed.startsWith("tools/")) msg = "This server does not have any tools.";
+          console.log(colors.yellow(`  ${msg}`));
+        } else {
+          console.error(colors.red(`\u2717 Error: ${err.message}`));
+        }
+      }
+      if (activeRl) {
+        setImmediate(() => {
+          if (activeRl) {
+            console.log();
+            activeRl.setPrompt(getPrompt(target));
+            activeRl.prompt();
+          }
+        });
+      }
+    }
+    processing = false;
+  };
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      if (!closed && activeRl) activeRl.prompt();
+      return;
+    }
+    replHistory.push(trimmed);
+    appendToHistoryFile(trimmed).catch(() => {
+    });
+    queue.push(trimmed);
+    processQueue();
+  });
+  rl.on("close", async () => {
+    setClosed(true);
+    setActiveRl(null);
+    if (!globalPauseReadlineClose) {
+      console.log(colors.dim("\nShutting down..."));
+      await target.close();
+      process.exit(0);
+    }
+  });
+}
+async function startRepl(targetCommand, opts) {
+  const [command, ...args] = targetCommand;
+  const target = new TargetManager(command, args, {
+    sandbox: opts.sandbox,
+    allowRead: opts.allowRead,
+    allowWrite: opts.allowWrite,
+    allowNet: opts.allowNet,
+    denyRead: opts.denyRead,
+    denyWrite: opts.denyWrite,
+    denyNet: opts.denyNet
+  });
+  const interceptor = new ResponseInterceptor({
+    outDir: opts.outDir,
+    mediaThresholdKb: opts.mediaThresholdKb,
+    openMedia: opts.openMedia
+  });
+  setIsScriptMode(!!opts.script);
+  if (!isScriptMode) {
+    await loadHistory();
+    await loadWizardDefaults();
+  }
+  target.on("stderr", (text) => {
+    for (const line of text.split("\n")) {
+      console.error(colors.dim(`[server] ${line}`));
+    }
+  });
+  console.log(colors.cyan("\u27F3 Connecting to target MCP server..."));
+  console.log(colors.dim(`  Command: ${targetCommand.join(" ")}`));
+  try {
+    await target.connect();
+  } catch (err) {
+    const msg = err.message ?? String(err);
+    if (msg.includes("ENOENT") || msg.includes("spawn")) {
+      console.error(colors.red(`\u2717 Failed to start server: command "${command}" not found.`));
+      console.error(colors.dim(`  Check that "${command}" is installed and in your PATH.`));
+    } else {
+      console.error(colors.red(`\u2717 Failed to connect: ${msg}`));
+      console.error(colors.dim(`  Check that the target command starts a valid MCP server on stdio.`));
+    }
+    process.exit(1);
+  }
+  const status = target.getStatus();
+  console.log(colors.green(`\u2713 Connected (PID: ${status.pid})`));
+  if (!isScriptMode) {
+    target.enableAutoReconnect();
+    target.on(
+      "reconnecting",
+      ({ attempt, maxAttempts }) => {
+        console.log(
+          colors.yellow(`
+\u27F3 Server disconnected. Reconnecting (${attempt}/${maxAttempts})...`)
+        );
+      }
+    );
+    target.on("reconnected", async ({ attempt }) => {
+      const s = target.getStatus();
+      console.log(colors.green(`\u2713 Reconnected (PID: ${s.pid}, attempt ${attempt})`));
+      await refreshCaches(target);
+    });
+    target.on("reconnect_failed", ({ reason, message }) => {
+      console.error(colors.red(`\u2717 ${message}`));
+      if (reason === "max_retries") {
+        console.log(
+          colors.dim("  Use 'exit' to quit or wait for the server to be fixed and restart manually.")
+        );
+      }
+    });
+    target.on("notification", (notification) => {
+      const method = notification.method;
+      if (method === "notifications/message") {
+        const lvl = notification.params?.level ?? "info";
+        const data = notification.params?.data ?? "";
+        const text = typeof data === "string" ? data : JSON.stringify(data);
+        console.log(colors.dim(`
+  [${lvl}] ${text}`));
+      } else if (method === "notifications/tools/list_changed") {
+        console.log(colors.yellow("\n  \u27F3 Server tools changed. Run tools/list to see updates."));
+        refreshCaches(target).catch(() => {
+        });
+      } else if (method === "notifications/resources/list_changed") {
+        console.log(colors.yellow("\n  \u27F3 Server resources changed. Run resources/list to see."));
+        refreshCaches(target).catch(() => {
+        });
+      } else if (method === "notifications/resources/updated") {
+        const uri = notification.params?.uri ?? "unknown";
+        console.log(colors.yellow(`
+  \u27F3 Resource updated: ${uri}`));
+      } else if (method === "notifications/prompts/list_changed") {
+        console.log(colors.yellow("\n  \u27F3 Server prompts changed. Run prompts/list to see."));
+        refreshCaches(target).catch(() => {
+        });
+      }
+    });
+    target.on("sampling_request", async ({ request, respond, reject: rejectFn }) => {
+      console.log(colors.magenta("\n  \u2554\u2550\u2550 Sampling Request \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+      const messages = request?.messages ?? [];
+      for (const msg of messages) {
+        const role = msg.role === "user" ? colors.blue("user") : colors.magenta("assistant");
+        const text = msg.content?.text ?? JSON.stringify(msg.content);
+        console.log(colors.magenta(`  \u2551 ${role}: ${text}`));
+      }
+      console.log(colors.magenta("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+      if (activeRl) {
+        try {
+          const answer = await question(activeRl, `  ${colors.bold("Approve? [y/N/text]:")} `);
+          const trimmed = answer.trim().toLowerCase();
+          if (trimmed === "y" || trimmed === "yes") {
+            respond({
+              model: "user-approved",
+              role: "assistant",
+              content: { type: "text", text: "Approved by user." }
+            });
+          } else if (trimmed === "n" || trimmed === "no" || trimmed === "") {
+            rejectFn(new Error("Sampling request rejected by user"));
+          } else {
+            respond({
+              model: "user-provided",
+              role: "assistant",
+              content: { type: "text", text: answer.trim() }
+            });
+          }
+        } catch (err) {
+          if (err instanceof AbortFlowError) {
+            rejectFn(new Error("Sampling request rejected by user"));
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        rejectFn(new Error("No interactive terminal available for sampling approval"));
+      }
+    });
+    target.on("elicitation_request", async ({ request, respond, reject: rejectFn }) => {
+      console.log(colors.cyan("\n  \u2554\u2550\u2550 Elicitation Request \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+      console.log(colors.cyan(`  \u2551 ${request?.message ?? "Server requests input"}`));
+      console.log(colors.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+      if (activeRl) {
+        try {
+          const answer = await question(
+            activeRl,
+            `  ${colors.bold("Your response (empty to decline):")} `
+          );
+          if (answer.trim() === "") {
+            respond({ action: "decline" });
+          } else {
+            try {
+              const parsed = JSON.parse(answer.trim());
+              respond({ action: "accept", content: parsed });
+            } catch {
+              respond({ action: "accept", content: { value: answer.trim() } });
+            }
+          }
+        } catch (err) {
+          if (err instanceof AbortFlowError) {
+            respond({ action: "decline" });
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        rejectFn(new Error("No interactive terminal available for elicitation"));
+      }
+    });
+  }
+  let toolCount;
+  let resourceCount = 0;
+  let promptCount = 0;
+  try {
+    const { tools } = await target.listTools();
+    toolCount = tools.length;
+    const caps = target.getServerCapabilities() ?? {};
+    if (caps.resources) {
+      try {
+        const { resources } = await target.listResources();
+        resourceCount = resources.length;
+      } catch {
       }
-    } else if (answer.type === "raw") {
-      return true;
     }
-    return false;
-  } catch (err) {
-    if (isAbortError(err)) {
-      console.log(pc2.dim("\nShutting down..."));
-      await target.close();
-      process.exit(0);
+    if (caps.prompts) {
+      try {
+        const { prompts } = await target.listPrompts();
+        promptCount = prompts.length;
+      } catch {
+      }
     }
-    throw err;
-  }
-}
-async function mainMenuLoop(target, interceptor) {
-  if (isScriptMode || !process.stdin.isTTY) {
-    startReadlineLoop(target, interceptor);
-    return;
+    const serverInfo = target.getServerVersion();
+    const serverName = serverInfo?.name ?? "MCP Server";
+    const serverVersion = serverInfo?.version ?? "";
+    const isHarness = serverName === "run-mcp";
+    printBanner(serverName, serverVersion, toolCount, resourceCount, promptCount, isHarness);
+    if (toolCount >= 10) {
+      const groups = groupToolsByPrefix(
+        cachedToolNames.length > 0 ? cachedToolNames : tools.map((t) => t.name)
+      );
+      if (!groups.has("All")) {
+        for (const [label, members] of groups) {
+          console.log(`  ${colors.bold(label.padEnd(16))} ${colors.dim(members.join(", "))}`);
+        }
+        console.log();
+      }
+    }
+  } catch (err) {
+    console.log(colors.yellow(`  Warning: Could not list tools: ${err.message}
+`));
   }
-  while (true) {
-    try {
-      const dropToRaw = await showMainMenu(target, interceptor);
-      if (dropToRaw) {
-        console.log(pc2.dim("  Entering raw command mode. Type 'menu' to return."));
-        startReadlineLoop(target, interceptor);
-        break;
+  await refreshCaches(target);
+  if (isScriptMode) {
+    const lines = await readScriptLines(opts.script);
+    const scriptContext = {};
+    let expectError = false;
+    for (const line of lines) {
+      let trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        if (trimmed === "# @expect-error") {
+          expectError = true;
+        }
+        continue;
       }
-    } catch (err) {
-      console.error(pc2.red(`Error in menu: ${err.message}`));
-      startReadlineLoop(target, interceptor);
-      break;
+      if (trimmed.endsWith("# @expect-error")) {
+        expectError = true;
+        trimmed = trimmed.replace(/\s*#\s*@expect-error$/, "");
+      }
+      const interpolated = interpolateString(trimmed, scriptContext);
+      try {
+        const res = await handleCommand(interpolated, target, interceptor);
+        if (res !== void 0) {
+          scriptContext.LAST = res;
+        }
+        const isErrorRes = res && typeof res === "object" && res.isError === true;
+        if (expectError && !isErrorRes) {
+          console.error(colors.red(`\u2717 Expected an error but the command succeeded.`));
+          await target.close();
+          process.exit(1);
+        }
+        if (!expectError && isErrorRes) {
+          console.error(colors.red(`\u2717 Command failed unexpectedly.`));
+          await target.close();
+          process.exit(1);
+        }
+        if (expectError && isErrorRes) {
+          console.log(colors.yellow(`  \u2713 Expected error caught: tool returned isError: true`));
+        }
+      } catch (err) {
+        if (expectError) {
+          console.log(colors.yellow(`  \u2713 Expected error caught: ${err.message}`));
+        } else {
+          if (err?.message?.includes("-32601") || err?.code === -32601) {
+            let msg = "Server does not support this feature (Method not found)";
+            if (trimmed.startsWith("prompts/")) msg = "This server does not have any prompts.";
+            else if (trimmed.startsWith("resources/"))
+              msg = "This server does not have any resources.";
+            else if (trimmed.startsWith("tools/")) msg = "This server does not have any tools.";
+            console.log(colors.yellow(`  ${msg}`));
+          } else {
+            console.error(colors.red(`\u2717 Error: ${err.message}`));
+          }
+          console.log(colors.dim("\nShutting down..."));
+          await target.close();
+          process.exit(1);
+        }
+      }
+      expectError = false;
     }
+    console.log(colors.dim("\nShutting down..."));
+    await target.close();
+    process.exit(0);
+  } else {
+    mainMenuLoop(target, interceptor);
   }
 }
+async function readScriptLines(filepath) {
+  const content = await readFile4(filepath, "utf8");
+  return content.split("\n");
+}
 
 // src/server.ts
 import { createHash } from "crypto";
@@ -3490,7 +4471,7 @@ async function startServer(opts) {
     mediaThresholdKb: opts.mediaThresholdKb
   });
   const mcpServer = new McpServer(
-    { name: "run-mcp", version: "1.6.3" },
+    { name: "run-mcp", version: "1.7.1" },
     {
       capabilities: {
         tools: {},
@@ -3651,7 +4632,15 @@ async function startServer(opts) {
         process.env[key] = value;
       }
     }
-    target = new TargetManager(cmdToUse, argsToUse ?? []);
+    target = new TargetManager(cmdToUse, argsToUse ?? [], {
+      sandbox: opts.sandbox,
+      allowRead: opts.allowRead,
+      allowWrite: opts.allowWrite,
+      allowNet: opts.allowNet,
+      denyRead: opts.denyRead,
+      denyWrite: opts.denyWrite,
+      denyNet: opts.denyNet
+    });
     setupTargetListeners(target);
     try {
       await target.connect();
@@ -3755,10 +4744,11 @@ async function startServer(opts) {
         ),
         summary: z.boolean().optional().describe(
           "If true, returns only the name and description of each primitive (omitting full schemas) when included to save tokens."
-        )
+        ),
+        sandbox: z.enum(["auto", "docker", "native", "audit", "none"]).optional().describe("Sandbox mode to use for this server")
       }
     },
-    async ({ command, args, env, include, summary }) => {
+    async ({ command, args, env, include, summary, sandbox }) => {
       if (target?.connected) {
         return {
           content: [
@@ -3780,7 +4770,15 @@ async function startServer(opts) {
             process.env[key] = value;
           }
         }
-        target = new TargetManager(command, args ?? []);
+        target = new TargetManager(command, args ?? [], {
+          sandbox: sandbox ?? opts.sandbox,
+          allowRead: opts.allowRead,
+          allowWrite: opts.allowWrite,
+          allowNet: opts.allowNet,
+          denyRead: opts.denyRead,
+          denyWrite: opts.denyWrite,
+          denyNet: opts.denyNet
+        });
         setupTargetListeners(target);
         try {
           await target.connect();
@@ -4068,7 +5066,7 @@ Available: ${available}`
     },
     async () => {
       try {
-        const servers = await discoverServers();
+        const servers = await discoverServers({ scan: opts.scan });
         if (servers.length === 0) {
           return {
             content: [
@@ -4115,6 +5113,7 @@ Available: ${available}`
         type: z.enum(["tool", "resource", "prompt"]).describe("The MCP primitive type to invoke"),
         name: z.string().describe("Tool name, resource URI, or prompt name"),
         arguments: z.record(z.unknown()).optional().describe("Arguments for the tool or prompt (not used for resources)"),
+        args: z.record(z.unknown()).optional().describe("Arguments for the tool or prompt (alias for 'arguments')"),
         // Auto-connect params (only needed if not already connected)
         auto_connect: z.object({
           command: z.string().describe("Command to spawn the server (e.g. 'node')."),
@@ -4138,12 +5137,14 @@ Available: ${available}`
       type: primitiveType,
       name,
       arguments: callArgs,
+      args: callArgsAlias,
       auto_connect,
       disconnect_after,
       timeout_ms,
       include_metadata,
       max_text_length
     }) => {
+      const finalArgs = callArgs ?? callArgsAlias;
       try {
         const connectError = await ensureConnected(
           auto_connect?.command,
@@ -4193,14 +5194,14 @@ Available tools: ${toolNames.join(", ")}`
               }
               const schema = matchedTool.inputSchema;
               const requiredProps = schema?.required ?? [];
-              const providedKeys = Object.keys(callArgs ?? {});
+              const providedKeys = Object.keys(finalArgs ?? {});
               const missingProps = requiredProps.filter((p) => !providedKeys.includes(p));
               if (missingProps.length > 0) {
                 return {
                   content: [
                     {
                       type: "text",
-                      text: `Tool "${name}" requires: ${missingProps.join(", ")}. Received: ${JSON.stringify(callArgs ?? {})}`
+                      text: `Tool "${name}" requires: ${missingProps.join(", ")}. Received: ${JSON.stringify(finalArgs ?? {})}`
                     }
                   ],
                   isError: true
@@ -4214,7 +5215,7 @@ Available tools: ${toolNames.join(", ")}`
               const { result: toolResult, metadata } = await interceptor.callToolWithMetadata(
                 target,
                 name,
-                callArgs ?? {},
+                finalArgs ?? {},
                 timeout_ms,
                 max_text_length
               );
@@ -4224,7 +5225,7 @@ Available tools: ${toolNames.join(", ")}`
               result = await interceptor.callTool(
                 target,
                 name,
-                callArgs ?? {},
+                finalArgs ?? {},
                 timeout_ms,
                 max_text_length
               );
@@ -4248,6 +5249,7 @@ Available tools: ${toolNames.join(", ")}`
                 text: `--- metadata ---
 ${JSON.stringify(meta)}`
               });
+              result.meta = meta;
             }
             break;
           }
@@ -4279,6 +5281,7 @@ ${JSON.stringify(meta)}`
                 text: `--- metadata ---
 ${JSON.stringify(meta)}`
               });
+              result.meta = meta;
             }
             break;
           }
@@ -4308,7 +5311,7 @@ Available prompts: ${promptNames.join(", ")}`
               target,
               {
                 name,
-                arguments: callArgs ?? {}
+                arguments: finalArgs ?? {}
               },
               timeout_ms,
               max_text_length
@@ -4347,6 +5350,7 @@ ${item.text}` });
                 text: `--- metadata ---
 ${JSON.stringify(meta)}`
               });
+              result.meta = meta;
             }
             break;
           }
@@ -4396,6 +5400,230 @@ ${JSON.stringify(meta)}`
       };
     }
   );
+  mcpServer.registerTool(
+    "validate_mcp_server",
+    {
+      title: "Validate MCP Server",
+      description: "Attempts to spawn the target MCP server, connect to it, check its tools, collect any stderr/errors, and shut it down cleanly. Returns pass/fail status and captured diagnostics.",
+      inputSchema: {
+        command: z.string().describe("Command to run (e.g. 'node', 'python')"),
+        args: z.array(z.string()).optional().describe("Arguments to pass"),
+        env: z.record(z.string()).optional().describe("Extra environment variables")
+      }
+    },
+    async ({ command, args, env }) => {
+      const originalEnv = {};
+      if (env) {
+        for (const [key, value] of Object.entries(env)) {
+          originalEnv[key] = process.env[key];
+          process.env[key] = value;
+        }
+      }
+      const tempTarget = new TargetManager(command, args ?? [], {
+        sandbox: opts.sandbox,
+        allowRead: opts.allowRead,
+        allowWrite: opts.allowWrite,
+        allowNet: opts.allowNet,
+        denyRead: opts.denyRead,
+        denyWrite: opts.denyWrite,
+        denyNet: opts.denyNet
+      });
+      const stderrLines = [];
+      tempTarget.on("stderr", (text) => {
+        stderrLines.push(text);
+      });
+      try {
+        const connectPromise = tempTarget.connect();
+        const timeoutPromise = new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Connection timed out after 5000ms")), 5e3)
+        );
+        await Promise.race([connectPromise, timeoutPromise]);
+        const toolsResult = await tempTarget.listTools();
+        const caps = tempTarget.getServerCapabilities() ?? {};
+        const ver = tempTarget.getServerVersion();
+        await tempTarget.close();
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Validation Result: SUCCESS
+Server Name: ${ver?.name ?? "unknown"}
+Server Version: ${ver?.version ?? "unknown"}
+Tools Count: ${toolsResult.tools.length}
+Capabilities: ${Object.keys(caps).join(", ") || "none"}
+
+Captured Stderr:
+${stderrLines.join("\n") || "(none)"}`
+            }
+          ]
+        };
+      } catch (err) {
+        await tempTarget.close().catch(() => {
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Validation Result: FAILED
+Error: ${err.message}
+
+Captured Stderr:
+${stderrLines.join("\n") || "(none)"}`
+            }
+          ],
+          isError: true
+        };
+      } finally {
+        if (env) {
+          for (const key of Object.keys(env)) {
+            if (originalEnv[key] === void 0) {
+              delete process.env[key];
+            } else {
+              process.env[key] = originalEnv[key];
+            }
+          }
+        }
+      }
+    }
+  );
+  mcpServer.registerTool(
+    "search_all_local_mcp_servers",
+    {
+      title: "Search All Local MCP Servers",
+      description: "Scans all configured/discovered local MCP servers, connects to them, and searches their tool names/descriptions or resource names/URIs for a query string.",
+      inputSchema: {
+        query: z.string().describe("Search query (case-insensitive substring match)"),
+        type: z.array(z.enum(["tools", "resources", "prompts"])).optional().describe("Primitives to search. Defaults to ['tools'].")
+      }
+    },
+    async ({ query, type }) => {
+      const searchTypes = type ?? ["tools"];
+      const lowerQuery = query.toLowerCase();
+      try {
+        const servers = await discoverServers({ scan: opts.scan });
+        if (servers.length === 0) {
+          return {
+            content: [{ type: "text", text: "No local MCP servers found to search." }]
+          };
+        }
+        const uniqueServers = /* @__PURE__ */ new Map();
+        for (const s of servers) {
+          const key = `${s.name}::${s.config.command}::${(s.config.args || []).join(" ")}`;
+          if (!uniqueServers.has(key)) {
+            uniqueServers.set(key, s);
+          } else if (s.source.includes("Project")) {
+            uniqueServers.set(key, s);
+          }
+        }
+        const matchResults = [];
+        for (const s of uniqueServers.values()) {
+          const originalEnv = {};
+          if (s.config.env) {
+            for (const [key, value] of Object.entries(s.config.env)) {
+              originalEnv[key] = process.env[key];
+              process.env[key] = value;
+            }
+          }
+          const tempTarget = new TargetManager(s.config.command, s.config.args || [], {
+            sandbox: opts.sandbox,
+            allowRead: opts.allowRead,
+            allowWrite: opts.allowWrite,
+            allowNet: opts.allowNet,
+            denyRead: opts.denyRead,
+            denyWrite: opts.denyWrite,
+            denyNet: opts.denyNet
+          });
+          try {
+            await Promise.race([
+              tempTarget.connect(),
+              new Promise(
+                (_, reject) => setTimeout(() => reject(new Error("Timeout")), 3e3)
+              )
+            ]);
+            const caps = tempTarget.getServerCapabilities() ?? {};
+            if (searchTypes.includes("tools") && caps.tools) {
+              const { tools } = await tempTarget.listTools();
+              for (const t of tools) {
+                if (t.name.toLowerCase().includes(lowerQuery) || t.description && t.description.toLowerCase().includes(lowerQuery)) {
+                  matchResults.push({
+                    server: s.name,
+                    primitive: "tool",
+                    name: t.name,
+                    description: t.description
+                  });
+                }
+              }
+            }
+            if (searchTypes.includes("resources") && caps.resources) {
+              const { resources } = await tempTarget.listResources();
+              for (const r of resources) {
+                if (r.name && r.name.toLowerCase().includes(lowerQuery) || r.uri.toLowerCase().includes(lowerQuery) || r.description && r.description.toLowerCase().includes(lowerQuery)) {
+                  matchResults.push({
+                    server: s.name,
+                    primitive: "resource",
+                    name: r.name || r.uri,
+                    uri: r.uri,
+                    description: r.description
+                  });
+                }
+              }
+            }
+            if (searchTypes.includes("prompts") && caps.prompts) {
+              const { prompts } = await tempTarget.listPrompts();
+              for (const p of prompts) {
+                if (p.name.toLowerCase().includes(lowerQuery) || p.description && p.description.toLowerCase().includes(lowerQuery)) {
+                  matchResults.push({
+                    server: s.name,
+                    primitive: "prompt",
+                    name: p.name,
+                    description: p.description
+                  });
+                }
+              }
+            }
+          } catch {
+          } finally {
+            await tempTarget.close().catch(() => {
+            });
+            if (s.config.env) {
+              for (const key of Object.keys(s.config.env)) {
+                if (originalEnv[key] === void 0) {
+                  delete process.env[key];
+                } else {
+                  process.env[key] = originalEnv[key];
+                }
+              }
+            }
+          }
+        }
+        if (matchResults.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No matches found for query "${query}".`
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Search results for "${query}":
+
+${JSON.stringify(matchResults, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error searching servers: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
   const transport = new StdioServerTransport();
   mcpServer.server.onclose = async () => {
     if (target) {
@@ -4410,7 +5638,8 @@ ${JSON.stringify(meta)}`
 
 // src/index.ts
 function requireTargetCommand(targetCommand, subcommandUsage) {
-  if (!activeTargetCommand) {
+  const target = activeTargetCommand ?? targetCommand;
+  if (!target || target.length === 0) {
     process.stderr.write(`Error: Target server command must be separated by '--'.
 `);
     process.stderr.write(`This avoids option parsing conflicts.
@@ -4418,19 +5647,19 @@ function requireTargetCommand(targetCommand, subcommandUsage) {
 `);
     process.stderr.write(`Usage: ${subcommandUsage}
 `);
-    process.exit(2);
+    process.exit(64);
   }
-  return activeTargetCommand;
+  return target;
 }
-var SESSION_DIR = join2(tmpdir2(), "run-mcp", "sessions");
+var SESSION_DIR = join6(tmpdir3(), "run-mcp", "sessions");
 function getSessionPath(name) {
-  return join2(SESSION_DIR, `${name}.json`);
+  return join6(SESSION_DIR, `${name}.json`);
 }
 async function getSession(name) {
   const path2 = getSessionPath(name);
-  if (!existsSync2(path2)) return null;
+  if (!existsSync6(path2)) return null;
   try {
-    const data = await readFile3(path2, "utf8");
+    const data = await readFile5(path2, "utf8");
     const parsed = JSON.parse(data);
     try {
       process.kill(parsed.pid, 0);
@@ -4445,7 +5674,7 @@ async function getSession(name) {
   }
 }
 function sendDaemonRequest(port, request) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const socket = createConnection({ port });
     let buffer = "";
     socket.on("connect", () => {
@@ -4460,7 +5689,7 @@ function sendDaemonRequest(port, request) {
         if (parsed.error) {
           reject(new Error(parsed.error.message));
         } else {
-          resolve2(parsed.result);
+          resolve3(parsed.result);
         }
       } catch (err) {
         reject(new Error(`Failed to parse daemon response: ${err}`));
@@ -4482,11 +5711,16 @@ async function handleHeadlessSession(sessionName, targetCommand, operation, opts
 `);
       process.stderr.write(`Usage: ${subcommandUsage}
 `);
-      process.exit(2);
+      process.exit(64);
     }
     const target = activeTargetCommand;
-    const binPath = resolve(import.meta.dirname, "./index.js");
-    const daemonProcess = spawn("node", [binPath, "daemon", sessionName, ...target], {
+    const binPath = resolve2(import.meta.dirname, "./index.js");
+    const daemonArgs = ["daemon", sessionName];
+    if (opts.sandbox) {
+      daemonArgs.push("--sandbox", opts.sandbox);
+    }
+    daemonArgs.push(...target);
+    const daemonProcess = spawn("node", [binPath, ...daemonArgs], {
       detached: true,
       stdio: "ignore"
     });
@@ -4495,7 +5729,7 @@ async function handleHeadlessSession(sessionName, targetCommand, operation, opts
     while (attempts < 50) {
       session = await getSession(sessionName);
       if (session) break;
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      await new Promise((resolve3) => setTimeout(resolve3, 100));
       attempts++;
     }
     if (!session) {
@@ -4528,7 +5762,14 @@ function parseHeadlessOpts(opts) {
     timeoutMs: opts.timeout ? Number.parseInt(opts.timeout, 10) : void 0,
     raw: opts.raw,
     showStderr: opts.showStderr,
-    mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0
+    mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0,
+    sandbox: opts.sandbox,
+    allowRead: opts.allowRead,
+    allowWrite: opts.allowWrite,
+    allowNet: opts.allowNet,
+    denyRead: opts.denyRead,
+    denyWrite: opts.denyWrite,
+    denyNet: opts.denyNet
   };
 }
 var activeTargetCommand;
@@ -4542,7 +5783,7 @@ program.enablePositionalOptions();
 program.command("call").argument("<tool>", "Tool name to call").argument("[json_args]", "JSON arguments for the tool").argument("[target_command...]", "Target server command (after --)").description("Call a tool on a target MCP server and print the result as JSON").option("-o, --out-dir <path>", "Output directory for saved media").option("-t, --timeout <ms>", "Timeout in milliseconds (default: 30000)").option(
   "-m, --media-threshold <kb>",
   "Media size threshold in KB to save to disk (0 to always save, -1 to keep inline)"
-).option("--raw", "Print the full result object including metadata").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(
+).option("--raw", "Print the full result object including metadata").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").option("--sandbox <mode>", "Sandbox execution mode: auto, docker, native, audit, none", "none").allowUnknownOption().action(
   async (tool, jsonArgs, targetCommand, opts) => {
     const operation = { type: "call", tool, args: jsonArgs };
     const parsedOpts = parseHeadlessOpts(opts);
@@ -4563,7 +5804,7 @@ program.command("call").argument("<tool>", "Tool name to call").argument("[json_
     }
   }
 );
-program.command("list-tools").argument("[target_command...]", "Target server command (after --)").description("List all tools on a target MCP server as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (targetCommand, opts) => {
+program.command("list-tools").argument("[target_command...]", "Target server command (after --)").description("List all tools on a target MCP server as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").option("--sandbox <mode>", "Sandbox execution mode: auto, docker, native, audit, none", "none").allowUnknownOption().action(async (targetCommand, opts) => {
   const operation = { type: "list-tools" };
   const parsedOpts = parseHeadlessOpts(opts);
   if (opts.session) {
@@ -4582,7 +5823,7 @@ program.command("list-tools").argument("[target_command...]", "Target server com
     await runHeadless(target, operation, parsedOpts);
   }
 });
-program.command("list-resources").argument("[target_command...]", "Target server command (after --)").description("List all resources on a target MCP server as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (targetCommand, opts) => {
+program.command("list-resources").argument("[target_command...]", "Target server command (after --)").description("List all resources on a target MCP server as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").option("--sandbox <mode>", "Sandbox execution mode: auto, docker, native, audit, none", "none").allowUnknownOption().action(async (targetCommand, opts) => {
   const operation = { type: "list-resources" };
   const parsedOpts = parseHeadlessOpts(opts);
   if (opts.session) {
@@ -4601,7 +5842,7 @@ program.command("list-resources").argument("[target_command...]", "Target server
     await runHeadless(target, operation, parsedOpts);
   }
 });
-program.command("list-prompts").argument("[target_command...]", "Target server command (after --)").description("List all prompts on a target MCP server as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (targetCommand, opts) => {
+program.command("list-prompts").argument("[target_command...]", "Target server command (after --)").description("List all prompts on a target MCP server as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").option("--sandbox <mode>", "Sandbox execution mode: auto, docker, native, audit, none", "none").allowUnknownOption().action(async (targetCommand, opts) => {
   const operation = { type: "list-prompts" };
   const parsedOpts = parseHeadlessOpts(opts);
   if (opts.session) {
@@ -4623,7 +5864,7 @@ program.command("list-prompts").argument("[target_command...]", "Target server c
 program.command("read").argument("<uri>", "Resource URI to read").argument("[target_command...]", "Target server command (after --)").description("Read a resource by URI from a target MCP server").option(
   "-m, --media-threshold <kb>",
   "Media size threshold in KB to save to disk (0 to always save, -1 to keep inline)"
-).option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (uri, targetCommand, opts) => {
+).option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").option("--sandbox <mode>", "Sandbox execution mode: auto, docker, native, audit, none", "none").allowUnknownOption().action(async (uri, targetCommand, opts) => {
   const operation = { type: "read", uri };
   const parsedOpts = parseHeadlessOpts(opts);
   if (opts.session) {
@@ -4642,7 +5883,7 @@ program.command("read").argument("<uri>", "Resource URI to read").argument("[tar
     await runHeadless(target, operation, parsedOpts);
   }
 });
-program.command("describe").argument("<tool>", "Tool name to describe").argument("[target_command...]", "Target server command (after --)").description("Print a tool's full schema as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(async (tool, targetCommand, opts) => {
+program.command("describe").argument("<tool>", "Tool name to describe").argument("[target_command...]", "Target server command (after --)").description("Print a tool's full schema as JSON").option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").option("--sandbox <mode>", "Sandbox execution mode: auto, docker, native, audit, none", "none").allowUnknownOption().action(async (tool, targetCommand, opts) => {
   const operation = { type: "describe", tool };
   const parsedOpts = parseHeadlessOpts(opts);
   if (opts.session) {
@@ -4664,7 +5905,7 @@ program.command("describe").argument("<tool>", "Tool name to describe").argument
 program.command("get-prompt").argument("<name>", "Prompt name").argument("[json_args]", "JSON arguments for the prompt").argument("[target_command...]", "Target server command (after --)").description("Get a prompt with optional arguments from a target MCP server").option(
   "-m, --media-threshold <kb>",
   "Media size threshold in KB to save to disk (0 to always save, -1 to keep inline)"
-).option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").allowUnknownOption().action(
+).option("--show-stderr", "Stream target server stderr to process stderr").option("--session <name>", "Persistent session name").option("--sandbox <mode>", "Sandbox execution mode: auto, docker, native, audit, none", "none").allowUnknownOption().action(
   async (name, jsonArgs, targetCommand, opts) => {
     const operation = { type: "get-prompt", name, args: jsonArgs };
     const parsedOpts = parseHeadlessOpts(opts);
@@ -4685,17 +5926,19 @@ program.command("get-prompt").argument("<name>", "Prompt name").argument("[json_
     }
   }
 );
-program.command("daemon").argument("<session_name>", "Session name").argument("[target_command...]", "Target server command").description("Start run-mcp in background session daemon mode").allowUnknownOption().action(async (sessionName, targetCommand) => {
+program.command("daemon").argument("<session_name>", "Session name").argument("[target_command...]", "Target server command").description("Start run-mcp in background session daemon mode").option("--sandbox <mode>", "Sandbox execution mode: auto, docker, native, audit, none", "none").allowUnknownOption().action(async (sessionName, targetCommand, opts) => {
   const targetCmd = activeTargetCommand ?? targetCommand;
   if (!targetCmd || targetCmd.length === 0) {
     process.stderr.write("Error: No target command provided for daemon.\n");
-    process.exit(1);
+    process.exit(64);
   }
   const server = createServer();
   server.listen(0, "127.0.0.1", async () => {
     const addr = server.address();
     const port = addr.port;
-    const target = new TargetManager(targetCmd[0], targetCmd.slice(1));
+    const target = new TargetManager(targetCmd[0], targetCmd.slice(1), {
+      sandbox: opts.sandbox
+    });
     const interceptor = new ResponseInterceptor();
     try {
       await target.connect();
@@ -4704,8 +5947,8 @@ program.command("daemon").argument("<session_name>", "Session name").argument("[
 `);
       process.exit(1);
     }
-    await mkdir2(SESSION_DIR, { recursive: true });
-    await writeFile2(
+    await mkdir3(SESSION_DIR, { recursive: true });
+    await writeFile3(
       getSessionPath(sessionName),
       JSON.stringify({ port, pid: process.pid }),
       "utf8"
@@ -4722,12 +5965,12 @@ program.command("daemon").argument("<session_name>", "Session name").argument("[
           try {
             const req = JSON.parse(trimmed);
             if (req.method === "execute") {
-              const { operation, opts } = req.params;
+              const { operation, opts: opts2 } = req.params;
               const { result, hasError } = await executeOperation(
                 target,
                 interceptor,
                 operation,
-                opts
+                opts2
               );
               socket.write(
                 JSON.stringify({ jsonrpc: "2.0", result: { result, hasError }, id: req.id }) + "\n"
@@ -4778,7 +6021,7 @@ program.command("close-session").argument("<session_name>", "Session name").desc
     }
   }
 });
-program.name("run-mcp").description("A smart interactive REPL and live test harness for MCP servers").version("1.6.3").passThroughOptions().allowUnknownOption().argument(
+program.name("run-mcp").description("A smart interactive REPL and live test harness for MCP servers").version("1.7.1").passThroughOptions().allowUnknownOption().argument(
   "[target_command...]",
   "Command to spawn the target MCP server (starts REPL if provided, Agent server otherwise)"
 ).option("-o, --out-dir <path>", "Directory to save intercepted images and audio").option(
@@ -4790,7 +6033,13 @@ program.name("run-mcp").description("A smart interactive REPL and live test harn
 ).option(
   "-m, --media-threshold <kb>",
   "Media size threshold in KB to save to disk (0 to always save, -1 to keep inline)"
-).option("--mcp", "Force start Agent Server mode even if run interactively without arguments").option("-s, --script <file>", "Read commands from a file instead of stdin (REPL Mode only)").addHelpText(
+).option("--mcp", "Force start Agent Server mode even if run interactively without arguments").option("-s, --script <file>", "Read commands from a file instead of stdin (REPL Mode only)").option("--color <mode>", "Color output mode: always, never, auto (default: auto)").option(
+  "--open-media",
+  "Automatically open intercepted images and audio files using the host OS viewer"
+).option("--sandbox <mode>", "Sandbox execution mode: auto, docker, native, audit, none", "none").option(
+  "--scan",
+  "Scan the current workspace and parent directories for any JSON files containing mcpServers"
+).addHelpText(
   "after",
   `
 Examples:
@@ -4827,6 +6076,8 @@ Agent Mode Tools:
   disconnect_from_mcp  \u2192 Tear down and reconnect after changes
   mcp_server_status    \u2192 Check connection status
   get_mcp_server_stderr \u2192 View target server stderr output
+  validate_mcp_server  \u2192 Validate an MCP server command and collect diagnostics
+  search_all_local_mcp_servers \u2192 Scan and search all local MCP servers for a query
 
 REPL Mode Commands (once connected):
   tools/list                          List all available tools
@@ -4855,18 +6106,20 @@ REPL Mode Commands (once connected):
 Shortcuts: tl td tc ts rl rr rt rs ru pl pg (see help for details)`
 ).action(
   async (targetCommand, opts) => {
-    if (targetCommand && targetCommand.length > 0 && !activeTargetCommand) {
-      process.stderr.write(
-        "Error: Target server command must be separated by '--'.\nThis avoids argument parsing ambiguity.\n\nExample:\n  run-mcp -- node my-server.js\n  run-mcp -s script.txt -- node my-server.js\n"
-      );
-      process.exit(1);
-    }
-    const target = activeTargetCommand ?? [];
+    const target = activeTargetCommand ?? targetCommand ?? [];
     if (target && target.length > 0) {
       await startRepl(target, {
         script: opts.script,
         outDir: opts.outDir,
-        mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0
+        mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0,
+        openMedia: opts.openMedia,
+        sandbox: opts.sandbox,
+        allowRead: opts.allowRead,
+        allowWrite: opts.allowWrite,
+        allowNet: opts.allowNet,
+        denyRead: opts.denyRead,
+        denyWrite: opts.denyWrite,
+        denyNet: opts.denyNet
       });
     } else {
       if (opts.mcp || !process.stdin.isTTY) {
@@ -4874,10 +6127,18 @@ Shortcuts: tl td tc ts rl rr rt rs ru pl pg (see help for details)`
           outDir: opts.outDir,
           timeoutMs: opts.timeout ? Number.parseInt(opts.timeout, 10) : void 0,
           maxTextLength: opts.maxText ? Number.parseInt(opts.maxText, 10) : void 0,
-          mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0
+          mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0,
+          sandbox: opts.sandbox,
+          allowRead: opts.allowRead,
+          allowWrite: opts.allowWrite,
+          allowNet: opts.allowNet,
+          denyRead: opts.denyRead,
+          denyWrite: opts.denyWrite,
+          denyNet: opts.denyNet,
+          scan: opts.scan
         });
       } else {
-        const selected = await pickDiscoveredServer();
+        const selected = await pickDiscoveredServer({ scan: opts.scan });
         if (!selected) {
           console.log("Run 'run-mcp --help' to see manual usage instructions.");
           return;
@@ -4888,10 +6149,26 @@ Shortcuts: tl td tc ts rl rr rt rs ru pl pg (see help for details)`
         await startRepl([selected.config.command, ...selected.config.args || []], {
           script: opts.script,
           outDir: opts.outDir,
-          mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0
+          mediaThresholdKb: opts.mediaThreshold ? Number.parseInt(opts.mediaThreshold, 10) : void 0,
+          openMedia: opts.openMedia,
+          sandbox: opts.sandbox,
+          allowRead: opts.allowRead,
+          allowWrite: opts.allowWrite,
+          allowNet: opts.allowNet,
+          denyRead: opts.denyRead,
+          denyWrite: opts.denyWrite,
+          denyNet: opts.denyNet
         });
       }
     }
   }
 );
+for (const cmd of [program, ...program.commands]) {
+  if (cmd.options.some((o) => o.long === "--sandbox")) {
+    cmd.option("--allow-read <paths...>", "Paths to allow reading under the sandbox").option("--allow-write <paths...>", "Paths to allow writing under the sandbox").option(
+      "--allow-net <domains...>",
+      "Network domains to allow connecting to under the sandbox"
+    ).option("--deny-read <paths...>", "Paths to deny reading under the sandbox").option("--deny-write <paths...>", "Paths to deny writing under the sandbox").option("--deny-net <domains...>", "Network domains to deny connecting to under the sandbox");
+  }
+}
 program.parse(argvToParse);