@enactprotocol/shared 1.2.4 → 1.2.6

package/dist/api/types.d.ts

@@ -87,4 +87,5 @@ export interface EnactExecOptions {
     verbose?: boolean;
     force?: boolean;
     dangerouslySkipVerification?: boolean;
+    mount?: string;
 }

package/dist/core/DaggerExecutionProvider.d.ts

@@ -72,6 +72,10 @@ export declare class DaggerExecutionProvider extends ExecutionProvider {
      * Execute command using Dagger connect with proper session management
      */
     private executeWithConnect;
+    /**
+     * Setup directory mounting for the container
+     */
+    private setupDirectoryMount;
     /**
      * Enhanced container setup with better tool detection and installation
      */

package/dist/core/DaggerExecutionProvider.js

@@ -504,6 +504,68 @@ export class DaggerExecutionProvider extends ExecutionProvider {
             });
         });
     }
+    /**
+     * Setup directory mounting for the container
+     */
+    async setupDirectoryMount(client, container, mountSpec) {
+        try {
+            // Parse mount specification (format: "localPath" or "localPath:containerPath")
+            let localPath;
+            let containerPath;
+            // Handle Windows drive letters (e.g., C:\path) vs mount separator (:)
+            const colonIndex = mountSpec.indexOf(':');
+            if (colonIndex > 0) {
+                // Check if this might be a Windows drive letter (single letter followed by colon)
+                const potentialDriveLetter = mountSpec.substring(0, colonIndex);
+                const isWindowsDrive = potentialDriveLetter.length === 1 && /[A-Za-z]/.test(potentialDriveLetter);
+                if (isWindowsDrive) {
+                    // Look for the next colon that separates local from container path
+                    const nextColonIndex = mountSpec.indexOf(':', colonIndex + 1);
+                    if (nextColonIndex > 0) {
+                        localPath = mountSpec.substring(0, nextColonIndex);
+                        containerPath = mountSpec.substring(nextColonIndex + 1);
+                    }
+                    else {
+                        // No container path specified, use default
+                        localPath = mountSpec;
+                        containerPath = '/workspace/src';
+                    }
+                }
+                else {
+                    // Regular path:container split
+                    localPath = mountSpec.substring(0, colonIndex);
+                    containerPath = mountSpec.substring(colonIndex + 1);
+                }
+            }
+            else if (colonIndex === 0) {
+                // Starts with colon (e.g., ":/app")
+                localPath = '';
+                containerPath = mountSpec.substring(1);
+            }
+            else {
+                localPath = mountSpec;
+                containerPath = '/workspace/src'; // Default container path
+            }
+            // Resolve local path to absolute path
+            const path = require('path');
+            const resolvedLocalPath = path.resolve(localPath);
+            // Check if local directory exists
+            const fs = require('fs');
+            if (!fs.existsSync(resolvedLocalPath)) {
+                throw new Error(`Mount source directory does not exist: ${resolvedLocalPath}`);
+            }
+            // Create Directory object from local path
+            const hostDirectory = client.host().directory(resolvedLocalPath);
+            // Mount directory in container using withMountedDirectory for better performance
+            container = container.withMountedDirectory(containerPath, hostDirectory);
+            logger.debug(`📂 Mounted ${resolvedLocalPath} -> ${containerPath}`);
+            return container;
+        }
+        catch (error) {
+            logger.error(`Failed to setup directory mount: ${error}`);
+            throw error;
+        }
+    }
     /**
      * Enhanced container setup with better tool detection and installation
      */
@@ -517,6 +579,10 @@ export class DaggerExecutionProvider extends ExecutionProvider {
         // Set working directory
         container = container.withWorkdir(this.options.workdir);
         logger.debug(`📁 Working directory set to: ${this.options.workdir}`);
+        // Handle directory mounting if specified
+        if (environment.mount) {
+            container = await this.setupDirectoryMount(client, container, environment.mount);
+        }
         // Add environment variables from Enact tool env config
         for (const [key, value] of Object.entries(environment.vars)) {
             container = container.withEnvVariable(key, String(value));

package/dist/core/EnactCore.d.ts

@@ -28,6 +28,7 @@ export interface ToolExecuteOptions {
     verbose?: boolean;
     isLocalFile?: boolean;
     dangerouslySkipVerification?: boolean;
+    mount?: string;
 }
 export declare class EnactCore {
     private apiClient;

package/dist/core/EnactCore.js

@@ -288,7 +288,10 @@ export 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,
@@ -297,15 +300,15 @@ export class EnactCore {
                 timestamp: new Date(tool.signatures[0].created).getTime()
             };
             // Check what canonical document looks like
-            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);
             // Test direct crypto verification
             const directVerify = CryptoUtils.verify(referenceSignature.publicKey, messageHash, referenceSignature.signature);
             // Check trusted keys
             // const trustedKeys = KeyManager.getAllTrustedPublicKeys();
-            const isValid = SigningService.verifyDocument(documentForVerification, referenceSignature, { includeFields: ['command'] });
-            console.log("Final verification result:", isValid);
+            const isValid = SigningService.verifyDocument(documentForVerification, referenceSignature, { includeFields: ['command', 'description', 'from', 'name'] });
+            // console.log("Final verification result:", isValid);
             if (!isValid) {
                 throw new Error(`Tool ${tool.name} has invalid signatures`);
             }
@@ -345,6 +348,7 @@ export class EnactCore {
                 resources: {
                     timeout: options.timeout || tool.timeout || this.options.defaultTimeout,
                 },
+                mount: options.mount,
             });
         }
         catch (error) {

package/dist/types.d.ts

@@ -117,6 +117,7 @@ export interface ExecutionEnvironment {
         timeout?: string;
     };
     namespace?: string;
+    mount?: string;
 }
 export declare abstract class ExecutionProvider {
     abstract setup(tool: EnactTool): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enactprotocol/shared",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "Shared utilities and core functionality for Enact Protocol",
   "type": "module",
   "main": "./dist/index.js",

package/src/api/types.ts

@@ -97,4 +97,5 @@ export interface EnactExecOptions {
 	verbose?: boolean;
 	force?: boolean; // Force execution even if verification fails (legacy)
 	dangerouslySkipVerification?: boolean; // Skip all signature verification (DANGEROUS)
+	mount?: string; // Mount local directory to container (format: "local:container")
 }

package/src/core/DaggerExecutionProvider.ts

@@ -702,6 +702,77 @@ export class DaggerExecutionProvider extends ExecutionProvider {
 		});
 	}
 
+	/**
+	 * Setup directory mounting for the container
+	 */
+	private async setupDirectoryMount(
+		client: Client,
+		container: Container,
+		mountSpec: string,
+	): Promise<Container> {
+		try {
+			// Parse mount specification (format: "localPath" or "localPath:containerPath")
+			let localPath: string;
+			let containerPath: string;
+
+			// Handle Windows drive letters (e.g., C:\path) vs mount separator (:)
+			const colonIndex = mountSpec.indexOf(':');
+			
+			if (colonIndex > 0) {
+				// Check if this might be a Windows drive letter (single letter followed by colon)
+				const potentialDriveLetter = mountSpec.substring(0, colonIndex);
+				const isWindowsDrive = potentialDriveLetter.length === 1 && /[A-Za-z]/.test(potentialDriveLetter);
+				
+				if (isWindowsDrive) {
+					// Look for the next colon that separates local from container path
+					const nextColonIndex = mountSpec.indexOf(':', colonIndex + 1);
+					if (nextColonIndex > 0) {
+						localPath = mountSpec.substring(0, nextColonIndex);
+						containerPath = mountSpec.substring(nextColonIndex + 1);
+					} else {
+						// No container path specified, use default
+						localPath = mountSpec;
+						containerPath = '/workspace/src';
+					}
+				} else {
+					// Regular path:container split
+					localPath = mountSpec.substring(0, colonIndex);
+					containerPath = mountSpec.substring(colonIndex + 1);
+				}
+			} else if (colonIndex === 0) {
+				// Starts with colon (e.g., ":/app")
+				localPath = '';
+				containerPath = mountSpec.substring(1);
+			} else {
+				localPath = mountSpec;
+				containerPath = '/workspace/src'; // Default container path
+			}
+
+			// Resolve local path to absolute path
+			const path = require('path');
+			const resolvedLocalPath = path.resolve(localPath);
+
+			// Check if local directory exists
+			const fs = require('fs');
+			if (!fs.existsSync(resolvedLocalPath)) {
+				throw new Error(`Mount source directory does not exist: ${resolvedLocalPath}`);
+			}
+
+			// Create Directory object from local path
+			const hostDirectory = client.host().directory(resolvedLocalPath);
+
+			// Mount directory in container using withMountedDirectory for better performance
+			container = container.withMountedDirectory(containerPath, hostDirectory);
+
+			logger.debug(`📂 Mounted ${resolvedLocalPath} -> ${containerPath}`);
+			
+			return container;
+		} catch (error) {
+			logger.error(`Failed to setup directory mount: ${error}`);
+			throw error;
+		}
+	}
+
 	/**
 	 * Enhanced container setup with better tool detection and installation
 	 */
@@ -726,6 +797,11 @@ export class DaggerExecutionProvider extends ExecutionProvider {
 		container = container.withWorkdir(this.options.workdir!);
 		logger.debug(`📁 Working directory set to: ${this.options.workdir}`);
 
+		// Handle directory mounting if specified
+		if (environment.mount) {
+			container = await this.setupDirectoryMount(client, container, environment.mount);
+		}
+
 		// Add environment variables from Enact tool env config
 		for (const [key, value] of Object.entries(environment.vars)) {
 			container = container.withEnvVariable(key, String(value));

package/src/core/EnactCore.ts

@@ -52,6 +52,7 @@ export interface ToolExecuteOptions {
 	verbose?: boolean;
 	isLocalFile?: boolean;
 	dangerouslySkipVerification?: boolean;
+	mount?: string; // Mount local directory to container (format: "localPath" or "localPath:containerPath")
 }
 
 export class EnactCore {
@@ -419,7 +420,10 @@ private async verifyTool(tool: EnactTool, dangerouslySkipVerification: boolean =
 		}
 	
 		const documentForVerification = {
-			command: tool.command
+			command: tool.command,
+			description: tool.description,
+			from: tool.from,
+			name: tool.name,
 		};
 
        	const referenceSignature = {
@@ -431,7 +435,8 @@ private async verifyTool(tool: EnactTool, dangerouslySkipVerification: boolean =
 
         
         // Check what canonical document looks like
-        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);
@@ -450,10 +455,10 @@ private async verifyTool(tool: EnactTool, dangerouslySkipVerification: boolean =
         const isValid = SigningService.verifyDocument(
             documentForVerification,
             referenceSignature,
-            { includeFields: ['command'] }
+    		{ includeFields: ['command', 'description', 'from', 'name'] }
         );
         
-        console.log("Final verification result:", isValid);
+        // console.log("Final verification result:", isValid);
 
         if (!isValid) {
             throw new Error(`Tool ${tool.name} has invalid signatures`);
@@ -510,6 +515,7 @@ private async verifyTool(tool: EnactTool, dangerouslySkipVerification: boolean =
 					resources: {
 						timeout: options.timeout || tool.timeout || this.options.defaultTimeout,
 					},
+					mount: options.mount,
 				},
 			);
 		} catch (error) {

package/src/types.ts

@@ -162,6 +162,7 @@ export interface ExecutionEnvironment {
 		timeout?: string;
 	};
 	namespace?: string; // Environment variable namespace
+	mount?: string; // Mount local directory to container (format: "localPath" or "localPath:containerPath")
 }
 
 // Updated execution provider interface