@enactprotocol/shared 1.2.13 → 2.0.1

package/dist/api/enact-api.js

@@ -1,428 +0,0 @@
-import { getFrontendUrl, getApiUrl } from "../utils/config";
-export class EnactApiClient {
-    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")
-            ? 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) && !process.env.ENACT_SILENT) {
-            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) && !process.env.ENACT_SILENT) {
-                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);
-        }
-    }
-    async signTool(toolId, payload, token, tokenType = "cli") {
-        const endpoint = `/functions/v1/tools/${encodeURIComponent(toolId)}/signatures`;
-        return this.makeRequest(endpoint, {
-            method: "POST",
-            body: JSON.stringify(payload),
-        }, token, tokenType);
-    }
-    // ===================
-    // 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 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) {
-        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) {
-    const defaultFrontend = "https://enact.tools";
-    const defaultApi = "https://xjnhhxwxovjifdxdwzih.supabase.co";
-    return new EnactApiClient(baseUrl || defaultFrontend, supabaseUrl || defaultApi);
-}

package/dist/api/index.d.ts

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

package/dist/api/index.js

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

package/dist/api/types.d.ts

@@ -1,103 +0,0 @@
-export interface EnactToolDefinition {
-    name: string;
-    description: string;
-    verified?: boolean;
-    command: string;
-    from?: 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?: {
-        signer: string;
-        algorithm: string;
-        type: string;
-        value: string;
-        created: string;
-        role?: string;
-    }[];
-    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;
-    force?: boolean;
-    dangerouslySkipVerification?: boolean;
-    mount?: string;
-}
-export interface ToolSignaturePayload {
-    algorithm: "sha256";
-    created: string;
-    key_id: string;
-    public_key: string;
-    role: "author";
-    signer: string;
-    timestamp: number;
-    type: "ecdsa-p256";
-    value: string;
-}

package/dist/api/types.js

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