@enactprotocol/mcp-server 1.2.4 → 1.2.6

package/dist/index.js

@@ -235541,6 +235541,49 @@ class DaggerExecutionProvider extends ExecutionProvider {
       });
     });
   }
+  async setupDirectoryMount(client, container, mountSpec) {
+    try {
+      let localPath2;
+      let containerPath;
+      const colonIndex = mountSpec.indexOf(":");
+      if (colonIndex > 0) {
+        const potentialDriveLetter = mountSpec.substring(0, colonIndex);
+        const isWindowsDrive = potentialDriveLetter.length === 1 && /[A-Za-z]/.test(potentialDriveLetter);
+        if (isWindowsDrive) {
+          const nextColonIndex = mountSpec.indexOf(":", colonIndex + 1);
+          if (nextColonIndex > 0) {
+            localPath2 = mountSpec.substring(0, nextColonIndex);
+            containerPath = mountSpec.substring(nextColonIndex + 1);
+          } else {
+            localPath2 = mountSpec;
+            containerPath = "/workspace/src";
+          }
+        } else {
+          localPath2 = mountSpec.substring(0, colonIndex);
+          containerPath = mountSpec.substring(colonIndex + 1);
+        }
+      } else if (colonIndex === 0) {
+        localPath2 = "";
+        containerPath = mountSpec.substring(1);
+      } else {
+        localPath2 = mountSpec;
+        containerPath = "/workspace/src";
+      }
+      const path7 = __require("path");
+      const resolvedLocalPath = path7.resolve(localPath2);
+      const fs4 = __require("fs");
+      if (!fs4.existsSync(resolvedLocalPath)) {
+        throw new Error(`Mount source directory does not exist: ${resolvedLocalPath}`);
+      }
+      const hostDirectory = client.host().directory(resolvedLocalPath);
+      container = container.withMountedDirectory(containerPath, hostDirectory);
+      logger_default.debug(`\uD83D\uDCC2 Mounted ${resolvedLocalPath} -> ${containerPath}`);
+      return container;
+    } catch (error) {
+      logger_default.error(`Failed to setup directory mount: ${error}`);
+      throw error;
+    }
+  }
   async setupContainer(client, environment, inputs, tool) {
     const containerImage = tool?.from || this.options.baseImage;
     logger_default.debug(`\uD83D\uDE80 Setting up container with image: ${containerImage}${tool?.from ? " (from tool.from)" : " (default baseImage)"}`);
@@ -235548,6 +235591,9 @@ class DaggerExecutionProvider extends ExecutionProvider {
     logger_default.debug("\uD83D\uDCE6 Base container created");
     container = container.withWorkdir(this.options.workdir);
     logger_default.debug(`\uD83D\uDCC1 Working directory set to: ${this.options.workdir}`);
+    if (environment.mount) {
+      container = await this.setupDirectoryMount(client, container, environment.mount);
+    }
     for (const [key, value] of Object.entries(environment.vars)) {
       container = container.withEnvVariable(key, String(value));
     }
@@ -238982,7 +239028,10 @@ class EnactCore {
         throw new Error(`Tool ${tool.name} does not have any signatures`);
       }
       const documentForVerification = {
-        command: tool.command
+        command: tool.command,
+        description: tool.description,
+        from: tool.from,
+        name: tool.name
       };
       const referenceSignature = {
         signature: tool.signatures[0].value,
@@ -238990,12 +239039,11 @@ class EnactCore {
         algorithm: tool.signatures[0].algorithm,
         timestamp: new Date(tool.signatures[0].created).getTime()
       };
-      const canonicalDoc = SigningService.getCanonicalDocument(documentForVerification, { includeFields: ["command"] });
+      const canonicalDoc = SigningService.getCanonicalDocument(documentForVerification, { includeFields: ["command", "description", "from", "name"] });
       const docString = JSON.stringify(canonicalDoc);
       const messageHash = CryptoUtils.hash(docString);
       const directVerify = CryptoUtils.verify(referenceSignature.publicKey, messageHash, referenceSignature.signature);
-      const isValid2 = SigningService.verifyDocument(documentForVerification, referenceSignature, { includeFields: ["command"] });
-      console.log("Final verification result:", isValid2);
+      const isValid2 = SigningService.verifyDocument(documentForVerification, referenceSignature, { includeFields: ["command", "description", "from", "name"] });
       if (!isValid2) {
         throw new Error(`Tool ${tool.name} has invalid signatures`);
       }
@@ -239025,7 +239073,8 @@ class EnactCore {
         vars: { ...envVars, ...validatedInputs },
         resources: {
           timeout: options.timeout || tool.timeout || this.options.defaultTimeout
-        }
+        },
+        mount: options.mount
       });
     } catch (error) {
       return {
@@ -239181,577 +239230,154 @@ class EnactCore {
     return `exec_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
   }
 }
-// ../shared/dist/utils/help.js
-var __dirname = "/Users/keithgroves/projects/enact/enact-cli/packages/shared/dist/utils";
-// ../shared/dist/utils/logger.js
-var LogLevel;
-(function(LogLevel2) {
-  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-  LogLevel2[LogLevel2["SUCCESS"] = 2] = "SUCCESS";
-  LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
-  LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
-})(LogLevel || (LogLevel = {}));
-var currentLogLevel = LogLevel.INFO;
-// ../shared/dist/utils/silent-monitor.js
-class McpSilentOperationMonitor {
-  getOriginalConsoleError() {
-    return this.originalConsoleError;
-  }
-  constructor() {
-    this.isMonitoring = false;
-    this.violations = [];
-    this.consoleOutput = [];
-    this.processExitAttempts = 0;
-    this.readlineUsageDetected = false;
-    this.startTime = 0;
-    this.originalConsoleLog = console.log;
-    this.originalConsoleError = console.error;
-    this.originalConsoleWarn = console.warn;
-    this.originalConsoleInfo = console.info;
-    this.originalProcessExit = process.exit;
-    this.originalStdoutWrite = process.stdout.write;
-    this.originalStderrWrite = process.stderr.write;
+// ../shared/dist/LocalToolResolver.js
+var yaml2 = __toESM(require_dist3(), 1);
+import { promises as fs5, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { join as join4, resolve, basename as basename2 } from "path";
+class LocalToolResolver {
+  constructor(enactCore, localToolsDir = "./tools", cacheDir = "./.tool-cache") {
+    this.enactCore = enactCore;
+    this.toolCache = new Map;
+    this.aliases = new Map;
+    this.favorites = new Set;
+    this.localToolsDir = resolve(localToolsDir);
+    this.cacheDir = resolve(cacheDir);
+    this.loadConfiguration();
   }
-  startMonitoring() {
-    if (this.isMonitoring) {
-      return;
+  async resolveTool(toolName) {
+    const resolvedName = this.aliases.get(toolName) || toolName;
+    const localTool = await this.getLocalTool(resolvedName);
+    if (localTool) {
+      return {
+        tool: localTool,
+        source: "local",
+        metadata: { path: localTool.path }
+      };
     }
-    this.isMonitoring = true;
-    this.violations = [];
-    this.consoleOutput = [];
-    this.processExitAttempts = 0;
-    this.readlineUsageDetected = false;
-    this.startTime = Date.now();
-    console.log = (...args) => {
-      const message = args.join(" ");
-      this.consoleOutput.push(`[LOG] ${message}`);
-      this.violations.push(`Console.log called: ${message}`);
-    };
-    console.error = (...args) => {
-      const message = args.join(" ");
-      this.consoleOutput.push(`[ERROR] ${message}`);
-      this.violations.push(`Console.error called: ${message}`);
-    };
-    console.warn = (...args) => {
-      const message = args.join(" ");
-      this.consoleOutput.push(`[WARN] ${message}`);
-      this.violations.push(`Console.warn called: ${message}`);
-    };
-    console.info = (...args) => {
-      const message = args.join(" ");
-      this.consoleOutput.push(`[INFO] ${message}`);
-      this.violations.push(`Console.info called: ${message}`);
-    };
-    process.exit = (code) => {
-      this.processExitAttempts++;
-      this.violations.push(`Process.exit called with code: ${code}`);
-      throw new Error(`Process exit intercepted: ${code}`);
-    };
-    process.stdout.write = (chunk, ...args) => {
-      if (typeof chunk === "string" && chunk.trim()) {
-        this.consoleOutput.push(`[STDOUT] ${chunk}`);
-        this.violations.push(`Process.stdout.write called: ${chunk.substring(0, 100)}...`);
-      }
-      return true;
-    };
-    process.stderr.write = (chunk, ...args) => {
-      if (typeof chunk === "string" && chunk.trim()) {
-        this.consoleOutput.push(`[STDERR] ${chunk}`);
-        this.violations.push(`Process.stderr.write called: ${chunk.substring(0, 100)}...`);
-      }
-      return true;
-    };
-    const originalRequire = __require;
-    const monitor = this;
-    global.require = function(id) {
-      if (id === "readline" || id.includes("readline")) {
-        monitor.readlineUsageDetected = true;
-        monitor.violations.push("Readline module usage detected");
+    const cachedTool = this.toolCache.get(resolvedName);
+    if (cachedTool && !this.isCacheExpired(cachedTool)) {
+      return {
+        tool: cachedTool,
+        source: "cache",
+        metadata: { cachedAt: cachedTool.lastModified }
+      };
+    }
+    try {
+      const registryTool = await this.enactCore.getToolByName(resolvedName);
+      if (registryTool) {
+        await this.cacheRegistryTool(resolvedName, registryTool);
+        return {
+          tool: registryTool,
+          source: "registry",
+          metadata: { cached: true }
+        };
       }
-      return originalRequire.apply(this, arguments);
-    };
-  }
-  stopMonitoring() {
-    if (!this.isMonitoring) {
-      throw new Error("Monitor is not currently running");
+    } catch (error) {
+      logger_default.debug(`Registry lookup failed for ${resolvedName}:`, error);
     }
-    console.log = this.originalConsoleLog;
-    console.error = this.originalConsoleError;
-    console.warn = this.originalConsoleWarn;
-    console.info = this.originalConsoleInfo;
-    process.exit = this.originalProcessExit;
-    process.stdout.write = this.originalStdoutWrite;
-    process.stderr.write = this.originalStderrWrite;
-    global.require = __require;
-    this.isMonitoring = false;
-    return {
-      violations: [...this.violations],
-      consoleOutputDetected: [...this.consoleOutput],
-      processExitAttempts: this.processExitAttempts,
-      readlineUsageDetected: this.readlineUsageDetected,
-      duration: Date.now() - this.startTime,
-      timestamp: new Date().toISOString()
-    };
+    return null;
   }
-  isCurrentlyMonitoring() {
-    return this.isMonitoring;
+  async getLocalTool(toolName) {
+    const possiblePaths = [
+      join4(this.localToolsDir, `${toolName}.yaml`),
+      join4(this.localToolsDir, `${toolName}.yml`),
+      join4(this.localToolsDir, toolName, "tool.yaml"),
+      join4(this.localToolsDir, toolName, "tool.yml"),
+      join4(this.localToolsDir, toolName, `${toolName}.yaml`),
+      join4(this.localToolsDir, toolName, `${toolName}.yml`)
+    ];
+    for (const toolPath of possiblePaths) {
+      try {
+        const stats = await fs5.stat(toolPath);
+        const content = await fs5.readFile(toolPath, "utf-8");
+        const definition = yaml2.parse(content);
+        if (definition && (definition.name === toolName || definition.name === undefined)) {
+          return {
+            name: definition.name || toolName,
+            path: toolPath,
+            definition,
+            lastModified: stats.mtime,
+            cached: false
+          };
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    return null;
   }
-  getViolations() {
-    return [...this.violations];
+  async cacheRegistryTool(toolName, tool) {
+    try {
+      await fs5.mkdir(this.cacheDir, { recursive: true });
+      const cachePath = join4(this.cacheDir, `${toolName}.yaml`);
+      const cacheData = {
+        ...tool,
+        _cached: true,
+        _cachedAt: new Date().toISOString(),
+        _source: "registry"
+      };
+      await fs5.writeFile(cachePath, yaml2.stringify(cacheData));
+      this.toolCache.set(toolName, {
+        name: toolName,
+        path: cachePath,
+        definition: tool,
+        lastModified: new Date,
+        cached: true
+      });
+      logger_default.debug(`Cached registry tool: ${toolName}`);
+    } catch (error) {
+      logger_default.warn(`Failed to cache tool ${toolName}:`, error);
+    }
   }
-}
-var globalMonitor = new McpSilentOperationMonitor;
-function validateSilentEnvironment() {
-  const issues = [];
-  if (process.env.CI !== "true") {
-    issues.push('CI environment variable not set to "true"');
+  isCacheExpired(tool, maxAge = 24 * 60 * 60 * 1000) {
+    return Date.now() - tool.lastModified.getTime() > maxAge;
   }
-  if (process.env.ENACT_SKIP_INTERACTIVE !== "true") {
-    issues.push('ENACT_SKIP_INTERACTIVE not set to "true"');
+  async listAllTools() {
+    const localTools = await this.scanLocalTools();
+    const cachedTools = Array.from(this.toolCache.values());
+    return {
+      local: localTools,
+      cached: cachedTools,
+      favorites: Array.from(this.favorites),
+      aliases: Object.fromEntries(this.aliases)
+    };
   }
-  if (process.env.DEBUG === "true" || process.env.VERBOSE === "true") {
-    issues.push("DEBUG or VERBOSE environment variables are enabled");
-  }
-  if (process.stdin.isTTY) {
-    issues.push("Process is running in TTY mode (potentially interactive)");
-  }
-  return {
-    valid: issues.length === 0,
-    issues
-  };
-}
-// ../shared/dist/utils/version.js
-var __filename = "/Users/keithgroves/projects/enact/enact-cli/packages/shared/dist/utils/version.js";
-// ../shared/dist/web/env-manager-server.js
-import { createServer } from "http";
-import { parse as parse3 } from "url";
-import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, readdir, stat as stat2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4, dirname as dirname3 } from "path";
-import { homedir as homedir4 } from "os";
-import { fileURLToPath as fileURLToPath4 } from "url";
-var __filename3 = fileURLToPath4(import.meta.url);
-var __dirname3 = dirname3(__filename3);
-var CONFIG_DIR3 = join4(homedir4(), ".enact");
-var ENV_BASE_DIR = join4(CONFIG_DIR3, "env");
-function findStaticDir() {
-  const candidates = [
-    join4(__dirname3, "web", "static"),
-    join4(__dirname3, "static"),
-    join4(__dirname3, "..", "src", "web", "static"),
-    join4(__dirname3, "..", "..", "src", "web", "static"),
-    join4(process.cwd(), "src", "web", "static"),
-    join4(__dirname3, "..", "..", "..", "src", "web", "static"),
-    join4(__dirname3, "..", "..", "src", "web", "static")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync4(join4(candidate, "index.html"))) {
-      logger_default.debug(`Found static directory: ${candidate}`);
-      return candidate;
-    }
-  }
-  throw new Error("Could not find static directory. Tried: " + candidates.join(", "));
-}
-var STATIC_DIR = findStaticDir();
-function parseDotEnv(content) {
-  const vars = {};
-  const lines = content.split(`
-`);
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      continue;
-    }
-    const equalIndex = trimmed.indexOf("=");
-    if (equalIndex === -1) {
-      continue;
-    }
-    const key = trimmed.slice(0, equalIndex).trim();
-    let value = trimmed.slice(equalIndex + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    if (key) {
-      vars[key] = value;
-    }
-  }
-  return vars;
-}
-function generateDotEnv(vars) {
-  return Object.entries(vars).map(([key, value]) => {
-    const needsQuotes = value.includes(" ") || value.includes("\t") || value.includes(`
-`) || value.includes('"');
-    const escapedValue = needsQuotes ? `"${value.replace(/"/g, "\\\"")}"` : value;
-    return `${key}=${escapedValue}`;
-  }).join(`
-`) + `
-`;
-}
-async function getAllPackageNamespaces() {
-  const packages = [];
-  if (!existsSync4(ENV_BASE_DIR)) {
-    return packages;
-  }
-  try {
-    await scanDirectory(ENV_BASE_DIR, "", packages);
-  } catch (error) {
-    logger_default.error("Failed to scan env directory:", error);
-  }
-  return packages;
-}
-async function scanDirectory(dir, relativePath, packages) {
-  try {
-    const entries = await readdir(dir);
-    for (const entry of entries) {
-      const fullPath = join4(dir, entry);
-      const stats = await stat2(fullPath);
-      if (stats.isDirectory()) {
-        const newRelativePath = relativePath ? `${relativePath}/${entry}` : entry;
-        await scanDirectory(fullPath, newRelativePath, packages);
-      } else if (entry === ".env") {
-        const namespace = relativePath || "root";
-        try {
-          const content = await readFile3(fullPath, "utf8");
-          const variables = parseDotEnv(content);
-          packages.push({
-            namespace,
-            path: fullPath,
-            variables
-          });
-        } catch (error) {
-          logger_default.error(`Failed to read .env file at ${fullPath}:`, error);
-        }
-      }
-    }
-  } catch (error) {
-    logger_default.error(`Failed to scan directory ${dir}:`, error);
-  }
-}
-async function getPackageEnvVars(namespace) {
-  const envFile = join4(ENV_BASE_DIR, namespace, ".env");
-  if (!existsSync4(envFile)) {
-    return {};
-  }
-  try {
-    const content = await readFile3(envFile, "utf8");
-    return parseDotEnv(content);
-  } catch (error) {
-    logger_default.error(`Failed to read env file for ${namespace}:`, error);
-    return {};
-  }
-}
-async function setPackageEnvVar(namespace, key, value) {
-  const envFile = join4(ENV_BASE_DIR, namespace, ".env");
-  const envDir = dirname3(envFile);
-  if (!existsSync4(envDir)) {
-    await mkdir2(envDir, { recursive: true });
-  }
-  const existingVars = await getPackageEnvVars(namespace);
-  existingVars[key] = value;
-  const envContent = generateDotEnv(existingVars);
-  await writeFile2(envFile, envContent, "utf8");
-}
-async function deletePackageEnvVar(namespace, key) {
-  const existingVars = await getPackageEnvVars(namespace);
-  if (!(key in existingVars)) {
-    throw new Error(`Environment variable '${key}' not found in package '${namespace}'`);
-  }
-  delete existingVars[key];
-  const envFile = join4(ENV_BASE_DIR, namespace, ".env");
-  const envContent = generateDotEnv(existingVars);
-  await writeFile2(envFile, envContent, "utf8");
-}
-async function serveStaticFile(filePath, res) {
-  try {
-    const content = await readFile3(filePath, "utf8");
-    const ext = filePath.split(".").pop()?.toLowerCase();
-    let contentType = "text/plain";
-    switch (ext) {
-      case "html":
-        contentType = "text/html";
-        break;
-      case "css":
-        contentType = "text/css";
-        break;
-      case "js":
-        contentType = "application/javascript";
-        break;
-      case "json":
-        contentType = "application/json";
-        break;
-    }
-    res.writeHead(200, { "Content-Type": contentType });
-    res.end(content);
-  } catch (error) {
-    logger_default.error("Error serving static file:", error);
-    res.writeHead(404, { "Content-Type": "text/plain" });
-    res.end("File not found");
-  }
-}
-async function handleRequest(req, res) {
-  const urlParts = parse3(req.url || "", true);
-  const pathname = urlParts.pathname || "/";
-  const method = req.method || "GET";
-  res.setHeader("Access-Control-Allow-Origin", "*");
-  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
-  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-  if (method === "OPTIONS") {
-    res.writeHead(200);
-    res.end();
-    return;
-  }
-  try {
-    if (pathname === "/") {
-      await serveStaticFile(join4(STATIC_DIR, "index.html"), res);
-    } else if (pathname === "/style.css") {
-      await serveStaticFile(join4(STATIC_DIR, "style.css"), res);
-    } else if (pathname === "/app.js") {
-      await serveStaticFile(join4(STATIC_DIR, "app.js"), res);
-    } else if (pathname === "/favicon.ico") {
-      const favicon = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><text y=".9em" font-size="90">\uD83C\uDF10</text></svg>`;
-      res.writeHead(200, { "Content-Type": "image/svg+xml" });
-      res.end(favicon);
-    } else if (pathname === "/api/packages" && method === "GET") {
-      const packages = await getAllPackageNamespaces();
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ packages }));
-    } else if (pathname === "/api/packages" && method === "POST") {
-      const body = await getRequestBody(req);
-      const { namespace } = JSON.parse(body);
-      if (!namespace) {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Namespace is required" }));
-        return;
-      }
-      const envDir = join4(ENV_BASE_DIR, namespace);
-      const envFile = join4(envDir, ".env");
-      if (!existsSync4(envDir)) {
-        await mkdir2(envDir, { recursive: true });
-      }
-      if (!existsSync4(envFile)) {
-        await writeFile2(envFile, "", "utf8");
-      }
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ success: true }));
-    } else if (pathname?.startsWith("/api/packages/") && method === "GET") {
-      const namespace = decodeURIComponent(pathname.replace("/api/packages/", ""));
-      const variables = await getPackageEnvVars(namespace);
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ namespace, variables }));
-    } else if (pathname?.startsWith("/api/packages/") && pathname.endsWith("/variables") && method === "POST") {
-      const namespace = decodeURIComponent(pathname.replace("/api/packages/", "").replace("/variables", ""));
-      const body = await getRequestBody(req);
-      const { key, value } = JSON.parse(body);
-      if (!key || value === undefined) {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Key and value are required" }));
-        return;
-      }
-      await setPackageEnvVar(namespace, key, value);
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ success: true }));
-    } else if (pathname?.includes("/variables/") && method === "DELETE") {
-      const pathParts = pathname.split("/");
-      const variableIndex = pathParts.indexOf("variables");
-      const namespace = decodeURIComponent(pathParts.slice(3, variableIndex).join("/"));
-      const key = decodeURIComponent(pathParts[variableIndex + 1]);
-      await deletePackageEnvVar(namespace, key);
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ success: true }));
-    } else {
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Not found" }));
-    }
-  } catch (error) {
-    logger_default.error("Web server error:", error);
-    res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({
-      error: error instanceof Error ? error.message : "Internal server error"
-    }));
-  }
-}
-function getRequestBody(req) {
-  return new Promise((resolve, reject) => {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk.toString();
-    });
-    req.on("end", () => {
-      resolve(body);
-    });
-    req.on("error", reject);
-  });
-}
-function startEnvManagerServer(port = 5555) {
-  return new Promise((resolve, reject) => {
-    const server2 = createServer(handleRequest);
-    server2.listen(port, () => {
-      const actualPort = server2.address()?.port || port;
-      logger_default.info(`\uD83C\uDF10 Environment Manager web server started on http://localhost:${actualPort}`);
-      resolve({ server: server2, port: actualPort });
-    });
-    server2.on("error", (error) => {
-      if (error.code === "EADDRINUSE") {
-        server2.listen(0, () => {
-          const actualPort = server2.address()?.port;
-          logger_default.info(`\uD83C\uDF10 Environment Manager web server started on http://localhost:${actualPort} (port ${port} was in use)`);
-          resolve({ server: server2, port: actualPort });
-        });
-      } else {
-        reject(error);
-      }
-    });
-  });
-}
-// ../shared/dist/LocalToolResolver.js
-var yaml2 = __toESM(require_dist3(), 1);
-import { promises as fs5, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { join as join5, resolve, basename as basename2 } from "path";
-class LocalToolResolver {
-  constructor(enactCore, localToolsDir = "./tools", cacheDir = "./.tool-cache") {
-    this.enactCore = enactCore;
-    this.toolCache = new Map;
-    this.aliases = new Map;
-    this.favorites = new Set;
-    this.localToolsDir = resolve(localToolsDir);
-    this.cacheDir = resolve(cacheDir);
-    this.loadConfiguration();
-  }
-  async resolveTool(toolName) {
-    const resolvedName = this.aliases.get(toolName) || toolName;
-    const localTool = await this.getLocalTool(resolvedName);
-    if (localTool) {
-      return {
-        tool: localTool,
-        source: "local",
-        metadata: { path: localTool.path }
-      };
-    }
-    const cachedTool = this.toolCache.get(resolvedName);
-    if (cachedTool && !this.isCacheExpired(cachedTool)) {
-      return {
-        tool: cachedTool,
-        source: "cache",
-        metadata: { cachedAt: cachedTool.lastModified }
-      };
-    }
-    try {
-      const registryTool = await this.enactCore.getToolByName(resolvedName);
-      if (registryTool) {
-        await this.cacheRegistryTool(resolvedName, registryTool);
-        return {
-          tool: registryTool,
-          source: "registry",
-          metadata: { cached: true }
-        };
-      }
-    } catch (error) {
-      logger_default.debug(`Registry lookup failed for ${resolvedName}:`, error);
-    }
-    return null;
-  }
-  async getLocalTool(toolName) {
-    const possiblePaths = [
-      join5(this.localToolsDir, `${toolName}.yaml`),
-      join5(this.localToolsDir, `${toolName}.yml`),
-      join5(this.localToolsDir, toolName, "tool.yaml"),
-      join5(this.localToolsDir, toolName, "tool.yml"),
-      join5(this.localToolsDir, toolName, `${toolName}.yaml`),
-      join5(this.localToolsDir, toolName, `${toolName}.yml`)
-    ];
-    for (const toolPath of possiblePaths) {
-      try {
-        const stats = await fs5.stat(toolPath);
-        const content = await fs5.readFile(toolPath, "utf-8");
-        const definition = yaml2.parse(content);
-        if (definition && (definition.name === toolName || definition.name === undefined)) {
-          return {
-            name: definition.name || toolName,
-            path: toolPath,
-            definition,
-            lastModified: stats.mtime,
-            cached: false
-          };
-        }
-      } catch (error) {
-        continue;
-      }
-    }
-    return null;
-  }
-  async cacheRegistryTool(toolName, tool) {
-    try {
-      await fs5.mkdir(this.cacheDir, { recursive: true });
-      const cachePath = join5(this.cacheDir, `${toolName}.yaml`);
-      const cacheData = {
-        ...tool,
-        _cached: true,
-        _cachedAt: new Date().toISOString(),
-        _source: "registry"
-      };
-      await fs5.writeFile(cachePath, yaml2.stringify(cacheData));
-      this.toolCache.set(toolName, {
-        name: toolName,
-        path: cachePath,
-        definition: tool,
-        lastModified: new Date,
-        cached: true
-      });
-      logger_default.debug(`Cached registry tool: ${toolName}`);
-    } catch (error) {
-      logger_default.warn(`Failed to cache tool ${toolName}:`, error);
-    }
-  }
-  isCacheExpired(tool, maxAge = 24 * 60 * 60 * 1000) {
-    return Date.now() - tool.lastModified.getTime() > maxAge;
-  }
-  async listAllTools() {
-    const localTools = await this.scanLocalTools();
-    const cachedTools = Array.from(this.toolCache.values());
-    return {
-      local: localTools,
-      cached: cachedTools,
-      favorites: Array.from(this.favorites),
-      aliases: Object.fromEntries(this.aliases)
-    };
-  }
-  async scanLocalTools() {
-    const tools = [];
-    try {
-      await fs5.mkdir(this.localToolsDir, { recursive: true });
-      const entries = await this.scanDirectory(this.localToolsDir);
-      for (const entry of entries) {
-        if (entry.endsWith(".yaml") || entry.endsWith(".yml")) {
-          try {
-            const content = await fs5.readFile(entry, "utf-8");
-            const definition = yaml2.parse(content);
-            if (definition && (definition.name || definition.command)) {
-              const stats = await fs5.stat(entry);
-              tools.push({
-                name: definition.name || basename2(entry, ".yaml").replace(".yml", ""),
-                path: entry,
-                definition,
-                lastModified: stats.mtime,
-                cached: false
-              });
-            }
-          } catch (error) {
-            logger_default.debug(`Skipping invalid tool file ${entry}:`, error);
-          }
-        }
-      }
-    } catch (error) {
-      logger_default.warn(`Failed to scan local tools directory:`, error);
-    }
-    return tools;
+  async scanLocalTools() {
+    const tools = [];
+    try {
+      await fs5.mkdir(this.localToolsDir, { recursive: true });
+      const entries = await this.scanDirectory(this.localToolsDir);
+      for (const entry of entries) {
+        if (entry.endsWith(".yaml") || entry.endsWith(".yml")) {
+          try {
+            const content = await fs5.readFile(entry, "utf-8");
+            const definition = yaml2.parse(content);
+            if (definition && (definition.name || definition.command)) {
+              const stats = await fs5.stat(entry);
+              tools.push({
+                name: definition.name || basename2(entry, ".yaml").replace(".yml", ""),
+                path: entry,
+                definition,
+                lastModified: stats.mtime,
+                cached: false
+              });
+            }
+          } catch (error) {
+            logger_default.debug(`Skipping invalid tool file ${entry}:`, error);
+          }
+        }
+      }
+    } catch (error) {
+      logger_default.warn(`Failed to scan local tools directory:`, error);
+    }
+    return tools;
   }
   async scanDirectory(dir) {
     const files = [];
     try {
       const entries = await fs5.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join5(dir, entry.name);
+        const fullPath = join4(dir, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.scanDirectory(fullPath);
           files.push(...subFiles);
@@ -239810,13 +239436,13 @@ class LocalToolResolver {
   }
   loadConfiguration() {
     try {
-      const configPath = join5(this.localToolsDir, "config.json");
-      const config2 = JSON.parse(readFileSync3(configPath, "utf-8"));
-      if (config2.aliases) {
-        this.aliases = new Map(Object.entries(config2.aliases));
+      const configPath = join4(this.localToolsDir, "config.json");
+      const config = JSON.parse(readFileSync3(configPath, "utf-8"));
+      if (config.aliases) {
+        this.aliases = new Map(Object.entries(config.aliases));
       }
-      if (config2.favorites) {
-        this.favorites = new Set(config2.favorites);
+      if (config.favorites) {
+        this.favorites = new Set(config.favorites);
       }
     } catch (error) {
       logger_default.debug("No tool configuration found, using defaults");
@@ -239824,13 +239450,13 @@ class LocalToolResolver {
   }
   saveConfiguration() {
     try {
-      const configPath = join5(this.localToolsDir, "config.json");
-      const config2 = {
+      const configPath = join4(this.localToolsDir, "config.json");
+      const config = {
         aliases: Object.fromEntries(this.aliases),
         favorites: Array.from(this.favorites),
         lastUpdated: new Date().toISOString()
       };
-      writeFileSync(configPath, JSON.stringify(config2, null, 2));
+      writeFileSync(configPath, JSON.stringify(config, null, 2));
     } catch (error) {
       logger_default.warn("Failed to save tool configuration:", error);
     }
@@ -239854,11 +239480,11 @@ class LocalToolResolver {
           }
         }
       };
-      const samplePath = join5(this.localToolsDir, "hello-world.yaml");
+      const samplePath = join4(this.localToolsDir, "hello-world.yaml");
       await fs5.writeFile(samplePath, yaml2.stringify(sampleTool));
       logger_default.info(`Created sample tool at ${samplePath}`);
     }
-    const readmePath = join5(this.localToolsDir, "README.md");
+    const readmePath = join4(this.localToolsDir, "README.md");
     const readme = `# Local Tools Directory
 
 This directory contains your local Enact tools. Tools can be organized as:
@@ -239890,6 +239516,148 @@ Use the MCP tools to manage this directory programmatically.
   }
 }
 var LocalToolResolver_default = LocalToolResolver;
+// ../shared/dist/utils/help.js
+var __dirname = "/Users/keithgroves/projects/enact/enact-cli/packages/shared/dist/utils";
+// ../shared/dist/utils/version.js
+var __filename = "/Users/keithgroves/projects/enact/enact-cli/packages/shared/dist/utils/version.js";
+// ../shared/dist/utils/logger.js
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["SUCCESS"] = 2] = "SUCCESS";
+  LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+var currentLogLevel = LogLevel.INFO;
+// ../shared/dist/utils/silent-monitor.js
+class McpSilentOperationMonitor {
+  getOriginalConsoleError() {
+    return this.originalConsoleError;
+  }
+  constructor() {
+    this.isMonitoring = false;
+    this.violations = [];
+    this.consoleOutput = [];
+    this.processExitAttempts = 0;
+    this.readlineUsageDetected = false;
+    this.startTime = 0;
+    this.originalConsoleLog = console.log;
+    this.originalConsoleError = console.error;
+    this.originalConsoleWarn = console.warn;
+    this.originalConsoleInfo = console.info;
+    this.originalProcessExit = process.exit;
+    this.originalStdoutWrite = process.stdout.write;
+    this.originalStderrWrite = process.stderr.write;
+  }
+  startMonitoring() {
+    if (this.isMonitoring) {
+      return;
+    }
+    this.isMonitoring = true;
+    this.violations = [];
+    this.consoleOutput = [];
+    this.processExitAttempts = 0;
+    this.readlineUsageDetected = false;
+    this.startTime = Date.now();
+    console.log = (...args) => {
+      const message = args.join(" ");
+      this.consoleOutput.push(`[LOG] ${message}`);
+      this.violations.push(`Console.log called: ${message}`);
+    };
+    console.error = (...args) => {
+      const message = args.join(" ");
+      this.consoleOutput.push(`[ERROR] ${message}`);
+      this.violations.push(`Console.error called: ${message}`);
+    };
+    console.warn = (...args) => {
+      const message = args.join(" ");
+      this.consoleOutput.push(`[WARN] ${message}`);
+      this.violations.push(`Console.warn called: ${message}`);
+    };
+    console.info = (...args) => {
+      const message = args.join(" ");
+      this.consoleOutput.push(`[INFO] ${message}`);
+      this.violations.push(`Console.info called: ${message}`);
+    };
+    process.exit = (code) => {
+      this.processExitAttempts++;
+      this.violations.push(`Process.exit called with code: ${code}`);
+      throw new Error(`Process exit intercepted: ${code}`);
+    };
+    process.stdout.write = (chunk, ...args) => {
+      if (typeof chunk === "string" && chunk.trim()) {
+        this.consoleOutput.push(`[STDOUT] ${chunk}`);
+        this.violations.push(`Process.stdout.write called: ${chunk.substring(0, 100)}...`);
+      }
+      return true;
+    };
+    process.stderr.write = (chunk, ...args) => {
+      if (typeof chunk === "string" && chunk.trim()) {
+        this.consoleOutput.push(`[STDERR] ${chunk}`);
+        this.violations.push(`Process.stderr.write called: ${chunk.substring(0, 100)}...`);
+      }
+      return true;
+    };
+    const originalRequire = __require;
+    const monitor = this;
+    global.require = function(id) {
+      if (id === "readline" || id.includes("readline")) {
+        monitor.readlineUsageDetected = true;
+        monitor.violations.push("Readline module usage detected");
+      }
+      return originalRequire.apply(this, arguments);
+    };
+  }
+  stopMonitoring() {
+    if (!this.isMonitoring) {
+      throw new Error("Monitor is not currently running");
+    }
+    console.log = this.originalConsoleLog;
+    console.error = this.originalConsoleError;
+    console.warn = this.originalConsoleWarn;
+    console.info = this.originalConsoleInfo;
+    process.exit = this.originalProcessExit;
+    process.stdout.write = this.originalStdoutWrite;
+    process.stderr.write = this.originalStderrWrite;
+    global.require = __require;
+    this.isMonitoring = false;
+    return {
+      violations: [...this.violations],
+      consoleOutputDetected: [...this.consoleOutput],
+      processExitAttempts: this.processExitAttempts,
+      readlineUsageDetected: this.readlineUsageDetected,
+      duration: Date.now() - this.startTime,
+      timestamp: new Date().toISOString()
+    };
+  }
+  isCurrentlyMonitoring() {
+    return this.isMonitoring;
+  }
+  getViolations() {
+    return [...this.violations];
+  }
+}
+var globalMonitor = new McpSilentOperationMonitor;
+function validateSilentEnvironment() {
+  const issues = [];
+  if (process.env.CI !== "true") {
+    issues.push('CI environment variable not set to "true"');
+  }
+  if (process.env.ENACT_SKIP_INTERACTIVE !== "true") {
+    issues.push('ENACT_SKIP_INTERACTIVE not set to "true"');
+  }
+  if (process.env.DEBUG === "true" || process.env.VERBOSE === "true") {
+    issues.push("DEBUG or VERBOSE environment variables are enabled");
+  }
+  if (process.stdin.isTTY) {
+    issues.push("Process is running in TTY mode (potentially interactive)");
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
 // ../shared/dist/services/McpCoreService.js
 class McpCoreService {
   constructor(options) {
@@ -239969,6 +239737,287 @@ class McpCoreService {
   }
 }
 var mcpCoreService = new McpCoreService;
+// ../shared/dist/web/env-manager-server.js
+import { createServer } from "http";
+import { parse as parse4 } from "url";
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, readdir, stat as stat2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { homedir as homedir4 } from "os";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __filename3 = fileURLToPath4(import.meta.url);
+var __dirname3 = dirname3(__filename3);
+var CONFIG_DIR3 = join5(homedir4(), ".enact");
+var ENV_BASE_DIR = join5(CONFIG_DIR3, "env");
+function findStaticDir() {
+  const candidates = [
+    join5(__dirname3, "web", "static"),
+    join5(__dirname3, "static"),
+    join5(__dirname3, "..", "src", "web", "static"),
+    join5(__dirname3, "..", "..", "src", "web", "static"),
+    join5(process.cwd(), "src", "web", "static"),
+    join5(__dirname3, "..", "..", "..", "src", "web", "static"),
+    join5(__dirname3, "..", "..", "src", "web", "static")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync4(join5(candidate, "index.html"))) {
+      logger_default.debug(`Found static directory: ${candidate}`);
+      return candidate;
+    }
+  }
+  throw new Error("Could not find static directory. Tried: " + candidates.join(", "));
+}
+var STATIC_DIR = findStaticDir();
+function parseDotEnv(content) {
+  const vars = {};
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const equalIndex = trimmed.indexOf("=");
+    if (equalIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, equalIndex).trim();
+    let value = trimmed.slice(equalIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key) {
+      vars[key] = value;
+    }
+  }
+  return vars;
+}
+function generateDotEnv(vars) {
+  return Object.entries(vars).map(([key, value]) => {
+    const needsQuotes = value.includes(" ") || value.includes("\t") || value.includes(`
+`) || value.includes('"');
+    const escapedValue = needsQuotes ? `"${value.replace(/"/g, "\\\"")}"` : value;
+    return `${key}=${escapedValue}`;
+  }).join(`
+`) + `
+`;
+}
+async function getAllPackageNamespaces() {
+  const packages = [];
+  if (!existsSync4(ENV_BASE_DIR)) {
+    return packages;
+  }
+  try {
+    await scanDirectory(ENV_BASE_DIR, "", packages);
+  } catch (error) {
+    logger_default.error("Failed to scan env directory:", error);
+  }
+  return packages;
+}
+async function scanDirectory(dir, relativePath, packages) {
+  try {
+    const entries = await readdir(dir);
+    for (const entry of entries) {
+      const fullPath = join5(dir, entry);
+      const stats = await stat2(fullPath);
+      if (stats.isDirectory()) {
+        const newRelativePath = relativePath ? `${relativePath}/${entry}` : entry;
+        await scanDirectory(fullPath, newRelativePath, packages);
+      } else if (entry === ".env") {
+        const namespace = relativePath || "root";
+        try {
+          const content = await readFile3(fullPath, "utf8");
+          const variables = parseDotEnv(content);
+          packages.push({
+            namespace,
+            path: fullPath,
+            variables
+          });
+        } catch (error) {
+          logger_default.error(`Failed to read .env file at ${fullPath}:`, error);
+        }
+      }
+    }
+  } catch (error) {
+    logger_default.error(`Failed to scan directory ${dir}:`, error);
+  }
+}
+async function getPackageEnvVars(namespace) {
+  const envFile = join5(ENV_BASE_DIR, namespace, ".env");
+  if (!existsSync4(envFile)) {
+    return {};
+  }
+  try {
+    const content = await readFile3(envFile, "utf8");
+    return parseDotEnv(content);
+  } catch (error) {
+    logger_default.error(`Failed to read env file for ${namespace}:`, error);
+    return {};
+  }
+}
+async function setPackageEnvVar(namespace, key, value) {
+  const envFile = join5(ENV_BASE_DIR, namespace, ".env");
+  const envDir = dirname3(envFile);
+  if (!existsSync4(envDir)) {
+    await mkdir2(envDir, { recursive: true });
+  }
+  const existingVars = await getPackageEnvVars(namespace);
+  existingVars[key] = value;
+  const envContent = generateDotEnv(existingVars);
+  await writeFile2(envFile, envContent, "utf8");
+}
+async function deletePackageEnvVar(namespace, key) {
+  const existingVars = await getPackageEnvVars(namespace);
+  if (!(key in existingVars)) {
+    throw new Error(`Environment variable '${key}' not found in package '${namespace}'`);
+  }
+  delete existingVars[key];
+  const envFile = join5(ENV_BASE_DIR, namespace, ".env");
+  const envContent = generateDotEnv(existingVars);
+  await writeFile2(envFile, envContent, "utf8");
+}
+async function serveStaticFile(filePath, res) {
+  try {
+    const content = await readFile3(filePath, "utf8");
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    let contentType = "text/plain";
+    switch (ext) {
+      case "html":
+        contentType = "text/html";
+        break;
+      case "css":
+        contentType = "text/css";
+        break;
+      case "js":
+        contentType = "application/javascript";
+        break;
+      case "json":
+        contentType = "application/json";
+        break;
+    }
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(content);
+  } catch (error) {
+    logger_default.error("Error serving static file:", error);
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("File not found");
+  }
+}
+async function handleRequest(req, res) {
+  const urlParts = parse4(req.url || "", true);
+  const pathname = urlParts.pathname || "/";
+  const method = req.method || "GET";
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  if (method === "OPTIONS") {
+    res.writeHead(200);
+    res.end();
+    return;
+  }
+  try {
+    if (pathname === "/") {
+      await serveStaticFile(join5(STATIC_DIR, "index.html"), res);
+    } else if (pathname === "/style.css") {
+      await serveStaticFile(join5(STATIC_DIR, "style.css"), res);
+    } else if (pathname === "/app.js") {
+      await serveStaticFile(join5(STATIC_DIR, "app.js"), res);
+    } else if (pathname === "/favicon.ico") {
+      const favicon = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><text y=".9em" font-size="90">\uD83C\uDF10</text></svg>`;
+      res.writeHead(200, { "Content-Type": "image/svg+xml" });
+      res.end(favicon);
+    } else if (pathname === "/api/packages" && method === "GET") {
+      const packages = await getAllPackageNamespaces();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ packages }));
+    } else if (pathname === "/api/packages" && method === "POST") {
+      const body = await getRequestBody(req);
+      const { namespace } = JSON.parse(body);
+      if (!namespace) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Namespace is required" }));
+        return;
+      }
+      const envDir = join5(ENV_BASE_DIR, namespace);
+      const envFile = join5(envDir, ".env");
+      if (!existsSync4(envDir)) {
+        await mkdir2(envDir, { recursive: true });
+      }
+      if (!existsSync4(envFile)) {
+        await writeFile2(envFile, "", "utf8");
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+    } else if (pathname?.startsWith("/api/packages/") && method === "GET") {
+      const namespace = decodeURIComponent(pathname.replace("/api/packages/", ""));
+      const variables = await getPackageEnvVars(namespace);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ namespace, variables }));
+    } else if (pathname?.startsWith("/api/packages/") && pathname.endsWith("/variables") && method === "POST") {
+      const namespace = decodeURIComponent(pathname.replace("/api/packages/", "").replace("/variables", ""));
+      const body = await getRequestBody(req);
+      const { key, value } = JSON.parse(body);
+      if (!key || value === undefined) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Key and value are required" }));
+        return;
+      }
+      await setPackageEnvVar(namespace, key, value);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+    } else if (pathname?.includes("/variables/") && method === "DELETE") {
+      const pathParts = pathname.split("/");
+      const variableIndex = pathParts.indexOf("variables");
+      const namespace = decodeURIComponent(pathParts.slice(3, variableIndex).join("/"));
+      const key = decodeURIComponent(pathParts[variableIndex + 1]);
+      await deletePackageEnvVar(namespace, key);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+    } else {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+    }
+  } catch (error) {
+    logger_default.error("Web server error:", error);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      error: error instanceof Error ? error.message : "Internal server error"
+    }));
+  }
+}
+function getRequestBody(req) {
+  return new Promise((resolve2, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      resolve2(body);
+    });
+    req.on("error", reject);
+  });
+}
+function startEnvManagerServer(port = 5555) {
+  return new Promise((resolve2, reject) => {
+    const server2 = createServer(handleRequest);
+    server2.listen(port, () => {
+      const actualPort = server2.address()?.port || port;
+      logger_default.info(`\uD83C\uDF10 Environment Manager web server started on http://localhost:${actualPort}`);
+      resolve2({ server: server2, port: actualPort });
+    });
+    server2.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        server2.listen(0, () => {
+          const actualPort = server2.address()?.port;
+          logger_default.info(`\uD83C\uDF10 Environment Manager web server started on http://localhost:${actualPort} (port ${port} was in use)`);
+          resolve2({ server: server2, port: actualPort });
+        });
+      } else {
+        reject(error);
+      }
+    });
+  });
+}
 // ../shared/dist/lib/enact-direct.js
 class EnactDirect {
   constructor(options = {}) {
@@ -240141,7 +240190,8 @@ server2.registerTool("execute-tool-by-name", {
     dryRun: exports_external.boolean().optional().describe("Dry run mode"),
     verbose: exports_external.boolean().optional().describe("Verbose output"),
     async: exports_external.boolean().optional().describe("Run in background for long operations"),
-    forceRegistry: exports_external.boolean().optional().describe("Skip local resolution and go straight to registry")
+    forceRegistry: exports_external.boolean().optional().describe("Skip local resolution and go straight to registry"),
+    mount: exports_external.string().optional().describe("Mount local directory to container (format: 'localPath' or 'localPath:containerPath')")
   }
 }, async (params) => {
   const {
@@ -240153,7 +240203,8 @@ server2.registerTool("execute-tool-by-name", {
     dryRun,
     verbose,
     async = false,
-    forceRegistry = false
+    forceRegistry = false,
+    mount
   } = params;
   try {
     logger_default.info(`Executing tool: ${name} (localFile: ${localFile}, async: ${async})`);
@@ -240244,7 +240295,7 @@ ${suggestions.map((s2) => `  • ${s2}`).join(`
     }
     const isLongRunning = toolToExecute.name.includes("dagger") || toolToExecute.name.includes("docker") || toolToExecute.name.includes("build") || async;
     if (isLongRunning) {
-      const operationId = `${toolToExecute.name}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const operationId = `${toolToExecute.name}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
       let executionPromise;
       if (isLocalFile) {
         const yamlContent = await import("fs/promises").then((fs6) => fs6.readFile(toolToExecute.path, "utf-8"));
@@ -240253,6 +240304,7 @@ ${suggestions.map((s2) => `  • ${s2}`).join(`
           force: dangerouslySkipVerification || true,
           dryRun,
           verbose,
+          mount,
           isLocalFile: true
         });
       } else {
@@ -240261,6 +240313,7 @@ ${suggestions.map((s2) => `  • ${s2}`).join(`
           force: dangerouslySkipVerification,
           dryRun,
           verbose,
+          mount,
           isLocalFile: false
         });
       }
@@ -240303,14 +240356,16 @@ Operation ID: ${operationId}
           timeout: timeout3 || "120s",
           force: dangerouslySkipVerification || true,
           dryRun,
-          verbose
+          verbose,
+          mount
         });
       } else {
         result = await enactCore.executeToolByName(toolToExecute.name || name, inputs, {
           timeout: timeout3 || "120s",
           force: dangerouslySkipVerification,
           dryRun,
-          verbose
+          verbose,
+          mount
         });
       }
       if (!result.success) {