@enactprotocol/shared 1.2.3 → 1.2.5

package/dist/api/enact-api.d.ts

@@ -2,7 +2,11 @@ import { EnactToolDefinition, ToolUsage, ToolSearchQuery, CLITokenCreate, OAuthT
 export declare class EnactApiClient {
     baseUrl: string;
     supabaseUrl: string;
-    constructor(baseUrl?: string, supabaseUrl?: string);
+    constructor(baseUrl: string, supabaseUrl: string);
+    /**
+     * Create API client with config-based URLs
+     */
+    static create(baseUrl?: string, supabaseUrl?: string): Promise<EnactApiClient>;
     private makeRequest;
     /**
      * Get all tools (public, no auth required)
@@ -115,6 +119,7 @@ export declare class EnactApiClient {
         errors: string[];
     };
 }
+export declare function createDefaultApiClient(): Promise<EnactApiClient>;
 export declare const enactApi: EnactApiClient;
 export declare class EnactApiError extends Error {
     statusCode?: number | undefined;

package/dist/api/enact-api.js

@@ -1,8 +1,17 @@
+import { getFrontendUrl, getApiUrl } from "../utils/config";
 export class EnactApiClient {
-    constructor(baseUrl = "https://enact.tools", supabaseUrl = "https://xjnhhxwxovjifdxdwzih.supabase.co") {
+    constructor(baseUrl, supabaseUrl) {
         this.baseUrl = baseUrl.replace(/\/$/, ""); // Remove trailing slash
         this.supabaseUrl = supabaseUrl.replace(/\/$/, "");
     }
+    /**
+     * Create API client with config-based URLs
+     */
+    static async create(baseUrl, supabaseUrl) {
+        const frontendUrl = baseUrl || await getFrontendUrl();
+        const apiUrl = supabaseUrl || await getApiUrl();
+        return new EnactApiClient(frontendUrl, apiUrl);
+    }
     // Helper method to make authenticated requests
     async makeRequest(endpoint, options = {}, token, tokenType = "jwt") {
         const url = endpoint.startsWith("http")
@@ -389,8 +398,12 @@ export class EnactApiClient {
         };
     }
 }
-// Export a default instance
-export const enactApi = new EnactApiClient();
+// Export a default instance factory
+export async function createDefaultApiClient() {
+    return await EnactApiClient.create();
+}
+// Keep backward compatibility with sync usage
+export const enactApi = new EnactApiClient("https://enact.tools", "https://xjnhhxwxovjifdxdwzih.supabase.co");
 // Export error types for better error handling
 export class EnactApiError extends Error {
     constructor(message, statusCode, endpoint) {
@@ -402,5 +415,7 @@ export class EnactApiError extends Error {
 }
 // Helper function to create API client with custom configuration
 export function createEnactApiClient(baseUrl, supabaseUrl) {
-    return new EnactApiClient(baseUrl, supabaseUrl);
+    const defaultFrontend = "https://enact.tools";
+    const defaultApi = "https://xjnhhxwxovjifdxdwzih.supabase.co";
+    return new EnactApiClient(baseUrl || defaultFrontend, supabaseUrl || defaultApi);
 }

package/dist/api/types.d.ts

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

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared constants for Enact CLI
+ */
+export declare const DEFAULT_FRONTEND_URL = "https://enact.tools";
+export declare const DEFAULT_API_URL = "https://xjnhhxwxovjifdxdwzih.supabase.co";
+export declare const ENV_FRONTEND_URL = "ENACT_FRONTEND_URL";
+export declare const ENV_API_URL = "ENACT_API_URL";

package/dist/constants.js

@@ -0,0 +1,10 @@
+/**
+ * Shared constants for Enact CLI
+ */
+// Frontend URL - used for OAuth redirects, registry browsing, documentation links
+export const DEFAULT_FRONTEND_URL = "https://enact.tools";
+// Backend API URL - used for all API calls (search, publish, etc.)
+export const DEFAULT_API_URL = "https://xjnhhxwxovjifdxdwzih.supabase.co";
+// Environment variable names for overriding defaults
+export const ENV_FRONTEND_URL = "ENACT_FRONTEND_URL";
+export const ENV_API_URL = "ENACT_API_URL";

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
      */
@@ -145,10 +149,6 @@ export declare class DaggerExecutionProvider extends ExecutionProvider {
      * Graceful shutdown with proper async cleanup
      */
     private gracefulShutdown;
-    /**
-     * Enhanced force cleanup for synchronous exit handlers
-     */
-    private forceCleanup;
     /**
      * Get current engine status for debugging
      */

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));
@@ -935,43 +1001,6 @@ export class DaggerExecutionProvider extends ExecutionProvider {
             process.exit(1);
         }
     }
-    /**
-     * Enhanced force cleanup for synchronous exit handlers
-     */
-    forceCleanup() {
-        if (this.isShuttingDown)
-            return;
-        try {
-            logger.info("🔄 Force cleaning up Dagger engines...");
-            const result = spawnSync("docker", [
-                "ps",
-                "--all",
-                "--filter",
-                "name=dagger-engine",
-                "--format",
-                "{{.Names}}",
-            ], {
-                encoding: "utf8",
-                timeout: 5000,
-            });
-            if (result.stdout) {
-                const names = result.stdout
-                    .trim()
-                    .split("\n")
-                    .filter((n) => n.trim());
-                if (names.length > 0) {
-                    logger.info(`Found ${names.length} engine containers, force removing...`);
-                    for (const name of names) {
-                        spawnSync("docker", ["rm", "-f", name.trim()], { timeout: 3000 });
-                    }
-                    logger.info("✅ Force cleanup completed");
-                }
-            }
-        }
-        catch (error) {
-            logger.debug("Force cleanup failed (this is usually fine):", error);
-        }
-    }
     /**
      * Get current engine status for debugging
      */

package/dist/core/EnactCore.d.ts

@@ -28,12 +28,17 @@ export interface ToolExecuteOptions {
     verbose?: boolean;
     isLocalFile?: boolean;
     dangerouslySkipVerification?: boolean;
+    mount?: string;
 }
 export declare class EnactCore {
     private apiClient;
     private executionProvider;
     private options;
     constructor(options?: EnactCoreOptions);
+    /**
+     * Create EnactCore with config-based URLs
+     */
+    static create(options?: EnactCoreOptions): Promise<EnactCore>;
     /**
      * Set authentication token for API operations
      */

package/dist/core/EnactCore.js

@@ -6,11 +6,12 @@ import { resolveToolEnvironmentVariables } from "../utils/env-loader.js";
 import logger from "../exec/logger.js";
 import yaml from "yaml";
 import { CryptoUtils, SecurityConfigManager, SigningService } from "@enactprotocol/security";
+import { getFrontendUrl, getApiUrl } from "../utils/config";
 export class EnactCore {
     constructor(options = {}) {
         this.options = {
-            apiUrl: "https://enact.tools",
-            supabaseUrl: "https://xjnhhxwxovjifdxdwzih.supabase.co",
+            apiUrl: "https://enact.tools", // Default, will be overridden by factory
+            supabaseUrl: "https://xjnhhxwxovjifdxdwzih.supabase.co", // Default, will be overridden by factory
             executionProvider: "dagger",
             defaultTimeout: "30s",
             ...options,
@@ -19,6 +20,18 @@ export class EnactCore {
         // Initialize the appropriate execution provider
         this.executionProvider = this.createExecutionProvider();
     }
+    /**
+     * Create EnactCore with config-based URLs
+     */
+    static async create(options = {}) {
+        const frontendUrl = options.apiUrl || await getFrontendUrl();
+        const apiUrl = options.supabaseUrl || await getApiUrl();
+        return new EnactCore({
+            ...options,
+            apiUrl: frontendUrl,
+            supabaseUrl: apiUrl,
+        });
+    }
     /**
      * Set authentication token for API operations
      */
@@ -292,7 +305,7 @@ export class EnactCore {
             // Check trusted keys
             // const trustedKeys = KeyManager.getAllTrustedPublicKeys();
             const isValid = SigningService.verifyDocument(documentForVerification, referenceSignature, { includeFields: ['command'] });
-            console.log("Final verification result:", isValid);
+            // console.log("Final verification result:", isValid);
             if (!isValid) {
                 throw new Error(`Tool ${tool.name} has invalid signatures`);
             }
@@ -332,6 +345,7 @@ export class EnactCore {
                 resources: {
                     timeout: options.timeout || tool.timeout || this.options.defaultTimeout,
                 },
+                mount: options.mount,
             });
         }
         catch (error) {

package/dist/lib/enact-direct.d.ts

@@ -14,6 +14,15 @@ export declare class EnactDirect {
         authToken?: string;
         defaultTimeout?: string;
     });
+    /**
+     * Create EnactDirect with config-based URLs
+     */
+    static create(options?: {
+        apiUrl?: string;
+        supabaseUrl?: string;
+        authToken?: string;
+        defaultTimeout?: string;
+    }): Promise<EnactDirect>;
     /**
      * Execute a tool by name with inputs
      *

package/dist/lib/enact-direct.js

@@ -1,5 +1,6 @@
 // src/lib/enact-direct.ts - Library interface for direct usage by MCP servers
 import { EnactCore, } from "../core/EnactCore";
+import { getFrontendUrl, getApiUrl } from "../utils/config";
 /**
  * Direct Enact Library Interface
  *
@@ -8,16 +9,27 @@ import { EnactCore, } from "../core/EnactCore";
  */
 export class EnactDirect {
     constructor(options = {}) {
+        // We need to handle async config loading in a factory method
         this.core = new EnactCore({
-            apiUrl: options.apiUrl || process.env.ENACT_API_URL || "https://enact.tools",
-            supabaseUrl: options.supabaseUrl ||
-                process.env.ENACT_SUPABASE_URL ||
-                "https://xjnhhxwxovjifdxdwzih.supabase.co",
+            apiUrl: options.apiUrl || process.env.ENACT_FRONTEND_URL || "https://enact.tools",
+            supabaseUrl: options.supabaseUrl || process.env.ENACT_API_URL || "https://xjnhhxwxovjifdxdwzih.supabase.co",
             executionProvider: "direct",
             authToken: options.authToken || process.env.ENACT_AUTH_TOKEN,
             defaultTimeout: options.defaultTimeout || "30s",
         });
     }
+    /**
+     * Create EnactDirect with config-based URLs
+     */
+    static async create(options = {}) {
+        const frontendUrl = options.apiUrl || process.env.ENACT_FRONTEND_URL || await getFrontendUrl();
+        const apiUrl = options.supabaseUrl || process.env.ENACT_API_URL || await getApiUrl();
+        return new EnactDirect({
+            ...options,
+            apiUrl: frontendUrl,
+            supabaseUrl: apiUrl,
+        });
+    }
     /**
      * Execute a tool by name with inputs
      *

package/dist/services/McpCoreService.d.ts

@@ -6,6 +6,14 @@ export declare class McpCoreService {
         supabaseUrl?: string;
         authToken?: string;
     });
+    /**
+     * Create McpCoreService with config-based URLs
+     */
+    static create(options?: {
+        apiUrl?: string;
+        supabaseUrl?: string;
+        authToken?: string;
+    }): Promise<McpCoreService>;
     /**
      * Set authentication token
      */

package/dist/services/McpCoreService.js

@@ -1,5 +1,6 @@
 // src/services/McpCoreService.ts - Direct core integration for MCP server
 import { EnactCore } from "../core/EnactCore";
+import { getFrontendUrl, getApiUrl } from "../utils/config";
 export class McpCoreService {
     constructor(options) {
         this.core = new EnactCore({
@@ -8,6 +9,18 @@ export class McpCoreService {
             authToken: options?.authToken,
         });
     }
+    /**
+     * Create McpCoreService with config-based URLs
+     */
+    static async create(options) {
+        const frontendUrl = options?.apiUrl || await getFrontendUrl();
+        const apiUrl = options?.supabaseUrl || await getApiUrl();
+        return new McpCoreService({
+            ...options,
+            apiUrl: frontendUrl,
+            supabaseUrl: apiUrl,
+        });
+    }
     /**
      * Set authentication token
      */

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/dist/utils/config.d.ts

@@ -1,6 +1,10 @@
 export interface EnactConfig {
     defaultUrl?: string;
     history?: string[];
+    urls?: {
+        frontend?: string;
+        api?: string;
+    };
 }
 /**
  * Ensure config directory and file exist
@@ -30,3 +34,78 @@ export declare function setDefaultUrl(url: string): Promise<void>;
  * Get the default publish URL
  */
 export declare function getDefaultUrl(): Promise<string | undefined>;
+export interface TrustedKeyMeta {
+    name: string;
+    description?: string;
+    addedAt: string;
+    source: "default" | "user" | "organization";
+    keyFile: string;
+}
+export interface TrustedKey {
+    id: string;
+    name: string;
+    publicKey: string;
+    description?: string;
+    addedAt: string;
+    source: "default" | "user" | "organization";
+    keyFile: string;
+}
+/**
+ * Get the frontend URL with fallbacks
+ */
+export declare function getFrontendUrl(): Promise<string>;
+/**
+ * Get the API URL with fallbacks
+ */
+export declare function getApiUrl(): Promise<string>;
+/**
+ * Set the frontend URL in config
+ */
+export declare function setFrontendUrl(url: string): Promise<void>;
+/**
+ * Set the API URL in config
+ */
+export declare function setApiUrl(url: string): Promise<void>;
+/**
+ * Reset URLs to defaults
+ */
+export declare function resetUrls(): Promise<void>;
+/**
+ * Get current URL configuration
+ */
+export declare function getUrlConfig(): Promise<{
+    frontend: {
+        value: string;
+        source: string;
+    };
+    api: {
+        value: string;
+        source: string;
+    };
+}>;
+/**
+ * Read all trusted keys from directory
+ */
+export declare function getTrustedKeys(): Promise<TrustedKey[]>;
+/**
+ * Add a trusted key
+ */
+export declare function addTrustedKey(keyData: {
+    id: string;
+    name: string;
+    publicKey: string;
+    description?: string;
+    source?: "user" | "organization";
+}): Promise<void>;
+/**
+ * Remove a trusted key
+ */
+export declare function removeTrustedKey(keyId: string): Promise<void>;
+/**
+ * Get a specific trusted key
+ */
+export declare function getTrustedKey(keyId: string): Promise<TrustedKey | null>;
+/**
+ * Check if a public key is trusted
+ */
+export declare function isKeyTrusted(publicKey: string): Promise<boolean>;