@enactprotocol/shared 1.0.13 → 1.2.0

package/dist/api/enact-api.js

@@ -33,7 +33,7 @@ export class EnactApiClient {
         }
         const responseData = await response.json();
         // Debug logging to help identify response structure issues
-        if (process.env.NODE_ENV === "development" || process.env.DEBUG) {
+        if ((process.env.NODE_ENV === "development" || process.env.DEBUG) && !process.env.ENACT_SILENT) {
             console.error(`API Response for ${endpoint}:`, responseData);
         }
         return responseData;
@@ -103,7 +103,7 @@ export class EnactApiClient {
         const endpoint = "/functions/v1/tools-search";
         try {
             // Log the request for debugging
-            if (process.env.NODE_ENV === "development" || process.env.DEBUG) {
+            if ((process.env.NODE_ENV === "development" || process.env.DEBUG) && !process.env.ENACT_SILENT) {
                 console.error(`Search request to ${endpoint}:`, JSON.stringify(query, null, 2));
             }
             const response = await this.makeRequest(endpoint, {

package/dist/api/types.d.ts

@@ -2,6 +2,7 @@ export interface EnactToolDefinition {
     name: string;
     description: string;
     command: string;
+    from?: string;
     version?: string;
     timeout?: string;
     tags?: string[];
@@ -34,7 +35,14 @@ export interface EnactToolDefinition {
         value: string;
         role?: string;
     };
-    signatures?: Record<string, any>;
+    signatures?: {
+        signer: string;
+        algorithm: string;
+        type: string;
+        value: string;
+        created: string;
+        role?: string;
+    }[];
     raw_content?: string;
     namespace?: string;
     enact?: string;
@@ -77,7 +85,6 @@ export interface EnactExecOptions {
     timeout?: string;
     dry?: boolean;
     verbose?: boolean;
-    skipVerification?: boolean;
-    verifyPolicy?: string;
     force?: boolean;
+    dangerouslySkipVerification?: boolean;
 }

package/dist/core/DaggerExecutionProvider.d.ts

@@ -67,7 +67,7 @@ export declare class DaggerExecutionProvider extends ExecutionProvider {
         verbose?: boolean;
         showSpinner?: boolean;
         streamOutput?: boolean;
-    }): Promise<CommandResult>;
+    }, tool?: EnactTool): Promise<CommandResult>;
     /**
      * Execute command using Dagger connect with proper session management
      */

package/dist/core/DaggerExecutionProvider.js

@@ -294,7 +294,7 @@ export class DaggerExecutionProvider extends ExecutionProvider {
                         logger.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.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 {
@@ -389,7 +389,7 @@ export 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;
         // Create abort controller for this execution
@@ -410,16 +410,18 @@ export class DaggerExecutionProvider extends ExecutionProvider {
             // Substitute template variables in command (Enact Protocol style)
             const substitutedCommand = this.substituteCommandVariables(command, inputs);
             if (verbose) {
+                // Determine which container image to use - prefer tool's 'from' field over default baseImage
+                const containerImage = tool?.from || this.options.baseImage;
                 try {
                     const pc = require("picocolors");
                     console.error(pc.cyan("\n🐳 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 (e) {
                     console.error("\n🐳 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)'}`);
                 }
             }
             // Parse and apply timeout with engine timeout consideration
@@ -428,7 +430,7 @@ export class DaggerExecutionProvider extends ExecutionProvider {
             logger.debug(`Parsed timeout: ${effectiveTimeout}ms (command: ${timeoutMs}ms, engine: ${this.options.engineTimeout}ms)`);
             // Execute command with enhanced error handling and timeout management
             const result = await Promise.race([
-                this.executeWithConnect(substitutedCommand, environment, inputs),
+                this.executeWithConnect(substitutedCommand, environment, inputs, tool),
                 this.createTimeoutPromise(effectiveTimeout),
             ]);
             if (spinner) {
@@ -462,7 +464,7 @@ export class DaggerExecutionProvider extends ExecutionProvider {
     /**
      * Execute command using Dagger connect with proper session management
      */
-    async executeWithConnect(command, environment, inputs) {
+    async executeWithConnect(command, environment, inputs, tool) {
         return new Promise((resolve, reject) => {
             // Setup abort handling
             const abortHandler = () => {
@@ -474,7 +476,7 @@ export class DaggerExecutionProvider extends ExecutionProvider {
             connect(async (client) => {
                 try {
                     logger.debug("🔗 Connected to Dagger client");
-                    const container = await this.setupContainer(client, environment, inputs);
+                    const container = await this.setupContainer(client, environment, inputs, tool);
                     logger.debug("📦 Container setup complete");
                     const commandResult = await this.executeInContainer(container, command);
                     logger.debug("⚡ Command execution complete");
@@ -505,10 +507,12 @@ export class DaggerExecutionProvider extends ExecutionProvider {
     /**
      * Enhanced container setup with better tool detection and installation
      */
-    async setupContainer(client, environment, inputs) {
-        logger.debug(`🚀 Setting up container with base image: ${this.options.baseImage}`);
+    async setupContainer(client, environment, inputs, tool) {
+        // Determine which container image to use - prefer tool's 'from' field over default baseImage
+        const containerImage = tool?.from || this.options.baseImage;
+        logger.debug(`🚀 Setting up container with image: ${containerImage}${tool?.from ? ' (from tool.from)' : ' (default baseImage)'}`);
         // Start with base container
-        let container = client.container().from(this.options.baseImage);
+        let container = client.container().from(containerImage);
         logger.debug("📦 Base container created");
         // Set working directory
         container = container.withWorkdir(this.options.workdir);
@@ -520,7 +524,7 @@ export class DaggerExecutionProvider extends ExecutionProvider {
         logger.debug(`🌍 Added ${Object.keys(environment.vars).length} environment variables`);
         // Install common tools needed for Enact commands
         if (this.options.enableNetwork) {
-            container = await this.installCommonTools(container);
+            container = await this.installCommonTools(container, containerImage);
             logger.debug("🔧 Common tools installed");
         }
         else {
@@ -541,18 +545,18 @@ export class DaggerExecutionProvider extends ExecutionProvider {
      * Install common tools that Enact commands might need
      * Enhanced with better error handling and timeout
      */
-    async installCommonTools(container) {
-        logger.debug(`🔧 Installing common tools for base image: ${this.options.baseImage}`);
+    async installCommonTools(container, containerImage) {
+        logger.debug(`🔧 Installing common tools for container image: ${containerImage}`);
         try {
             // For node images, most tools are already available, so we can skip installation
-            if (this.options.baseImage?.includes("node:")) {
+            if (containerImage.includes("node:")) {
                 logger.debug("📦 Node.js image detected, skipping tool installation (most tools already available)");
                 return container;
             }
             // Determine package manager based on base image
-            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.debug("📦 Detected Alpine Linux, installing basic tools");
                 // Alpine Linux uses apk package manager - with better timeout handling
@@ -572,7 +576,7 @@ export class DaggerExecutionProvider extends ExecutionProvider {
                 ]);
             }
             else {
-                logger.warn(`Unknown base image ${this.options.baseImage}, skipping tool installation`);
+                logger.warn(`Unknown container image ${containerImage}, skipping tool installation`);
             }
             logger.debug("✅ Common tools installation complete");
             return container;
@@ -878,7 +882,7 @@ export 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}`);
         }

package/dist/core/EnactCore.d.ts

@@ -6,7 +6,6 @@ export interface EnactCoreOptions {
     authToken?: string;
     verbose?: boolean;
     defaultTimeout?: string;
-    verificationPolicy?: "permissive" | "enterprise" | "paranoid";
     daggerOptions?: {
         baseImage?: string;
         enableNetwork?: boolean;
@@ -24,11 +23,11 @@ export interface ToolSearchOptions {
 }
 export interface ToolExecuteOptions {
     timeout?: string;
-    verifyPolicy?: "permissive" | "enterprise" | "paranoid";
-    skipVerification?: boolean;
     force?: boolean;
     dryRun?: boolean;
     verbose?: boolean;
+    isLocalFile?: boolean;
+    dangerouslySkipVerification?: boolean;
 }
 export declare class EnactCore {
     private apiClient;
@@ -40,21 +39,30 @@ export declare class EnactCore {
      */
     setAuthToken(token: string): void;
     /**
-     * Search for tools
+     * Static method to search for tools (no execution provider needed)
+     */
+    static searchTools(options: ToolSearchOptions, coreOptions?: Pick<EnactCoreOptions, 'apiUrl' | 'supabaseUrl'>): Promise<EnactTool[]>;
+    /**
+     * Instance method wrapper for backward compatibility
      */
     searchTools(options: ToolSearchOptions): Promise<EnactTool[]>;
     /**
-     * Fallback search method that gets all tools and filters locally
+     * Static fallback search method that gets all tools and filters locally
+     */
+    private static searchToolsFallback;
+    /**
+     * Static method to get a specific tool by name
      */
-    private searchToolsFallback;
+    static getToolByName(name: string, version?: string, coreOptions?: Pick<EnactCoreOptions, 'apiUrl' | 'supabaseUrl'>): Promise<EnactTool | null>;
     /**
-     * Get a specific tool by name
+     * Instance method wrapper for backward compatibility
      */
     getToolByName(name: string, version?: string): Promise<EnactTool | null>;
     /**
      * Execute a tool by name
      */
     executeToolByName(name: string, inputs?: Record<string, any>, options?: ToolExecuteOptions): Promise<ExecutionResult>;
+    private verifyTool;
     /**
      * Execute a tool directly
      */
@@ -64,16 +72,11 @@ export declare class EnactCore {
      */
     executeRawTool(toolYaml: string, inputs?: Record<string, any>, options?: ToolExecuteOptions): Promise<ExecutionResult>;
     /**
-     * Verify a tool's signature
+     * Static method to check if a tool exists
      */
-    verifyTool(name: string, policy?: string): Promise<{
-        verified: boolean;
-        signatures: any[];
-        policy: string;
-        errors?: string[];
-    }>;
+    static toolExists(name: string, coreOptions?: Pick<EnactCoreOptions, 'apiUrl' | 'supabaseUrl'>): Promise<boolean>;
     /**
-     * Check if a tool exists
+     * Instance method wrapper for backward compatibility
      */
     toolExists(name: string): Promise<boolean>;
     /**
@@ -85,7 +88,16 @@ export declare class EnactCore {
      */
     getToolsByAuthor(author: string, limit?: number): Promise<EnactTool[]>;
     /**
-     * Get all tools with filters
+     * Static method to get all tools with filters
+     */
+    static getTools(options?: {
+        limit?: number;
+        offset?: number;
+        tags?: string[];
+        author?: string;
+    }, coreOptions?: Pick<EnactCoreOptions, 'apiUrl' | 'supabaseUrl'>): Promise<EnactTool[]>;
+    /**
+     * Instance method wrapper for backward compatibility
      */
     getTools(options?: {
         limit?: number;
@@ -102,7 +114,14 @@ export declare class EnactCore {
         server?: string;
     }>;
     /**
-     * Publish a tool (requires authentication)
+     * Static method to publish a tool
+     */
+    static publishTool(tool: EnactTool, authToken: string, coreOptions?: Pick<EnactCoreOptions, 'apiUrl' | 'supabaseUrl'>): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Instance method wrapper for backward compatibility
      */
     publishTool(tool: EnactTool): Promise<{
         success: boolean;
@@ -118,7 +137,6 @@ export declare class EnactCore {
     getStatus(): Promise<{
         executionProvider: string;
         apiUrl: string;
-        verificationPolicy: string;
         defaultTimeout: string;
         authenticated: boolean;
     }>;
@@ -135,4 +153,3 @@ export declare class EnactCore {
      */
     private generateExecutionId;
 }
-export declare const enactCore: EnactCore;