sandstream-kit 1.0.0

package/dist/mcp-kit-tools-service.js

@@ -0,0 +1,943 @@
+import { randomUUID } from "node:crypto";
+const configs = new Map();
+const adapters = new Map();
+const tools = new Map();
+const services = new Map();
+const paths = new Map();
+const featureFlags = new Map();
+const snapshots = new Map();
+const validationHistory = new Map();
+const environmentVariables = new Map();
+/**
+ * Get configuration value
+ */
+export function getConfig(key) {
+    const config = configs.get(key);
+    if (!config) {
+        return {
+            success: false,
+            error: `Configuration key '${key}' not found`,
+        };
+    }
+    return {
+        success: true,
+        data: config,
+    };
+}
+/**
+ * Set configuration value
+ */
+export function setConfig(key, value, scope = "project", category = "tool", modified_by) {
+    const validation = validateConfigValue(key, value);
+    if (validation.result === "invalid") {
+        return {
+            success: false,
+            error: validation.message,
+            warnings: validation.suggestions,
+        };
+    }
+    const config = {
+        key,
+        value,
+        type: typeof value === "object" ? (Array.isArray(value) ? "array" : "object") : typeof value,
+        scope,
+        category,
+        last_modified: new Date().toISOString(),
+        modified_by,
+    };
+    configs.set(key, config);
+    return {
+        success: true,
+        data: config,
+    };
+}
+/**
+ * List configurations
+ */
+export function listConfigs(scope, category, limit = 100, offset = 0) {
+    let results = Array.from(configs.values());
+    if (scope) {
+        results = results.filter((c) => c.scope === scope);
+    }
+    if (category) {
+        results = results.filter((c) => c.category === category);
+    }
+    const total = results.length;
+    const paged = results.slice(offset, offset + limit);
+    return {
+        success: true,
+        data: { configs: paged, total },
+    };
+}
+/**
+ * Validate configuration value
+ */
+export function validateConfigValue(key, value) {
+    const existingConfig = configs.get(key);
+    let result = "valid";
+    let message = `Configuration '${key}' is valid`;
+    const suggestions = [];
+    // Type validation
+    if (existingConfig && existingConfig.type !== typeof value) {
+        if (typeof value === "string" && existingConfig.type === "number") {
+            // Allow string to number conversion
+            result = "warning";
+            message = `Type mismatch: expected ${existingConfig.type}, got ${typeof value}. Will attempt conversion.`;
+        }
+        else {
+            result = "invalid";
+            message = `Type mismatch: expected ${existingConfig.type}, got ${typeof value}`;
+        }
+    }
+    // Pattern validation
+    if (existingConfig?.validation_rule && typeof value === "string") {
+        const regex = new RegExp(existingConfig.validation_rule);
+        if (!regex.test(value)) {
+            result = "invalid";
+            message = `Value does not match required pattern: ${existingConfig.validation_rule}`;
+        }
+    }
+    // Range validation
+    const configAny = existingConfig;
+    if (configAny?.min && typeof value === "number" && value < configAny.min) {
+        result = "warning";
+        message = `Value ${value} is below minimum ${configAny.min}`;
+    }
+    if (configAny?.max && typeof value === "number" && value > configAny.max) {
+        result = "warning";
+        message = `Value ${value} is above maximum ${configAny.max}`;
+    }
+    const validation = {
+        key,
+        result,
+        message,
+        suggestions,
+        timestamp: new Date().toISOString(),
+    };
+    validationHistory.set(`${key}_${Date.now()}`, validation);
+    return validation;
+}
+/**
+ * Get adapter configuration
+ */
+export function getAdapterConfig(name) {
+    const adapter = adapters.get(name);
+    if (!adapter) {
+        return {
+            success: false,
+            error: `Adapter '${name}' not found`,
+        };
+    }
+    return {
+        success: true,
+        data: adapter,
+    };
+}
+/**
+ * List adapters
+ */
+export function listAdapters() {
+    const adapterList = Array.from(adapters.values());
+    return {
+        success: true,
+        data: adapterList,
+    };
+}
+/**
+ * Configure adapter
+ */
+export function configureAdapter(name, enabled, settings) {
+    const existing = adapters.get(name);
+    const adapter = {
+        name,
+        enabled,
+        version: existing?.version,
+        settings,
+        credentials_configured: Object.keys(settings).length > 0,
+        health_status: "healthy",
+        last_check: new Date().toISOString(),
+    };
+    adapters.set(name, adapter);
+    return {
+        success: true,
+        data: adapter,
+    };
+}
+/**
+ * Get tool configuration
+ */
+export function getToolConfig(name) {
+    const tool = tools.get(name);
+    if (!tool) {
+        return {
+            success: false,
+            error: `Tool '${name}' not found`,
+        };
+    }
+    return {
+        success: true,
+        data: tool,
+    };
+}
+/**
+ * List tools
+ */
+export function listTools() {
+    return {
+        success: true,
+        data: Array.from(tools.values()),
+    };
+}
+/**
+ * Get service configuration
+ */
+export function getServiceConfig(name) {
+    const service = services.get(name);
+    if (!service) {
+        return {
+            success: false,
+            error: `Service '${name}' not found`,
+        };
+    }
+    return {
+        success: true,
+        data: service,
+    };
+}
+/**
+ * List services
+ */
+export function listServices() {
+    return {
+        success: true,
+        data: Array.from(services.values()),
+    };
+}
+/**
+ * Configure service
+ */
+export function configureService(name, enabled, endpoint, port) {
+    const service = {
+        name,
+        enabled,
+        endpoint,
+        port,
+        status: enabled ? "running" : "stopped",
+        last_status_check: new Date().toISOString(),
+    };
+    services.set(name, service);
+    return {
+        success: true,
+        data: service,
+    };
+}
+/**
+ * Get path configuration
+ */
+export function getPathConfig(key) {
+    const path = paths.get(key);
+    if (!path) {
+        return {
+            success: false,
+            error: `Path '${key}' not found`,
+        };
+    }
+    return {
+        success: true,
+        data: path,
+    };
+}
+/**
+ * List paths
+ */
+export function listPaths() {
+    return {
+        success: true,
+        data: Array.from(paths.values()),
+    };
+}
+/**
+ * Set path configuration
+ */
+export function setPathConfig(key, value, type) {
+    const path = {
+        key,
+        value,
+        type,
+        expandable: value.includes("$") || value.includes("~"),
+        must_exist: type !== "temp_dir",
+        writable: !["project_root"].includes(type),
+    };
+    paths.set(key, path);
+    return {
+        success: true,
+        data: path,
+    };
+}
+/**
+ * Get feature flag
+ */
+export function getFeatureFlag(name) {
+    const flag = featureFlags.get(name);
+    if (!flag) {
+        return {
+            success: false,
+            error: `Feature flag '${name}' not found`,
+        };
+    }
+    return {
+        success: true,
+        data: flag,
+    };
+}
+/**
+ * List feature flags
+ */
+export function listFeatureFlags() {
+    return {
+        success: true,
+        data: Array.from(featureFlags.values()),
+    };
+}
+/**
+ * Toggle feature flag
+ */
+export function toggleFeatureFlag(name, enabled, scope = "project") {
+    const existing = featureFlags.get(name) || {
+        name,
+        enabled: false,
+        scope,
+    };
+    const flag = {
+        ...existing,
+        enabled,
+        scope,
+    };
+    featureFlags.set(name, flag);
+    return {
+        success: true,
+        data: flag,
+    };
+}
+/**
+ * Create configuration snapshot
+ */
+export function createConfigSnapshot(created_by, description) {
+    const snapshot = {
+        id: `snap_${randomUUID()}`,
+        timestamp: new Date().toISOString(),
+        created_by,
+        config_state: Object.fromEntries(configs),
+        description,
+    };
+    snapshots.set(snapshot.id, snapshot);
+    return {
+        success: true,
+        data: snapshot,
+    };
+}
+/**
+ * List configuration snapshots
+ */
+export function listSnapshots(limit = 20, offset = 0) {
+    const all = Array.from(snapshots.values()).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    const total = all.length;
+    const paged = all.slice(offset, offset + limit);
+    return {
+        success: true,
+        data: { snapshots: paged, total },
+    };
+}
+/**
+ * Rollback to snapshot
+ */
+export function rollbackToSnapshot(snapshot_id, performed_by) {
+    const snapshot = snapshots.get(snapshot_id);
+    if (!snapshot) {
+        return {
+            success: false,
+            error: `Snapshot '${snapshot_id}' not found`,
+        };
+    }
+    const changeCount = configs.size;
+    // Restore config state
+    configs.clear();
+    Object.entries(snapshot.config_state).forEach(([key, value]) => {
+        configs.set(key, value);
+    });
+    const rollback = {
+        from_snapshot: snapshots.get(Array.from(snapshots.keys())[0])?.id || "current",
+        to_snapshot: snapshot_id,
+        changes_reverted: changeCount,
+        timestamp: new Date().toISOString(),
+        performed_by,
+    };
+    return {
+        success: true,
+        data: rollback,
+    };
+}
+/**
+ * Check adapter status
+ */
+export function checkAdapterStatus(adapter_name) {
+    const adapter = adapters.get(adapter_name);
+    if (!adapter) {
+        return {
+            success: false,
+            error: `Adapter '${adapter_name}' not found`,
+        };
+    }
+    const checks = [];
+    // Check if installed
+    checks.push({
+        name: "installation",
+        status: adapter.enabled ? "pass" : "fail",
+        message: adapter.enabled
+            ? `${adapter_name} is installed and enabled`
+            : `${adapter_name} is not enabled`,
+    });
+    // Check configuration
+    checks.push({
+        name: "configuration",
+        status: Object.keys(adapter.settings).length > 0 ? "pass" : "warning",
+        message: Object.keys(adapter.settings).length > 0
+            ? `Configuration present (${Object.keys(adapter.settings).length} settings)`
+            : "No configuration found",
+    });
+    // Check credentials
+    checks.push({
+        name: "credentials",
+        status: adapter.credentials_configured ? "pass" : "warning",
+        message: adapter.credentials_configured
+            ? "Credentials are configured"
+            : "Credentials not configured",
+    });
+    // Check health
+    checks.push({
+        name: "health",
+        status: adapter.health_status === "healthy" ? "pass" : adapter.health_status === "warning" ? "warning" : "fail",
+        message: `Health status: ${adapter.health_status || "unknown"}`,
+    });
+    const overallStatus = checks.every((c) => c.status === "pass")
+        ? "healthy"
+        : checks.some((c) => c.status === "fail")
+            ? "unhealthy"
+            : "degraded";
+    const result = {
+        adapter_name,
+        overall_status: overallStatus,
+        installed: adapter.enabled,
+        configured: Object.keys(adapter.settings).length > 0,
+        authenticated: adapter.credentials_configured,
+        available: adapter.health_status === "healthy",
+        checks,
+        last_checked: new Date().toISOString(),
+    };
+    // Add recommendations
+    if (overallStatus !== "healthy") {
+        result.recommendations = [];
+        if (!adapter.enabled) {
+            result.recommendations.push(`Enable ${adapter_name} in configuration`);
+        }
+        if (!adapter.credentials_configured) {
+            result.recommendations.push(`Configure credentials for ${adapter_name}`);
+        }
+        if (adapter.health_status === "warning" || adapter.health_status === "error") {
+            result.recommendations.push(`Check ${adapter_name} health status`);
+        }
+    }
+    return {
+        success: true,
+        data: result,
+    };
+}
+/**
+ * Check adapter dependencies
+ */
+export function checkAdapterDependencies(adapter_name) {
+    // Simulated dependencies for adapters
+    const dependencyMap = {
+        stripe: [
+            { name: "node", required: true, installed: true, compatible: true, version: "20.0.0" },
+            { name: "npm", required: true, installed: true, compatible: true, version: "10.0.0" },
+        ],
+        github: [
+            { name: "git", required: true, installed: true, compatible: true, version: "2.40.0" },
+            { name: "curl", required: false, installed: true, compatible: true },
+        ],
+        slack: [
+            { name: "node", required: true, installed: true, compatible: true, version: "20.0.0" },
+        ],
+    };
+    const deps = dependencyMap[adapter_name] || [];
+    return {
+        success: true,
+        data: deps,
+    };
+}
+/**
+ * Get adapter health status
+ */
+export function getAdapterHealth(adapter_name) {
+    const adapter = adapters.get(adapter_name);
+    if (!adapter) {
+        return {
+            success: false,
+            error: `Adapter '${adapter_name}' not found`,
+        };
+    }
+    const health = {
+        adapter_name,
+        healthy: adapter.health_status === "healthy",
+        uptime_seconds: Math.floor(Math.random() * 86400),
+        error_count: Math.floor(Math.random() * 5),
+        success_count: Math.floor(Math.random() * 100),
+        average_response_time_ms: Math.floor(Math.random() * 500) + 50,
+        last_checked: adapter.last_check || new Date().toISOString(),
+    };
+    return {
+        success: true,
+        data: health,
+    };
+}
+/**
+ * Install adapter
+ */
+export function installAdapter(adapter_name, auto_configure = false, version, installed_by) {
+    const existing = adapters.get(adapter_name);
+    const result = {
+        adapter_name,
+        success: true,
+        installed: true,
+        version: version || existing?.version || "1.0.0",
+        configured: false,
+        env_vars_set: [],
+        setup_required: !auto_configure,
+        next_steps: auto_configure
+            ? []
+            : [
+                `Run: kit adapter setup ${adapter_name}`,
+                `Or set environment variables manually`,
+            ],
+        message: `${adapter_name} adapter installed successfully`,
+        timestamp: new Date().toISOString(),
+    };
+    // Mark adapter as installed
+    const adapter = {
+        name: adapter_name,
+        enabled: true,
+        version: result.version,
+        settings: {},
+        credentials_configured: false,
+        health_status: "healthy",
+        last_check: new Date().toISOString(),
+    };
+    adapters.set(adapter_name, adapter);
+    if (auto_configure) {
+        result.setup_required = false;
+        result.message += " and auto-configured";
+    }
+    return {
+        success: true,
+        data: result,
+    };
+}
+/**
+ * Setup adapter automatically
+ */
+export function setupAdapterAuto(adapter_name, env_vars, setup_by) {
+    const adapter = adapters.get(adapter_name);
+    if (!adapter) {
+        return {
+            success: false,
+            error: `Adapter '${adapter_name}' not found. Install it first.`,
+        };
+    }
+    const vars_set = [];
+    // Set environment variables
+    Object.entries(env_vars).forEach(([key, value]) => {
+        const var_key = `${adapter_name}_${key}`.toUpperCase();
+        const envVar = {
+            key: var_key,
+            value,
+            adapter_name,
+            required: true,
+            set_at: new Date().toISOString(),
+        };
+        environmentVariables.set(var_key, envVar);
+        vars_set.push(var_key);
+    });
+    // Update adapter config
+    adapter.settings = env_vars;
+    adapter.credentials_configured = true;
+    adapter.last_check = new Date().toISOString();
+    const result = {
+        adapter_name,
+        success: true,
+        installed: true,
+        version: adapter.version,
+        configured: true,
+        env_vars_set: vars_set,
+        setup_required: false,
+        next_steps: [],
+        message: `${adapter_name} adapter configured with ${vars_set.length} environment variables`,
+        timestamp: new Date().toISOString(),
+    };
+    return {
+        success: true,
+        data: result,
+    };
+}
+/**
+ * Setup adapter interactively
+ */
+export function setupAdapterInteractive(adapter_name, responses, setup_by) {
+    const adapter = adapters.get(adapter_name);
+    if (!adapter) {
+        return {
+            success: false,
+            error: `Adapter '${adapter_name}' not found. Install it first.`,
+        };
+    }
+    const vars_set = [];
+    // Process interactive responses
+    Object.entries(responses).forEach(([key, value]) => {
+        const var_key = `${adapter_name}_${key}`.toUpperCase();
+        const envVar = {
+            key: var_key,
+            value,
+            adapter_name,
+            required: true,
+            set_at: new Date().toISOString(),
+        };
+        environmentVariables.set(var_key, envVar);
+        vars_set.push(var_key);
+    });
+    // Update adapter settings
+    adapter.settings = responses;
+    adapter.credentials_configured = true;
+    adapter.last_check = new Date().toISOString();
+    const result = {
+        adapter_name,
+        success: true,
+        installed: true,
+        version: adapter.version,
+        configured: true,
+        env_vars_set: vars_set,
+        setup_required: false,
+        next_steps: [],
+        message: `${adapter_name} adapter configured interactively with ${vars_set.length} variables`,
+        timestamp: new Date().toISOString(),
+    };
+    return {
+        success: true,
+        data: result,
+    };
+}
+/**
+ * Set environment variable
+ */
+export function setEnvironmentVariable(key, value, adapter_name, required = false, description) {
+    const envVar = {
+        key,
+        value,
+        adapter_name,
+        required,
+        description,
+        set_at: new Date().toISOString(),
+    };
+    environmentVariables.set(key, envVar);
+    return {
+        success: true,
+        data: envVar,
+    };
+}
+/**
+ * Get environment variables for adapter
+ */
+export function getEnvironmentVariables(adapter_name, required_only = false) {
+    let vars = Array.from(environmentVariables.values());
+    if (adapter_name) {
+        vars = vars.filter((v) => v.adapter_name === adapter_name);
+    }
+    if (required_only) {
+        vars = vars.filter((v) => v.required);
+    }
+    return {
+        success: true,
+        data: vars,
+    };
+}
+/**
+ * Get MCP tool definitions
+ */
+export function getMCPTools() {
+    return [
+        {
+            id: "kit_configure",
+            name: "kit_configure",
+            description: "Get/set/list/validate kit configuration",
+            category: "configuration",
+            version: "1.0.0",
+            requires_auth: false,
+            actions: [
+                {
+                    name: "get",
+                    description: "Get configuration value by key",
+                    parameters: [
+                        {
+                            name: "key",
+                            description: "Configuration key",
+                            type: "string",
+                            required: true,
+                        },
+                    ],
+                    returns: {
+                        type: "object",
+                        description: "Configuration value object",
+                    },
+                },
+                {
+                    name: "set",
+                    description: "Set configuration value",
+                    parameters: [
+                        {
+                            name: "key",
+                            description: "Configuration key",
+                            type: "string",
+                            required: true,
+                        },
+                        {
+                            name: "value",
+                            description: "Value to set",
+                            type: "string",
+                            required: true,
+                        },
+                        {
+                            name: "scope",
+                            description: "Configuration scope",
+                            type: "string",
+                            required: false,
+                            enum: ["global", "project", "user"],
+                        },
+                    ],
+                    returns: {
+                        type: "object",
+                        description: "Updated configuration",
+                    },
+                },
+                {
+                    name: "list",
+                    description: "List configurations",
+                    parameters: [
+                        {
+                            name: "scope",
+                            description: "Filter by scope",
+                            type: "string",
+                            required: false,
+                        },
+                        {
+                            name: "category",
+                            description: "Filter by category",
+                            type: "string",
+                            required: false,
+                        },
+                    ],
+                    returns: {
+                        type: "object",
+                        description: "Configuration list",
+                    },
+                },
+                {
+                    name: "validate",
+                    description: "Validate configuration value",
+                    parameters: [
+                        {
+                            name: "key",
+                            description: "Configuration key",
+                            type: "string",
+                            required: true,
+                        },
+                        {
+                            name: "value",
+                            description: "Value to validate",
+                            type: "string",
+                            required: true,
+                        },
+                    ],
+                    returns: {
+                        type: "object",
+                        description: "Validation result",
+                    },
+                },
+            ],
+        },
+        {
+            id: "kit_adapter_check",
+            name: "kit_adapter_check",
+            description: "Check adapter installation, configuration, and authentication status",
+            category: "health",
+            version: "1.0.0",
+            requires_auth: false,
+            actions: [
+                {
+                    name: "status",
+                    description: "Get complete adapter status with all checks",
+                    parameters: [
+                        {
+                            name: "adapter",
+                            description: "Adapter name",
+                            type: "string",
+                            required: true,
+                        },
+                    ],
+                    returns: {
+                        type: "object",
+                        description: "Adapter status with check results",
+                    },
+                },
+                {
+                    name: "dependencies",
+                    description: "Check adapter dependencies",
+                    parameters: [
+                        {
+                            name: "adapter",
+                            description: "Adapter name",
+                            type: "string",
+                            required: true,
+                        },
+                    ],
+                    returns: {
+                        type: "array",
+                        description: "Dependency list",
+                    },
+                },
+                {
+                    name: "health",
+                    description: "Get adapter health metrics",
+                    parameters: [
+                        {
+                            name: "adapter",
+                            description: "Adapter name",
+                            type: "string",
+                            required: true,
+                        },
+                    ],
+                    returns: {
+                        type: "object",
+                        description: "Health metrics",
+                    },
+                },
+            ],
+        },
+        {
+            id: "kit_adapter_install",
+            name: "kit_adapter_install",
+            description: "Install, configure, and setup kit adapters with auto or interactive configuration",
+            category: "installation",
+            version: "1.0.0",
+            requires_auth: false,
+            actions: [
+                {
+                    name: "install",
+                    description: "Install an adapter",
+                    parameters: [
+                        {
+                            name: "adapter",
+                            description: "Adapter name",
+                            type: "string",
+                            required: true,
+                        },
+                        {
+                            name: "version",
+                            description: "Adapter version",
+                            type: "string",
+                            required: false,
+                        },
+                        {
+                            name: "auto_configure",
+                            description: "Auto-configure after installation",
+                            type: "boolean",
+                            required: false,
+                        },
+                    ],
+                    returns: {
+                        type: "object",
+                        description: "Installation result",
+                    },
+                },
+                {
+                    name: "setup",
+                    description: "Setup adapter with environment variables",
+                    parameters: [
+                        {
+                            name: "adapter",
+                            description: "Adapter name",
+                            type: "string",
+                            required: true,
+                        },
+                        {
+                            name: "mode",
+                            description: "Setup mode",
+                            type: "string",
+                            required: true,
+                            enum: ["auto", "interactive"],
+                        },
+                        {
+                            name: "env_vars",
+                            description: "Environment variables for auto mode",
+                            type: "object",
+                            required: false,
+                        },
+                        {
+                            name: "responses",
+                            description: "Interactive responses",
+                            type: "object",
+                            required: false,
+                        },
+                    ],
+                    returns: {
+                        type: "object",
+                        description: "Setup result",
+                    },
+                },
+                {
+                    name: "configure",
+                    description: "Configure environment variables",
+                    parameters: [
+                        {
+                            name: "key",
+                            description: "Environment variable key",
+                            type: "string",
+                            required: true,
+                        },
+                        {
+                            name: "value",
+                            description: "Environment variable value",
+                            type: "string",
+                            required: true,
+                        },
+                        {
+                            name: "adapter",
+                            description: "Adapter name",
+                            type: "string",
+                            required: true,
+                        },
+                        {
+                            name: "required",
+                            description: "Whether variable is required",
+                            type: "boolean",
+                            required: false,
+                        },
+                    ],
+                    returns: {
+                        type: "object",
+                        description: "Configuration result",
+                    },
+                },
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=mcp-kit-tools-service.js.map