@enactprotocol/shared 1.2.13 → 2.0.1

package/dist/LocalToolResolver.js

@@ -1,353 +0,0 @@
-import { promises as fs, readFileSync, writeFileSync } from "fs";
-import { join, resolve, basename } from "path";
-import * as yaml from "yaml";
-import logger from "./exec/logger";
-export class LocalToolResolver {
-    constructor(enactCore, localToolsDir = "./tools", cacheDir = "./.tool-cache") {
-        this.enactCore = enactCore;
-        this.toolCache = new Map();
-        this.aliases = new Map();
-        this.favorites = new Set();
-        this.localToolsDir = resolve(localToolsDir);
-        this.cacheDir = resolve(cacheDir);
-        this.loadConfiguration();
-    }
-    /**
-     * Main resolution method - checks local first, then registry
-     */
-    async resolveTool(toolName) {
-        // Check aliases first
-        const resolvedName = this.aliases.get(toolName) || toolName;
-        // 1. Check local directory first
-        const localTool = await this.getLocalTool(resolvedName);
-        if (localTool) {
-            return {
-                tool: localTool,
-                source: "local",
-                metadata: { path: localTool.path },
-            };
-        }
-        // 2. Check cache for registry tools
-        const cachedTool = this.toolCache.get(resolvedName);
-        if (cachedTool && !this.isCacheExpired(cachedTool)) {
-            return {
-                tool: cachedTool,
-                source: "cache",
-                metadata: { cachedAt: cachedTool.lastModified },
-            };
-        }
-        // 3. Fall back to registry
-        try {
-            const registryTool = await this.enactCore.getToolByName(resolvedName);
-            if (registryTool) {
-                // Cache the registry tool locally
-                await this.cacheRegistryTool(resolvedName, registryTool);
-                return {
-                    tool: registryTool,
-                    source: "registry",
-                    metadata: { cached: true },
-                };
-            }
-        }
-        catch (error) {
-            logger.debug(`Registry lookup failed for ${resolvedName}:`, error);
-        }
-        return null;
-    }
-    /**
-     * Get tool from local directory
-     */
-    async getLocalTool(toolName) {
-        const possiblePaths = [
-            join(this.localToolsDir, `${toolName}.yaml`),
-            join(this.localToolsDir, `${toolName}.yml`),
-            join(this.localToolsDir, toolName, "tool.yaml"),
-            join(this.localToolsDir, toolName, "tool.yml"),
-            join(this.localToolsDir, toolName, `${toolName}.yaml`),
-            join(this.localToolsDir, toolName, `${toolName}.yml`),
-        ];
-        for (const toolPath of possiblePaths) {
-            try {
-                const stats = await fs.stat(toolPath);
-                const content = await fs.readFile(toolPath, "utf-8");
-                const definition = yaml.parse(content);
-                if (definition &&
-                    (definition.name === toolName || definition.name === undefined)) {
-                    return {
-                        name: definition.name || toolName,
-                        path: toolPath,
-                        definition,
-                        lastModified: stats.mtime,
-                        cached: false,
-                    };
-                }
-            }
-            catch (error) {
-                // File doesn't exist or can't be read, continue to next path
-                continue;
-            }
-        }
-        return null;
-    }
-    /**
-     * Cache a registry tool locally for faster access
-     */
-    async cacheRegistryTool(toolName, tool) {
-        try {
-            await fs.mkdir(this.cacheDir, { recursive: true });
-            const cachePath = join(this.cacheDir, `${toolName}.yaml`);
-            const cacheData = {
-                ...tool,
-                _cached: true,
-                _cachedAt: new Date().toISOString(),
-                _source: "registry",
-            };
-            await fs.writeFile(cachePath, yaml.stringify(cacheData));
-            this.toolCache.set(toolName, {
-                name: toolName,
-                path: cachePath,
-                definition: tool,
-                lastModified: new Date(),
-                cached: true,
-            });
-            logger.debug(`Cached registry tool: ${toolName}`);
-        }
-        catch (error) {
-            logger.warn(`Failed to cache tool ${toolName}:`, error);
-        }
-    }
-    /**
-     * Check if cached tool is expired (24 hours by default)
-     */
-    isCacheExpired(tool, maxAge = 24 * 60 * 60 * 1000) {
-        return Date.now() - tool.lastModified.getTime() > maxAge;
-    }
-    /**
-     * List all available tools from all sources
-     */
-    async listAllTools() {
-        const localTools = await this.scanLocalTools();
-        const cachedTools = Array.from(this.toolCache.values());
-        return {
-            local: localTools,
-            cached: cachedTools,
-            favorites: Array.from(this.favorites),
-            aliases: Object.fromEntries(this.aliases),
-        };
-    }
-    /**
-     * Scan local tools directory
-     */
-    async scanLocalTools() {
-        const tools = [];
-        try {
-            await fs.mkdir(this.localToolsDir, { recursive: true });
-            const entries = await this.scanDirectory(this.localToolsDir);
-            for (const entry of entries) {
-                if (entry.endsWith(".yaml") || entry.endsWith(".yml")) {
-                    try {
-                        const content = await fs.readFile(entry, "utf-8");
-                        const definition = yaml.parse(content);
-                        if (definition && (definition.name || definition.command)) {
-                            const stats = await fs.stat(entry);
-                            tools.push({
-                                name: definition.name ||
-                                    basename(entry, ".yaml").replace(".yml", ""),
-                                path: entry,
-                                definition,
-                                lastModified: stats.mtime,
-                                cached: false,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        logger.debug(`Skipping invalid tool file ${entry}:`, error);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            logger.warn(`Failed to scan local tools directory:`, error);
-        }
-        return tools;
-    }
-    /**
-     * Recursively scan directory for tool files
-     */
-    async scanDirectory(dir) {
-        const files = [];
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    const subFiles = await this.scanDirectory(fullPath);
-                    files.push(...subFiles);
-                }
-                else if (entry.isFile()) {
-                    files.push(fullPath);
-                }
-            }
-        }
-        catch (error) {
-            logger.debug(`Cannot scan directory ${dir}:`, error);
-        }
-        return files;
-    }
-    /**
-     * Add a tool to favorites for priority resolution
-     */
-    addToFavorites(toolName) {
-        this.favorites.add(toolName);
-        this.saveConfiguration();
-    }
-    /**
-     * Add an alias for a tool
-     */
-    addAlias(alias, toolName) {
-        this.aliases.set(alias, toolName);
-        this.saveConfiguration();
-    }
-    /**
-     * Get suggestions based on partial tool name
-     */
-    async getSuggestions(partial) {
-        const allTools = await this.listAllTools();
-        const suggestions = new Set();
-        // Add local tools
-        allTools.local.forEach((tool) => {
-            if (tool.name.includes(partial)) {
-                suggestions.add(tool.name);
-            }
-        });
-        // Add favorites first
-        this.favorites.forEach((fav) => {
-            if (fav.includes(partial)) {
-                suggestions.add(fav);
-            }
-        });
-        // Add aliases
-        this.aliases.forEach((toolName, alias) => {
-            if (alias.includes(partial) || toolName.includes(partial)) {
-                suggestions.add(alias);
-            }
-        });
-        return Array.from(suggestions).slice(0, 10); // Limit suggestions
-    }
-    /**
-     * Clear expired cache entries
-     */
-    async cleanupCache() {
-        let cleaned = 0;
-        for (const [toolName, tool] of this.toolCache.entries()) {
-            if (this.isCacheExpired(tool)) {
-                try {
-                    await fs.unlink(tool.path);
-                    this.toolCache.delete(toolName);
-                    cleaned++;
-                }
-                catch (error) {
-                    logger.debug(`Failed to clean cache for ${toolName}:`, error);
-                }
-            }
-        }
-        logger.info(`Cleaned ${cleaned} expired cache entries`);
-        return cleaned;
-    }
-    /**
-     * Load configuration from file
-     */
-    loadConfiguration() {
-        try {
-            const configPath = join(this.localToolsDir, "config.json");
-            const config = JSON.parse(readFileSync(configPath, "utf-8"));
-            if (config.aliases) {
-                this.aliases = new Map(Object.entries(config.aliases));
-            }
-            if (config.favorites) {
-                this.favorites = new Set(config.favorites);
-            }
-        }
-        catch (error) {
-            // Config file doesn't exist or is invalid, use defaults
-            logger.debug("No tool configuration found, using defaults");
-        }
-    }
-    /**
-     * Save configuration to file
-     */
-    saveConfiguration() {
-        try {
-            const configPath = join(this.localToolsDir, "config.json");
-            const config = {
-                aliases: Object.fromEntries(this.aliases),
-                favorites: Array.from(this.favorites),
-                lastUpdated: new Date().toISOString(),
-            };
-            writeFileSync(configPath, JSON.stringify(config, null, 2));
-        }
-        catch (error) {
-            logger.warn("Failed to save tool configuration:", error);
-        }
-    }
-    /**
-     * Initialize local tools directory with examples
-     */
-    async initialize() {
-        await fs.mkdir(this.localToolsDir, { recursive: true });
-        await fs.mkdir(this.cacheDir, { recursive: true });
-        // Create a sample local tool if directory is empty
-        const tools = await this.scanLocalTools();
-        if (tools.length === 0) {
-            const sampleTool = {
-                name: "hello-world",
-                description: "A simple hello world tool",
-                version: "1.0.0",
-                command: 'echo "Hello, World!"',
-                inputSchema: {
-                    properties: {
-                        message: {
-                            type: "string",
-                            description: "Custom message to display",
-                        },
-                    },
-                },
-            };
-            const samplePath = join(this.localToolsDir, "hello-world.yaml");
-            await fs.writeFile(samplePath, yaml.stringify(sampleTool));
-            logger.info(`Created sample tool at ${samplePath}`);
-        }
-        // Create README
-        const readmePath = join(this.localToolsDir, "README.md");
-        const readme = `# Local Tools Directory
-
-This directory contains your local Enact tools. Tools can be organized as:
-
-## File Structure
-- \`tool-name.yaml\` - Single tool file
-- \`tool-name/tool.yaml\` - Tool in subdirectory
-- \`tool-name/tool-name.yaml\` - Named tool in subdirectory
-
-## Configuration
-- \`config.json\` - Aliases and favorites configuration
-
-## Cache
-Registry tools are cached in \`.tool-cache/\` for faster access.
-
-## Priority Order
-1. Favorites (if name matches)
-2. Local tools
-3. Cached registry tools
-4. Registry lookup
-
-Use the MCP tools to manage this directory programmatically.
-`;
-        try {
-            await fs.access(readmePath);
-        }
-        catch {
-            await fs.writeFile(readmePath, readme);
-        }
-    }
-}
-export default LocalToolResolver;

package/dist/api/enact-api.d.ts

@@ -1,130 +0,0 @@
-import { EnactToolDefinition, ToolSignaturePayload, ToolUsage, ToolSearchQuery, CLITokenCreate, OAuthTokenExchange } from "./types";
-export declare class EnactApiClient {
-    baseUrl: string;
-    supabaseUrl: string;
-    constructor(baseUrl: string, supabaseUrl: string);
-    /**
-     * Create API client with config-based URLs
-     */
-    static create(baseUrl?: string, supabaseUrl?: string): Promise<EnactApiClient>;
-    private makeRequest;
-    /**
-     * Get all tools (public, no auth required)
-     */
-    getTools(params?: {
-        limit?: number;
-        offset?: number;
-        tags?: string[];
-        author?: string;
-    }): Promise<EnactToolDefinition[]>;
-    /**
-     * Get specific tool details (public, no auth required)
-     */
-    getTool(name: string): Promise<EnactToolDefinition>;
-    /**
-     * Get tool usage statistics (public, no auth required)
-     */
-    getToolUsage(name: string): Promise<any>;
-    /**
-     * Log tool usage (public, no auth required)
-     */
-    logToolUsage(name: string, usage: ToolUsage): Promise<any>;
-    /**
-     * Search tools with semantic/text search (public, no auth required)
-     */
-    searchTools(query: ToolSearchQuery): Promise<EnactToolDefinition[]>;
-    /**
-     * Publish/create new tool (requires authentication)
-     */
-    publishTool(tool: EnactToolDefinition, token: string, tokenType?: "jwt" | "cli"): Promise<any>;
-    /**
-     * Update existing tool (requires authentication, must be owner)
-     */
-    updateTool(name: string, tool: EnactToolDefinition, token: string, tokenType?: "jwt" | "cli"): Promise<any>;
-    /**
-     * Delete tool (requires authentication, must be owner)
-     */
-    deleteTool(name: string, token: string, tokenType?: "jwt" | "cli"): Promise<any>;
-    /**
-     * Create new CLI token (requires JWT authentication)
-     */
-    createCLIToken(tokenData: CLITokenCreate, jwtToken: string): Promise<{
-        token: string;
-        id: string;
-        name?: string;
-    }>;
-    /**
-     * List user's CLI tokens (requires JWT authentication)
-     */
-    getCLITokens(jwtToken: string): Promise<any[]>;
-    /**
-     * Delete CLI token (requires JWT authentication, must be owner)
-     */
-    deleteCLIToken(tokenId: string, jwtToken: string): Promise<any>;
-    /**
-     * Exchange OAuth authorization code for access token
-     */
-    exchangeOAuthCode(oauthData: OAuthTokenExchange): Promise<{
-        access_token: string;
-        token_type: string;
-        expires_in: number;
-        scope?: string;
-    }>;
-    /**
-     * Generate embeddings for tools (requires authentication)
-     */
-    generateEmbeddings(data: {
-        toolId: string;
-        text: string;
-    }, token: string, tokenType?: "jwt" | "cli"): Promise<any>;
-    /**
-     * Check if a tool exists
-     */
-    toolExists(name: string): Promise<boolean>;
-    /**
-     * Publish or update tool based on existence
-     */
-    publishOrUpdateTool(tool: EnactToolDefinition, token: string, tokenType?: "jwt" | "cli"): Promise<{
-        isUpdate: boolean;
-        result: any;
-    }>;
-    /**
-     * Search tools by tags
-     */
-    getToolsByTags(tags: string[], limit?: number): Promise<EnactToolDefinition[]>;
-    /**
-     * Get tools by author
-     */
-    getToolsByAuthor(author: string, limit?: number): Promise<EnactToolDefinition[]>;
-    /**
-     * Get a user's public key
-     */
-    getUserPublicKey(userId: string): Promise<any>;
-    signTool(toolId: string, payload: ToolSignaturePayload, token: string, tokenType?: "jwt" | "cli"): Promise<any>;
-    /**
-     * Generate OAuth authorization URL
-     */
-    generateOAuthUrl(options: {
-        clientId: string;
-        redirectUri: string;
-        scope: string;
-        state: string;
-        codeChallenge: string;
-        codeChallengeMethod: string;
-    }): string;
-    /**
-     * Validate tool definition before publishing
-     */
-    validateTool(tool: any): {
-        valid: boolean;
-        errors: string[];
-    };
-}
-export declare function createDefaultApiClient(): Promise<EnactApiClient>;
-export declare const enactApi: EnactApiClient;
-export declare class EnactApiError extends Error {
-    statusCode?: number | undefined;
-    endpoint?: string | undefined;
-    constructor(message: string, statusCode?: number | undefined, endpoint?: string | undefined);
-}
-export declare function createEnactApiClient(baseUrl?: string, supabaseUrl?: string): EnactApiClient;