@enactprotocol/shared 1.0.12

package/dist/api/enact-api.js

@@ -0,0 +1,406 @@
+export class EnactApiClient {
+    constructor(baseUrl = "https://enact.tools", supabaseUrl = "https://xjnhhxwxovjifdxdwzih.supabase.co") {
+        this.baseUrl = baseUrl.replace(/\/$/, ""); // Remove trailing slash
+        this.supabaseUrl = supabaseUrl.replace(/\/$/, "");
+    }
+    // Helper method to make authenticated requests
+    async makeRequest(endpoint, options = {}, token, tokenType = "jwt") {
+        const url = endpoint.startsWith("http")
+            ? endpoint
+            : `${this.supabaseUrl}${endpoint}`;
+        const headers = {
+            "Content-Type": "application/json",
+            ...options.headers,
+        };
+        // Add authentication headers if token provided
+        if (token) {
+            if (tokenType === "jwt") {
+                headers.Authorization = `Bearer ${token}`;
+            }
+            else {
+                headers["X-API-Key"] = token;
+            }
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+        if (!response.ok) {
+            const errorData = await response
+                .json()
+                .catch(() => ({ error: "Unknown error" }));
+            throw new EnactApiError(`${errorData.error || response.statusText}`, response.status, endpoint);
+        }
+        const responseData = await response.json();
+        // Debug logging to help identify response structure issues
+        if (process.env.NODE_ENV === "development" || process.env.DEBUG) {
+            console.error(`API Response for ${endpoint}:`, responseData);
+        }
+        return responseData;
+    }
+    // =================
+    // PUBLIC ENDPOINTS
+    // =================
+    /**
+     * Get all tools (public, no auth required)
+     */
+    async getTools(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.limit)
+            searchParams.set("limit", params.limit.toString());
+        if (params?.offset)
+            searchParams.set("offset", params.offset.toString());
+        if (params?.tags)
+            searchParams.set("tags", params.tags.join(","));
+        if (params?.author)
+            searchParams.set("author", params.author);
+        const query = searchParams.toString();
+        const endpoint = `/functions/v1/tools${query ? `?${query}` : ""}`;
+        const response = await this.makeRequest(endpoint);
+        // Handle different response structures
+        if (Array.isArray(response)) {
+            return response;
+        }
+        else if (response.data && Array.isArray(response.data)) {
+            return response.data;
+        }
+        else if (response.tools && Array.isArray(response.tools)) {
+            return response.tools;
+        }
+        else {
+            console.warn("Unexpected response structure for getTools:", response);
+            return [];
+        }
+    }
+    /**
+     * Get specific tool details (public, no auth required)
+     */
+    async getTool(name) {
+        const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}`;
+        return this.makeRequest(endpoint);
+    }
+    /**
+     * Get tool usage statistics (public, no auth required)
+     */
+    async getToolUsage(name) {
+        const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}/usage`;
+        return this.makeRequest(endpoint);
+    }
+    /**
+     * Log tool usage (public, no auth required)
+     */
+    async logToolUsage(name, usage) {
+        const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}/usage`;
+        return this.makeRequest(endpoint, {
+            method: "POST",
+            body: JSON.stringify(usage),
+        });
+    }
+    /**
+     * Search tools with semantic/text search (public, no auth required)
+     */
+    async searchTools(query) {
+        const endpoint = "/functions/v1/tools-search";
+        try {
+            // Log the request for debugging
+            if (process.env.NODE_ENV === "development" || process.env.DEBUG) {
+                console.error(`Search request to ${endpoint}:`, JSON.stringify(query, null, 2));
+            }
+            const response = await this.makeRequest(endpoint, {
+                method: "POST",
+                body: JSON.stringify(query),
+            });
+            // Handle different response structures
+            if (Array.isArray(response)) {
+                return response;
+            }
+            else if (response.data && Array.isArray(response.data)) {
+                return response.data;
+            }
+            else if (response.results && Array.isArray(response.results)) {
+                return response.results;
+            }
+            else if (response.tools && Array.isArray(response.tools)) {
+                return response.tools;
+            }
+            else {
+                console.warn("Unexpected response structure for searchTools:", response);
+                return [];
+            }
+        }
+        catch (error) {
+            // Enhanced error logging
+            if (error instanceof EnactApiError) {
+                console.error(`Search API error (${error.statusCode}): ${error.message}`);
+                console.error(`Endpoint: ${error.endpoint}`);
+                // If it's a 502 error, provide more specific guidance
+                if (error.statusCode === 502) {
+                    console.error("502 Bad Gateway error - this usually indicates:");
+                    console.error("• The API server is temporarily unavailable");
+                    console.error("• The search service is overloaded");
+                    console.error("• Network connectivity issues");
+                    console.error("• Try again in a few moments");
+                }
+            }
+            else {
+                console.error("Unexpected search error:", error);
+            }
+            // Re-throw the error
+            throw error;
+        }
+    }
+    // ===================
+    // AUTHENTICATED ENDPOINTS
+    // ===================
+    /**
+     * Publish/create new tool (requires authentication)
+     */
+    async publishTool(tool, token, tokenType = "cli") {
+        const endpoint = "/functions/v1/tools";
+        return this.makeRequest(endpoint, {
+            method: "POST",
+            body: JSON.stringify(tool),
+        }, token, tokenType);
+    }
+    /**
+     * Update existing tool (requires authentication, must be owner)
+     */
+    async updateTool(name, tool, token, tokenType = "cli") {
+        const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}`;
+        return this.makeRequest(endpoint, {
+            method: "PUT",
+            body: JSON.stringify(tool),
+        }, token, tokenType);
+    }
+    /**
+     * Delete tool (requires authentication, must be owner)
+     */
+    async deleteTool(name, token, tokenType = "cli") {
+        const endpoint = `/functions/v1/tools/${encodeURIComponent(name)}`;
+        return this.makeRequest(endpoint, {
+            method: "DELETE",
+        }, token, tokenType);
+    }
+    /**
+     * Create new CLI token (requires JWT authentication)
+     */
+    async createCLIToken(tokenData, jwtToken) {
+        const endpoint = "/functions/v1/cli-token";
+        return this.makeRequest(endpoint, {
+            method: "POST",
+            body: JSON.stringify(tokenData),
+        }, jwtToken, "jwt");
+    }
+    /**
+     * List user's CLI tokens (requires JWT authentication)
+     */
+    async getCLITokens(jwtToken) {
+        const endpoint = "/functions/v1/cli-token";
+        return this.makeRequest(endpoint, {
+            method: "GET",
+        }, jwtToken, "jwt");
+    }
+    /**
+     * Delete CLI token (requires JWT authentication, must be owner)
+     */
+    async deleteCLIToken(tokenId, jwtToken) {
+        const endpoint = `/functions/v1/cli-token/${tokenId}`;
+        return this.makeRequest(endpoint, {
+            method: "DELETE",
+        }, jwtToken, "jwt");
+    }
+    /**
+     * Exchange OAuth authorization code for access token
+     */
+    async exchangeOAuthCode(oauthData) {
+        const endpoint = "/functions/v1/cli-oauth";
+        return this.makeRequest(endpoint, {
+            method: "POST",
+            body: JSON.stringify(oauthData),
+        });
+    }
+    /**
+     * Generate embeddings for tools (requires authentication)
+     */
+    async generateEmbeddings(data, token, tokenType = "cli") {
+        const endpoint = "/functions/v1/generate-embeddings";
+        return this.makeRequest(endpoint, {
+            method: "POST",
+            body: JSON.stringify(data),
+        }, token, tokenType);
+    }
+    // ===================
+    // CONVENIENCE METHODS
+    // ===================
+    /**
+     * Check if a tool exists
+     */
+    async toolExists(name) {
+        try {
+            await this.getTool(name);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("404")) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Publish or update tool based on existence
+     */
+    async publishOrUpdateTool(tool, token, tokenType = "cli") {
+        let exists;
+        try {
+            exists = await this.toolExists(tool.name);
+        }
+        catch (error) {
+            exists = false;
+        }
+        if (exists) {
+            const result = await this.updateTool(tool.name, tool, token, tokenType);
+            return { isUpdate: true, result };
+        }
+        else {
+            const result = await this.publishTool(tool, token, tokenType);
+            return { isUpdate: false, result };
+        }
+    }
+    /**
+     * Search tools by tags
+     */
+    async getToolsByTags(tags, limit = 20) {
+        return this.searchTools({
+            query: tags.join(" "),
+            tags,
+            limit,
+        });
+    }
+    /**
+     * Get tools by author
+     */
+    async getToolsByAuthor(author, limit = 20) {
+        return this.getTools({
+            author,
+            limit,
+        });
+    }
+    /**
+     * Get a user's public key
+     */
+    async getUserPublicKey(userId) {
+        const url = `${this.supabaseUrl}/functions/v1/tools/user/public-key/${userId}`;
+        const headers = {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        };
+        try {
+            const response = await fetch(url, {
+                method: "GET",
+                headers,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+                try {
+                    const errorJson = JSON.parse(errorText);
+                    if (errorJson.message) {
+                        errorMessage = errorJson.message;
+                    }
+                    else if (errorJson.error) {
+                        errorMessage = errorJson.error;
+                    }
+                }
+                catch {
+                    // If we can't parse JSON, stick with the original error message
+                }
+                throw new EnactApiError(errorMessage, response.status);
+            }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            if (error instanceof EnactApiError) {
+                throw error;
+            }
+            // Handle network errors
+            if (error instanceof Error) {
+                if (error.message.includes("fetch")) {
+                    throw new EnactApiError("Network error: Could not connect to Enact API", 0);
+                }
+                throw new EnactApiError(error.message, 0);
+            }
+            throw new EnactApiError("Unknown error occurred", 0);
+        }
+    }
+    // ===================
+    // OAUTH FLOW HELPERS
+    // ===================
+    /**
+     * Generate OAuth authorization URL
+     */
+    generateOAuthUrl(options) {
+        const params = new URLSearchParams({
+            response_type: "code",
+            client_id: options.clientId,
+            redirect_uri: options.redirectUri,
+            scope: options.scope,
+            state: options.state,
+            code_challenge: options.codeChallenge,
+            code_challenge_method: options.codeChallengeMethod,
+        });
+        return `${this.baseUrl}/auth/cli/oauth?${params.toString()}`;
+    }
+    /**
+     * Validate tool definition before publishing
+     */
+    validateTool(tool) {
+        const errors = [];
+        if (!tool.name || typeof tool.name !== "string") {
+            errors.push("Tool name is required and must be a string");
+        }
+        else if (!/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_\/-]+$/.test(tool.name)) {
+            errors.push("Tool name must follow hierarchical format: org/package/tool-name");
+        }
+        if (!tool.description || typeof tool.description !== "string") {
+            errors.push("Tool description is required and must be a string");
+        }
+        if (!tool.command || typeof tool.command !== "string") {
+            errors.push("Tool command is required and must be a string");
+        }
+        if (tool.timeout && typeof tool.timeout === "string") {
+            if (!/^\d+[smh]$/.test(tool.timeout)) {
+                errors.push('Timeout must be in Go duration format (e.g., "30s", "5m", "1h")');
+            }
+        }
+        if (tool.tags && !Array.isArray(tool.tags)) {
+            errors.push("Tags must be an array of strings");
+        }
+        if (tool.inputSchema && typeof tool.inputSchema !== "object") {
+            errors.push("inputSchema must be a valid JSON Schema object");
+        }
+        if (tool.outputSchema && typeof tool.outputSchema !== "object") {
+            errors.push("outputSchema must be a valid JSON Schema object");
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}
+// Export a default instance
+export const enactApi = new EnactApiClient();
+// Export error types for better error handling
+export class EnactApiError extends Error {
+    constructor(message, statusCode, endpoint) {
+        super(message);
+        this.statusCode = statusCode;
+        this.endpoint = endpoint;
+        this.name = "EnactApiError";
+    }
+}
+// Helper function to create API client with custom configuration
+export function createEnactApiClient(baseUrl, supabaseUrl) {
+    return new EnactApiClient(baseUrl, supabaseUrl);
+}

package/dist/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './enact-api';
+export * from './types';

package/dist/api/index.js

@@ -0,0 +1,2 @@
+export * from './enact-api';
+export * from './types';

package/dist/api/types.d.ts

@@ -0,0 +1,83 @@
+export interface EnactToolDefinition {
+    name: string;
+    description: string;
+    command: string;
+    version?: string;
+    timeout?: string;
+    tags?: string[];
+    inputSchema?: any;
+    outputSchema?: any;
+    examples?: any[];
+    annotations?: {
+        title?: string;
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    env?: Record<string, {
+        description: string;
+        source?: string;
+        required: boolean;
+        default?: string;
+    }>;
+    resources?: {
+        memory?: string;
+        gpu?: string;
+        disk?: string;
+    };
+    signature?: {
+        algorithm: string;
+        type: string;
+        signer: string;
+        created: string;
+        value: string;
+        role?: string;
+    };
+    signatures?: Record<string, any>;
+    raw_content?: string;
+    namespace?: string;
+    enact?: string;
+    [key: string]: any;
+}
+export interface ToolSearchQuery {
+    query: string;
+    limit?: number;
+    tags?: string[];
+    format?: string;
+}
+export interface ToolUsage {
+    action: "view" | "download" | "execute";
+    metadata?: any;
+}
+export interface CLITokenCreate {
+    name?: string;
+}
+export interface OAuthTokenExchange {
+    grant_type: "authorization_code";
+    code: string;
+    redirect_uri: string;
+    client_id: string;
+    code_verifier: string;
+}
+export interface ApiResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export interface VerificationPolicy {
+    minimumSignatures?: number;
+    trustedSigners?: string[];
+    allowedAlgorithms?: string[];
+}
+export interface EnactExecOptions {
+    help?: boolean;
+    input?: string;
+    params?: string;
+    timeout?: string;
+    dry?: boolean;
+    verbose?: boolean;
+    skipVerification?: boolean;
+    verifyPolicy?: string;
+    force?: boolean;
+}

package/dist/api/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/DaggerExecutionProvider.d.ts

@@ -0,0 +1,169 @@
+import { ExecutionProvider, type EnactTool, type ExecutionEnvironment, type ExecutionResult } from "../types.js";
+export interface DaggerExecutionOptions {
+    baseImage?: string;
+    workdir?: string;
+    enableNetwork?: boolean;
+    enableHostFS?: boolean;
+    maxMemory?: string;
+    maxCPU?: string;
+    cacheVolume?: string;
+    useShell?: boolean;
+    engineTimeout?: number;
+    maxRetries?: number;
+    enableEngineHealthCheck?: boolean;
+}
+interface CommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+interface EngineHealthStatus {
+    isHealthy: boolean;
+    lastCheck: Date;
+    consecutiveFailures: number;
+}
+export declare class DaggerExecutionProvider extends ExecutionProvider {
+    private client;
+    private options;
+    private tempDir;
+    private connectionCleanup;
+    private engineHealth;
+    private abortController;
+    private activeSessions;
+    private isShuttingDown;
+    constructor(options?: DaggerExecutionOptions);
+    setup(tool: EnactTool): Promise<boolean>;
+    /**
+     * Enhanced cleanup with comprehensive engine management and session tracking
+     */
+    cleanup(): Promise<boolean>;
+    /**
+     * Enhanced engine cleanup with better container detection
+     */
+    private performEngineCleanup;
+    /**
+     * Check engine health with comprehensive diagnostics
+     */
+    private checkEngineHealth;
+    /**
+     * Reset engine container when health check fails
+     */
+    private resetEngineContainer;
+    /**
+     * Start periodic engine health monitoring
+     */
+    private startEngineHealthMonitoring;
+    /**
+     * Wait for active sessions to complete with timeout
+     */
+    private waitForActiveSessions;
+    resolveEnvironmentVariables(envConfig: Record<string, any>, namespace?: string): Promise<Record<string, any>>;
+    execute(tool: EnactTool, inputs: Record<string, any>, environment: ExecutionEnvironment): Promise<ExecutionResult>;
+    /**
+     * Categorize errors for better handling
+     */
+    private categorizeError;
+    executeCommand(command: string, inputs: Record<string, any>, environment: ExecutionEnvironment, timeout?: string, options?: {
+        verbose?: boolean;
+        showSpinner?: boolean;
+        streamOutput?: boolean;
+    }): Promise<CommandResult>;
+    /**
+     * Execute command using Dagger connect with proper session management
+     */
+    private executeWithConnect;
+    /**
+     * Enhanced container setup with better tool detection and installation
+     */
+    private setupContainer;
+    /**
+     * Install common tools that Enact commands might need
+     * Enhanced with better error handling and timeout
+     */
+    private installCommonTools;
+    /**
+     * Execute command in container with enhanced error handling
+     */
+    private executeInContainer;
+    /**
+     * Enhanced execution error parsing
+     */
+    private parseExecutionError;
+    /**
+     * Apply resource limits based on Enact tool specifications
+     */
+    private applyResourceLimits;
+    /**
+     * Substitute template variables in Enact commands with enhanced security
+     */
+    private substituteCommandVariables;
+    /**
+     * Enhanced shell argument escaping
+     */
+    private escapeShellArg;
+    /**
+     * Prepare input files for Enact tools that expect file inputs
+     */
+    private prepareInputFiles;
+    /**
+     * Heuristics to determine if input should be treated as file content
+     */
+    private looksLikeFileContent;
+    /**
+     * Check if content looks like common file types
+     */
+    private hasCommonFileExtensions;
+    /**
+     * Generate appropriate filename for input content
+     */
+    private getInputFileName;
+    /**
+     * Map MIME types to file extensions
+     */
+    private getExtensionFromMimeType;
+    /**
+     * Enhanced command parsing for non-shell execution
+     */
+    private parseCommand;
+    /**
+     * Enhanced timeout promise with abort signal support
+     */
+    private createTimeoutPromise;
+    /**
+     * Parse command output according to Enact tool output schema
+     */
+    private parseOutput;
+    /**
+     * Execute command with exec.ts style interface for backwards compatibility
+     */
+    executeCommandExecStyle(command: string, timeout: string, verbose?: boolean, envVars?: Record<string, string>): Promise<void>;
+    /**
+     * Enhanced cleanup handlers with graceful shutdown
+     */
+    private registerCleanupHandlers;
+    /**
+     * Graceful shutdown with proper async cleanup
+     */
+    private gracefulShutdown;
+    /**
+     * Enhanced force cleanup for synchronous exit handlers
+     */
+    private forceCleanup;
+    /**
+     * Get current engine status for debugging
+     */
+    getEngineStatus(): {
+        health: EngineHealthStatus;
+        activeSessions: number;
+        isShuttingDown: boolean;
+    };
+    /**
+     * Manually trigger engine reset (for debugging/testing)
+     */
+    resetEngine(): Promise<void>;
+    /**
+     * Check if provider is ready for new executions
+     */
+    isReady(): boolean;
+}
+export {};