@friggframework/admin-scripts 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.21b69ac.0

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

@@ -54,7 +54,7 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
         config: {
             timeout: 900000, // 15 minutes
             maxRetries: 0,
-            requiresIntegrationFactory: true,
+            requireIntegrationInstance: true,
         },
 
         schedule: {
@@ -62,14 +62,13 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
             cronExpression: 'cron(0 6 * * ? *)', // Daily at 6 AM UTC
         },
 
+        // UI-specific overrides
         display: {
-            label: 'Integration Health Check',
-            description: 'Check health and connectivity of integrations',
             category: 'maintenance',
         },
     };
 
-    async execute(frigg, params = {}) {
+    async execute(params = {}) {
         const {
             integrationIds = null,
             checkCredentials = true,
@@ -84,7 +83,7 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
             results: []
         };
 
-        frigg.log('info', 'Starting integration health check', {
+        this.context.log('info', 'Starting integration health check', {
             checkCredentials,
             checkConnectivity,
             updateStatus,
@@ -95,17 +94,17 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
         let integrations;
         if (integrationIds && integrationIds.length > 0) {
             integrations = await Promise.all(
-                integrationIds.map(id => frigg.findIntegrationById(id).catch(() => null))
+                integrationIds.map(id => this.context.findIntegrationById(id).catch(() => null))
             );
             integrations = integrations.filter(Boolean);
         } else {
-            integrations = await this.getAllIntegrations(frigg);
+            integrations = await this.getAllIntegrations();
         }
 
-        frigg.log('info', `Checking ${integrations.length} integrations`);
+        this.context.log('info', `Checking ${integrations.length} integrations`);
 
         for (const integration of integrations) {
-            const result = await this.checkIntegration(frigg, integration, {
+            const result = await this.checkIntegration(integration, {
                 checkCredentials,
                 checkConnectivity
             });
@@ -124,17 +123,17 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
             if (updateStatus && result.status !== 'unknown') {
                 try {
                     const newStatus = result.status === 'healthy' ? 'ACTIVE' : 'ERROR';
-                    await frigg.updateIntegrationStatus(integration.id, newStatus);
-                    frigg.log('info', `Updated status for ${integration.id} to ${newStatus}`);
+                    await this.context.updateIntegrationStatus(integration.id, newStatus);
+                    this.context.log('info', `Updated status for ${integration.id} to ${newStatus}`);
                 } catch (error) {
-                    frigg.log('warn', `Failed to update status for ${integration.id}`, {
+                    this.context.log('warn', `Failed to update status for ${integration.id}`, {
                         error: error.message
                     });
                 }
             }
         }
 
-        frigg.log('info', 'Health check completed', {
+        this.context.log('info', 'Health check completed', {
             healthy: summary.healthy,
             unhealthy: summary.unhealthy,
             unknown: summary.unknown
@@ -143,19 +142,19 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
         return summary;
     }
 
-    async getAllIntegrations(frigg) {
-        return frigg.listIntegrations({});
+    async getAllIntegrations() {
+        return this.context.listIntegrations({});
     }
 
-    async checkIntegration(frigg, integration, options) {
+    async checkIntegration(integration, options) {
         const { checkCredentials, checkConnectivity } = options;
         const result = this._createCheckResult(integration);
 
         try {
-            await this._runChecks(frigg, integration, result, { checkCredentials, checkConnectivity });
+            await this._runChecks(integration, result, { checkCredentials, checkConnectivity });
             this._determineOverallStatus(result);
         } catch (error) {
-            this._handleCheckError(frigg, integration, result, error);
+            this._handleCheckError(integration, result, error);
         }
 
         return result;
@@ -179,7 +178,7 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
      * Run all requested checks
      * @private
      */
-    async _runChecks(frigg, integration, result, options) {
+    async _runChecks(integration, result, options) {
         const { checkCredentials, checkConnectivity } = options;
 
         if (checkCredentials) {
@@ -187,7 +186,7 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
         }
 
         if (checkConnectivity) {
-            this._addCheckResult(result, 'connectivity', await this.checkApiConnectivity(frigg, integration));
+            this._addCheckResult(result, 'connectivity', await this.checkApiConnectivity(integration));
         }
     }
 
@@ -214,8 +213,8 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
      * Handle check error and update result
      * @private
      */
-    _handleCheckError(frigg, integration, result, error) {
-        frigg.log('error', `Error checking integration ${integration.id}`, {
+    _handleCheckError(integration, result, error) {
+        this.context.log('error', `Error checking integration ${integration.id}`, {
             error: error.message
         });
         result.status = 'unknown';
@@ -246,12 +245,12 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
         return result;
     }
 
-    async checkApiConnectivity(frigg, integration) {
+    async checkApiConnectivity(integration) {
         const result = { valid: true, issue: null, responseTime: null };
 
         try {
             const startTime = Date.now();
-            const instance = await frigg.instantiate(integration.id);
+            const instance = await this.context.instantiate(integration.id);
 
             // Try to make a simple API call
             if (instance.primary?.api?.getAuthenticationInfo) {

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

@@ -47,17 +47,16 @@ class OAuthTokenRefreshScript extends AdminScriptBase {
         config: {
             timeout: 600000, // 10 minutes
             maxRetries: 1,
-            requiresIntegrationFactory: true, // Needs to call external APIs
+            requireIntegrationInstance: true, // Needs to call external APIs
         },
 
+        // UI-specific overrides
         display: {
-            label: 'OAuth Token Refresh',
-            description: 'Refresh OAuth tokens before they expire',
             category: 'maintenance',
         },
     };
 
-    async execute(frigg, params = {}) {
+    async execute(params = {}) {
         const {
             integrationIds = null,
             expiryThresholdHours = 24,
@@ -71,7 +70,7 @@ class OAuthTokenRefreshScript extends AdminScriptBase {
             details: []
         };
 
-        frigg.log('info', 'Starting OAuth token refresh', {
+        this.context.log('info', 'Starting OAuth token refresh', {
             expiryThresholdHours,
             dryRun,
             specificIds: integrationIds?.length || 'all'
@@ -81,19 +80,19 @@ class OAuthTokenRefreshScript extends AdminScriptBase {
         let integrations;
         if (integrationIds && integrationIds.length > 0) {
             integrations = await Promise.all(
-                integrationIds.map(id => frigg.findIntegrationById(id).catch(() => null))
+                integrationIds.map(id => this.context.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(frigg);
+            integrations = await this.getAllIntegrations();
         }
 
-        frigg.log('info', `Found ${integrations.length} integrations to check`);
+        this.context.log('info', `Found ${integrations.length} integrations to check`);
 
         for (const integration of integrations) {
             try {
-                const detail = await this.processIntegration(frigg, integration, {
+                const detail = await this.processIntegration(integration, {
                     expiryThresholdHours,
                     dryRun
                 });
@@ -108,7 +107,7 @@ class OAuthTokenRefreshScript extends AdminScriptBase {
                     results.failed++;
                 }
             } catch (error) {
-                frigg.log('error', `Error processing integration ${integration.id}`, {
+                this.context.log('error', `Error processing integration ${integration.id}`, {
                     error: error.message
                 });
                 results.failed++;
@@ -120,7 +119,7 @@ class OAuthTokenRefreshScript extends AdminScriptBase {
             }
         }
 
-        frigg.log('info', 'OAuth token refresh completed', {
+        this.context.log('info', 'OAuth token refresh completed', {
             refreshed: results.refreshed,
             failed: results.failed,
             skipped: results.skipped
@@ -129,13 +128,13 @@ class OAuthTokenRefreshScript extends AdminScriptBase {
         return results;
     }
 
-    async getAllIntegrations(frigg) {
+    async getAllIntegrations() {
         // This is a simplified implementation
         // In production, would need pagination for large datasets
-        return frigg.listIntegrations({});
+        return this.context.listIntegrations({});
     }
 
-    async processIntegration(frigg, integration, options) {
+    async processIntegration(integration, options) {
         const { expiryThresholdHours, dryRun } = options;
 
         // Check prerequisites
@@ -146,12 +145,12 @@ class OAuthTokenRefreshScript extends AdminScriptBase {
 
         // Handle dry run
         if (dryRun) {
-            frigg.log('info', `[DRY RUN] Would refresh token for ${integration.id}`);
+            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(frigg, integration);
+        return this._performTokenRefresh(integration);
     }
 
     /**
@@ -183,18 +182,18 @@ class OAuthTokenRefreshScript extends AdminScriptBase {
      * Perform the actual token refresh
      * @private
      */
-    async _performTokenRefresh(frigg, integration) {
+    async _performTokenRefresh(integration) {
         const expiresAt = integration.config?.credentials?.expires_at;
 
         try {
-            const instance = await frigg.instantiate(integration.id);
+            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();
-            frigg.log('info', `Refreshed token for integration ${integration.id}`);
+            this.context.log('info', `Refreshed token for integration ${integration.id}`);
 
             return {
                 integrationId: integration.id,
@@ -202,7 +201,7 @@ class OAuthTokenRefreshScript extends AdminScriptBase {
                 previousExpiry: expiresAt
             };
         } catch (error) {
-            frigg.log('error', `Failed to refresh token for ${integration.id}`, {
+            this.context.log('error', `Failed to refresh token for ${integration.id}`, {
                 error: error.message
             });
             return this._createResult(integration.id, 'failed', error.message);

package/src/infrastructure/__tests__/admin-auth-middleware.test.js

@@ -1,22 +1,17 @@
-const { adminAuthMiddleware } = require('../admin-auth-middleware');
+const { validateAdminApiKey } = require('../admin-auth-middleware');
 
-// Mock the admin script commands
-jest.mock('@friggframework/core/application/commands/admin-script-commands', () => ({
-    createAdminScriptCommands: jest.fn(),
-}));
-
-const { createAdminScriptCommands } = require('@friggframework/core/application/commands/admin-script-commands');
-
-describe('adminAuthMiddleware', () => {
+describe('validateAdminApiKey', () => {
     let mockReq;
     let mockRes;
     let mockNext;
-    let mockCommands;
+    let originalEnv;
 
     beforeEach(() => {
+        originalEnv = process.env.ADMIN_API_KEY;
+        process.env.ADMIN_API_KEY = 'test-admin-key-123';
+
         mockReq = {
             headers: {},
-            ip: '127.0.0.1',
         };
 
         mockRes = {
@@ -25,124 +20,66 @@ describe('adminAuthMiddleware', () => {
         };
 
         mockNext = jest.fn();
-
-        mockCommands = {
-            validateAdminApiKey: jest.fn(),
-        };
-
-        createAdminScriptCommands.mockReturnValue(mockCommands);
     });
 
     afterEach(() => {
+        if (originalEnv) {
+            process.env.ADMIN_API_KEY = originalEnv;
+        } else {
+            delete process.env.ADMIN_API_KEY;
+        }
         jest.clearAllMocks();
     });
 
-    describe('Authorization header validation', () => {
-        it('should reject request without Authorization header', async () => {
-            await adminAuthMiddleware(mockReq, mockRes, mockNext);
-
-            expect(mockRes.status).toHaveBeenCalledWith(401);
-            expect(mockRes.json).toHaveBeenCalledWith({
-                error: 'Missing or invalid Authorization header',
-                code: 'MISSING_AUTH',
-            });
-            expect(mockNext).not.toHaveBeenCalled();
-        });
-
-        it('should reject request with invalid Authorization format', async () => {
-            mockReq.headers.authorization = 'InvalidFormat key123';
+    describe('Environment configuration', () => {
+        it('should reject when ADMIN_API_KEY not configured', () => {
+            delete process.env.ADMIN_API_KEY;
 
-            await adminAuthMiddleware(mockReq, mockRes, mockNext);
+            validateAdminApiKey(mockReq, mockRes, mockNext);
 
             expect(mockRes.status).toHaveBeenCalledWith(401);
             expect(mockRes.json).toHaveBeenCalledWith({
-                error: 'Missing or invalid Authorization header',
-                code: 'MISSING_AUTH',
+                error: 'Unauthorized',
+                message: 'Admin API key not configured',
             });
             expect(mockNext).not.toHaveBeenCalled();
         });
     });
 
-    describe('API key validation', () => {
-        it('should reject request with invalid API key', async () => {
-            mockReq.headers.authorization = 'Bearer invalid-key';
-            mockCommands.validateAdminApiKey.mockResolvedValue({
-                error: 401,
-                reason: 'Invalid API key',
-                code: 'INVALID_API_KEY',
-            });
-
-            await adminAuthMiddleware(mockReq, mockRes, mockNext);
+    describe('Header validation', () => {
+        it('should reject request without x-frigg-admin-api-key header', () => {
+            validateAdminApiKey(mockReq, mockRes, mockNext);
 
-            expect(mockCommands.validateAdminApiKey).toHaveBeenCalledWith('invalid-key');
             expect(mockRes.status).toHaveBeenCalledWith(401);
             expect(mockRes.json).toHaveBeenCalledWith({
-                error: 'Invalid API key',
-                code: 'INVALID_API_KEY',
+                error: 'Unauthorized',
+                message: 'x-frigg-admin-api-key header required',
             });
             expect(mockNext).not.toHaveBeenCalled();
         });
+    });
 
-        it('should reject request with expired API key', async () => {
-            mockReq.headers.authorization = 'Bearer expired-key';
-            mockCommands.validateAdminApiKey.mockResolvedValue({
-                error: 401,
-                reason: 'API key has expired',
-                code: 'EXPIRED_API_KEY',
-            });
+    describe('API key validation', () => {
+        it('should reject request with invalid API key', () => {
+            mockReq.headers['x-frigg-admin-api-key'] = 'invalid-key';
 
-            await adminAuthMiddleware(mockReq, mockRes, mockNext);
+            validateAdminApiKey(mockReq, mockRes, mockNext);
 
-            expect(mockCommands.validateAdminApiKey).toHaveBeenCalledWith('expired-key');
             expect(mockRes.status).toHaveBeenCalledWith(401);
             expect(mockRes.json).toHaveBeenCalledWith({
-                error: 'API key has expired',
-                code: 'EXPIRED_API_KEY',
+                error: 'Unauthorized',
+                message: 'Invalid admin API key',
             });
             expect(mockNext).not.toHaveBeenCalled();
         });
 
-        it('should accept request with valid API key', async () => {
-            const validKey = 'valid-api-key-123';
-            mockReq.headers.authorization = `Bearer ${validKey}`;
-            mockCommands.validateAdminApiKey.mockResolvedValue({
-                valid: true,
-                apiKey: {
-                    id: 'key-id-1',
-                    name: 'test-key',
-                    keyLast4: 'e123',
-                },
-            });
+        it('should accept request with valid API key', () => {
+            mockReq.headers['x-frigg-admin-api-key'] = 'test-admin-key-123';
 
-            await adminAuthMiddleware(mockReq, mockRes, mockNext);
+            validateAdminApiKey(mockReq, mockRes, mockNext);
 
-            expect(mockCommands.validateAdminApiKey).toHaveBeenCalledWith(validKey);
-            expect(mockReq.adminApiKey).toBeDefined();
-            expect(mockReq.adminApiKey.name).toBe('test-key');
-            expect(mockReq.adminAudit).toBeDefined();
-            expect(mockReq.adminAudit.apiKeyName).toBe('test-key');
-            expect(mockReq.adminAudit.apiKeyLast4).toBe('e123');
-            expect(mockReq.adminAudit.ipAddress).toBe('127.0.0.1');
             expect(mockNext).toHaveBeenCalled();
             expect(mockRes.status).not.toHaveBeenCalled();
         });
     });
-
-    describe('Error handling', () => {
-        it('should handle validation errors gracefully', async () => {
-            mockReq.headers.authorization = 'Bearer some-key';
-            mockCommands.validateAdminApiKey.mockRejectedValue(
-                new Error('Database error')
-            );
-
-            await adminAuthMiddleware(mockReq, mockRes, mockNext);
-
-            expect(mockRes.status).toHaveBeenCalledWith(500);
-            expect(mockRes.json).toHaveBeenCalledWith({
-                error: 'Authentication failed',
-                code: 'AUTH_ERROR',
-            });
-            expect(mockNext).not.toHaveBeenCalled();
-        });
-    });
 });