enact-cli 1.0.9 → 1.0.10

package/dist/index.js

@@ -11104,7 +11104,7 @@ async function installMcpServer(client) {
       config2.extensions.enact = {
         name: "Enact Tools",
         cmd: "npx",
-        args: ["-y", "enact-cli", "mcp"],
+        args: ["-y", "enact-cli", "enact-mcp"],
         enabled: true,
         type: "stdio",
         timeout: 300
@@ -11131,12 +11131,7 @@ async function installMcpServer(client) {
     }
   }
   const mcpServerConfig = {
-    command: "npx",
-    args: [
-      "-y",
-      "enact-cli",
-      "mcp"
-    ]
+    command: "enact-mcp"
   };
   if (client.id === "claude-desktop" || client.id === "claude-code") {
     if (!config.mcpServers) {
@@ -11567,8 +11562,29 @@ class DirectExecutionProvider extends ExecutionProvider {
       try {
         const proc = spawn(cmd, args, {
           env,
-          stdio: ["pipe", "pipe", "pipe"]
+          stdio: ["pipe", "pipe", "pipe"],
+          detached: process.platform !== "win32"
         });
+        const cleanup = () => {
+          if (proc && !proc.killed) {
+            try {
+              console.log(`[DEBUG] Cleaning up process PID: ${proc.pid}`);
+              if (process.platform === "win32") {
+                proc.kill("SIGKILL");
+              } else {
+                process.kill(-proc.pid, "SIGTERM");
+                setTimeout(() => {
+                  if (!proc.killed) {
+                    console.log(`[DEBUG] Force killing process PID: ${proc.pid}`);
+                    process.kill(-proc.pid, "SIGKILL");
+                  }
+                }, 2000);
+              }
+            } catch (killError) {
+              logger_default.debug(`Process cleanup error (likely harmless): ${killError}`);
+            }
+          }
+        };
         proc.stdout.on("data", (data) => {
           const chunk = data.toString();
           stdout += chunk;
@@ -11580,6 +11596,8 @@ class DirectExecutionProvider extends ExecutionProvider {
           process.stderr.write(chunk);
         });
         proc.on("close", (code) => {
+          console.log(`[DEBUG] Process closed with code: ${code}, PID: ${proc.pid}`);
+          cleanup();
           resolve({
             stdout: stdout.trim(),
             stderr: stderr.trim(),
@@ -11587,12 +11605,13 @@ class DirectExecutionProvider extends ExecutionProvider {
           });
         });
         proc.on("error", (error) => {
+          cleanup();
           reject(new Error(`Command execution error: ${error.message}`));
         });
         if (timeout) {
           const timeoutMs = this.parseTimeout(timeout);
           setTimeout(() => {
-            proc.kill("SIGTERM");
+            cleanup();
             reject(new Error(`Command timed out after ${timeout}`));
           }, timeoutMs);
         }

package/dist/index.js.bak

@@ -11103,7 +11103,7 @@ async function installMcpServer(client) {
       config2.extensions.enact = {
         name: "Enact Tools",
         cmd: "npx",
-        args: ["-y", "enact-cli", "mcp"],
+        args: ["-y", "enact-cli", "enact-mcp"],
         enabled: true,
         type: "stdio",
         timeout: 300
@@ -11130,12 +11130,7 @@ async function installMcpServer(client) {
     }
   }
   const mcpServerConfig = {
-    command: "npx",
-    args: [
-      "-y",
-      "enact-cli",
-      "mcp"
-    ]
+    command: "enact-mcp"
   };
   if (client.id === "claude-desktop" || client.id === "claude-code") {
     if (!config.mcpServers) {
@@ -11566,8 +11561,29 @@ class DirectExecutionProvider extends ExecutionProvider {
       try {
         const proc = spawn(cmd, args, {
           env,
-          stdio: ["pipe", "pipe", "pipe"]
+          stdio: ["pipe", "pipe", "pipe"],
+          detached: process.platform !== "win32"
         });
+        const cleanup = () => {
+          if (proc && !proc.killed) {
+            try {
+              console.log(`[DEBUG] Cleaning up process PID: ${proc.pid}`);
+              if (process.platform === "win32") {
+                proc.kill("SIGKILL");
+              } else {
+                process.kill(-proc.pid, "SIGTERM");
+                setTimeout(() => {
+                  if (!proc.killed) {
+                    console.log(`[DEBUG] Force killing process PID: ${proc.pid}`);
+                    process.kill(-proc.pid, "SIGKILL");
+                  }
+                }, 2000);
+              }
+            } catch (killError) {
+              logger_default.debug(`Process cleanup error (likely harmless): ${killError}`);
+            }
+          }
+        };
         proc.stdout.on("data", (data) => {
           const chunk = data.toString();
           stdout += chunk;
@@ -11579,6 +11595,8 @@ class DirectExecutionProvider extends ExecutionProvider {
           process.stderr.write(chunk);
         });
         proc.on("close", (code) => {
+          console.log(`[DEBUG] Process closed with code: ${code}, PID: ${proc.pid}`);
+          cleanup();
           resolve({
             stdout: stdout.trim(),
             stderr: stderr.trim(),
@@ -11586,12 +11604,13 @@ class DirectExecutionProvider extends ExecutionProvider {
           });
         });
         proc.on("error", (error) => {
+          cleanup();
           reject(new Error(`Command execution error: ${error.message}`));
         });
         if (timeout) {
           const timeoutMs = this.parseTimeout(timeout);
           setTimeout(() => {
-            proc.kill("SIGTERM");
+            cleanup();
             reject(new Error(`Command timed out after ${timeout}`));
           }, timeoutMs);
         }

package/dist/mcp-server.js

@@ -21044,8 +21044,29 @@ class DirectExecutionProvider extends ExecutionProvider {
       try {
         const proc = spawn(cmd, args, {
           env,
-          stdio: ["pipe", "pipe", "pipe"]
+          stdio: ["pipe", "pipe", "pipe"],
+          detached: process.platform !== "win32"
         });
+        const cleanup = () => {
+          if (proc && !proc.killed) {
+            try {
+              console.log(`[DEBUG] Cleaning up process PID: ${proc.pid}`);
+              if (process.platform === "win32") {
+                proc.kill("SIGKILL");
+              } else {
+                process.kill(-proc.pid, "SIGTERM");
+                setTimeout(() => {
+                  if (!proc.killed) {
+                    console.log(`[DEBUG] Force killing process PID: ${proc.pid}`);
+                    process.kill(-proc.pid, "SIGKILL");
+                  }
+                }, 2000);
+              }
+            } catch (killError) {
+              logger_default.debug(`Process cleanup error (likely harmless): ${killError}`);
+            }
+          }
+        };
         proc.stdout.on("data", (data) => {
           const chunk = data.toString();
           stdout += chunk;
@@ -21057,6 +21078,8 @@ class DirectExecutionProvider extends ExecutionProvider {
           process.stderr.write(chunk);
         });
         proc.on("close", (code) => {
+          console.log(`[DEBUG] Process closed with code: ${code}, PID: ${proc.pid}`);
+          cleanup();
           resolve({
             stdout: stdout.trim(),
             stderr: stderr.trim(),
@@ -21064,12 +21087,13 @@ class DirectExecutionProvider extends ExecutionProvider {
           });
         });
         proc.on("error", (error) => {
+          cleanup();
           reject(new Error(`Command execution error: ${error.message}`));
         });
         if (timeout) {
           const timeoutMs = this.parseTimeout(timeout);
           setTimeout(() => {
-            proc.kill("SIGTERM");
+            cleanup();
             reject(new Error(`Command timed out after ${timeout}`));
           }, timeoutMs);
         }
@@ -21875,7 +21899,8 @@ var enactCore2 = new EnactCore({
   supabaseUrl: process.env.ENACT_SUPABASE_URL || "https://xjnhhxwxovjifdxdwzih.supabase.co",
   executionProvider: "direct",
   verificationPolicy: process.env.ENACT_VERIFY_POLICY || "permissive",
-  authToken: process.env.ENACT_AUTH_TOKEN
+  authToken: process.env.ENACT_AUTH_TOKEN,
+  defaultTimeout: "120s"
 });
 var server = new McpServer({
   name: "enact-mcp-server",
@@ -21887,6 +21912,7 @@ var server = new McpServer({
     }
   }
 });
+var runningOperations = new Map;
 function safeJsonStringify(obj, fallback = "Unable to stringify object") {
   try {
     return JSON.stringify(obj, null, 2);
@@ -21895,6 +21921,266 @@ function safeJsonStringify(obj, fallback = "Unable to stringify object") {
     return fallback;
   }
 }
+server.registerTool("execute-tool-by-name-async", {
+  title: "Execute Enact Tool (Async)",
+  description: "Execute an Enact tool by its name using direct core integration with background execution for long-running operations",
+  inputSchema: {
+    name: exports_external.string().describe("Name of the tool to execute"),
+    inputs: exports_external.record(exports_external.any()).optional().describe("Input parameters for the 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"),
+    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")
+  }
+}, async (params) => {
+  const { name, inputs = {}, timeout, verifyPolicy, skipVerification, force, dryRun, verbose, async = false } = params;
+  try {
+    logger_default.info(`Executing tool ${name} via direct core library`);
+    const isLongRunningTool = name.includes("dagger") || name.includes("docker") || name.includes("build") || async;
+    if (isLongRunningTool) {
+      const operationId = `${name}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const executionPromise = enactCore2.executeToolByName(name, inputs, {
+        timeout: timeout || "300s",
+        verifyPolicy,
+        skipVerification,
+        force,
+        dryRun,
+        verbose
+      });
+      const operation = {
+        id: operationId,
+        name,
+        startTime: new Date,
+        promise: executionPromise,
+        status: "running",
+        result: undefined,
+        error: undefined
+      };
+      runningOperations.set(operationId, operation);
+      executionPromise.then((result2) => {
+        operation.status = "completed";
+        operation.result = result2;
+        logger_default.info(`Background operation completed: ${operationId}`);
+      }).catch((error) => {
+        operation.status = "failed";
+        operation.error = error;
+        logger_default.error(`Background operation failed: ${operationId}`, error);
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `\uD83D\uDE80 Started background execution of tool: ${name}
+
+Operation ID: ${operationId}
+Started: ${operation.startTime.toISOString()}
+
+⏳ This operation is running in the background. Use the "check-operation-status" tool with operation ID "${operationId}" to check progress.
+
+Estimated completion time: 1-3 minutes for Dagger operations.`
+        }]
+      };
+    }
+    const result = await enactCore2.executeToolByName(name, inputs, {
+      timeout: timeout || "30s",
+      verifyPolicy,
+      skipVerification,
+      force,
+      dryRun,
+      verbose
+    });
+    if (!result.success) {
+      return {
+        content: [{
+          type: "text",
+          text: `❌ Error executing tool ${name}: ${result.error?.message}`
+        }],
+        isError: true
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `✅ Successfully executed tool ${name}
+Output: ${safeJsonStringify(result)}`
+      }]
+    };
+  } catch (error) {
+    logger_default.error(`Error executing tool:`, error);
+    if (error instanceof Error && error.message.includes("timed out")) {
+      return {
+        content: [{
+          type: "text",
+          text: `⏰ Tool execution timed out: ${name}
+
+For long-running operations like Dagger builds, try using the async mode by setting "async": true in your request.
+
+Original error: ${error.message}`
+        }],
+        isError: true
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `Internal error executing tool: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
+server.registerTool("check-operation-status", {
+  title: "Check Operation Status",
+  description: "Check the status of a background operation",
+  inputSchema: {
+    operationId: exports_external.string().describe("The operation ID to check")
+  }
+}, async ({ operationId }) => {
+  try {
+    const operation = runningOperations.get(operationId);
+    if (!operation) {
+      return {
+        content: [{
+          type: "text",
+          text: `❌ Operation not found: ${operationId}
+
+The operation may have been completed and cleaned up, or the ID is incorrect.`
+        }],
+        isError: true
+      };
+    }
+    const duration = Math.round((Date.now() - operation.startTime.getTime()) / 1000);
+    switch (operation.status) {
+      case "running":
+        return {
+          content: [{
+            type: "text",
+            text: `⏳ Operation Status: RUNNING
+
+Operation ID: ${operationId}
+Tool: ${operation.name}
+Started: ${operation.startTime.toISOString()}
+Duration: ${duration} seconds
+
+The operation is still running. Please check again in a moment.`
+          }]
+        };
+      case "completed":
+        if (!operation.resultFetched) {
+          operation.resultFetched = true;
+          setTimeout(() => {
+            console.log(`[INFO] Cleaning up completed operation: ${operationId}`);
+            runningOperations.delete(operationId);
+          }, 60000);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `✅ Operation Status: COMPLETED
+
+Operation ID: ${operationId}
+Tool: ${operation.name}
+Started: ${operation.startTime.toISOString()}
+Duration: ${duration} seconds
+
+Result:
+${safeJsonStringify(operation.result)}`
+          }]
+        };
+      case "failed":
+        if (!operation.errorFetched) {
+          operation.errorFetched = true;
+          setTimeout(() => {
+            console.log(`[INFO] Cleaning up failed operation: ${operationId}`);
+            runningOperations.delete(operationId);
+          }, 60000);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `❌ Operation Status: FAILED
+
+Operation ID: ${operationId}
+Tool: ${operation.name}
+Started: ${operation.startTime.toISOString()}
+Duration: ${duration} seconds
+
+Error: ${operation.error instanceof Error ? operation.error.message : String(operation.error)}`
+          }],
+          isError: true
+        };
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: `❓ Unknown operation status: ${operation.status}`
+          }],
+          isError: true
+        };
+    }
+  } catch (error) {
+    logger_default.error(`Error checking operation status:`, error);
+    return {
+      content: [{
+        type: "text",
+        text: `Error checking operation status: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
+server.registerTool("list-operations", {
+  title: "List Operations",
+  description: "List all background operations",
+  inputSchema: {}
+}, async () => {
+  try {
+    const operations = Array.from(runningOperations.values());
+    if (operations.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: `\uD83D\uDCCB No background operations currently running or recently completed.`
+        }]
+      };
+    }
+    let summary = `\uD83D\uDCCB Background Operations (${operations.length} total)
+
+`;
+    operations.forEach((op) => {
+      const duration = Math.round((Date.now() - op.startTime.getTime()) / 1000);
+      const statusEmoji = op.status === "running" ? "⏳" : op.status === "completed" ? "✅" : "❌";
+      summary += `${statusEmoji} ${op.id}
+`;
+      summary += `   Tool: ${op.name}
+`;
+      summary += `   Status: ${op.status.toUpperCase()}
+`;
+      summary += `   Duration: ${duration}s
+`;
+      summary += `   Started: ${op.startTime.toISOString()}
+
+`;
+    });
+    return {
+      content: [{
+        type: "text",
+        text: summary
+      }]
+    };
+  } catch (error) {
+    logger_default.error(`Error listing operations:`, error);
+    return {
+      content: [{
+        type: "text",
+        text: `Error listing operations: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
 server.registerTool("execute-tool-by-name", {
   title: "Execute Enact Tool",
   description: "Execute an Enact tool by its name using direct core integration",
@@ -21912,8 +22198,12 @@ server.registerTool("execute-tool-by-name", {
   const { name, inputs = {}, timeout, verifyPolicy, skipVerification, force, dryRun, verbose } = params;
   try {
     logger_default.info(`Executing tool ${name} via direct core library`);
+    const isLongRunningTool = name.includes("dagger") || name.includes("docker") || name.includes("build");
+    if (isLongRunningTool) {
+      logger_default.info(`⏳ Starting long-running operation: ${name} (this may take 1-2 minutes)`);
+    }
     const result = await enactCore2.executeToolByName(name, inputs, {
-      timeout,
+      timeout: timeout || "120s",
       verifyPolicy,
       skipVerification,
       force,
@@ -21938,6 +22228,23 @@ Output: ${safeJsonStringify(result)}`
     };
   } catch (error) {
     logger_default.error(`Error executing tool:`, error);
+    if (error instanceof Error && error.message.includes("timed out")) {
+      return {
+        content: [{
+          type: "text",
+          text: `⏰ Tool execution timed out: ${name}
+
+This may happen with long-running operations like Dagger builds. The operation may still be running in the background. Consider:
+
+1. Running the tool directly from CLI for long operations
+2. Using smaller, more focused operations
+3. Checking if the operation completed successfully outside of MCP
+
+Original error: ${error.message}`
+        }],
+        isError: true
+      };
+    }
     return {
       content: [{
         type: "text",
@@ -22355,25 +22662,6 @@ ${safeJsonStringify(result)}`
   });
   server.server.sendToolListChanged();
 }
-async function main() {
-  try {
-    const transport = new StdioServerTransport;
-    await server.connect(transport);
-    logger_default.info("\uD83D\uDE80 Enact MCP Server with Direct Core Integration started successfully");
-  } catch (error) {
-    console.error("❌ Server connection error:", error);
-    if (error instanceof Error) {
-      console.error("Stack trace:", error.stack);
-    }
-    process.exit(1);
-  }
-}
-if (__require.main == __require.module) {
-  main().catch((error) => {
-    console.error("❌ Failed to start server:", error);
-    process.exit(1);
-  });
-}
 server.registerTool("enact-get-tools-by-author", {
   title: "Get Tools by Author",
   description: "Get tools by a specific author using direct core integration",
@@ -22514,6 +22802,25 @@ ${safeJsonStringify(allResults)}`
     };
   }
 });
+async function main() {
+  try {
+    const transport = new StdioServerTransport;
+    await server.connect(transport);
+    logger_default.info("\uD83D\uDE80 Enact MCP Server with Direct Core Integration started successfully");
+  } catch (error) {
+    console.error("❌ Server connection error:", error);
+    if (error instanceof Error) {
+      console.error("Stack trace:", error.stack);
+    }
+    process.exit(1);
+  }
+}
+if (__require.main == __require.module) {
+  main().catch((error) => {
+    console.error("❌ Failed to start server:", error);
+    process.exit(1);
+  });
+}
 export {
   server,
   enactCore2 as enactCore

package/dist/mcp-server.js.bak

@@ -21043,8 +21043,29 @@ class DirectExecutionProvider extends ExecutionProvider {
       try {
         const proc = spawn(cmd, args, {
           env,
-          stdio: ["pipe", "pipe", "pipe"]
+          stdio: ["pipe", "pipe", "pipe"],
+          detached: process.platform !== "win32"
         });
+        const cleanup = () => {
+          if (proc && !proc.killed) {
+            try {
+              console.log(`[DEBUG] Cleaning up process PID: ${proc.pid}`);
+              if (process.platform === "win32") {
+                proc.kill("SIGKILL");
+              } else {
+                process.kill(-proc.pid, "SIGTERM");
+                setTimeout(() => {
+                  if (!proc.killed) {
+                    console.log(`[DEBUG] Force killing process PID: ${proc.pid}`);
+                    process.kill(-proc.pid, "SIGKILL");
+                  }
+                }, 2000);
+              }
+            } catch (killError) {
+              logger_default.debug(`Process cleanup error (likely harmless): ${killError}`);
+            }
+          }
+        };
         proc.stdout.on("data", (data) => {
           const chunk = data.toString();
           stdout += chunk;
@@ -21056,6 +21077,8 @@ class DirectExecutionProvider extends ExecutionProvider {
           process.stderr.write(chunk);
         });
         proc.on("close", (code) => {
+          console.log(`[DEBUG] Process closed with code: ${code}, PID: ${proc.pid}`);
+          cleanup();
           resolve({
             stdout: stdout.trim(),
             stderr: stderr.trim(),
@@ -21063,12 +21086,13 @@ class DirectExecutionProvider extends ExecutionProvider {
           });
         });
         proc.on("error", (error) => {
+          cleanup();
           reject(new Error(`Command execution error: ${error.message}`));
         });
         if (timeout) {
           const timeoutMs = this.parseTimeout(timeout);
           setTimeout(() => {
-            proc.kill("SIGTERM");
+            cleanup();
             reject(new Error(`Command timed out after ${timeout}`));
           }, timeoutMs);
         }
@@ -21874,7 +21898,8 @@ var enactCore2 = new EnactCore({
   supabaseUrl: process.env.ENACT_SUPABASE_URL || "https://xjnhhxwxovjifdxdwzih.supabase.co",
   executionProvider: "direct",
   verificationPolicy: process.env.ENACT_VERIFY_POLICY || "permissive",
-  authToken: process.env.ENACT_AUTH_TOKEN
+  authToken: process.env.ENACT_AUTH_TOKEN,
+  defaultTimeout: "120s"
 });
 var server = new McpServer({
   name: "enact-mcp-server",
@@ -21886,6 +21911,7 @@ var server = new McpServer({
     }
   }
 });
+var runningOperations = new Map;
 function safeJsonStringify(obj, fallback = "Unable to stringify object") {
   try {
     return JSON.stringify(obj, null, 2);
@@ -21894,6 +21920,266 @@ function safeJsonStringify(obj, fallback = "Unable to stringify object") {
     return fallback;
   }
 }
+server.registerTool("execute-tool-by-name-async", {
+  title: "Execute Enact Tool (Async)",
+  description: "Execute an Enact tool by its name using direct core integration with background execution for long-running operations",
+  inputSchema: {
+    name: exports_external.string().describe("Name of the tool to execute"),
+    inputs: exports_external.record(exports_external.any()).optional().describe("Input parameters for the 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"),
+    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")
+  }
+}, async (params) => {
+  const { name, inputs = {}, timeout, verifyPolicy, skipVerification, force, dryRun, verbose, async = false } = params;
+  try {
+    logger_default.info(`Executing tool ${name} via direct core library`);
+    const isLongRunningTool = name.includes("dagger") || name.includes("docker") || name.includes("build") || async;
+    if (isLongRunningTool) {
+      const operationId = `${name}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const executionPromise = enactCore2.executeToolByName(name, inputs, {
+        timeout: timeout || "300s",
+        verifyPolicy,
+        skipVerification,
+        force,
+        dryRun,
+        verbose
+      });
+      const operation = {
+        id: operationId,
+        name,
+        startTime: new Date,
+        promise: executionPromise,
+        status: "running",
+        result: undefined,
+        error: undefined
+      };
+      runningOperations.set(operationId, operation);
+      executionPromise.then((result2) => {
+        operation.status = "completed";
+        operation.result = result2;
+        logger_default.info(`Background operation completed: ${operationId}`);
+      }).catch((error) => {
+        operation.status = "failed";
+        operation.error = error;
+        logger_default.error(`Background operation failed: ${operationId}`, error);
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `\uD83D\uDE80 Started background execution of tool: ${name}
+
+Operation ID: ${operationId}
+Started: ${operation.startTime.toISOString()}
+
+⏳ This operation is running in the background. Use the "check-operation-status" tool with operation ID "${operationId}" to check progress.
+
+Estimated completion time: 1-3 minutes for Dagger operations.`
+        }]
+      };
+    }
+    const result = await enactCore2.executeToolByName(name, inputs, {
+      timeout: timeout || "30s",
+      verifyPolicy,
+      skipVerification,
+      force,
+      dryRun,
+      verbose
+    });
+    if (!result.success) {
+      return {
+        content: [{
+          type: "text",
+          text: `❌ Error executing tool ${name}: ${result.error?.message}`
+        }],
+        isError: true
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `✅ Successfully executed tool ${name}
+Output: ${safeJsonStringify(result)}`
+      }]
+    };
+  } catch (error) {
+    logger_default.error(`Error executing tool:`, error);
+    if (error instanceof Error && error.message.includes("timed out")) {
+      return {
+        content: [{
+          type: "text",
+          text: `⏰ Tool execution timed out: ${name}
+
+For long-running operations like Dagger builds, try using the async mode by setting "async": true in your request.
+
+Original error: ${error.message}`
+        }],
+        isError: true
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `Internal error executing tool: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
+server.registerTool("check-operation-status", {
+  title: "Check Operation Status",
+  description: "Check the status of a background operation",
+  inputSchema: {
+    operationId: exports_external.string().describe("The operation ID to check")
+  }
+}, async ({ operationId }) => {
+  try {
+    const operation = runningOperations.get(operationId);
+    if (!operation) {
+      return {
+        content: [{
+          type: "text",
+          text: `❌ Operation not found: ${operationId}
+
+The operation may have been completed and cleaned up, or the ID is incorrect.`
+        }],
+        isError: true
+      };
+    }
+    const duration = Math.round((Date.now() - operation.startTime.getTime()) / 1000);
+    switch (operation.status) {
+      case "running":
+        return {
+          content: [{
+            type: "text",
+            text: `⏳ Operation Status: RUNNING
+
+Operation ID: ${operationId}
+Tool: ${operation.name}
+Started: ${operation.startTime.toISOString()}
+Duration: ${duration} seconds
+
+The operation is still running. Please check again in a moment.`
+          }]
+        };
+      case "completed":
+        if (!operation.resultFetched) {
+          operation.resultFetched = true;
+          setTimeout(() => {
+            console.log(`[INFO] Cleaning up completed operation: ${operationId}`);
+            runningOperations.delete(operationId);
+          }, 60000);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `✅ Operation Status: COMPLETED
+
+Operation ID: ${operationId}
+Tool: ${operation.name}
+Started: ${operation.startTime.toISOString()}
+Duration: ${duration} seconds
+
+Result:
+${safeJsonStringify(operation.result)}`
+          }]
+        };
+      case "failed":
+        if (!operation.errorFetched) {
+          operation.errorFetched = true;
+          setTimeout(() => {
+            console.log(`[INFO] Cleaning up failed operation: ${operationId}`);
+            runningOperations.delete(operationId);
+          }, 60000);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `❌ Operation Status: FAILED
+
+Operation ID: ${operationId}
+Tool: ${operation.name}
+Started: ${operation.startTime.toISOString()}
+Duration: ${duration} seconds
+
+Error: ${operation.error instanceof Error ? operation.error.message : String(operation.error)}`
+          }],
+          isError: true
+        };
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: `❓ Unknown operation status: ${operation.status}`
+          }],
+          isError: true
+        };
+    }
+  } catch (error) {
+    logger_default.error(`Error checking operation status:`, error);
+    return {
+      content: [{
+        type: "text",
+        text: `Error checking operation status: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
+server.registerTool("list-operations", {
+  title: "List Operations",
+  description: "List all background operations",
+  inputSchema: {}
+}, async () => {
+  try {
+    const operations = Array.from(runningOperations.values());
+    if (operations.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: `\uD83D\uDCCB No background operations currently running or recently completed.`
+        }]
+      };
+    }
+    let summary = `\uD83D\uDCCB Background Operations (${operations.length} total)
+
+`;
+    operations.forEach((op) => {
+      const duration = Math.round((Date.now() - op.startTime.getTime()) / 1000);
+      const statusEmoji = op.status === "running" ? "⏳" : op.status === "completed" ? "✅" : "❌";
+      summary += `${statusEmoji} ${op.id}
+`;
+      summary += `   Tool: ${op.name}
+`;
+      summary += `   Status: ${op.status.toUpperCase()}
+`;
+      summary += `   Duration: ${duration}s
+`;
+      summary += `   Started: ${op.startTime.toISOString()}
+
+`;
+    });
+    return {
+      content: [{
+        type: "text",
+        text: summary
+      }]
+    };
+  } catch (error) {
+    logger_default.error(`Error listing operations:`, error);
+    return {
+      content: [{
+        type: "text",
+        text: `Error listing operations: ${error instanceof Error ? error.message : String(error)}`
+      }],
+      isError: true
+    };
+  }
+});
 server.registerTool("execute-tool-by-name", {
   title: "Execute Enact Tool",
   description: "Execute an Enact tool by its name using direct core integration",
@@ -21911,8 +22197,12 @@ server.registerTool("execute-tool-by-name", {
   const { name, inputs = {}, timeout, verifyPolicy, skipVerification, force, dryRun, verbose } = params;
   try {
     logger_default.info(`Executing tool ${name} via direct core library`);
+    const isLongRunningTool = name.includes("dagger") || name.includes("docker") || name.includes("build");
+    if (isLongRunningTool) {
+      logger_default.info(`⏳ Starting long-running operation: ${name} (this may take 1-2 minutes)`);
+    }
     const result = await enactCore2.executeToolByName(name, inputs, {
-      timeout,
+      timeout: timeout || "120s",
       verifyPolicy,
       skipVerification,
       force,
@@ -21937,6 +22227,23 @@ Output: ${safeJsonStringify(result)}`
     };
   } catch (error) {
     logger_default.error(`Error executing tool:`, error);
+    if (error instanceof Error && error.message.includes("timed out")) {
+      return {
+        content: [{
+          type: "text",
+          text: `⏰ Tool execution timed out: ${name}
+
+This may happen with long-running operations like Dagger builds. The operation may still be running in the background. Consider:
+
+1. Running the tool directly from CLI for long operations
+2. Using smaller, more focused operations
+3. Checking if the operation completed successfully outside of MCP
+
+Original error: ${error.message}`
+        }],
+        isError: true
+      };
+    }
     return {
       content: [{
         type: "text",
@@ -22354,25 +22661,6 @@ ${safeJsonStringify(result)}`
   });
   server.server.sendToolListChanged();
 }
-async function main() {
-  try {
-    const transport = new StdioServerTransport;
-    await server.connect(transport);
-    logger_default.info("\uD83D\uDE80 Enact MCP Server with Direct Core Integration started successfully");
-  } catch (error) {
-    console.error("❌ Server connection error:", error);
-    if (error instanceof Error) {
-      console.error("Stack trace:", error.stack);
-    }
-    process.exit(1);
-  }
-}
-if (__require.main == __require.module) {
-  main().catch((error) => {
-    console.error("❌ Failed to start server:", error);
-    process.exit(1);
-  });
-}
 server.registerTool("enact-get-tools-by-author", {
   title: "Get Tools by Author",
   description: "Get tools by a specific author using direct core integration",
@@ -22513,6 +22801,25 @@ ${safeJsonStringify(allResults)}`
     };
   }
 });
+async function main() {
+  try {
+    const transport = new StdioServerTransport;
+    await server.connect(transport);
+    logger_default.info("\uD83D\uDE80 Enact MCP Server with Direct Core Integration started successfully");
+  } catch (error) {
+    console.error("❌ Server connection error:", error);
+    if (error instanceof Error) {
+      console.error("Stack trace:", error.stack);
+    }
+    process.exit(1);
+  }
+}
+if (__require.main == __require.module) {
+  main().catch((error) => {
+    console.error("❌ Failed to start server:", error);
+    process.exit(1);
+  });
+}
 export {
   server,
   enactCore2 as enactCore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enact-cli",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Official CLI for the Enact Protocol - package, secure, and discover AI tools",
   "type": "module",
   "main": "./dist/index.js",
@@ -76,4 +76,4 @@
     "yaml": "^2.8.0",
     "zod": "^3.25.67"
   }
-}
+}