@friggframework/admin-scripts 2.0.0--canary.545.b4ca16d.0 → 2.0.0--canary.517.ff03f2c.0

package/src/infrastructure/bootstrap.js

@@ -0,0 +1,82 @@
+const { getScriptFactory } = require('../application/script-factory');
+
+/**
+ * Admin Script Bootstrap
+ *
+ * Loads the host app's definition at Lambda runtime and registers its admin
+ * scripts (and the built-ins, when enabled) into the global ScriptFactory, so
+ * the router and SQS worker can resolve scripts by name. Also constructs the
+ * integrationFactory used by scripts that need hydrated integration instances.
+ *
+ * Runs once per process (memoized) and never throws — a missing/unloadable app
+ * definition is logged and leaves the factory empty rather than crashing the
+ * Lambda cold start.
+ */
+let bootstrapped = false;
+let integrationFactory = null;
+
+function registerScripts(factory, scriptClasses) {
+    for (const ScriptClass of scriptClasses || []) {
+        const name = ScriptClass?.Definition?.name;
+        // Guard against re-registration (register() throws on name collision)
+        if (name && !factory.has(name)) {
+            factory.register(ScriptClass);
+        }
+    }
+}
+
+/**
+ * Build an integration factory backed by the framework's runtime hydration.
+ * Scripts call `context.instantiate(integrationId)` which delegates here.
+ * The require is lazy so the admin-scripts package has no load-time coupling
+ * to core's backend utilities (and unit tests never hit this path).
+ */
+function createIntegrationFactory() {
+    return {
+        async getInstanceFromIntegrationId({ integrationId }) {
+            const {
+                loadIntegrationForWebhook,
+            } = require('@friggframework/core/handlers/backend-utils');
+            return loadIntegrationForWebhook(integrationId);
+        },
+    };
+}
+
+/**
+ * @returns {{ integrationFactory: object }}
+ */
+function bootstrapAdminScripts() {
+    if (bootstrapped) {
+        return { integrationFactory };
+    }
+    bootstrapped = true;
+
+    try {
+        const {
+            loadAppDefinition,
+        } = require('@friggframework/core/handlers/app-definition-loader');
+        const { adminScripts = [] } = loadAppDefinition();
+
+        const factory = getScriptFactory();
+        registerScripts(factory, adminScripts);
+    } catch (error) {
+        console.error(
+            '[admin-scripts] bootstrap: could not load app definition:',
+            error.message
+        );
+    }
+
+    integrationFactory = createIntegrationFactory();
+    return { integrationFactory };
+}
+
+/** Test-only: reset memoized bootstrap state. */
+function _resetBootstrapForTests() {
+    bootstrapped = false;
+    integrationFactory = null;
+}
+
+module.exports = {
+    bootstrapAdminScripts,
+    _resetBootstrapForTests,
+};

package/src/infrastructure/script-executor-handler.js

@@ -1,69 +1,136 @@
 const { createScriptRunner } = require('../application/script-runner');
-const { createAdminScriptCommands } = require('@friggframework/core/application/commands/admin-script-commands');
+const {
+    createAdminScriptCommands,
+} = require('@friggframework/core/application/commands/admin-script-commands');
+const { bootstrapAdminScripts } = require('./bootstrap');
 
 /**
- * SQS Queue Worker Lambda Handler
- *
- * Processes script execution messages from AdminScriptQueue.
- * Thin adapter: parses SQS messages and delegates to ScriptRunner.
- * ScriptRunner handles execution tracking, error recording, and status updates.
+ * Run a single execution message through the ScriptRunner.
+ * @private
  */
-async function handler(event) {
-    const results = [];
+async function runMessage(message, integrationFactory) {
+    const { scriptName, executionId, trigger, params, parentExecutionId } =
+        message;
 
-    for (const record of event.Records) {
-        let scriptName;
-        let executionId;
+    if (!scriptName) {
+        throw new Error('Invalid message: missing scriptName');
+    }
 
-        try {
-            const message = JSON.parse(record.body);
-            ({ scriptName, executionId } = message);
-            const { trigger, params } = message;
+    console.log(
+        `Processing script: ${scriptName}${
+            executionId ? `, executionId: ${executionId}` : ''
+        }`
+    );
 
-            if (!scriptName || !executionId) {
-                throw new Error(`Invalid SQS message: missing scriptName or executionId`);
-            }
+    const runner = createScriptRunner({ integrationFactory });
+    const result = await runner.execute(scriptName, params, {
+        trigger: trigger || 'QUEUE',
+        mode: 'async',
+        // executionId is optional — when absent, ScriptRunner creates the record.
+        // Scheduled direct invokes and queueScript continuations have no id yet.
+        ...(executionId && { executionId }),
+        ...(parentExecutionId && { parentExecutionId }),
+    });
 
-            console.log(`Processing script: ${scriptName}, executionId: ${executionId}`);
+    return {
+        scriptName,
+        status: result.status,
+        executionId: result.executionId,
+    };
+}
 
-            const runner = createScriptRunner();
-            const result = await runner.execute(scriptName, params, {
-                trigger: trigger || 'QUEUE',
-                mode: 'async',
-                executionId,
-            });
+/**
+ * Mark an admin process FAILED when the worker itself blows up (parse error,
+ * runner construction), so the record doesn't stay stuck in a non-terminal
+ * state. No-op when there is no execution id.
+ * @private
+ */
+async function markFailed(executionId, error) {
+    if (!executionId) return;
+    try {
+        const commands = createAdminScriptCommands();
+        await commands.completeAdminProcess(executionId, {
+            state: 'FAILED',
+            error: {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            },
+        });
+    } catch (updateError) {
+        console.error(
+            `Failed to update execution ${executionId} state:`,
+            updateError
+        );
+    }
+}
 
-            console.log(`Script completed: ${scriptName}, status: ${result.status}`);
-            results.push({
-                scriptName,
-                status: result.status,
-                executionId: result.executionId,
-            });
-        } catch (error) {
-            // Only reaches here for unexpected failures (message parse errors, runner construction).
-            // Script execution errors are handled by ScriptRunner and returned as { status: 'FAILED' }.
-            console.error(`Unexpected error processing record:`, error);
+/**
+ * Admin Script Executor Lambda Handler
+ *
+ * Handles two invocation shapes:
+ * - SQS: `event.Records[]` — each record body is a JSON execution message
+ *   (manual async executions and queueScript continuations).
+ * - EventBridge Scheduler direct invoke: the event itself is the message
+ *   (`{ scriptName, trigger: 'SCHEDULED', params }`) with no `Records` wrapper.
+ *
+ * Thin adapter: parses the event and delegates to ScriptRunner, which owns
+ * execution tracking, error recording, and status updates.
+ */
+async function handler(event) {
+    const { integrationFactory } = bootstrapAdminScripts();
 
-            // If we have an executionId, mark the admin process as FAILED
-            // so the record doesn't stay stuck in a non-terminal state.
-            if (executionId) {
-                try {
-                    const commands = createAdminScriptCommands();
-                    await commands.completeAdminProcess(executionId, {
-                        state: 'FAILED',
-                        error: {
-                            name: error.name,
-                            message: error.message,
-                            stack: error.stack,
+    // EventBridge Scheduler invokes the Lambda directly (no Records wrapper)
+    if (!event.Records) {
+        try {
+            const result = await runMessage(event, integrationFactory);
+            console.log(
+                `Script completed: ${result.scriptName}, status: ${result.status}`
+            );
+            return {
+                statusCode: 200,
+                body: JSON.stringify({ processed: 1, results: [result] }),
+            };
+        } catch (error) {
+            console.error(
+                'Unexpected error processing scheduled invoke:',
+                error
+            );
+            await markFailed(event.executionId, error);
+            return {
+                statusCode: 200,
+                body: JSON.stringify({
+                    processed: 1,
+                    results: [
+                        {
+                            scriptName: event.scriptName || 'unknown',
+                            status: 'FAILED',
+                            error: error.message,
                         },
-                    });
-                } catch (updateError) {
-                    console.error(`Failed to update execution ${executionId} state:`, updateError);
-                }
-            }
+                    ],
+                }),
+            };
+        }
+    }
 
+    const results = [];
+    for (const record of event.Records) {
+        let message = {};
+        try {
+            message = JSON.parse(record.body);
+            const result = await runMessage(message, integrationFactory);
+            console.log(
+                `Script completed: ${result.scriptName}, status: ${result.status}`
+            );
+            results.push(result);
+        } catch (error) {
+            // Only unexpected failures reach here (message parse errors, runner
+            // construction). Script execution errors are handled by ScriptRunner
+            // and returned as { status: 'FAILED' }.
+            console.error('Unexpected error processing record:', error);
+            await markFailed(message.executionId, error);
             results.push({
-                scriptName: scriptName || 'unknown',
+                scriptName: message.scriptName || 'unknown',
                 status: 'FAILED',
                 error: error.message,
             });

package/src/application/__tests__/dry-run-http-interceptor.test.js

@@ -1,313 +0,0 @@
-const {
-    createDryRunHttpClient,
-    injectDryRunHttpClient,
-    sanitizeHeaders,
-    sanitizeData,
-    detectService,
-} = require('../dry-run-http-interceptor');
-
-describe('Dry-Run HTTP Interceptor', () => {
-    describe('sanitizeHeaders', () => {
-        test('should redact authorization headers', () => {
-            const headers = {
-                'Content-Type': 'application/json',
-                Authorization: 'Bearer secret-token',
-                'X-API-Key': 'api-key-123',
-                'User-Agent': 'frigg/1.0',
-            };
-
-            const sanitized = sanitizeHeaders(headers);
-
-            expect(sanitized['Content-Type']).toBe('application/json');
-            expect(sanitized['User-Agent']).toBe('frigg/1.0');
-            expect(sanitized.Authorization).toBe('[REDACTED]');
-            expect(sanitized['X-API-Key']).toBe('[REDACTED]');
-        });
-
-        test('should handle case variations', () => {
-            const headers = {
-                authorization: 'Bearer token',
-                Authorization: 'Bearer token',
-                'x-api-key': 'key1',
-                'X-API-Key': 'key2',
-            };
-
-            const sanitized = sanitizeHeaders(headers);
-
-            expect(sanitized.authorization).toBe('[REDACTED]');
-            expect(sanitized.Authorization).toBe('[REDACTED]');
-            expect(sanitized['x-api-key']).toBe('[REDACTED]');
-            expect(sanitized['X-API-Key']).toBe('[REDACTED]');
-        });
-
-        test('should handle null/undefined', () => {
-            expect(sanitizeHeaders(null)).toEqual({});
-            expect(sanitizeHeaders(undefined)).toEqual({});
-            expect(sanitizeHeaders({})).toEqual({});
-        });
-    });
-
-    describe('detectService', () => {
-        test('should detect CRM services', () => {
-            expect(detectService('https://api.hubapi.com')).toBe('HubSpot');
-            expect(detectService('https://login.salesforce.com')).toBe('Salesforce');
-            expect(detectService('https://api.pipedrive.com')).toBe('Pipedrive');
-            expect(detectService('https://api.attio.com')).toBe('Attio');
-        });
-
-        test('should detect communication services', () => {
-            expect(detectService('https://slack.com/api')).toBe('Slack');
-            expect(detectService('https://discord.com/api')).toBe('Discord');
-            expect(detectService('https://graph.teams.microsoft.com')).toBe('Microsoft Teams');
-        });
-
-        test('should detect project management tools', () => {
-            expect(detectService('https://app.asana.com/api')).toBe('Asana');
-            expect(detectService('https://api.monday.com')).toBe('Monday.com');
-            expect(detectService('https://api.trello.com')).toBe('Trello');
-        });
-
-        test('should return unknown for unrecognized services', () => {
-            expect(detectService('https://example.com/api')).toBe('unknown');
-            expect(detectService(null)).toBe('unknown');
-            expect(detectService(undefined)).toBe('unknown');
-        });
-
-        test('should be case insensitive', () => {
-            expect(detectService('HTTPS://API.HUBSPOT.COM')).toBe('HubSpot');
-            expect(detectService('https://API.SLACK.COM')).toBe('Slack');
-        });
-    });
-
-    describe('sanitizeData', () => {
-        test('should redact sensitive fields', () => {
-            const data = {
-                name: 'Test User',
-                email: 'test@example.com',
-                password: 'secret123',
-                apiToken: 'token-abc',
-                authKey: 'key-xyz',
-            };
-
-            const sanitized = sanitizeData(data);
-
-            expect(sanitized.name).toBe('Test User');
-            expect(sanitized.email).toBe('test@example.com');
-            expect(sanitized.password).toBe('[REDACTED]');
-            expect(sanitized.apiToken).toBe('[REDACTED]');
-            expect(sanitized.authKey).toBe('[REDACTED]');
-        });
-
-        test('should handle nested objects', () => {
-            const data = {
-                user: {
-                    name: 'Test',
-                    credentials: {
-                        password: 'secret',
-                        token: 'abc123',
-                    },
-                },
-            };
-
-            const sanitized = sanitizeData(data);
-
-            expect(sanitized.user.name).toBe('Test');
-            expect(sanitized.user.credentials.password).toBe('[REDACTED]');
-            expect(sanitized.user.credentials.token).toBe('[REDACTED]');
-        });
-
-        test('should handle arrays', () => {
-            const data = [
-                { id: '1', password: 'secret1' },
-                { id: '2', apiKey: 'key2' },
-            ];
-
-            const sanitized = sanitizeData(data);
-
-            expect(sanitized[0].id).toBe('1');
-            expect(sanitized[0].password).toBe('[REDACTED]');
-            expect(sanitized[1].apiKey).toBe('[REDACTED]');
-        });
-
-        test('should preserve primitives', () => {
-            expect(sanitizeData('string')).toBe('string');
-            expect(sanitizeData(123)).toBe(123);
-            expect(sanitizeData(true)).toBe(true);
-            expect(sanitizeData(null)).toBe(null);
-            expect(sanitizeData(undefined)).toBe(undefined);
-        });
-    });
-
-    describe('createDryRunHttpClient', () => {
-        let operationLog;
-
-        beforeEach(() => {
-            operationLog = [];
-        });
-
-        test('should log GET requests', async () => {
-            const client = createDryRunHttpClient(operationLog);
-
-            const response = await client.get('/contacts', {
-                baseURL: 'https://api.hubapi.com',
-                headers: { Authorization: 'Bearer token' },
-            });
-
-            expect(operationLog).toHaveLength(1);
-            expect(operationLog[0]).toMatchObject({
-                operation: 'HTTP_REQUEST',
-                method: 'GET',
-                url: 'https://api.hubapi.com/contacts',
-                service: 'HubSpot',
-            });
-
-            expect(operationLog[0].headers.Authorization).toBe('[REDACTED]');
-            expect(response.data._dryRun).toBe(true);
-        });
-
-        test('should log POST requests with data', async () => {
-            const client = createDryRunHttpClient(operationLog);
-
-            const postData = {
-                name: 'John Doe',
-                email: 'john@example.com',
-                password: 'secret123',
-            };
-
-            await client.post('/users', postData, {
-                baseURL: 'https://api.example.com',
-            });
-
-            expect(operationLog).toHaveLength(1);
-            expect(operationLog[0].method).toBe('POST');
-            expect(operationLog[0].data.name).toBe('John Doe');
-            expect(operationLog[0].data.email).toBe('john@example.com');
-            expect(operationLog[0].data.password).toBe('[REDACTED]');
-        });
-
-        test('should log PUT requests', async () => {
-            const client = createDryRunHttpClient(operationLog);
-
-            await client.put('/users/123', { status: 'active' }, {
-                baseURL: 'https://api.example.com',
-            });
-
-            expect(operationLog).toHaveLength(1);
-            expect(operationLog[0].method).toBe('PUT');
-            expect(operationLog[0].data.status).toBe('active');
-        });
-
-        test('should log PATCH requests', async () => {
-            const client = createDryRunHttpClient(operationLog);
-
-            await client.patch('/users/123', { name: 'Updated' });
-
-            expect(operationLog).toHaveLength(1);
-            expect(operationLog[0].method).toBe('PATCH');
-        });
-
-        test('should log DELETE requests', async () => {
-            const client = createDryRunHttpClient(operationLog);
-
-            await client.delete('/users/123', {
-                baseURL: 'https://api.example.com',
-            });
-
-            expect(operationLog).toHaveLength(1);
-            expect(operationLog[0].method).toBe('DELETE');
-        });
-
-        test('should return mock response', async () => {
-            const client = createDryRunHttpClient(operationLog);
-
-            const response = await client.get('/test');
-
-            expect(response.status).toBe(200);
-            expect(response.statusText).toContain('Dry-Run');
-            expect(response.data._dryRun).toBe(true);
-            expect(response.headers['x-dry-run']).toBe('true');
-        });
-
-        test('should include query params in log', async () => {
-            const client = createDryRunHttpClient(operationLog);
-
-            await client.get('/search', {
-                baseURL: 'https://api.example.com',
-                params: { q: 'test', limit: 10 },
-            });
-
-            expect(operationLog[0].params).toEqual({ q: 'test', limit: 10 });
-        });
-    });
-
-    describe('injectDryRunHttpClient', () => {
-        let operationLog;
-        let dryRunClient;
-
-        beforeEach(() => {
-            operationLog = [];
-            dryRunClient = createDryRunHttpClient(operationLog);
-        });
-
-        test('should inject into primary API module', () => {
-            const integrationInstance = {
-                primary: {
-                    api: {
-                        _httpClient: { get: jest.fn() },
-                    },
-                },
-            };
-
-            injectDryRunHttpClient(integrationInstance, dryRunClient);
-
-            expect(integrationInstance.primary.api._httpClient).toBe(dryRunClient);
-        });
-
-        test('should inject into target API module', () => {
-            const integrationInstance = {
-                target: {
-                    api: {
-                        _httpClient: { get: jest.fn() },
-                    },
-                },
-            };
-
-            injectDryRunHttpClient(integrationInstance, dryRunClient);
-
-            expect(integrationInstance.target.api._httpClient).toBe(dryRunClient);
-        });
-
-        test('should inject into both primary and target', () => {
-            const integrationInstance = {
-                primary: {
-                    api: { _httpClient: { get: jest.fn() } },
-                },
-                target: {
-                    api: { _httpClient: { get: jest.fn() } },
-                },
-            };
-
-            injectDryRunHttpClient(integrationInstance, dryRunClient);
-
-            expect(integrationInstance.primary.api._httpClient).toBe(dryRunClient);
-            expect(integrationInstance.target.api._httpClient).toBe(dryRunClient);
-        });
-
-        test('should handle missing api modules gracefully', () => {
-            const integrationInstance = {
-                primary: {},
-                target: null,
-            };
-
-            expect(() => {
-                injectDryRunHttpClient(integrationInstance, dryRunClient);
-            }).not.toThrow();
-        });
-
-        test('should handle null integration instance', () => {
-            expect(() => {
-                injectDryRunHttpClient(null, dryRunClient);
-            }).not.toThrow();
-        });
-    });
-});