@enactprotocol/mcp-server 1.0.13 → 1.2.0

package/dist/minimal.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -225969,7 +225968,7 @@ class EnactApiClient {
       throw new EnactApiError(`${errorData.error || response.statusText}`, response.status, endpoint);
     }
     const responseData = await response.json();
-    if (true) {
+    if (!process.env.ENACT_SILENT) {
       console.error(`API Response for ${endpoint}:`, responseData);
     }
     return responseData;
@@ -226016,7 +226015,7 @@ class EnactApiClient {
   async searchTools(query) {
     const endpoint = "/functions/v1/tools-search";
     try {
-      if (true) {
+      if (!process.env.ENACT_SILENT) {
         console.error(`Search request to ${endpoint}:`, JSON.stringify(query, null, 2));
       }
       const response = await this.makeRequest(endpoint, {
@@ -226376,25 +226375,6 @@ function verifyCommandSafety(command, tool) {
     ...blocked.length > 0 && { blocked }
   };
 }
-function sanitizeEnvironmentVariables(envVars) {
-  const sanitized = {};
-  for (const [key, value] of Object.entries(envVars)) {
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
-      logger_default.warn(`Invalid environment variable name: ${key}`);
-      continue;
-    }
-    const strValue = String(value);
-    if (strValue.includes(`
-`) || strValue.includes("\r")) {
-      logger_default.warn(`Environment variable ${key} contains newline characters`);
-    }
-    if (strValue.includes("$(") || strValue.includes("`")) {
-      logger_default.warn(`Environment variable ${key} contains command substitution patterns`);
-    }
-    sanitized[key] = strValue;
-  }
-  return sanitized;
-}
 
 // ../shared/dist/exec/validate.js
 function validateAgainstSchema(value, schema, fieldName) {
@@ -226521,24 +226501,6 @@ function validateInputs(tool, inputs) {
   }
   return validatedInputs;
 }
-function validateOutput(tool, output) {
-  if (!tool.outputSchema) {
-    return output;
-  }
-  try {
-    validateAgainstSchema(output, tool.outputSchema, "output");
-    if (tool.outputSchema.required && Array.isArray(tool.outputSchema.required)) {
-      for (const requiredField of tool.outputSchema.required) {
-        if (output[requiredField] === undefined) {
-          throw new Error(`Missing required output field: ${requiredField}`);
-        }
-      }
-    }
-    return output;
-  } catch (error) {
-    throw new Error(`Output validation failed: ${error.message}`);
-  }
-}
 
 // ../shared/dist/core/DirectExecutionProvider.js
 import { spawn } from "child_process";
@@ -235380,7 +235342,7 @@ class DaggerExecutionProvider extends ExecutionProvider {
             logger_default.warn(`Attempt ${attempt}: Engine unhealthy, resetting...`);
             await this.resetEngineContainer();
           }
-          const result = await this.executeCommand(tool.command, inputs, environment, tool.timeout);
+          const result = await this.executeCommand(tool.command, inputs, environment, tool.timeout, undefined, tool);
           logger_default.debug(`Command result: exitCode=${result.exitCode}, stdout length=${result.stdout?.length || 0}, stderr length=${result.stderr?.length || 0}`);
           const output = this.parseOutput(result.stdout, tool);
           return {
@@ -235463,7 +235425,7 @@ class DaggerExecutionProvider extends ExecutionProvider {
     }
     return "EXECUTION_ERROR";
   }
-  async executeCommand(command, inputs, environment, timeout, options) {
+  async executeCommand(command, inputs, environment, timeout, options, tool) {
     const verbose = options?.verbose ?? false;
     const showSpinner = options?.showSpinner ?? false;
     this.abortController = new AbortController;
@@ -235480,24 +235442,25 @@ class DaggerExecutionProvider extends ExecutionProvider {
     try {
       const substitutedCommand = this.substituteCommandVariables(command, inputs);
       if (verbose) {
+        const containerImage = tool?.from || this.options.baseImage;
         try {
           const pc = require_picocolors();
           console.error(pc.cyan(`
 \uD83D\uDC33 Executing Enact command in Dagger container:`));
           console.error(pc.white(substitutedCommand));
-          console.error(pc.gray(`Base image: ${this.options.baseImage}`));
+          console.error(pc.gray(`Container image: ${containerImage}${tool?.from ? " (from tool.from)" : " (default baseImage)"}`));
         } catch (e2) {
           console.error(`
 \uD83D\uDC33 Executing Enact command in Dagger container:`);
           console.error(substitutedCommand);
-          console.error(`Base image: ${this.options.baseImage}`);
+          console.error(`Container image: ${containerImage}${tool?.from ? " (from tool.from)" : " (default baseImage)"}`);
         }
       }
       const timeoutMs = timeout ? parseTimeout(timeout) : 30000;
       const effectiveTimeout = Math.max(timeoutMs, this.options.engineTimeout);
       logger_default.debug(`Parsed timeout: ${effectiveTimeout}ms (command: ${timeoutMs}ms, engine: ${this.options.engineTimeout}ms)`);
       const result = await Promise.race([
-        this.executeWithConnect(substitutedCommand, environment, inputs),
+        this.executeWithConnect(substitutedCommand, environment, inputs, tool),
         this.createTimeoutPromise(effectiveTimeout)
       ]);
       if (spinner) {
@@ -235521,7 +235484,7 @@ class DaggerExecutionProvider extends ExecutionProvider {
       this.abortController = null;
     }
   }
-  async executeWithConnect(command, environment, inputs) {
+  async executeWithConnect(command, environment, inputs, tool) {
     return new Promise((resolve, reject) => {
       const abortHandler = () => {
         reject(new Error("Execution aborted"));
@@ -235532,7 +235495,7 @@ class DaggerExecutionProvider extends ExecutionProvider {
       connect(async (client) => {
         try {
           logger_default.debug("\uD83D\uDD17 Connected to Dagger client");
-          const container = await this.setupContainer(client, environment, inputs);
+          const container = await this.setupContainer(client, environment, inputs, tool);
           logger_default.debug("\uD83D\uDCE6 Container setup complete");
           const commandResult = await this.executeInContainer(container, command);
           logger_default.debug("⚡ Command execution complete");
@@ -235556,9 +235519,10 @@ class DaggerExecutionProvider extends ExecutionProvider {
       });
     });
   }
-  async setupContainer(client, environment, inputs) {
-    logger_default.debug(`\uD83D\uDE80 Setting up container with base image: ${this.options.baseImage}`);
-    let container = client.container().from(this.options.baseImage);
+  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)"}`);
+    let container = client.container().from(containerImage);
     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}`);
@@ -235567,7 +235531,7 @@ class DaggerExecutionProvider extends ExecutionProvider {
     }
     logger_default.debug(`\uD83C\uDF0D Added ${Object.keys(environment.vars).length} environment variables`);
     if (this.options.enableNetwork) {
-      container = await this.installCommonTools(container);
+      container = await this.installCommonTools(container, containerImage);
       logger_default.debug("\uD83D\uDD27 Common tools installed");
     } else {
       logger_default.debug("\uD83D\uDD27 Skipping common tools installation (network disabled)");
@@ -235581,15 +235545,15 @@ class DaggerExecutionProvider extends ExecutionProvider {
     logger_default.debug("✅ Container setup complete");
     return container;
   }
-  async installCommonTools(container) {
-    logger_default.debug(`\uD83D\uDD27 Installing common tools for base image: ${this.options.baseImage}`);
+  async installCommonTools(container, containerImage) {
+    logger_default.debug(`\uD83D\uDD27 Installing common tools for container image: ${containerImage}`);
     try {
-      if (this.options.baseImage?.includes("node:")) {
+      if (containerImage.includes("node:")) {
         logger_default.debug("\uD83D\uDCE6 Node.js image detected, skipping tool installation (most tools already available)");
         return container;
       }
-      const isAlpine = this.options.baseImage?.includes("alpine");
-      const isDebian = this.options.baseImage?.includes("debian") || this.options.baseImage?.includes("ubuntu");
+      const isAlpine = containerImage.includes("alpine");
+      const isDebian = containerImage.includes("debian") || containerImage.includes("ubuntu");
       if (isAlpine) {
         logger_default.debug("\uD83D\uDCE6 Detected Alpine Linux, installing basic tools");
         container = container.withExec([
@@ -235605,7 +235569,7 @@ class DaggerExecutionProvider extends ExecutionProvider {
           'timeout 60 apt-get update && timeout 60 apt-get install -y curl wget git && rm -rf /var/lib/apt/lists/* || echo "Package installation failed, continuing..."'
         ]);
       } else {
-        logger_default.warn(`Unknown base image ${this.options.baseImage}, skipping tool installation`);
+        logger_default.warn(`Unknown container image ${containerImage}, skipping tool installation`);
       }
       logger_default.debug("✅ Common tools installation complete");
       return container;
@@ -235846,7 +235810,7 @@ class DaggerExecutionProvider extends ExecutionProvider {
       verbose,
       showSpinner: true,
       streamOutput: false
-    });
+    }, undefined);
     if (result.exitCode !== 0) {
       throw new Error(`Command failed with exit code ${result.exitCode}: ${result.stderr}`);
     }
@@ -236392,9 +236356,26 @@ var VERIFICATION_POLICIES = {
 };
 
 // ../shared/dist/security/verification-enforcer.js
+function getSecurityPolicy(options) {
+  if (options.isLocalFile) {
+    return {
+      allowSkipVerification: true,
+      allowUnsigned: true,
+      requireInteractiveConfirmation: false,
+      defaultVerificationPolicy: "permissive"
+    };
+  }
+  return {
+    allowSkipVerification: false,
+    allowUnsigned: false,
+    requireInteractiveConfirmation: !!options.interactive,
+    defaultVerificationPolicy: options.verifyPolicy || "permissive"
+  };
+}
 async function enforceSignatureVerification(tool, options = {}) {
   const toolName = tool.name || "unknown";
-  if (options.skipVerification) {
+  const securityPolicy = getSecurityPolicy(options);
+  if (options.skipVerification && securityPolicy.allowSkipVerification) {
     logger_default.warn(`\uD83D\uDEA8 SECURITY WARNING: Signature verification skipped for tool: ${toolName}`);
     logger_default.warn(`   This bypasses security measures and is NOT recommended for production use!`);
     return {
@@ -236413,7 +236394,7 @@ async function enforceSignatureVerification(tool, options = {}) {
   const hasSignatures = !!(tool.signatures && Object.keys(tool.signatures).length > 0) || !!tool.signature;
   if (!hasSignatures) {
     logger_default.warn(`⚠️  Tool has no signatures: ${toolName}`);
-    if (options.allowUnsigned) {
+    if (options.allowUnsigned || securityPolicy.allowUnsigned) {
       logger_default.warn(`   Allowing unsigned tool execution due to allowUnsigned flag (DEV/TEST ONLY)`);
       return {
         allowed: true,
@@ -236555,7 +236536,7 @@ class EnactCore {
     this.options = {
       apiUrl: "https://enact.tools",
       supabaseUrl: "https://xjnhhxwxovjifdxdwzih.supabase.co",
-      executionProvider: "direct",
+      executionProvider: "dagger",
       defaultTimeout: "30s",
       verificationPolicy: "permissive",
       ...options
@@ -236566,7 +236547,8 @@ class EnactCore {
   setAuthToken(token) {
     this.options.authToken = token;
   }
-  async searchTools(options) {
+  static async searchTools(options, coreOptions = {}) {
+    const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
     try {
       logger_default.info(`Searching for tools with query: "${options.query}"`);
       const searchParams = {
@@ -236574,12 +236556,12 @@ class EnactCore {
         limit: options.limit,
         tags: options.tags
       };
-      const results = await this.apiClient.searchTools(searchParams);
+      const results = await apiClient.searchTools(searchParams);
       const tools = [];
       for (const result of results) {
         if (result.name) {
           try {
-            const tool = await this.getToolByName(result.name);
+            const tool = await EnactCore.getToolByName(result.name, undefined, coreOptions);
             if (tool) {
               tools.push(tool);
             }
@@ -236594,15 +236576,19 @@ class EnactCore {
       logger_default.error("Error searching tools:", error);
       if (error instanceof Error && error.message.includes("502")) {
         logger_default.info("Search API unavailable, trying fallback to local filtering...");
-        return this.searchToolsFallback(options);
+        return EnactCore.searchToolsFallback(options, coreOptions);
       }
       throw new Error(`Search failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  async searchToolsFallback(options) {
+  async searchTools(options) {
+    return EnactCore.searchTools(options, this.options);
+  }
+  static async searchToolsFallback(options, coreOptions = {}) {
+    const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
     try {
       logger_default.info("Using fallback search method...");
-      const allTools = await this.apiClient.getTools({
+      const allTools = await apiClient.getTools({
         limit: options.limit || 100
       });
       const filteredTools = [];
@@ -236610,7 +236596,7 @@ class EnactCore {
       for (const result of allTools) {
         if (result.name) {
           try {
-            const tool = await this.getToolByName(result.name);
+            const tool = await EnactCore.getToolByName(result.name, undefined, coreOptions);
             if (tool) {
               const matchesQuery = tool.name.toLowerCase().includes(query) || tool.description && tool.description.toLowerCase().includes(query) || tool.tags && tool.tags.some((tag) => tag.toLowerCase().includes(query));
               const matchesTags = !options.tags || !options.tags.length || tool.tags && options.tags.some((searchTag) => tool.tags.some((toolTag) => toolTag.toLowerCase().includes(searchTag.toLowerCase())));
@@ -236634,10 +236620,11 @@ class EnactCore {
       throw new Error(`Search failed (including fallback): ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
     }
   }
-  async getToolByName(name, version) {
+  static async getToolByName(name, version, coreOptions = {}) {
+    const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
     try {
       logger_default.info(`Fetching tool: ${name}${version ? `@${version}` : ""}`);
-      const response = await this.apiClient.getTool(name);
+      const response = await apiClient.getTool(name);
       if (!response) {
         logger_default.info(`Tool not found: ${name}`);
         return null;
@@ -236687,6 +236674,9 @@ class EnactCore {
       throw error;
     }
   }
+  async getToolByName(name, version) {
+    return EnactCore.getToolByName(name, version, this.options);
+  }
   async executeToolByName(name, inputs = {}, options = {}) {
     const executionId = this.generateExecutionId();
     try {
@@ -236728,20 +236718,6 @@ class EnactCore {
     try {
       logger_default.info(`Executing tool: ${tool.name}`);
       validateToolStructure(tool);
-      const verificationResult = await enforceSignatureVerification(tool, {
-        skipVerification: options.skipVerification,
-        verifyPolicy: options.verifyPolicy,
-        force: options.force,
-        allowUnsigned: false
-      });
-      logSecurityAudit(tool, verificationResult, verificationResult.allowed, {
-        skipVerification: options.skipVerification,
-        verifyPolicy: options.verifyPolicy,
-        force: options.force
-      });
-      if (!verificationResult.allowed) {
-        return createVerificationFailureResult(tool, verificationResult, executionId);
-      }
       const validatedInputs = validateInputs(tool, inputs);
       const safetyCheck = verifyCommandSafety(tool.command, tool);
       if (!safetyCheck.isSafe && !options.force) {
@@ -236757,81 +236733,48 @@ class EnactCore {
             toolName: tool.name,
             version: tool.version,
             executedAt: new Date().toISOString(),
-            environment: "direct",
-            command: tool.command
-          }
-        };
-      }
-      if (safetyCheck.warnings.length > 0) {
-        safetyCheck.warnings.forEach((warning) => logger_default.warn(warning));
-      }
-      if (options.dryRun) {
-        return {
-          success: true,
-          output: {
-            dryRun: true,
-            tool: tool.name,
-            command: tool.command,
-            inputs: validatedInputs,
-            safetyCheck
-          },
-          metadata: {
-            executionId,
-            toolName: tool.name,
-            version: tool.version,
-            executedAt: new Date().toISOString(),
-            environment: "direct",
-            command: tool.command
+            environment: "direct"
           }
         };
       }
-      const envResult = await resolveToolEnvironmentVariables(tool.name, tool.env);
-      if (envResult.missing.length > 0) {
-        logger_default.warn(`Missing required environment variables: ${envResult.missing.join(", ")}`);
+      const { resolved: envVars, missing: missingEnvVars } = await resolveToolEnvironmentVariables(tool.name, tool.env || {});
+      const verificationResult = await enforceSignatureVerification(tool, {
+        skipVerification: options.skipVerification,
+        verifyPolicy: options.verifyPolicy,
+        force: options.force,
+        allowUnsigned: false,
+        isLocalFile: options.isLocalFile,
+        interactive: options.interactive
+      });
+      logSecurityAudit(tool, verificationResult, verificationResult.allowed, {
+        skipVerification: options.skipVerification,
+        verifyPolicy: options.verifyPolicy,
+        force: options.force
+      });
+      if (!verificationResult.allowed) {
+        return createVerificationFailureResult(tool, verificationResult, executionId);
       }
-      const environment = {
-        vars: {
-          ...envResult.resolved,
-          ...sanitizeEnvironmentVariables(validatedInputs)
-        },
-        resources: tool.resources,
-        namespace: tool.namespace
-      };
-      await this.executionProvider.setup(tool);
-      const result = await this.executionProvider.execute(tool, validatedInputs, environment);
-      if (result.success && result.output && tool.outputSchema) {
-        try {
-          result.output = validateOutput(tool, result.output);
-        } catch (error) {
-          logger_default.warn(`Output validation failed: ${error.message}`);
+      logger_default.info(`✅ Security verification passed for tool: ${tool.name}`);
+      return await this.executionProvider.execute(tool, { ...validatedInputs, ...envVars }, {
+        vars: { ...envVars, ...validatedInputs },
+        resources: {
+          timeout: options.timeout || tool.timeout || this.options.defaultTimeout
         }
-      }
-      logger_default.info(`Tool execution completed: ${tool.name} (success: ${result.success})`);
-      return result;
+      });
     } catch (error) {
-      logger_default.error(`Error executing tool: ${error.message}`);
       return {
         success: false,
         error: {
           message: error.message,
-          code: "EXECUTION_ERROR",
-          details: error
+          code: "EXECUTION_ERROR"
         },
         metadata: {
           executionId,
           toolName: tool.name,
-          version: tool.version,
           executedAt: new Date().toISOString(),
-          environment: "direct",
-          command: tool.command
+          environment: "direct"
         }
       };
-    } finally {
-      try {
-        await this.executionProvider.cleanup();
-      } catch (cleanupError) {
-        logger_default.error("Error during cleanup:", cleanupError);
-      }
     }
   }
   async executeRawTool(toolYaml, inputs = {}, options = {}) {
@@ -236861,9 +236804,9 @@ class EnactCore {
       };
     }
   }
-  async verifyTool(name, policy) {
+  static async verifyTool(name, policy, coreOptions = {}) {
     try {
-      const tool = await this.getToolByName(name);
+      const tool = await EnactCore.getToolByName(name, undefined, coreOptions);
       if (!tool) {
         return {
           verified: false,
@@ -236919,36 +236862,43 @@ class EnactCore {
       };
     }
   }
-  async toolExists(name) {
+  async verifyTool(name, policy) {
+    return EnactCore.verifyTool(name, policy, this.options);
+  }
+  static async toolExists(name, coreOptions = {}) {
     try {
-      const tool = await this.getToolByName(name);
+      const tool = await EnactCore.getToolByName(name, undefined, coreOptions);
       return tool !== null;
     } catch (error) {
       return false;
     }
   }
+  async toolExists(name) {
+    return EnactCore.toolExists(name, this.options);
+  }
   async getToolsByTags(tags, limit = 20) {
-    return this.searchTools({
+    return EnactCore.searchTools({
       query: tags.join(" "),
       tags,
       limit
-    });
+    }, this.options);
   }
   async getToolsByAuthor(author, limit = 20) {
-    return this.searchTools({
+    return EnactCore.searchTools({
       query: `author:${author}`,
       author,
       limit
-    });
+    }, this.options);
   }
-  async getTools(options = {}) {
+  static async getTools(options = {}, coreOptions = {}) {
+    const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
     try {
-      const apiResults = await this.apiClient.getTools(options);
+      const apiResults = await apiClient.getTools(options);
       const tools = [];
       for (const result of apiResults) {
         if (result.name) {
           try {
-            const tool = await this.getToolByName(result.name);
+            const tool = await EnactCore.getToolByName(result.name, undefined, coreOptions);
             if (tool) {
               tools.push(tool);
             }
@@ -236963,22 +236913,20 @@ class EnactCore {
       throw new Error(`Failed to get tools: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+  async getTools(options = {}) {
+    return EnactCore.getTools(options, this.options);
+  }
   async getAuthStatus() {
     return {
       authenticated: !!this.options.authToken,
       server: this.options.apiUrl
     };
   }
-  async publishTool(tool) {
-    if (!this.options.authToken) {
-      return {
-        success: false,
-        message: "Authentication required to publish tools"
-      };
-    }
+  static async publishTool(tool, authToken, coreOptions = {}) {
+    const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
     try {
       validateToolStructure(tool);
-      await this.apiClient.publishTool(tool, this.options.authToken);
+      await apiClient.publishTool(tool, authToken);
       return {
         success: true,
         message: `Successfully published tool: ${tool.name}`
@@ -236990,8 +236938,17 @@ class EnactCore {
       };
     }
   }
+  async publishTool(tool) {
+    if (!this.options.authToken) {
+      return {
+        success: false,
+        message: "Authentication required to publish tools"
+      };
+    }
+    return EnactCore.publishTool(tool, this.options.authToken, this.options);
+  }
   async getToolInfo(name, version) {
-    return this.getToolByName(name, version);
+    return EnactCore.getToolByName(name, version, this.options);
   }
   async getStatus() {
     const authStatus = await this.getAuthStatus();
@@ -237005,11 +236962,11 @@ class EnactCore {
   }
   createExecutionProvider() {
     switch (this.options.executionProvider) {
-      case "dagger":
-        return new DaggerExecutionProvider(this.options.daggerOptions);
       case "direct":
-      default:
         return new DirectExecutionProvider;
+      case "dagger":
+      default:
+        return new DaggerExecutionProvider(this.options.daggerOptions);
     }
   }
   switchExecutionProvider(provider, options) {
@@ -237020,7 +236977,6 @@ class EnactCore {
     return `exec_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
   }
 }
-var enactCore = new EnactCore;
 // ../shared/dist/utils/config.js
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
@@ -237166,6 +237122,8 @@ function validateSilentEnvironment() {
     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 parse4 } from "url";
@@ -237452,8 +237410,8 @@ var yaml2 = __toESM(require_dist3(), 1);
 import { promises as fs6, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 import { join as join6, resolve, basename as basename2 } from "path";
 class LocalToolResolver {
-  constructor(enactCore2, localToolsDir = "./tools", cacheDir = "./.tool-cache") {
-    this.enactCore = enactCore2;
+  constructor(enactCore, localToolsDir = "./tools", cacheDir = "./.tool-cache") {
+    this.enactCore = enactCore;
     this.toolCache = new Map;
     this.aliases = new Map;
     this.favorites = new Set;
@@ -237874,10 +237832,10 @@ if (true) {
 `);
   }
 }
-var enactCore2 = new EnactCore({
+var enactCore = new EnactCore({
   apiUrl: process.env.ENACT_API_URL || "https://enact.tools",
   supabaseUrl: process.env.ENACT_SUPABASE_URL || "https://xjnhhxwxovjifdxdwzih.supabase.co",
-  executionProvider: "direct",
+  executionProvider: process.env.ENACT_EXECUTION_PROVIDER || "dagger",
   verificationPolicy: process.env.ENACT_VERIFY_POLICY || "permissive",
   authToken: process.env.ENACT_AUTH_TOKEN,
   defaultTimeout: "120s"
@@ -237957,7 +237915,7 @@ async function validateMcpToolEnvironmentVariables(toolName, toolEnv) {
 }
 var defaultToolsDir = join7(homedir5(), ".enact", "tools");
 var defaultCacheDir = join7(homedir5(), ".enact", "cache");
-var toolResolver = new LocalToolResolver_default(enactCore2, process.env.LOCAL_TOOLS_DIR || defaultToolsDir, process.env.TOOL_CACHE_DIR || defaultCacheDir);
+var toolResolver = new LocalToolResolver_default(enactCore, process.env.LOCAL_TOOLS_DIR || defaultToolsDir, process.env.TOOL_CACHE_DIR || defaultCacheDir);
 (async () => {
   try {
     await toolResolver.initialize();
@@ -237965,8 +237923,8 @@ var toolResolver = new LocalToolResolver_default(enactCore2, process.env.LOCAL_T
     logger_default.warn(`Failed to initialize LocalToolResolver: ${error instanceof Error ? error.message : String(error)}`);
   }
 })();
-server2.registerTool("execute-tool-by-name-enhanced", {
-  title: "Execute Tool (Enhanced)",
+server2.registerTool("execute-tool-by-name", {
+  title: "Execute Tool",
   description: "Execute tools with smart resolution: local files, local tools directory, or registry. Supports async execution.",
   inputSchema: {
     name: exports_external.string().describe("Tool name OR file path to local YAML"),
@@ -237974,8 +237932,7 @@ server2.registerTool("execute-tool-by-name-enhanced", {
     localFile: exports_external.boolean().optional().describe("Treat 'name' as a file path to local YAML tool"),
     timeout: exports_external.string().optional().describe("Execution timeout"),
     verifyPolicy: exports_external.enum(["permissive", "enterprise", "paranoid"]).optional().describe("Verification policy"),
-    skipVerification: exports_external.boolean().optional().describe("Skip signature verification"),
-    force: exports_external.boolean().optional().describe("Force execution"),
+    dangerouslySkipVerification: exports_external.boolean().optional().describe("Skip all signature verification (DANGEROUS)"),
     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"),
@@ -237988,8 +237945,7 @@ server2.registerTool("execute-tool-by-name-enhanced", {
     localFile = false,
     timeout: timeout3,
     verifyPolicy,
-    skipVerification,
-    force,
+    dangerouslySkipVerification,
     dryRun,
     verbose,
     async = false,
@@ -238028,7 +237984,7 @@ server2.registerTool("execute-tool-by-name-enhanced", {
         };
       }
     } else if (forceRegistry) {
-      toolToExecute = await enactCore2.getToolByName(name);
+      toolToExecute = await enactCore.getToolByName(name);
       resolutionInfo = "\uD83C\uDF10 Registry (forced)";
     } else {
       const resolution = await toolResolver.resolveTool(name);
@@ -238088,20 +238044,20 @@ ${suggestions.map((s2) => `  • ${s2}`).join(`
       let executionPromise;
       if (isLocalFile) {
         const yamlContent = await import("fs/promises").then((fs7) => fs7.readFile(toolToExecute.path, "utf-8"));
-        executionPromise = enactCore2.executeRawTool(yamlContent, inputs, {
+        executionPromise = enactCore.executeRawTool(yamlContent, inputs, {
           timeout: timeout3 || "300s",
           verifyPolicy,
-          skipVerification: true,
-          force,
+          skipVerification: dangerouslySkipVerification || true,
+          force: dangerouslySkipVerification || true,
           dryRun,
           verbose
         });
       } else {
-        executionPromise = enactCore2.executeToolByName(toolToExecute.name || name, inputs, {
+        executionPromise = enactCore.executeToolByName(toolToExecute.name || name, inputs, {
           timeout: timeout3 || "300s",
           verifyPolicy,
-          skipVerification,
-          force,
+          skipVerification: dangerouslySkipVerification,
+          force: dangerouslySkipVerification,
           dryRun,
           verbose
         });
@@ -238141,20 +238097,20 @@ Operation ID: ${operationId}
       let result;
       if (isLocalFile) {
         const yamlContent = await import("fs/promises").then((fs7) => fs7.readFile(toolToExecute.path, "utf-8"));
-        result = await enactCore2.executeRawTool(yamlContent, inputs, {
+        result = await enactCore.executeRawTool(yamlContent, inputs, {
           timeout: timeout3 || "120s",
           verifyPolicy,
-          skipVerification: true,
-          force,
+          skipVerification: dangerouslySkipVerification || true,
+          force: dangerouslySkipVerification || true,
           dryRun,
           verbose
         });
       } else {
-        result = await enactCore2.executeToolByName(toolToExecute.name || name, inputs, {
+        result = await enactCore.executeToolByName(toolToExecute.name || name, inputs, {
           timeout: timeout3 || "120s",
           verifyPolicy,
-          skipVerification,
-          force,
+          skipVerification: dangerouslySkipVerification,
+          force: dangerouslySkipVerification,
           dryRun,
           verbose
         });
@@ -238395,7 +238351,7 @@ server2.registerTool("create-local-tool", {
     timeout: exports_external.string().optional().describe("Execution timeout"),
     inputSchema: exports_external.record(exports_external.any()).optional().describe("Input schema for the tool"),
     env: exports_external.record(exports_external.any()).optional().describe("Environment variables"),
-    force: exports_external.boolean().default(false).describe("Overwrite if tool already exists")
+    overwrite: exports_external.boolean().default(false).describe("Overwrite if tool already exists")
   }
 }, async ({
   name,
@@ -238405,7 +238361,7 @@ server2.registerTool("create-local-tool", {
   timeout: timeout3,
   inputSchema,
   env: env3,
-  force = false
+  overwrite = false
 }) => {
   try {
     const { promises: fs7 } = await import("fs");
@@ -238413,7 +238369,7 @@ server2.registerTool("create-local-tool", {
     const toolsDir = join7(homedir5(), ".enact", "tools");
     await fs7.mkdir(toolsDir, { recursive: true });
     const toolPath = join7(toolsDir, `${name}.yaml`);
-    if (!force) {
+    if (!overwrite) {
       try {
         await fs7.access(toolPath);
         return {
@@ -238422,7 +238378,7 @@ server2.registerTool("create-local-tool", {
               type: "text",
               text: `❌ Tool already exists: ${toolPath}
 
-Use force: true to overwrite, or choose a different name.`
+Use overwrite: true to overwrite, or choose a different name.`
             }
           ],
           isError: true
@@ -238459,7 +238415,7 @@ Use force: true to overwrite, or choose a different name.`
 `;
     }
     output += `
-\uD83D\uDCA1 Execute with: execute-tool-by-name-enhanced "${name}"`;
+\uD83D\uDCA1 Execute with: execute-tool-by-name "${name}"`;
     return { content: [{ type: "text", text: output }] };
   } catch (error) {
     return {
@@ -238486,7 +238442,7 @@ server2.registerTool("enact-search-tools", {
 }, async ({ query, limit = 10, tags, author, detailed = false }) => {
   try {
     logger_default.info(`Searching registry tools: "${query}"`);
-    const tools = await enactCore2.searchTools({ query, limit, tags, author });
+    const tools = await enactCore.searchTools({ query, limit, tags, author });
     if (tools.length === 0) {
       return {
         content: [
@@ -238525,7 +238481,7 @@ server2.registerTool("enact-search-tools", {
       output += `
 `;
     });
-    output += `\uD83D\uDCA1 Execute any tool with: execute-tool-by-name-enhanced "<tool-name>"`;
+    output += `\uD83D\uDCA1 Execute any tool with: execute-tool-by-name "<tool-name>"`;
     return { content: [{ type: "text", text: output }] };
   } catch (error) {
     logger_default.error("Error searching tools:", error);
@@ -238766,7 +238722,7 @@ server2.registerTool("enact-core-status", {
   }
 }, async ({ detailed = false }) => {
   try {
-    const status = await enactCore2.getStatus();
+    const status = await enactCore.getStatus();
     const toolStats = await toolResolver.listAllTools();
     let output = `\uD83D\uDD27 Enact MCP Status
 `;
@@ -238903,5 +238859,5 @@ if (__require.main == __require.module) {
 }
 export {
   server2 as server,
-  enactCore2 as enactCore
+  enactCore
 };