@friggframework/admin-scripts 2.0.0--canary.517.8eaf5df.0 → 2.0.0--canary.517.c197eb5.0

package/src/builtins/integration-health-check.js

@@ -1,311 +0,0 @@
-const { AdminScriptBase } = require('../application/admin-script-base');
-
-/**
- * Integration Health Check Script
- *
- * Checks the health of integrations by verifying:
- * - Credential validity
- * - API connectivity
- * - Configuration integrity
- */
-class IntegrationHealthCheckScript extends AdminScriptBase {
-    static Definition = {
-        name: 'integration-health-check',
-        version: '1.0.0',
-        description: 'Checks health of integrations and reports issues',
-        source: 'BUILTIN',
-
-        inputSchema: {
-            type: 'object',
-            properties: {
-                integrationIds: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description:
-                        'Specific integration IDs to check (optional, defaults to all)',
-                },
-                checkCredentials: {
-                    type: 'boolean',
-                    default: true,
-                    description: 'Verify credential validity',
-                },
-                checkConnectivity: {
-                    type: 'boolean',
-                    default: true,
-                    description: 'Test API connectivity',
-                },
-                updateStatus: {
-                    type: 'boolean',
-                    default: false,
-                    description: 'Update integration status based on health',
-                },
-            },
-        },
-
-        outputSchema: {
-            type: 'object',
-            properties: {
-                healthy: { type: 'number' },
-                unhealthy: { type: 'number' },
-                unknown: { type: 'number' },
-                results: { type: 'array' },
-            },
-        },
-
-        config: {
-            timeout: 900000, // 15 minutes
-            requireIntegrationInstance: true,
-        },
-
-        schedule: {
-            enabled: false, // Can be enabled via API
-            cronExpression: 'cron(0 6 * * ? *)', // Daily at 6 AM UTC
-        },
-
-        // UI-specific overrides
-        display: {
-            category: 'maintenance',
-        },
-    };
-
-    async execute(params = {}) {
-        const {
-            integrationIds = null,
-            checkCredentials = true,
-            checkConnectivity = true,
-            updateStatus = false,
-        } = params;
-
-        const summary = {
-            healthy: 0,
-            unhealthy: 0,
-            unknown: 0,
-            results: [],
-        };
-
-        this.context.log('info', 'Starting integration health check', {
-            checkCredentials,
-            checkConnectivity,
-            updateStatus,
-            specificIds: integrationIds?.length || 'all',
-        });
-
-        // Get integrations to check
-        let integrations;
-        if (integrationIds && integrationIds.length > 0) {
-            integrations = await Promise.all(
-                integrationIds.map((id) =>
-                    this.context.integrationRepository
-                        .findIntegrationById(id)
-                        .catch(() => null)
-                )
-            );
-            integrations = integrations.filter(Boolean);
-        } else {
-            integrations = await this.getAllIntegrations();
-        }
-
-        this.context.log(
-            'info',
-            `Checking ${integrations.length} integrations`
-        );
-
-        for (const integration of integrations) {
-            const result = await this.checkIntegration(integration, {
-                checkCredentials,
-                checkConnectivity,
-            });
-
-            summary.results.push(result);
-
-            if (result.status === 'healthy') {
-                summary.healthy++;
-            } else if (result.status === 'unhealthy') {
-                summary.unhealthy++;
-            } else {
-                summary.unknown++;
-            }
-
-            // Optionally update integration status
-            if (updateStatus && result.status !== 'unknown') {
-                try {
-                    const newStatus =
-                        result.status === 'healthy' ? 'ACTIVE' : 'ERROR';
-                    await this.context.integrationRepository.updateIntegrationStatus(
-                        integration.id,
-                        newStatus
-                    );
-                    this.context.log(
-                        'info',
-                        `Updated status for ${integration.id} to ${newStatus}`
-                    );
-                } catch (error) {
-                    this.context.log(
-                        'warn',
-                        `Failed to update status for ${integration.id}`,
-                        {
-                            error: error.message,
-                        }
-                    );
-                }
-            }
-        }
-
-        this.context.log('info', 'Health check completed', {
-            healthy: summary.healthy,
-            unhealthy: summary.unhealthy,
-            unknown: summary.unknown,
-        });
-
-        return summary;
-    }
-
-    async getAllIntegrations() {
-        return this.context.integrationRepository.findIntegrations({});
-    }
-
-    async checkIntegration(integration, options) {
-        const { checkCredentials, checkConnectivity } = options;
-        const result = this._createCheckResult(integration);
-
-        try {
-            await this._runChecks(integration, result, {
-                checkCredentials,
-                checkConnectivity,
-            });
-            this._determineOverallStatus(result);
-        } catch (error) {
-            this._handleCheckError(integration, result, error);
-        }
-
-        return result;
-    }
-
-    /**
-     * Create initial check result object
-     * @private
-     */
-    _createCheckResult(integration) {
-        return {
-            integrationId: integration.id,
-            integrationType: integration.config?.type || 'unknown',
-            status: 'unknown',
-            checks: {},
-            issues: [],
-        };
-    }
-
-    /**
-     * Run all requested checks
-     * @private
-     */
-    async _runChecks(integration, result, options) {
-        const { checkCredentials, checkConnectivity } = options;
-
-        if (checkCredentials) {
-            this._addCheckResult(
-                result,
-                'credentials',
-                this.checkCredentialValidity(integration)
-            );
-        }
-
-        if (checkConnectivity) {
-            this._addCheckResult(
-                result,
-                'connectivity',
-                await this.checkApiConnectivity(integration)
-            );
-        }
-    }
-
-    /**
-     * Add a check result and track any issues
-     * @private
-     */
-    _addCheckResult(result, checkName, checkResult) {
-        result.checks[checkName] = checkResult;
-        if (!checkResult.valid) {
-            result.issues.push(checkResult.issue);
-        }
-    }
-
-    /**
-     * Determine overall health status from issues
-     * @private
-     */
-    _determineOverallStatus(result) {
-        result.status = result.issues.length === 0 ? 'healthy' : 'unhealthy';
-    }
-
-    /**
-     * Handle check error and update result
-     * @private
-     */
-    _handleCheckError(integration, result, error) {
-        this.context.log(
-            'error',
-            `Error checking integration ${integration.id}`,
-            {
-                error: error.message,
-            }
-        );
-        result.status = 'unknown';
-        result.issues.push(`Check failed: ${error.message}`);
-    }
-
-    checkCredentialValidity(integration) {
-        const result = { valid: true, issue: null };
-
-        // Check for access token
-        if (!integration.config?.credentials?.access_token) {
-            result.valid = false;
-            result.issue = 'Missing access token';
-            return result;
-        }
-
-        // Check for expiry
-        const expiresAt = integration.config?.credentials?.expires_at;
-        if (expiresAt) {
-            const expiryTime = new Date(expiresAt);
-            if (expiryTime < new Date()) {
-                result.valid = false;
-                result.issue = 'Access token expired';
-                return result;
-            }
-        }
-
-        return result;
-    }
-
-    async checkApiConnectivity(integration) {
-        const result = { valid: true, issue: null, responseTime: null };
-
-        try {
-            const startTime = Date.now();
-            const instance = await this.context.instantiate(integration.id);
-
-            // Try to make a simple API call
-            if (instance.primary?.api?.getAuthenticationInfo) {
-                await instance.primary.api.getAuthenticationInfo();
-            } else if (instance.primary?.api?.getCurrentUser) {
-                await instance.primary.api.getCurrentUser();
-            } else {
-                // No suitable health check method
-                result.valid = true;
-                result.issue = null;
-                result.note = 'No health check endpoint available';
-                return result;
-            }
-
-            result.responseTime = Date.now() - startTime;
-        } catch (error) {
-            result.valid = false;
-            result.issue = `API connectivity failed: ${error.message}`;
-        }
-
-        return result;
-    }
-}
-
-module.exports = { IntegrationHealthCheckScript };

package/src/builtins/oauth-token-refresh.js

@@ -1,255 +0,0 @@
-const { AdminScriptBase } = require('../application/admin-script-base');
-
-/**
- * OAuth Token Refresh Script
- *
- * Refreshes OAuth tokens for integrations that are near expiry.
- * This helps prevent authentication failures due to expired tokens.
- */
-class OAuthTokenRefreshScript extends AdminScriptBase {
-    static Definition = {
-        name: 'oauth-token-refresh',
-        version: '1.0.0',
-        description: 'Refreshes OAuth tokens for integrations near expiry',
-        source: 'BUILTIN',
-
-        inputSchema: {
-            type: 'object',
-            properties: {
-                integrationIds: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description:
-                        'Specific integration IDs to refresh (optional, defaults to all)',
-                },
-                expiryThresholdHours: {
-                    type: 'number',
-                    default: 24,
-                    description:
-                        'Refresh tokens expiring within this many hours',
-                },
-                dryRun: {
-                    type: 'boolean',
-                    default: false,
-                    description: 'Preview without making changes',
-                },
-            },
-        },
-
-        outputSchema: {
-            type: 'object',
-            properties: {
-                refreshed: { type: 'number' },
-                failed: { type: 'number' },
-                skipped: { type: 'number' },
-                details: { type: 'array' },
-            },
-        },
-
-        config: {
-            timeout: 600000, // 10 minutes
-            requireIntegrationInstance: true, // Needs to call external APIs
-        },
-
-        // UI-specific overrides
-        display: {
-            category: 'maintenance',
-        },
-    };
-
-    async execute(params = {}) {
-        const {
-            integrationIds = null,
-            expiryThresholdHours = 24,
-            dryRun = false,
-        } = params;
-
-        const results = {
-            refreshed: 0,
-            failed: 0,
-            skipped: 0,
-            details: [],
-        };
-
-        this.context.log('info', 'Starting OAuth token refresh', {
-            expiryThresholdHours,
-            dryRun,
-            specificIds: integrationIds?.length || 'all',
-        });
-
-        // Get integrations to check
-        let integrations;
-        if (integrationIds && integrationIds.length > 0) {
-            integrations = await Promise.all(
-                integrationIds.map((id) =>
-                    this.context.integrationRepository
-                        .findIntegrationById(id)
-                        .catch(() => null)
-                )
-            );
-            integrations = integrations.filter(Boolean);
-        } else {
-            // Get all integrations (this would need to be paginated for large deployments)
-            integrations = await this.getAllIntegrations();
-        }
-
-        this.context.log(
-            'info',
-            `Found ${integrations.length} integrations to check`
-        );
-
-        for (const integration of integrations) {
-            try {
-                const detail = await this.processIntegration(integration, {
-                    expiryThresholdHours,
-                    dryRun,
-                });
-
-                results.details.push(detail);
-
-                if (detail.action === 'refreshed') {
-                    results.refreshed++;
-                } else if (detail.action === 'skipped') {
-                    results.skipped++;
-                } else if (detail.action === 'failed') {
-                    results.failed++;
-                }
-            } catch (error) {
-                this.context.log(
-                    'error',
-                    `Error processing integration ${integration.id}`,
-                    {
-                        error: error.message,
-                    }
-                );
-                results.failed++;
-                results.details.push({
-                    integrationId: integration.id,
-                    action: 'failed',
-                    reason: error.message,
-                });
-            }
-        }
-
-        this.context.log('info', 'OAuth token refresh completed', {
-            refreshed: results.refreshed,
-            failed: results.failed,
-            skipped: results.skipped,
-        });
-
-        return results;
-    }
-
-    async getAllIntegrations() {
-        // This is a simplified implementation
-        // In production, would need pagination for large datasets
-        return this.context.integrationRepository.findIntegrations({});
-    }
-
-    async processIntegration(integration, options) {
-        const { expiryThresholdHours, dryRun } = options;
-
-        // Check prerequisites
-        const skipReason = this._checkRefreshPrerequisites(
-            integration,
-            expiryThresholdHours
-        );
-        if (skipReason) {
-            return this._createResult(integration.id, 'skipped', skipReason);
-        }
-
-        // Handle dry run
-        if (dryRun) {
-            this.context.log(
-                'info',
-                `[DRY RUN] Would refresh token for ${integration.id}`
-            );
-            return this._createResult(
-                integration.id,
-                'skipped',
-                'Dry run - would have refreshed'
-            );
-        }
-
-        // Perform refresh
-        return this._performTokenRefresh(integration);
-    }
-
-    /**
-     * Check if integration meets prerequisites for token refresh
-     * @private
-     * @returns {string|null} Skip reason or null if eligible
-     */
-    _checkRefreshPrerequisites(integration, expiryThresholdHours) {
-        if (!integration.config?.credentials?.access_token) {
-            return 'No OAuth credentials found';
-        }
-
-        const expiresAt = integration.config?.credentials?.expires_at;
-        if (!expiresAt) {
-            return 'No expiry time found';
-        }
-
-        const expiryTime = new Date(expiresAt);
-        const thresholdTime = new Date(
-            Date.now() + expiryThresholdHours * 60 * 60 * 1000
-        );
-
-        if (expiryTime > thresholdTime) {
-            return 'Token not near expiry';
-        }
-
-        return null;
-    }
-
-    /**
-     * Perform the actual token refresh
-     * @private
-     */
-    async _performTokenRefresh(integration) {
-        const expiresAt = integration.config?.credentials?.expires_at;
-
-        try {
-            const instance = await this.context.instantiate(integration.id);
-
-            if (!instance.primary?.api?.refreshAccessToken) {
-                return this._createResult(
-                    integration.id,
-                    'skipped',
-                    'API does not support token refresh'
-                );
-            }
-
-            await instance.primary.api.refreshAccessToken();
-            this.context.log(
-                'info',
-                `Refreshed token for integration ${integration.id}`
-            );
-
-            return {
-                integrationId: integration.id,
-                action: 'refreshed',
-                previousExpiry: expiresAt,
-            };
-        } catch (error) {
-            this.context.log(
-                'error',
-                `Failed to refresh token for ${integration.id}`,
-                {
-                    error: error.message,
-                }
-            );
-            return this._createResult(integration.id, 'failed', error.message);
-        }
-    }
-
-    /**
-     * Create a result object
-     * @private
-     */
-    _createResult(integrationId, action, reason) {
-        return { integrationId, action, reason };
-    }
-}
-
-module.exports = { OAuthTokenRefreshScript };