@enactprotocol/shared 1.0.12

package/dist/exec/validate.d.ts

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

@@ -0,0 +1,167 @@
+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/index.d.ts

@@ -0,0 +1,25 @@
+export { EnactCore } from './core/EnactCore';
+export { DirectExecutionProvider } from './core/DirectExecutionProvider';
+export { DaggerExecutionProvider } from './core/DaggerExecutionProvider';
+export type { EnactTool } from './types';
+export type { EnactToolDefinition } from './api/types';
+export { default as LocalToolResolver } from './LocalToolResolver';
+export { default } from './LocalToolResolver';
+export { default as logger } from './exec/logger';
+export * from './exec/validate';
+export * from './utils/config';
+export * from './utils/env-loader';
+export { showHelp } from './utils/help';
+export { showVersion as utilsShowVersion } from './utils/version';
+export * from './utils/logger';
+export * from './utils/silent-monitor';
+export * from './utils/timeout';
+export * from './security/security';
+export { verifyTool, shouldExecuteTool, VERIFICATION_POLICIES } from './security/sign';
+export type { VerificationPolicy as SecurityVerificationPolicy } from './security/sign';
+export * from './security/verification-enforcer';
+export * from './services/McpCoreService';
+export * from './web/env-manager-server';
+export * from './api/enact-api';
+export type { ApiResponse, ToolSearchQuery, ToolUsage, CLITokenCreate, OAuthTokenExchange } from './api/types';
+export * from './lib/enact-direct';

package/dist/index.js

@@ -0,0 +1,29 @@
+// Core exports
+export { EnactCore } from './core/EnactCore';
+export { DirectExecutionProvider } from './core/DirectExecutionProvider';
+export { DaggerExecutionProvider } from './core/DaggerExecutionProvider';
+export { default as LocalToolResolver } from './LocalToolResolver';
+export { default } from './LocalToolResolver';
+// Exec utilities
+export { default as logger } from './exec/logger';
+export * from './exec/validate';
+// Utils
+export * from './utils/config';
+export * from './utils/env-loader';
+export { showHelp } from './utils/help';
+export { showVersion as utilsShowVersion } from './utils/version';
+export * from './utils/logger';
+export * from './utils/silent-monitor';
+export * from './utils/timeout';
+// Security
+export * from './security/security';
+export { verifyTool, shouldExecuteTool, VERIFICATION_POLICIES } from './security/sign';
+export * from './security/verification-enforcer';
+// Services
+export * from './services/McpCoreService';
+// Web
+export * from './web/env-manager-server';
+// API
+export * from './api/enact-api';
+// Lib
+export * from './lib/enact-direct';

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

@@ -0,0 +1,156 @@
+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;
+        verificationPolicy?: "permissive" | "enterprise" | "paranoid";
+        defaultTimeout?: string;
+    });
+    /**
+     * 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>;
+    /**
+     * Verify a tool's cryptographic signatures
+     *
+     * @param name - Tool name
+     * @param policy - Verification policy
+     * @returns Verification result
+     */
+    verifyTool(name: string, policy?: "permissive" | "enterprise" | "paranoid"): Promise<{
+        verified: boolean;
+        signatures: any[];
+        policy: string;
+        errors?: string[];
+    }>;
+    /**
+     * 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;
+        verificationPolicy: 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

@@ -0,0 +1,158 @@
+// src/lib/enact-direct.ts - Library interface for direct usage by MCP servers
+import { EnactCore, } from "../core/EnactCore";
+/**
+ * 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 = {}) {
+        this.core = new EnactCore({
+            apiUrl: options.apiUrl || process.env.ENACT_API_URL || "https://enact.tools",
+            supabaseUrl: options.supabaseUrl ||
+                process.env.ENACT_SUPABASE_URL ||
+                "https://xjnhhxwxovjifdxdwzih.supabase.co",
+            executionProvider: "direct",
+            authToken: options.authToken || process.env.ENACT_AUTH_TOKEN,
+            verificationPolicy: options.verificationPolicy || "permissive",
+            defaultTimeout: options.defaultTimeout || "30s",
+        });
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Verify a tool's cryptographic signatures
+     *
+     * @param name - Tool name
+     * @param policy - Verification policy
+     * @returns Verification result
+     */
+    async verifyTool(name, policy) {
+        return this.core.verifyTool(name, policy);
+    }
+    /**
+     * 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

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

package/dist/lib/index.js

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

package/dist/security/index.d.ts

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

package/dist/security/index.js

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

package/dist/security/security.d.ts

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