@enactprotocol/shared 1.2.2 → 1.2.4

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/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

@@ -145,10 +145,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

@@ -935,43 +935,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

@@ -34,6 +34,10 @@ export declare class EnactCore {
     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

@@ -5,12 +5,13 @@ import { DaggerExecutionProvider } from "./DaggerExecutionProvider.js";
 import { resolveToolEnvironmentVariables } from "../utils/env-loader.js";
 import logger from "../exec/logger.js";
 import yaml from "yaml";
-import { CryptoUtils, KeyManager, SecurityConfigManager, SigningService } from "@enactprotocol/security";
+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
      */
@@ -266,7 +279,6 @@ export class EnactCore {
         }
     }
     async verifyTool(tool, dangerouslySkipVerification = false) {
-        console.log("=== VERIFY TOOL CALLED ===", tool.name, "skipVerification:", dangerouslySkipVerification);
         if (dangerouslySkipVerification) {
             logger.warn(`Skipping signature verification for tool: ${tool.name}`);
             return;
@@ -275,9 +287,6 @@ export class EnactCore {
             if (!tool.signatures || tool.signatures.length === 0) {
                 throw new Error(`Tool ${tool.name} does not have any signatures`);
             }
-            console.log("=== TOOL SIGNATURE DATA ===");
-            console.log("Tool signatures from database:", JSON.stringify(tool.signatures, null, 2));
-            console.log("Tool command:", tool.command);
             const documentForVerification = {
                 command: tool.command
             };
@@ -289,22 +298,12 @@ export class EnactCore {
             };
             // Check what canonical document looks like
             const canonicalDoc = SigningService.getCanonicalDocument(documentForVerification, { includeFields: ['command'] });
-            console.log("=== SIGNATURE VERIFICATION DEBUG ===");
-            console.log("Original document for verification:", JSON.stringify(documentForVerification, null, 2));
-            console.log("Canonical document:", JSON.stringify(canonicalDoc, null, 2));
             const docString = JSON.stringify(canonicalDoc);
             const messageHash = CryptoUtils.hash(docString);
-            console.log("Document string:", docString);
-            console.log("Message hash:", messageHash);
-            console.log("Reference signature object:", JSON.stringify(referenceSignature, null, 2));
             // Test direct crypto verification
             const directVerify = CryptoUtils.verify(referenceSignature.publicKey, messageHash, referenceSignature.signature);
-            console.log("KEITH DEBUG - Direct crypto verification result:", directVerify, "publicKey:", referenceSignature.publicKey);
             // Check trusted keys
-            const trustedKeys = KeyManager.getAllTrustedPublicKeys();
-            console.log("Trusted keys:", trustedKeys);
-            console.log("Our referenceSignature.publicKey:", JSON.stringify(referenceSignature.publicKey));
-            console.log("Is our public key trusted?", trustedKeys.includes(referenceSignature.publicKey));
+            // const trustedKeys = KeyManager.getAllTrustedPublicKeys();
             const isValid = SigningService.verifyDocument(documentForVerification, referenceSignature, { includeFields: ['command'] });
             console.log("Final verification result:", isValid);
             if (!isValid) {

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/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>;