@enactprotocol/shared 1.0.12

package/dist/LocalToolResolver.d.ts

@@ -0,0 +1,84 @@
+import { EnactCore } from "./core/EnactCore";
+export interface LocalTool {
+    name: string;
+    path: string;
+    definition: any;
+    lastModified: Date;
+    cached: boolean;
+}
+export interface ToolResolutionResult {
+    tool: LocalTool | any;
+    source: "local" | "registry" | "cache";
+    metadata?: any;
+}
+export declare class LocalToolResolver {
+    private enactCore;
+    private localToolsDir;
+    private cacheDir;
+    private toolCache;
+    private aliases;
+    private favorites;
+    constructor(enactCore: EnactCore, localToolsDir?: string, cacheDir?: string);
+    /**
+     * Main resolution method - checks local first, then registry
+     */
+    resolveTool(toolName: string): Promise<ToolResolutionResult | null>;
+    /**
+     * Get tool from local directory
+     */
+    private getLocalTool;
+    /**
+     * Cache a registry tool locally for faster access
+     */
+    private cacheRegistryTool;
+    /**
+     * Check if cached tool is expired (24 hours by default)
+     */
+    private isCacheExpired;
+    /**
+     * List all available tools from all sources
+     */
+    listAllTools(): Promise<{
+        local: LocalTool[];
+        cached: LocalTool[];
+        favorites: string[];
+        aliases: Record<string, string>;
+    }>;
+    /**
+     * Scan local tools directory
+     */
+    private scanLocalTools;
+    /**
+     * Recursively scan directory for tool files
+     */
+    private scanDirectory;
+    /**
+     * Add a tool to favorites for priority resolution
+     */
+    addToFavorites(toolName: string): void;
+    /**
+     * Add an alias for a tool
+     */
+    addAlias(alias: string, toolName: string): void;
+    /**
+     * Get suggestions based on partial tool name
+     */
+    getSuggestions(partial: string): Promise<string[]>;
+    /**
+     * Clear expired cache entries
+     */
+    cleanupCache(): Promise<number>;
+    /**
+     * Load configuration from file
+     */
+    private loadConfiguration;
+    /**
+     * Save configuration to file
+     */
+    private saveConfiguration;
+    /**
+     * Initialize local tools directory with examples
+     */
+    initialize(): Promise<void>;
+}
+export default LocalToolResolver;

package/dist/LocalToolResolver.js

@@ -0,0 +1,353 @@
+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

@@ -0,0 +1,124 @@
+import { EnactToolDefinition, ToolUsage, ToolSearchQuery, CLITokenCreate, OAuthTokenExchange } from "./types";
+export declare class EnactApiClient {
+    baseUrl: string;
+    supabaseUrl: string;
+    constructor(baseUrl?: string, supabaseUrl?: string);
+    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>;
+    /**
+     * 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 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;