@enactprotocol/shared 1.2.13 → 2.0.1

package/dist/exec/logger.js

@@ -1,57 +0,0 @@
-import pino from "pino";
-// Determine if the environment is silent (e.g., CI, testing, or specific env var)
-const isSilentMode = () => process.env.CI === "true" ||
-    process.env.NODE_ENV === "test" ||
-    process.env.ENACT_SILENT === "true" ||
-    process.env.ENACT_SKIP_INTERACTIVE === "true";
-// Base logger configuration
-const logger = pino({
-    level: process.env.LOG_LEVEL || "info",
-    // In tests, we don't want the pretty transport, as it adds noise.
-    // The output is captured anyway.
-    ...(process.env.NODE_ENV !== "test" && {
-        transport: {
-            target: "pino-pretty",
-            options: {
-                colorize: true,
-                ignore: "pid,hostname",
-                translateTime: "SYS:standard",
-            },
-        },
-    }),
-});
-// Wrapper to dynamically check silent mode on each call
-const wrappedLogger = {
-    info: (...args) => {
-        if (!isSilentMode()) {
-            logger.info(...args);
-        }
-    },
-    warn: (...args) => {
-        if (!isSilentMode()) {
-            logger.warn(...args);
-        }
-    },
-    error: (...args) => {
-        // The silent tests expect errors to be silent too.
-        if (!isSilentMode()) {
-            logger.error(...args);
-        }
-    },
-    debug: (...args) => {
-        if (!isSilentMode() && (process.env.DEBUG || process.env.VERBOSE)) {
-            logger.debug(...args);
-        }
-    },
-    // Expose a way to check if client logging is enabled (for MCP)
-    clientLoggingEnabled: () => !process.env.ENACT_MCP_CLIENT,
-    isLevelEnabled: (level) => {
-        if (isSilentMode()) {
-            return false;
-        }
-        return logger.isLevelEnabled(level);
-    },
-    // Keep original pino instance available if needed
-    pino: logger,
-};
-export default wrappedLogger;

package/dist/exec/validate.d.ts

@@ -1,5 +0,0 @@
-import type { EnactTool, JSONSchemaDefinition } from "../types";
-export declare function validateAgainstSchema(value: any, schema: JSONSchemaDefinition, fieldName: string): void;
-export declare function validateToolStructure(tool: EnactTool): void;
-export declare function validateInputs(tool: EnactTool, inputs: Record<string, any>): Record<string, any>;
-export declare function validateOutput(tool: EnactTool, output: any): any;

package/dist/exec/validate.js

@@ -1,167 +0,0 @@
-export function validateAgainstSchema(value, schema, fieldName) {
-    const { type, format, enum: enumValues, minimum, maximum, pattern, required, } = schema;
-    // Type validation
-    if (type) {
-        let validType = false;
-        switch (type) {
-            case "string":
-                validType = typeof value === "string";
-                break;
-            case "number":
-            case "integer":
-                validType = typeof value === "number";
-                if (type === "integer" && !Number.isInteger(value)) {
-                    validType = false;
-                }
-                break;
-            case "boolean":
-                validType = typeof value === "boolean";
-                break;
-            case "array":
-                validType = Array.isArray(value);
-                break;
-            case "object":
-                validType =
-                    typeof value === "object" && value !== null && !Array.isArray(value);
-                break;
-        }
-        if (!validType) {
-            throw new Error(`Invalid type for ${fieldName}: expected ${type}`);
-        }
-    }
-    // For object types, validate required properties
-    if (type === "object" && required && Array.isArray(required)) {
-        for (const requiredProp of required) {
-            if (value[requiredProp] === undefined) {
-                throw new Error(`Missing required property: ${requiredProp} in ${fieldName}`);
-            }
-        }
-    }
-    // Format validation (simplified)
-    if (format && type === "string") {
-        const formatValidators = {
-            email: /^.+@.+\..+$/,
-            "date-time": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d+)?(Z|[+-]\d{2}:\d{2})$/,
-            uri: /^https?:\/\/.+/,
-        };
-        if (formatValidators[format] && !formatValidators[format].test(value)) {
-            throw new Error(`Invalid format for ${fieldName}: expected ${format}`);
-        }
-    }
-    // Enum validation
-    if (enumValues && !enumValues.includes(value)) {
-        throw new Error(`Invalid value for ${fieldName}: must be one of [${enumValues.join(", ")}]`);
-    }
-    // Range validation for numbers
-    if ((minimum !== undefined || maximum !== undefined) &&
-        typeof value === "number") {
-        if (minimum !== undefined && value < minimum) {
-            throw new Error(`Value for ${fieldName} must be >= ${minimum}`);
-        }
-        if (maximum !== undefined && value > maximum) {
-            throw new Error(`Value for ${fieldName} must be <= ${maximum}`);
-        }
-    }
-    // Pattern validation for strings
-    if (pattern &&
-        typeof value === "string" &&
-        !new RegExp(pattern).test(value)) {
-        throw new Error(`Value for ${fieldName} must match pattern: ${pattern}`);
-    }
-}
-export function validateToolStructure(tool) {
-    // Check required fields
-    const requiredFields = ["name", "description", "command"];
-    for (const field of requiredFields) {
-        if (!tool[field]) {
-            throw new Error(`Missing required field: ${field} in tool ${JSON.stringify(tool)}`);
-        }
-    }
-    // Validate name format - supports hierarchical names with forward slashes
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*(?:\/[a-zA-Z0-9][a-zA-Z0-9_-]*)*$/.test(tool.name)) {
-        throw new Error(`Invalid tool name: ${tool.name}. Must follow hierarchical format like "tool-name" or "org/package/tool-name".`);
-    }
-    // Validate command is not empty
-    if (!tool.command.trim()) {
-        throw new Error("Command field cannot be empty");
-    }
-    // Validate timeout format if provided
-    if (tool.timeout) {
-        if (!/^\d+[smh]$/.test(tool.timeout)) {
-            throw new Error(`Invalid timeout format: ${tool.timeout}. Must be Go duration format like "30s", "5m", "1h"`);
-        }
-    }
-    // Validate environment variables structure
-    if (tool.env) {
-        for (const [varName, config] of Object.entries(tool.env)) {
-            if (!config.description ||
-                !config.source ||
-                config.required === undefined) {
-                throw new Error(`Environment variable ${varName} must have description, source, and required fields`);
-            }
-            if (!/^[A-Z][A-Z0-9_]*$/.test(varName)) {
-                throw new Error(`Invalid environment variable name: ${varName}. Must be uppercase with underscores`);
-            }
-        }
-    }
-    // Validate authors structure if provided
-    if (tool.authors) {
-        for (const author of tool.authors) {
-            if (!author.name) {
-                throw new Error("Author must have a name field");
-            }
-            if (author.email && !/^.+@.+\..+$/.test(author.email)) {
-                throw new Error(`Invalid email format for author: ${author.email}`);
-            }
-            if (author.url && !/^https?:\/\/.+/.test(author.url)) {
-                throw new Error(`Invalid URL format for author: ${author.url}`);
-            }
-        }
-    }
-}
-export function validateInputs(tool, inputs) {
-    const validatedInputs = {};
-    if (!tool.inputSchema || !tool.inputSchema.properties) {
-        return inputs;
-    }
-    // Check for required fields
-    const requiredFields = tool.inputSchema.required || [];
-    for (const field of requiredFields) {
-        if (inputs[field] === undefined) {
-            throw new Error(`Missing required input: ${field}`);
-        }
-    }
-    // Validate and extract values
-    for (const [key, schema] of Object.entries(tool.inputSchema.properties)) {
-        if (inputs[key] !== undefined) {
-            validateAgainstSchema(inputs[key], schema, key);
-            validatedInputs[key] = inputs[key];
-        }
-        else if (schema.default !== undefined) {
-            validatedInputs[key] = schema.default;
-        }
-    }
-    return validatedInputs;
-}
-export function validateOutput(tool, output) {
-    if (!tool.outputSchema) {
-        return output;
-    }
-    try {
-        // Validate the entire output against the schema
-        validateAgainstSchema(output, tool.outputSchema, "output");
-        // Also check required fields specifically
-        if (tool.outputSchema.required &&
-            Array.isArray(tool.outputSchema.required)) {
-            for (const requiredField of tool.outputSchema.required) {
-                if (output[requiredField] === undefined) {
-                    throw new Error(`Missing required output field: ${requiredField}`);
-                }
-            }
-        }
-        return output;
-    }
-    catch (error) {
-        throw new Error(`Output validation failed: ${error.message}`);
-    }
-}

package/dist/lib/enact-direct.d.ts

@@ -1,150 +0,0 @@
-import { type ToolSearchOptions, type ToolExecuteOptions } from "../core/EnactCore";
-import type { EnactTool, ExecutionResult } from "../types";
-/**
- * Direct Enact Library Interface
- *
- * This provides a simple, direct interface for MCP servers to use Enact
- * without any CLI process spawning. All operations happen in-process.
- */
-export declare class EnactDirect {
-    private core;
-    constructor(options?: {
-        apiUrl?: string;
-        supabaseUrl?: string;
-        authToken?: string;
-        defaultTimeout?: string;
-    });
-    /**
-     * Create EnactDirect with config-based URLs
-     */
-    static create(options?: {
-        apiUrl?: string;
-        supabaseUrl?: string;
-        authToken?: string;
-        defaultTimeout?: string;
-    }): Promise<EnactDirect>;
-    /**
-     * Execute a tool by name with inputs
-     *
-     * @param name - Tool name (e.g., "my-org/data-processor")
-     * @param inputs - Input parameters for the tool
-     * @param options - Execution options
-     * @returns Execution result
-     */
-    executeToolByName(name: string, inputs?: Record<string, any>, options?: ToolExecuteOptions): Promise<ExecutionResult>;
-    /**
-     * Search for tools matching a query
-     *
-     * @param options - Search options
-     * @returns Array of matching tools
-     */
-    searchTools(options: ToolSearchOptions): Promise<EnactTool[]>;
-    /**
-     * Get detailed information about a specific tool
-     *
-     * @param name - Tool name
-     * @param version - Optional specific version
-     * @returns Tool information or null if not found
-     */
-    getToolInfo(name: string, version?: string): Promise<EnactTool | null>;
-    /**
-     * Execute a tool from raw YAML definition
-     *
-     * @param toolYaml - YAML tool definition
-     * @param inputs - Input parameters
-     * @param options - Execution options
-     * @returns Execution result
-     */
-    executeRawTool(toolYaml: string, inputs?: Record<string, any>, options?: ToolExecuteOptions): Promise<ExecutionResult>;
-    /**
-     * Check if a tool exists in the registry
-     *
-     * @param name - Tool name
-     * @returns True if tool exists
-     */
-    toolExists(name: string): Promise<boolean>;
-    /**
-     * Get all tools with optional filtering
-     *
-     * @param options - Filter options
-     * @returns Array of tools
-     */
-    getTools(options?: {
-        limit?: number;
-        offset?: number;
-        tags?: string[];
-        author?: string;
-    }): Promise<EnactTool[]>;
-    /**
-     * Get tools by specific tags
-     *
-     * @param tags - Array of tags to filter by
-     * @param limit - Maximum number of results
-     * @returns Array of tools
-     */
-    getToolsByTags(tags: string[], limit?: number): Promise<EnactTool[]>;
-    /**
-     * Get tools by a specific author
-     *
-     * @param author - Author name
-     * @param limit - Maximum number of results
-     * @returns Array of tools
-     */
-    getToolsByAuthor(author: string, limit?: number): Promise<EnactTool[]>;
-    /**
-     * Get the current status of the Enact core
-     *
-     * @returns Status information
-     */
-    getStatus(): Promise<{
-        executionProvider: string;
-        apiUrl: string;
-        defaultTimeout: string;
-        authenticated: boolean;
-    }>;
-    /**
-     * Set authentication token
-     *
-     * @param token - Authentication token
-     */
-    setAuthToken(token: string): void;
-    /**
-     * Get authentication status
-     *
-     * @returns Authentication status
-     */
-    getAuthStatus(): Promise<{
-        authenticated: boolean;
-        user?: string;
-        server?: string;
-    }>;
-    /**
-     * Publish a tool (requires authentication)
-     *
-     * @param tool - Tool definition to publish
-     * @returns Publication result
-     */
-    publishTool(tool: EnactTool): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-}
-export declare const enactDirect: EnactDirect;
-export declare const executeToolByName: (name: string, inputs?: Record<string, any>, options?: ToolExecuteOptions) => Promise<ExecutionResult>;
-export declare const searchTools: (options: ToolSearchOptions) => Promise<EnactTool[]>;
-export declare const getToolInfo: (name: string, version?: string) => Promise<EnactTool | null>;
-export declare const executeRawTool: (toolYaml: string, inputs?: Record<string, any>, options?: ToolExecuteOptions) => Promise<ExecutionResult>;
-export declare const getToolsByTags: (tags: string[], limit?: number) => Promise<EnactTool[]>;
-export declare const getToolsByAuthor: (author: string, limit?: number) => Promise<EnactTool[]>;
-export declare const toolExists: (name: string) => Promise<boolean>;
-export declare const getAuthStatus: () => Promise<{
-    authenticated: boolean;
-    user?: string;
-    server?: string;
-}>;
-export declare const publishTool: (tool: EnactTool) => Promise<{
-    success: boolean;
-    message: string;
-}>;
-export { EnactCore, type ToolSearchOptions, type ToolExecuteOptions, } from "../core/EnactCore";
-export type { EnactTool, ExecutionResult } from "../types";

package/dist/lib/enact-direct.js

@@ -1,159 +0,0 @@
-// src/lib/enact-direct.ts - Library interface for direct usage by MCP servers
-import { EnactCore, } from "../core/EnactCore";
-import { getFrontendUrl, getApiUrl } from "../utils/config";
-/**
- * Direct Enact Library Interface
- *
- * This provides a simple, direct interface for MCP servers to use Enact
- * without any CLI process spawning. All operations happen in-process.
- */
-export class EnactDirect {
-    constructor(options = {}) {
-        // We need to handle async config loading in a factory method
-        this.core = new EnactCore({
-            apiUrl: options.apiUrl || process.env.ENACT_FRONTEND_URL || "https://enact.tools",
-            supabaseUrl: options.supabaseUrl || process.env.ENACT_API_URL || "https://xjnhhxwxovjifdxdwzih.supabase.co",
-            executionProvider: "direct",
-            authToken: options.authToken || process.env.ENACT_AUTH_TOKEN,
-            defaultTimeout: options.defaultTimeout || "30s",
-        });
-    }
-    /**
-     * Create EnactDirect with config-based URLs
-     */
-    static async create(options = {}) {
-        const frontendUrl = options.apiUrl || process.env.ENACT_FRONTEND_URL || await getFrontendUrl();
-        const apiUrl = options.supabaseUrl || process.env.ENACT_API_URL || await getApiUrl();
-        return new EnactDirect({
-            ...options,
-            apiUrl: frontendUrl,
-            supabaseUrl: apiUrl,
-        });
-    }
-    /**
-     * Execute a tool by name with inputs
-     *
-     * @param name - Tool name (e.g., "my-org/data-processor")
-     * @param inputs - Input parameters for the tool
-     * @param options - Execution options
-     * @returns Execution result
-     */
-    async executeToolByName(name, inputs = {}, options = {}) {
-        return this.core.executeToolByName(name, inputs, options);
-    }
-    /**
-     * Search for tools matching a query
-     *
-     * @param options - Search options
-     * @returns Array of matching tools
-     */
-    async searchTools(options) {
-        return this.core.searchTools(options);
-    }
-    /**
-     * Get detailed information about a specific tool
-     *
-     * @param name - Tool name
-     * @param version - Optional specific version
-     * @returns Tool information or null if not found
-     */
-    async getToolInfo(name, version) {
-        return this.core.getToolInfo(name, version);
-    }
-    /**
-     * Execute a tool from raw YAML definition
-     *
-     * @param toolYaml - YAML tool definition
-     * @param inputs - Input parameters
-     * @param options - Execution options
-     * @returns Execution result
-     */
-    async executeRawTool(toolYaml, inputs = {}, options = {}) {
-        return this.core.executeRawTool(toolYaml, inputs, options);
-    }
-    /**
-     * Check if a tool exists in the registry
-     *
-     * @param name - Tool name
-     * @returns True if tool exists
-     */
-    async toolExists(name) {
-        return this.core.toolExists(name);
-    }
-    /**
-     * Get all tools with optional filtering
-     *
-     * @param options - Filter options
-     * @returns Array of tools
-     */
-    async getTools(options = {}) {
-        return this.core.getTools(options);
-    }
-    /**
-     * Get tools by specific tags
-     *
-     * @param tags - Array of tags to filter by
-     * @param limit - Maximum number of results
-     * @returns Array of tools
-     */
-    async getToolsByTags(tags, limit = 20) {
-        return this.core.getToolsByTags(tags, limit);
-    }
-    /**
-     * Get tools by a specific author
-     *
-     * @param author - Author name
-     * @param limit - Maximum number of results
-     * @returns Array of tools
-     */
-    async getToolsByAuthor(author, limit = 20) {
-        return this.core.getToolsByAuthor(author, limit);
-    }
-    /**
-     * Get the current status of the Enact core
-     *
-     * @returns Status information
-     */
-    async getStatus() {
-        return this.core.getStatus();
-    }
-    /**
-     * Set authentication token
-     *
-     * @param token - Authentication token
-     */
-    setAuthToken(token) {
-        this.core.setAuthToken(token);
-    }
-    /**
-     * Get authentication status
-     *
-     * @returns Authentication status
-     */
-    async getAuthStatus() {
-        return this.core.getAuthStatus();
-    }
-    /**
-     * Publish a tool (requires authentication)
-     *
-     * @param tool - Tool definition to publish
-     * @returns Publication result
-     */
-    async publishTool(tool) {
-        return this.core.publishTool(tool);
-    }
-}
-// Create and export a default instance
-export const enactDirect = new EnactDirect();
-// Export convenience functions using the default instance
-export const executeToolByName = (name, inputs = {}, options = {}) => enactDirect.executeToolByName(name, inputs, options);
-export const searchTools = (options) => enactDirect.searchTools(options);
-export const getToolInfo = (name, version) => enactDirect.getToolInfo(name, version);
-export const executeRawTool = (toolYaml, inputs = {}, options = {}) => enactDirect.executeRawTool(toolYaml, inputs, options);
-export const getToolsByTags = (tags, limit = 20) => enactDirect.getToolsByTags(tags, limit);
-export const getToolsByAuthor = (author, limit = 20) => enactDirect.getToolsByAuthor(author, limit);
-export const toolExists = (name) => enactDirect.toolExists(name);
-export const getAuthStatus = () => enactDirect.getAuthStatus();
-export const publishTool = (tool) => enactDirect.publishTool(tool);
-// Also export the core for advanced usage
-export { EnactCore, } from "../core/EnactCore";

package/dist/lib/index.d.ts

@@ -1 +0,0 @@
-export * from './enact-direct';

package/dist/lib/index.js

@@ -1 +0,0 @@
-export * from './enact-direct';

package/dist/security/index.d.ts

@@ -1,3 +0,0 @@
-export * from './security';
-export * from './sign';
-export * from './verification-enforcer';

package/dist/security/index.js

@@ -1,3 +0,0 @@
-export * from './security';
-export * from './sign';
-export * from './verification-enforcer';

package/dist/security/security.d.ts

@@ -1,23 +0,0 @@
-import type { EnactTool } from "../types";
-/**
- * Verify the signature of an Enact tool before execution
- * @param tool The tool to verify
- * @returns Boolean indicating validity
- */
-/**
- * Verify that a command is safe to execute
- * @param command The command to verify
- * @param tool The tool containing the command
- * @returns Object with safety status and warnings
- */
-export declare function verifyCommandSafety(command: string, tool: EnactTool): {
-    isSafe: boolean;
-    warnings: string[];
-    blocked?: string[];
-};
-/**
- * Sanitize environment variables to prevent injection attacks
- * @param envVars Environment variables to sanitize
- * @returns Sanitized environment variables
- */
-export declare function sanitizeEnvironmentVariables(envVars: Record<string, any>): Record<string, string>;