@enactprotocol/shared 1.2.13 → 2.0.1

package/dist/core/EnactCore.js

@@ -1,597 +0,0 @@
-import { EnactApiClient } from "../api/enact-api.js";
-import { validateToolStructure, validateInputs, } from "../exec/validate.js";
-import { DirectExecutionProvider } from "./DirectExecutionProvider.js";
-import { DaggerExecutionProvider } from "./DaggerExecutionProvider.js";
-import { resolveToolEnvironmentVariables } from "../utils/env-loader.js";
-import logger from "../exec/logger.js";
-import yaml from "yaml";
-import { SecurityConfigManager, SigningService } from "@enactprotocol/security";
-import { getFrontendUrl, getApiUrl } from "../utils/config";
-export class EnactCore {
-    constructor(options = {}) {
-        this.options = {
-            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,
-        };
-        this.apiClient = new EnactApiClient(this.options.apiUrl, this.options.supabaseUrl);
-        // 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
-     */
-    setAuthToken(token) {
-        this.options.authToken = token;
-    }
-    /**
-     * Static method to search for tools (no execution provider needed)
-     */
-    static async searchTools(options, coreOptions = {}) {
-        const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
-        try {
-            logger.info(`Searching for tools with query: "${options.query}"`);
-            const searchParams = {
-                query: options.query,
-                limit: options.limit,
-                tags: options.tags,
-            };
-            const results = await apiClient.searchTools(searchParams);
-            // Parse and validate results
-            const tools = [];
-            for (const result of results) {
-                if (result.name) {
-                    try {
-                        const tool = await EnactCore.getToolByName(result.name, undefined, coreOptions);
-                        if (tool) {
-                            tools.push(tool);
-                        }
-                    }
-                    catch (error) {
-                        logger.warn(`Failed to fetch tool ${result.name}:`, error);
-                    }
-                }
-            }
-            logger.info(`Found ${tools.length} tools`);
-            return tools;
-        }
-        catch (error) {
-            logger.error("Error searching tools:", error);
-            // If it's a 502 error (API server issue), try fallback to local filtering
-            if (error instanceof Error && error.message.includes("502")) {
-                logger.info("Search API unavailable, trying fallback to local filtering...");
-                return EnactCore.searchToolsFallback(options, coreOptions);
-            }
-            throw new Error(`Search failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Instance method wrapper for backward compatibility
-     */
-    async searchTools(options) {
-        return EnactCore.searchTools(options, this.options);
-    }
-    /**
-     * Static fallback search method that gets all tools and filters locally
-     */
-    static async searchToolsFallback(options, coreOptions = {}) {
-        const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
-        try {
-            logger.info("Using fallback search method...");
-            // Get all tools (limited to avoid overwhelming the API)
-            const allTools = await apiClient.getTools({
-                limit: options.limit || 100,
-            });
-            // Filter tools locally based on search criteria
-            const filteredTools = [];
-            const query = options.query.toLowerCase();
-            for (const result of allTools) {
-                if (result.name) {
-                    try {
-                        const tool = await EnactCore.getToolByName(result.name, undefined, coreOptions);
-                        if (tool) {
-                            // Check if tool matches search criteria
-                            const matchesQuery = tool.name.toLowerCase().includes(query) ||
-                                (tool.description &&
-                                    tool.description.toLowerCase().includes(query)) ||
-                                (tool.tags &&
-                                    tool.tags.some((tag) => tag.toLowerCase().includes(query)));
-                            const matchesTags = !options.tags ||
-                                !options.tags.length ||
-                                (tool.tags &&
-                                    options.tags.some((searchTag) => tool.tags.some((toolTag) => toolTag.toLowerCase().includes(searchTag.toLowerCase()))));
-                            const matchesAuthor = !options.author ||
-                                (tool.authors &&
-                                    tool.authors.some((author) => author.name &&
-                                        author.name
-                                            .toLowerCase()
-                                            .includes(options.author.toLowerCase())));
-                            if (matchesQuery && matchesTags && matchesAuthor) {
-                                filteredTools.push(tool);
-                                // Apply limit if specified
-                                if (options.limit && filteredTools.length >= options.limit) {
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                    catch (error) {
-                        logger.warn(`Failed to fetch tool ${result.name} in fallback search:`, error);
-                    }
-                }
-            }
-            logger.info(`Fallback search found ${filteredTools.length} tools`);
-            return filteredTools;
-        }
-        catch (fallbackError) {
-            logger.error("Fallback search also failed:", fallbackError);
-            throw new Error(`Search failed (including fallback): ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
-        }
-    }
-    /**
-     * Static method to get a specific tool by name
-     */
-    static async getToolByName(name, version, coreOptions = {}) {
-        const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
-        try {
-            logger.info(`Fetching tool: ${name}${version ? `@${version}` : ""}`);
-            const response = await apiClient.getTool(name);
-            if (!response) {
-                logger.info(`Tool not found: ${name}`);
-                return null;
-            }
-            // Parse tool from response - prefer raw_content for signature compatibility
-            let tool;
-            // Try raw_content first (contains original tool definition with correct field names for signatures)
-            if (response.raw_content && typeof response.raw_content === "string") {
-                try {
-                    tool = JSON.parse(response.raw_content);
-                }
-                catch {
-                    tool = yaml.parse(response.raw_content);
-                }
-                // Merge signature information from response if not already in raw content
-                if (!tool.signature && response.signature) {
-                    tool.signature = response.signature;
-                }
-                if (!tool.signatures && response.signatures) {
-                    // Convert object format to array format
-                    if (Array.isArray(response.signatures)) {
-                        tool.signatures = response.signatures;
-                    }
-                    else {
-                        // Convert object format {keyId: signatureData} to array format
-                        tool.signatures = Object.values(response.signatures);
-                    }
-                }
-            }
-            else if (response.content && typeof response.content === "string") {
-                tool = yaml.parse(response.content);
-                // Merge signature information
-                if (!tool.signature && response.signature) {
-                    tool.signature = response.signature;
-                }
-                if (!tool.signatures && response.signatures) {
-                    // Convert object format to array format
-                    if (Array.isArray(response.signatures)) {
-                        tool.signatures = response.signatures;
-                    }
-                    else {
-                        // Convert object format {keyId: signatureData} to array format
-                        tool.signatures = Object.values(response.signatures);
-                    }
-                }
-            }
-            else {
-                // Fallback: map database fields to tool format (may cause signature verification issues)
-                tool = {
-                    name: response.name,
-                    description: response.description,
-                    command: response.command,
-                    timeout: response.timeout || "30s",
-                    tags: response.tags || [],
-                    license: response.license || response.spdx_license,
-                    outputSchema: response.output_schema || response.outputSchema,
-                    enact: response.protocol_version || response.enact || "1.0.0",
-                    version: response.version,
-                    inputSchema: response.input_schema || response.inputSchema,
-                    examples: response.examples,
-                    annotations: response.annotations,
-                    env: response.env_vars || response.env,
-                    resources: response.resources,
-                    signature: response.signature,
-                    signatures: response.signatures ? (Array.isArray(response.signatures) ? response.signatures : Object.values(response.signatures)) : undefined,
-                    namespace: response.namespace,
-                };
-            }
-            logger.info(`Successfully fetched tool: ${tool.name}`);
-            return tool;
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes("404")) {
-                logger.info(`Tool not found: ${name}`);
-                return null;
-            }
-            logger.error(`Error fetching tool: ${error instanceof Error ? error.message : String(error)}`);
-            throw error;
-        }
-    }
-    /**
-     * Instance method wrapper for backward compatibility
-     */
-    async getToolByName(name, version) {
-        return EnactCore.getToolByName(name, version, this.options);
-    }
-    /**
-     * Execute a tool by name
-     */
-    async executeToolByName(name, inputs = {}, options = {}) {
-        const executionId = this.generateExecutionId();
-        try {
-            // Fetch the tool
-            const tool = await this.getToolByName(name);
-            if (!tool) {
-                return {
-                    success: false,
-                    error: {
-                        message: `Tool not found: ${name}`,
-                        code: "NOT_FOUND",
-                    },
-                    metadata: {
-                        executionId,
-                        toolName: name,
-                        executedAt: new Date().toISOString(),
-                        environment: "direct",
-                    },
-                };
-            }
-            // Execute the tool
-            return await this.executeTool(tool, inputs, options);
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: {
-                    message: error.message,
-                    code: "EXECUTION_ERROR",
-                },
-                metadata: {
-                    executionId,
-                    toolName: name,
-                    executedAt: new Date().toISOString(),
-                    environment: "direct",
-                },
-            };
-        }
-    }
-    static async checkToolVerificationStatus(tool) {
-        const documentForVerification = {
-            command: tool.command,
-            description: tool.description,
-            from: tool.from,
-            name: tool.name,
-            signatures: tool.signatures?.map(sig => ({
-                signature: sig.value,
-                publicKey: "", // TODO: Look up the correct public key
-                algorithm: sig.algorithm,
-                timestamp: new Date(sig.created).getTime(),
-            })),
-        };
-        let isValid = false;
-        if (tool.signatures && tool.signatures.length > 0) {
-            isValid = tool.signatures.some(sig => {
-                const referenceSignature = {
-                    signature: sig.value,
-                    publicKey: "", // TODO: Lookup correct public key based on signature UUID
-                    algorithm: sig.algorithm,
-                    timestamp: new Date(sig.created).getTime()
-                };
-                return SigningService.verifyDocument(documentForVerification, referenceSignature, { includeFields: ['command', 'description', 'from', 'name'] });
-            });
-        }
-        return isValid;
-    }
-    async verifyTool(tool, dangerouslySkipVerification = false) {
-        if (dangerouslySkipVerification) {
-            logger.warn(`Skipping signature verification for tool: ${tool.name}`);
-            return;
-        }
-        try {
-            if (!tool.signatures || tool.signatures.length === 0) {
-                throw new Error(`Tool ${tool.name} does not have any signatures`);
-            }
-            // const documentForVerification = {
-            // 	command: tool.command,
-            // 	description: tool.description,
-            // 	from: tool.from,
-            // 	name: tool.name,
-            // };
-            // const referenceSignature = {
-            // 		signature: tool.signatures[0].value,
-            // 		publicKey: "", // Correct public key for UUID 71e02e2c-148c-4534-9900-bd9646e99333
-            // 		algorithm: tool.signatures[0].algorithm,
-            // 		timestamp: new Date(tool.signatures[0].created).getTime()
-            // 	};
-            //         // Check what canonical document looks like
-            //         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 = await EnactCore.checkToolVerificationStatus(tool);
-            console.log("Final verification result:", isValid);
-            if (!isValid) {
-                throw new Error(`Tool ${tool.name} has invalid signatures`);
-            }
-            logger.info(`Tool ${tool.name} signature verification passed`);
-        }
-        catch (error) {
-            logger.error(`Signature verification failed for tool ${tool.name}:`, error);
-            throw new Error(`Signature verification failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Execute a tool directly
-     */
-    async executeTool(tool, inputs = {}, options = {}) {
-        const executionId = this.generateExecutionId();
-        try {
-            logger.info(`Executing tool: ${tool.name}`);
-            // Validate tool structure
-            validateToolStructure(tool);
-            // Validate inputs
-            const validatedInputs = validateInputs(tool, inputs);
-            const config = SecurityConfigManager.loadConfig();
-            if (options.isLocalFile && config.allowLocalUnsigned) {
-                logger.warn(`Executing local file without signature verification: ${tool.name} (you can disallow in your security config)`);
-            }
-            if (options.dangerouslySkipVerification) {
-                logger.warn(`Skipping signature verification for tool: ${tool.name} because of dangerouslySkipVerification option`);
-            }
-            const skipVerification = (options.isLocalFile && config.allowLocalUnsigned) || Boolean(options.dangerouslySkipVerification);
-            // Verify tool signatures (unless explicitly skipped)
-            await this.verifyTool(tool, skipVerification);
-            // Resolve environment variables
-            const { resolved: envVars } = await resolveToolEnvironmentVariables(tool.name, tool.env || {});
-            // Execute the tool via the execution provider
-            return await this.executionProvider.execute(tool, { ...validatedInputs, ...envVars }, {
-                vars: { ...envVars, ...validatedInputs },
-                resources: {
-                    timeout: options.timeout || tool.timeout || this.options.defaultTimeout,
-                },
-                mount: options.mount,
-            });
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: {
-                    message: error.message,
-                    code: "EXECUTION_ERROR",
-                },
-                metadata: {
-                    executionId,
-                    toolName: tool.name,
-                    executedAt: new Date().toISOString(),
-                    environment: "direct",
-                },
-            };
-        }
-    }
-    /**
-     * Execute a tool from raw YAML definition
-     */
-    async executeRawTool(toolYaml, inputs = {}, options = {}) {
-        try {
-            // Parse the YAML
-            const tool = yaml.parse(toolYaml);
-            // Validate that it's a proper tool definition
-            if (!tool || typeof tool !== "object") {
-                throw new Error("Invalid tool definition: YAML must contain a tool object");
-            }
-            // Check for required fields
-            if (!tool.name || !tool.description || !tool.command) {
-                throw new Error("Invalid tool definition: missing required fields (name, description, command)");
-            }
-            // Execute the tool
-            return await this.executeTool(tool, inputs, options);
-        }
-        catch (error) {
-            const executionId = this.generateExecutionId();
-            return {
-                success: false,
-                error: {
-                    message: error.message,
-                    code: "PARSE_ERROR",
-                },
-                metadata: {
-                    executionId,
-                    toolName: "unknown",
-                    executedAt: new Date().toISOString(),
-                    environment: "direct",
-                },
-            };
-        }
-    }
-    /**
-     * Static method to check if a tool exists
-     */
-    static async toolExists(name, coreOptions = {}) {
-        try {
-            const tool = await EnactCore.getToolByName(name, undefined, coreOptions);
-            return tool !== null;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Instance method wrapper for backward compatibility
-     */
-    async toolExists(name) {
-        return EnactCore.toolExists(name, this.options);
-    }
-    /**
-     * Get tools by tags
-     */
-    async getToolsByTags(tags, limit = 20) {
-        return EnactCore.searchTools({
-            query: tags.join(" "),
-            tags,
-            limit,
-        }, this.options);
-    }
-    /**
-     * Get tools by author
-     */
-    async getToolsByAuthor(author, limit = 20) {
-        return EnactCore.searchTools({
-            query: `author:${author}`,
-            author,
-            limit,
-        }, this.options);
-    }
-    /**
-     * Static method to get all tools with filters
-     */
-    static async getTools(options = {}, coreOptions = {}) {
-        const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
-        try {
-            const apiResults = await apiClient.getTools(options);
-            // Parse and validate results
-            const tools = [];
-            for (const result of apiResults) {
-                if (result.name) {
-                    try {
-                        const tool = await EnactCore.getToolByName(result.name, undefined, coreOptions);
-                        if (tool) {
-                            tools.push(tool);
-                        }
-                    }
-                    catch (error) {
-                        logger.warn(`Failed to fetch tool ${result.name}:`, error);
-                    }
-                }
-            }
-            return tools;
-        }
-        catch (error) {
-            logger.error("Error getting tools:", error);
-            throw new Error(`Failed to get tools: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Instance method wrapper for backward compatibility
-     */
-    async getTools(options = {}) {
-        return EnactCore.getTools(options, this.options);
-    }
-    /**
-     * Get authentication status (placeholder - would need actual auth implementation)
-     */
-    async getAuthStatus() {
-        // This would need to check actual auth state
-        // For now, return based on whether we have a token
-        return {
-            authenticated: !!this.options.authToken,
-            server: this.options.apiUrl,
-        };
-    }
-    /**
-     * Static method to publish a tool
-     */
-    static async publishTool(tool, authToken, coreOptions = {}) {
-        const apiClient = new EnactApiClient(coreOptions.apiUrl || "https://enact.tools", coreOptions.supabaseUrl || "https://xjnhhxwxovjifdxdwzih.supabase.co");
-        try {
-            validateToolStructure(tool);
-            await apiClient.publishTool(tool, authToken);
-            return {
-                success: true,
-                message: `Successfully published tool: ${tool.name}`,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                message: `Failed to publish tool: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    /**
-     * Instance method wrapper for backward compatibility
-     */
-    async publishTool(tool) {
-        if (!this.options.authToken) {
-            return {
-                success: false,
-                message: "Authentication required to publish tools",
-            };
-        }
-        return EnactCore.publishTool(tool, this.options.authToken, this.options);
-    }
-    /**
-     * Get tool information (alias for getToolByName for consistency)
-     */
-    async getToolInfo(name, version) {
-        return EnactCore.getToolByName(name, version, this.options);
-    }
-    /**
-     * Get core library status
-     */
-    async getStatus() {
-        const authStatus = await this.getAuthStatus();
-        return {
-            executionProvider: this.options.executionProvider || "direct",
-            apiUrl: this.options.apiUrl || "https://enact.tools",
-            defaultTimeout: this.options.defaultTimeout || "30s",
-            authenticated: authStatus.authenticated,
-        };
-    }
-    /**
-     * Create the appropriate execution provider based on options
-     */
-    createExecutionProvider() {
-        switch (this.options.executionProvider) {
-            case "direct":
-                return new DirectExecutionProvider();
-            case "dagger":
-            default:
-                return new DaggerExecutionProvider(this.options.daggerOptions);
-        }
-    }
-    /**
-     * Switch execution provider at runtime
-     */
-    switchExecutionProvider(provider, options) {
-        this.options.executionProvider = provider;
-        this.executionProvider = this.createExecutionProvider();
-    }
-    /**
-     * Generate execution ID
-     */
-    generateExecutionId() {
-        return `exec_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-    }
-}
-// No default instance to avoid eager initialization of Dagger

package/dist/core/NativeExecutionProvider.d.ts

@@ -1,9 +0,0 @@
-import { ExecutionProvider, type EnactTool, type ExecutionEnvironment, type ExecutionResult } from "../types.js";
-/**
- * Native execution provider that throws an error if used for actual execution.
- * This is for CLI commands that use Core for API operations only.
- */
-export declare class NativeExecutionProvider extends ExecutionProvider {
-    resolveEnvironmentVariables(envConfig: Record<string, any>, namespace?: string): Promise<Record<string, any>>;
-    execute(tool: EnactTool, input: Record<string, any>, environment: ExecutionEnvironment): Promise<ExecutionResult>;
-}

package/dist/core/NativeExecutionProvider.js

@@ -1,16 +0,0 @@
-// src/core/NativeExecutionProvider.ts - No-op execution provider for CLI commands
-import { ExecutionProvider, } from "../types.js";
-/**
- * Native execution provider that throws an error if used for actual execution.
- * This is for CLI commands that use Core for API operations only.
- */
-export class NativeExecutionProvider extends ExecutionProvider {
-    async resolveEnvironmentVariables(envConfig, namespace) {
-        // This should never be called for native CLI commands
-        throw new Error("Native execution provider cannot resolve environment variables");
-    }
-    async execute(tool, input, environment) {
-        // This should never be called for native CLI commands
-        throw new Error(`Native execution provider cannot execute tools. Tool "${tool.name}" should be executed via direct or dagger provider.`);
-    }
-}

package/dist/core/index.d.ts

@@ -1,3 +0,0 @@
-export * from './EnactCore';
-export * from './DirectExecutionProvider';
-export * from './DaggerExecutionProvider';

package/dist/core/index.js

@@ -1,3 +0,0 @@
-export * from './EnactCore';
-export * from './DirectExecutionProvider';
-export * from './DaggerExecutionProvider';

package/dist/exec/index.d.ts

@@ -1,3 +0,0 @@
-export { default } from './logger';
-export { default as logger } from './logger';
-export * from './validate';

package/dist/exec/index.js

@@ -1,3 +0,0 @@
-export { default } from './logger';
-export { default as logger } from './logger';
-export * from './validate';

package/dist/exec/logger.d.ts

@@ -1,11 +0,0 @@
-declare const logger: import("pino").Logger<never, boolean>;
-declare const wrappedLogger: {
-    info: (msg: string, ...args: any[]) => void;
-    warn: (msg: string, ...args: any[]) => void;
-    error: (msg: string, ...args: any[]) => void;
-    debug: (msg: string, ...args: any[]) => void;
-    clientLoggingEnabled: () => boolean;
-    isLevelEnabled: (level: string) => boolean;
-    pino: import("pino").Logger<never, boolean>;
-};
-export default wrappedLogger;