@enactprotocol/shared 1.2.13 → 2.0.1

package/dist/core/DirectExecutionProvider.d.ts

@@ -1,23 +0,0 @@
-import { ExecutionProvider, type EnactTool, type ExecutionEnvironment, type ExecutionResult } from "../types.js";
-export declare class DirectExecutionProvider extends ExecutionProvider {
-    resolveEnvironmentVariables(envConfig: Record<string, any>, namespace?: string): Promise<Record<string, any>>;
-    executeCommand(command: string, inputs: Record<string, any>, environment: ExecutionEnvironment, timeout?: string, options?: {
-        verbose?: boolean;
-        showSpinner?: boolean;
-        streamOutput?: boolean;
-    }): Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }>;
-    /**
-     * Execute command with exec.ts compatible interface
-     * This method provides the same interface as the exec.ts executeCommand function
-     */
-    executeCommandExecStyle(command: string, timeout: string, verbose?: boolean, envVars?: Record<string, string>): Promise<void>;
-    setup(tool: EnactTool): Promise<boolean>;
-    execute(tool: EnactTool, inputs: Record<string, any>, environment: ExecutionEnvironment): Promise<ExecutionResult>;
-    cleanup(): Promise<boolean>;
-    private generateExecutionId;
-    private parseCommand;
-}

package/dist/core/DirectExecutionProvider.js

@@ -1,406 +0,0 @@
-// src/core/DirectExecutionProvider.ts - Direct execution provider that doesn't use external CLI
-import { spawn } from "child_process";
-import { ExecutionProvider, } from "../types.js";
-import logger from "../exec/logger.js";
-import { parseTimeout } from "../utils/timeout.js";
-export class DirectExecutionProvider extends ExecutionProvider {
-    async resolveEnvironmentVariables(envConfig, namespace) {
-        const resolved = {};
-        for (const [key, config] of Object.entries(envConfig)) {
-            if (typeof config === "object" && config.source) {
-                // Handle different sources
-                switch (config.source) {
-                    case "env":
-                        resolved[key] = process.env[key] || config.default;
-                        break;
-                    case "user":
-                        // Could get from user config file
-                        resolved[key] = config.default;
-                        break;
-                    default:
-                        resolved[key] = config.default;
-                }
-            }
-            else {
-                // Direct value
-                resolved[key] = config;
-            }
-        }
-        return resolved;
-    }
-    async executeCommand(command, inputs, environment, timeout, options) {
-        return new Promise((resolve, reject) => {
-            let stdout = "";
-            let stderr = "";
-            // UI Setup
-            const verbose = options?.verbose ?? false;
-            const showSpinner = options?.showSpinner ?? false;
-            const streamOutput = options?.streamOutput ?? true;
-            let spinner = null;
-            if (showSpinner) {
-                // Dynamic import to avoid dependency issues when not needed
-                try {
-                    const p = require("@clack/prompts");
-                    spinner = p.spinner();
-                    spinner.start("Executing tool...");
-                }
-                catch (e) {
-                    // Fallback if @clack/prompts not available
-                    console.log("Executing tool...");
-                }
-            }
-            if (verbose) {
-                try {
-                    const pc = require("picocolors");
-                    console.error(pc.cyan("\n🚀 Executing command:"));
-                    console.error(pc.white(command));
-                }
-                catch (e) {
-                    console.error("\n🚀 Executing command:");
-                    console.error(command);
-                }
-            }
-            // Substitute template variables in command with input values
-            let substitutedCommand = command;
-            for (const [key, value] of Object.entries(inputs)) {
-                const templateVar = `\${${key}}`;
-                // Handle different value types
-                let substitutionValue;
-                if (typeof value === "string") {
-                    substitutionValue = value;
-                }
-                else if (typeof value === "object") {
-                    substitutionValue = JSON.stringify(value);
-                }
-                else {
-                    substitutionValue = String(value);
-                }
-                substitutedCommand = substitutedCommand.replace(new RegExp(`\\$\\{${key}\\}`, "g"), substitutionValue);
-            }
-            // Prepare environment
-            const env = {
-                ...process.env,
-                ...environment.vars,
-            };
-            // Parse command and arguments properly handling quoted strings
-            const commandParts = this.parseCommand(substitutedCommand);
-            const cmd = commandParts[0];
-            const args = commandParts.slice(1);
-            logger.info(`Executing command: ${command}`);
-            try {
-                const proc = spawn(cmd, args, {
-                    env,
-                    stdio: ["pipe", "pipe", "pipe"],
-                    // Create a new process group for better cleanup of child processes
-                    detached: process.platform !== "win32",
-                });
-                // Cleanup function to ensure process and children are properly terminated
-                let isCleanedUp = false;
-                let cleanupTimer = null;
-                const cleanup = () => {
-                    if (isCleanedUp)
-                        return;
-                    isCleanedUp = true;
-                    // Clear any pending cleanup timer
-                    if (cleanupTimer) {
-                        clearTimeout(cleanupTimer);
-                        cleanupTimer = null;
-                    }
-                    if (proc && !proc.killed) {
-                        try {
-                            logger.debug(`Cleaning up process PID: ${proc.pid}`);
-                            // For Dagger and other tools that may spawn child processes
-                            if (process.platform === "win32") {
-                                proc.kill("SIGKILL");
-                            }
-                            else {
-                                // Try graceful termination first
-                                proc.kill("SIGTERM");
-                                // Set a cleanup timer for force kill if needed
-                                cleanupTimer = setTimeout(() => {
-                                    if (!proc.killed && !isCleanedUp) {
-                                        logger.debug(`Force killing process PID: ${proc.pid}`);
-                                        try {
-                                            proc.kill("SIGKILL");
-                                        }
-                                        catch (killError) {
-                                            // Process might already be dead, ignore
-                                            logger.debug(`Force kill error (likely harmless): ${killError}`);
-                                        }
-                                    }
-                                    cleanupTimer = null;
-                                }, 1000); // Reduced from 2000ms to 1000ms
-                            }
-                        }
-                        catch (killError) {
-                            // Process might already be dead, ignore
-                            logger.debug(`Process cleanup error (likely harmless): ${killError}`);
-                        }
-                    }
-                };
-                // Collect stdout and stream it in real-time
-                proc.stdout.on("data", (data) => {
-                    const chunk = data.toString();
-                    stdout += chunk;
-                    // Stream stdout to console in real-time if enabled
-                    if (streamOutput) {
-                        process.stdout.write(chunk);
-                    }
-                });
-                // Collect stderr and stream it in real-time
-                proc.stderr.on("data", (data) => {
-                    const chunk = data.toString();
-                    stderr += chunk;
-                    // Stream stderr to console in real-time if enabled
-                    if (streamOutput) {
-                        process.stderr.write(chunk);
-                    }
-                });
-                // Handle process completion with more robust cleanup
-                proc.on("close", (code) => {
-                    logger.debug(`Process closed with code: ${code}, PID: ${proc.pid}`);
-                    // Force cleanup any remaining resources
-                    cleanup();
-                    // Handle spinner cleanup and success/error messaging
-                    if (spinner) {
-                        spinner.stop("Execution completed");
-                    }
-                    if (code === 0) {
-                        if (showSpinner || verbose) {
-                            try {
-                                const pc = require("picocolors");
-                                console.error(pc.green("\n✅ Tool executed successfully"));
-                                if (stdout.trim() && !streamOutput) {
-                                    console.error(pc.cyan("\n📤 Output:"));
-                                    console.error(stdout.trim());
-                                }
-                            }
-                            catch (e) {
-                                console.error("\n✅ Tool executed successfully");
-                                if (stdout.trim() && !streamOutput) {
-                                    console.error("\n📤 Output:");
-                                    console.error(stdout.trim());
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        if (showSpinner || verbose) {
-                            try {
-                                const pc = require("picocolors");
-                                console.error(pc.red(`\n❌ Tool execution failed (exit code: ${code})`));
-                                if (stderr.trim() && !streamOutput) {
-                                    console.error(pc.red("\n📤 Error output:"));
-                                    console.error(stderr.trim());
-                                }
-                                if (stdout.trim() && !streamOutput) {
-                                    console.error(pc.yellow("\n📤 Standard output:"));
-                                    console.error(stdout.trim());
-                                }
-                            }
-                            catch (e) {
-                                console.error(`\n❌ Tool execution failed (exit code: ${code})`);
-                                if (stderr.trim() && !streamOutput) {
-                                    console.error("\n📤 Error output:");
-                                    console.error(stderr.trim());
-                                }
-                                if (stdout.trim() && !streamOutput) {
-                                    console.error("\n📤 Standard output:");
-                                    console.error(stdout.trim());
-                                }
-                            }
-                        }
-                    }
-                    resolve({
-                        stdout: stdout.trim(),
-                        stderr: stderr.trim(),
-                        exitCode: code || 0,
-                    });
-                });
-                // Handle process errors
-                proc.on("error", (error) => {
-                    cleanup();
-                    if (spinner) {
-                        spinner.stop("Execution failed");
-                    }
-                    if (showSpinner || verbose) {
-                        try {
-                            const pc = require("picocolors");
-                            console.error(pc.red(`\n❌ Failed to execute command: ${error.message}`));
-                        }
-                        catch (e) {
-                            console.error(`\n❌ Failed to execute command: ${error.message}`);
-                        }
-                    }
-                    reject(new Error(`Command execution error: ${error.message}`));
-                });
-                // Set timeout if specified
-                if (timeout) {
-                    const timeoutMs = parseTimeout(timeout);
-                    setTimeout(() => {
-                        cleanup();
-                        if (spinner) {
-                            spinner.stop("Execution failed");
-                        }
-                        reject(new Error(`Command timed out after ${timeout}`));
-                    }, timeoutMs);
-                }
-            }
-            catch (spawnError) {
-                reject(new Error(`Failed to spawn command: ${spawnError}`));
-            }
-        });
-    }
-    /**
-     * Execute command with exec.ts compatible interface
-     * This method provides the same interface as the exec.ts executeCommand function
-     */
-    async executeCommandExecStyle(command, timeout, verbose = false, envVars = {}) {
-        const environment = {
-            vars: envVars,
-            resources: { timeout },
-        };
-        const result = await this.executeCommand(command, {}, // No template substitution needed for this interface
-        environment, timeout, {
-            verbose,
-            showSpinner: true,
-            streamOutput: false, // Don't stream since exec.ts shows output at the end
-        });
-        if (result.exitCode !== 0) {
-            throw new Error(`Command failed with exit code ${result.exitCode}`);
-        }
-    }
-    async setup(tool) {
-        // No special setup needed for direct execution
-        logger.debug(`Setting up direct execution for tool: ${tool.name}`);
-        return true;
-    }
-    async execute(tool, inputs, environment) {
-        const executionId = this.generateExecutionId();
-        const timeout = tool.timeout || environment.resources?.timeout;
-        // Substitute template variables in command with input values
-        let substitutedCommand = tool.command;
-        for (const [key, value] of Object.entries(inputs)) {
-            const templateVar = `\${${key}}`;
-            // Handle different value types
-            let substitutionValue;
-            if (typeof value === "string") {
-                substitutionValue = value;
-            }
-            else if (typeof value === "object") {
-                substitutionValue = JSON.stringify(value);
-            }
-            else {
-                substitutionValue = String(value);
-            }
-            substitutedCommand = substitutedCommand.replace(new RegExp(`\\$\\{${key}\\}`, "g"), substitutionValue);
-        }
-        try {
-            // Execute the command
-            const result = await this.executeCommand(substitutedCommand, inputs, environment, timeout);
-            // Parse output
-            let parsedOutput;
-            try {
-                // Try to parse as JSON first
-                parsedOutput = JSON.parse(result.stdout);
-            }
-            catch {
-                // If not JSON, return structured output
-                parsedOutput = {
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                };
-            }
-            return {
-                success: result.exitCode === 0,
-                output: parsedOutput,
-                ...(result.exitCode !== 0 && {
-                    error: {
-                        message: `Command failed with exit code ${result.exitCode}`,
-                        code: "COMMAND_FAILED",
-                        details: {
-                            stdout: result.stdout,
-                            stderr: result.stderr,
-                            command: substitutedCommand, // Show the substituted command
-                            exitCode: result.exitCode,
-                        },
-                    },
-                }),
-                metadata: {
-                    executionId,
-                    toolName: tool.name,
-                    version: tool.version,
-                    executedAt: new Date().toISOString(),
-                    environment: "direct",
-                    timeout,
-                    command: substitutedCommand, // Show the substituted command in metadata
-                },
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: {
-                    message: error.message,
-                    code: "EXECUTION_ERROR",
-                    details: error,
-                },
-                metadata: {
-                    executionId,
-                    toolName: tool.name,
-                    version: tool.version,
-                    executedAt: new Date().toISOString(),
-                    environment: "direct",
-                },
-            };
-        }
-    }
-    async cleanup() {
-        // No cleanup needed for direct execution
-        return true;
-    }
-    generateExecutionId() {
-        return `exec_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-    }
-    parseCommand(command) {
-        const parts = [];
-        let current = "";
-        let inQuotes = false;
-        let quoteChar = "";
-        let i = 0;
-        while (i < command.length) {
-            const char = command[i];
-            if (!inQuotes && (char === '"' || char === "'")) {
-                // Start of quoted section
-                inQuotes = true;
-                quoteChar = char;
-            }
-            else if (inQuotes && char === quoteChar) {
-                // End of quoted section
-                inQuotes = false;
-                quoteChar = "";
-            }
-            else if (!inQuotes && char === " ") {
-                // Space outside quotes - end current part
-                if (current.length > 0) {
-                    parts.push(current);
-                    current = "";
-                }
-                // Skip whitespace
-                while (i + 1 < command.length && command[i + 1] === " ") {
-                    i++;
-                }
-            }
-            else {
-                // Regular character or space inside quotes
-                current += char;
-            }
-            i++;
-        }
-        // Add the last part if it exists
-        if (current.length > 0) {
-            parts.push(current);
-        }
-        return parts;
-    }
-}

package/dist/core/EnactCore.d.ts

@@ -1,162 +0,0 @@
-import type { EnactTool, ExecutionResult } from "../types.js";
-import { EnactToolDefinition } from "../api/types.js";
-export interface EnactCoreOptions {
-    apiUrl?: string;
-    supabaseUrl?: string;
-    executionProvider?: "direct" | "docker" | "dagger" | "cloud";
-    authToken?: string;
-    verbose?: boolean;
-    defaultTimeout?: string;
-    daggerOptions?: {
-        baseImage?: string;
-        enableNetwork?: boolean;
-        enableHostFS?: boolean;
-        maxMemory?: string;
-        maxCPU?: string;
-    };
-}
-export interface ToolSearchOptions {
-    query: string;
-    limit?: number;
-    tags?: string[];
-    author?: string;
-    format?: "json" | "table" | "list";
-}
-export interface ToolExecuteOptions {
-    timeout?: string;
-    force?: boolean;
-    dryRun?: boolean;
-    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
-     */
-    setAuthToken(token: string): void;
-    /**
-     * 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[]>;
-    /**
-     * Static fallback search method that gets all tools and filters locally
-     */
-    private static searchToolsFallback;
-    /**
-     * Static method to get a specific tool by name
-     */
-    static getToolByName(name: string, version?: string, coreOptions?: Pick<EnactCoreOptions, 'apiUrl' | 'supabaseUrl'>): Promise<EnactTool | null>;
-    /**
-     * 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>;
-    static checkToolVerificationStatus(tool: EnactToolDefinition): Promise<boolean>;
-    private verifyTool;
-    /**
-     * Execute a tool directly
-     */
-    executeTool(tool: EnactTool, inputs?: Record<string, any>, options?: ToolExecuteOptions): Promise<ExecutionResult>;
-    /**
-     * Execute a tool from raw YAML definition
-     */
-    executeRawTool(toolYaml: string, inputs?: Record<string, any>, options?: ToolExecuteOptions): Promise<ExecutionResult>;
-    /**
-     * Static method to check if a tool exists
-     */
-    static toolExists(name: string, coreOptions?: Pick<EnactCoreOptions, 'apiUrl' | 'supabaseUrl'>): Promise<boolean>;
-    /**
-     * Instance method wrapper for backward compatibility
-     */
-    toolExists(name: string): Promise<boolean>;
-    /**
-     * Get tools by tags
-     */
-    getToolsByTags(tags: string[], limit?: number): Promise<EnactTool[]>;
-    /**
-     * Get tools by author
-     */
-    getToolsByAuthor(author: string, limit?: number): Promise<EnactTool[]>;
-    /**
-     * 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;
-        offset?: number;
-        tags?: string[];
-        author?: string;
-    }): Promise<EnactTool[]>;
-    /**
-     * Get authentication status (placeholder - would need actual auth implementation)
-     */
-    getAuthStatus(): Promise<{
-        authenticated: boolean;
-        user?: string;
-        server?: string;
-    }>;
-    /**
-     * 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;
-        message: string;
-    }>;
-    /**
-     * Get tool information (alias for getToolByName for consistency)
-     */
-    getToolInfo(name: string, version?: string): Promise<EnactTool | null>;
-    /**
-     * Get core library status
-     */
-    getStatus(): Promise<{
-        executionProvider: string;
-        apiUrl: string;
-        defaultTimeout: string;
-        authenticated: boolean;
-    }>;
-    /**
-     * Create the appropriate execution provider based on options
-     */
-    private createExecutionProvider;
-    /**
-     * Switch execution provider at runtime
-     */
-    switchExecutionProvider(provider: "direct" | "dagger", options?: any): void;
-    /**
-     * Generate execution ID
-     */
-    private generateExecutionId;
-}