@friggframework/devtools 2.0.0--canary.531.14108ff.0 → 2.0.0--canary.517.aeeef23.0

package/infrastructure/domains/admin-scripts/admin-script-builder.js

@@ -0,0 +1,200 @@
+/**
+ * Admin Script Builder
+ *
+ * Domain Layer - Hexagonal Architecture
+ *
+ * Responsible for:
+ * - Creating SQS queue for admin script execution
+ * - Creating Lambda function for script execution (worker)
+ * - Creating Lambda function for admin API routes (router)
+ * - Creating EventBridge Scheduler resources (Phase 2)
+ * - Creating IAM roles for scheduler to invoke Lambda
+ */
+
+const { InfrastructureBuilder, ValidationResult } = require('../shared/base-builder');
+
+class AdminScriptBuilder extends InfrastructureBuilder {
+    constructor() {
+        super();
+        this.name = 'AdminScriptBuilder';
+    }
+
+    shouldExecute(appDefinition) {
+        return Array.isArray(appDefinition.adminScripts) && appDefinition.adminScripts.length > 0;
+    }
+
+    getDependencies() {
+        return []; // Can run independently
+    }
+
+    validate(appDefinition) {
+        const result = new ValidationResult();
+
+        if (!appDefinition.adminScripts) {
+            return result; // Not an error, just no scripts
+        }
+
+        if (!Array.isArray(appDefinition.adminScripts)) {
+            result.addError('adminScripts must be an array');
+            return result;
+        }
+
+        // Validate each script
+        appDefinition.adminScripts.forEach((script, index) => {
+            if (!script?.Definition?.name) {
+                result.addError(`Admin script at index ${index} is missing Definition or name`);
+            }
+        });
+
+        return result;
+    }
+
+    async build(appDefinition, discoveredResources) {
+        console.log(`\n[${this.name}] Configuring admin scripts...`);
+        console.log(`  Processing ${appDefinition.adminScripts.length} scripts...`);
+
+        const usePrismaLayer = appDefinition.usePrismaLambdaLayer !== false;
+        const adminConfig = appDefinition.admin || {};
+
+        const result = {
+            functions: {},
+            resources: {},
+            environment: {},
+            custom: {},
+            iamStatements: [],
+        };
+
+        // Create admin script queue
+        this.createAdminScriptQueue(result);
+
+        // Create Lambda function for script execution
+        this.createScriptExecutorFunction(result, usePrismaLayer);
+
+        // Create API routes for script management
+        this.createAdminScriptRoutes(result, usePrismaLayer);
+
+        // Phase 2: Create EventBridge Scheduler resources
+        if (adminConfig.enableScheduling) {
+            this.createSchedulerResources(appDefinition, result);
+        }
+
+        // Log registered scripts
+        appDefinition.adminScripts.forEach(script => {
+            const name = script.Definition?.name || 'unknown';
+            const schedule = script.Definition?.schedule;
+            console.log(`    ✓ Registered: ${name}${schedule?.enabled ? ' (scheduled)' : ''}`);
+        });
+
+        console.log(`[${this.name}] ✅ Admin script configuration completed`);
+        return result;
+    }
+
+    createAdminScriptQueue(result) {
+        result.resources.AdminScriptQueue = {
+            Type: 'AWS::SQS::Queue',
+            Properties: {
+                QueueName: '${self:service}-${self:provider.stage}-AdminScriptQueue',
+                MessageRetentionPeriod: 86400, // 1 day
+                VisibilityTimeout: 900, // 15 minutes (Lambda max)
+                RedrivePolicy: {
+                    maxReceiveCount: 3,
+                    deadLetterTargetArn: {
+                        'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
+                    },
+                },
+            },
+        };
+
+        result.environment.ADMIN_SCRIPT_QUEUE_URL = { Ref: 'AdminScriptQueue' };
+        console.log('  ✓ Created AdminScriptQueue');
+    }
+
+    createScriptExecutorFunction(result, usePrismaLayer) {
+        result.functions.adminScriptExecutor = {
+            handler: 'node_modules/@friggframework/admin-scripts/src/infrastructure/script-executor-handler.handler',
+            skipEsbuild: true,
+            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
+            timeout: 900, // 15 minutes max
+            memorySize: 1024,
+            events: [
+                {
+                    sqs: {
+                        arn: { 'Fn::GetAtt': ['AdminScriptQueue', 'Arn'] },
+                        batchSize: 1,
+                    },
+                },
+            ],
+        };
+        console.log('  ✓ Created adminScriptExecutor function');
+    }
+
+    createAdminScriptRoutes(result, usePrismaLayer) {
+        result.functions.adminScriptRouter = {
+            handler: 'node_modules/@friggframework/admin-scripts/src/infrastructure/admin-script-router.handler',
+            skipEsbuild: true,
+            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
+            timeout: 30,
+            events: [
+                // List scripts
+                { httpApi: { path: '/admin/scripts', method: 'GET' } },
+                // Get script details
+                { httpApi: { path: '/admin/scripts/{scriptName}', method: 'GET' } },
+                // Execute script (sync or async)
+                { httpApi: { path: '/admin/scripts/{scriptName}/execute', method: 'POST' } },
+                // Get execution status
+                { httpApi: { path: '/admin/executions/{executionId}', method: 'GET' } },
+                // List executions
+                { httpApi: { path: '/admin/executions', method: 'GET' } },
+                // Schedule management (Phase 2)
+                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'GET' } },
+                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'PUT' } },
+                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'DELETE' } },
+            ],
+        };
+        console.log('  ✓ Created adminScriptRouter function');
+    }
+
+    createSchedulerResources(appDefinition, result) {
+        // Create IAM role for EventBridge Scheduler
+        result.resources.AdminScriptSchedulerRole = {
+            Type: 'AWS::IAM::Role',
+            Properties: {
+                RoleName: '${self:service}-${self:provider.stage}-admin-script-scheduler',
+                AssumeRolePolicyDocument: {
+                    Version: '2012-10-17',
+                    Statement: [{
+                        Effect: 'Allow',
+                        Principal: { Service: 'scheduler.amazonaws.com' },
+                        Action: 'sts:AssumeRole',
+                    }],
+                },
+                Policies: [{
+                    PolicyName: 'InvokeLambda',
+                    PolicyDocument: {
+                        Version: '2012-10-17',
+                        Statement: [{
+                            Effect: 'Allow',
+                            Action: 'lambda:InvokeFunction',
+                            Resource: { 'Fn::GetAtt': ['AdminScriptExecutorLambdaFunction', 'Arn'] },
+                        }],
+                    },
+                }],
+            },
+        };
+
+        // Create schedule group
+        result.resources.AdminScriptScheduleGroup = {
+            Type: 'AWS::Scheduler::ScheduleGroup',
+            Properties: {
+                Name: '${self:service}-${self:provider.stage}-admin-scripts',
+            },
+        };
+
+        result.environment.SCHEDULER_ROLE_ARN = { 'Fn::GetAtt': ['AdminScriptSchedulerRole', 'Arn'] };
+        result.environment.SCHEDULE_GROUP_NAME = { Ref: 'AdminScriptScheduleGroup' };
+
+        console.log('  ✓ Created EventBridge Scheduler resources');
+    }
+}
+
+module.exports = { AdminScriptBuilder };

package/infrastructure/domains/admin-scripts/admin-script-builder.test.js

@@ -0,0 +1,499 @@
+/**
+ * Tests for Admin Script Builder
+ *
+ * Tests admin script infrastructure generation including:
+ * - SQS queue for script execution
+ * - Lambda executor function
+ * - Lambda router function with HTTP routes
+ * - EventBridge Scheduler resources (optional)
+ */
+
+const { AdminScriptBuilder } = require('./admin-script-builder');
+const { ValidationResult } = require('../shared/base-builder');
+
+describe('AdminScriptBuilder', () => {
+    let adminScriptBuilder;
+
+    beforeEach(() => {
+        adminScriptBuilder = new AdminScriptBuilder();
+    });
+
+    describe('shouldExecute()', () => {
+        it('should return false when no adminScripts', () => {
+            const appDefinition = {};
+
+            expect(adminScriptBuilder.shouldExecute(appDefinition)).toBe(false);
+        });
+
+        it('should return false when adminScripts is empty array', () => {
+            const appDefinition = {
+                adminScripts: [],
+            };
+
+            expect(adminScriptBuilder.shouldExecute(appDefinition)).toBe(false);
+        });
+
+        it('should return true when adminScripts has items', () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            expect(adminScriptBuilder.shouldExecute(appDefinition)).toBe(true);
+        });
+
+        it('should return false when adminScripts is not an array', () => {
+            const appDefinition = {
+                adminScripts: { name: 'test' },
+            };
+
+            expect(adminScriptBuilder.shouldExecute(appDefinition)).toBe(false);
+        });
+    });
+
+    describe('getDependencies()', () => {
+        it('should have no dependencies', () => {
+            const deps = adminScriptBuilder.getDependencies();
+
+            expect(deps).toEqual([]);
+        });
+    });
+
+    describe('validate()', () => {
+        it('should pass validation with valid adminScripts', () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'oauth-refresh' } },
+                    { Definition: { name: 'health-check' } },
+                ],
+            };
+
+            const result = adminScriptBuilder.validate(appDefinition);
+
+            expect(result).toBeInstanceOf(ValidationResult);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toEqual([]);
+        });
+
+        it('should pass when adminScripts is undefined', () => {
+            const appDefinition = {};
+
+            const result = adminScriptBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(true);
+        });
+
+        it('should fail when adminScripts is not an array', () => {
+            const appDefinition = {
+                adminScripts: 'invalid',
+            };
+
+            const result = adminScriptBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('adminScripts must be an array');
+        });
+
+        it('should fail when script missing Definition.name', () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: {} },
+                ],
+            };
+
+            const result = adminScriptBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain(
+                'Admin script at index 0 is missing Definition or name'
+            );
+        });
+
+        it('should fail when script missing Definition', () => {
+            const appDefinition = {
+                adminScripts: [
+                    { someOtherField: 'value' },
+                ],
+            };
+
+            const result = adminScriptBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain(
+                'Admin script at index 0 is missing Definition or name'
+            );
+        });
+
+        it('should validate all scripts', () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'valid' } },
+                    { Definition: {} }, // Invalid - no name
+                    { someField: 'value' }, // Invalid - no Definition
+                ],
+            };
+
+            const result = adminScriptBuilder.validate(appDefinition);
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toHaveLength(2);
+        });
+    });
+
+    describe('build()', () => {
+        it('should create AdminScriptQueue resource', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.resources.AdminScriptQueue).toBeDefined();
+            expect(result.resources.AdminScriptQueue.Type).toBe('AWS::SQS::Queue');
+        });
+
+        it('should configure AdminScriptQueue with correct retention and timeout', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.resources.AdminScriptQueue.Properties.MessageRetentionPeriod).toBe(86400); // 1 day
+            expect(result.resources.AdminScriptQueue.Properties.VisibilityTimeout).toBe(900); // 15 minutes
+        });
+
+        it('should configure AdminScriptQueue redrive policy to InternalErrorQueue', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.resources.AdminScriptQueue.Properties.RedrivePolicy).toEqual({
+                maxReceiveCount: 3,
+                deadLetterTargetArn: {
+                    'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
+                },
+            });
+        });
+
+        it('should add ADMIN_SCRIPT_QUEUE_URL to environment variables', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.environment.ADMIN_SCRIPT_QUEUE_URL).toEqual({
+                Ref: 'AdminScriptQueue',
+            });
+        });
+
+        it('should create adminScriptExecutor function', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptExecutor).toBeDefined();
+            expect(result.functions.adminScriptExecutor.handler).toBe(
+                'node_modules/@friggframework/admin-scripts/src/infrastructure/script-executor-handler.handler'
+            );
+        });
+
+        it('should configure adminScriptExecutor with SQS event', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptExecutor.events).toEqual([
+                {
+                    sqs: {
+                        arn: { 'Fn::GetAtt': ['AdminScriptQueue', 'Arn'] },
+                        batchSize: 1,
+                    },
+                },
+            ]);
+        });
+
+        it('should set adminScriptExecutor timeout to 900 seconds', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptExecutor.timeout).toBe(900); // 15 minutes (Lambda max)
+        });
+
+        it('should set adminScriptExecutor memory size', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptExecutor.memorySize).toBe(1024);
+        });
+
+        it('should attach Prisma layer to adminScriptExecutor', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptExecutor.layers).toEqual([
+                { Ref: 'PrismaLambdaLayer' }
+            ]);
+        });
+
+        it('should create adminScriptRouter function', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptRouter).toBeDefined();
+            expect(result.functions.adminScriptRouter.handler).toBe(
+                'node_modules/@friggframework/admin-scripts/src/infrastructure/admin-script-router.handler'
+            );
+        });
+
+        it('should configure adminScriptRouter with correct HTTP routes', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptRouter.events).toEqual([
+                // List scripts
+                { httpApi: { path: '/admin/scripts', method: 'GET' } },
+                // Get script details
+                { httpApi: { path: '/admin/scripts/{scriptName}', method: 'GET' } },
+                // Execute script (sync or async)
+                { httpApi: { path: '/admin/scripts/{scriptName}/execute', method: 'POST' } },
+                // Get execution status
+                { httpApi: { path: '/admin/executions/{executionId}', method: 'GET' } },
+                // List executions
+                { httpApi: { path: '/admin/executions', method: 'GET' } },
+                // Schedule management (Phase 2)
+                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'GET' } },
+                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'PUT' } },
+                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'DELETE' } },
+            ]);
+        });
+
+        it('should set adminScriptRouter timeout to 30 seconds', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptRouter.timeout).toBe(30);
+        });
+
+        it('should attach Prisma layer to adminScriptRouter', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptRouter.layers).toEqual([
+                { Ref: 'PrismaLambdaLayer' }
+            ]);
+        });
+
+        it('should create scheduler resources when admin.enableScheduling is true', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+                admin: {
+                    enableScheduling: true,
+                },
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            // Check for scheduler IAM role
+            expect(result.resources.AdminScriptSchedulerRole).toBeDefined();
+            expect(result.resources.AdminScriptSchedulerRole.Type).toBe('AWS::IAM::Role');
+
+            // Check for schedule group
+            expect(result.resources.AdminScriptScheduleGroup).toBeDefined();
+            expect(result.resources.AdminScriptScheduleGroup.Type).toBe('AWS::Scheduler::ScheduleGroup');
+
+            // Check for environment variables
+            expect(result.environment.SCHEDULER_ROLE_ARN).toEqual({
+                'Fn::GetAtt': ['AdminScriptSchedulerRole', 'Arn'],
+            });
+            expect(result.environment.SCHEDULE_GROUP_NAME).toEqual({
+                Ref: 'AdminScriptScheduleGroup',
+            });
+        });
+
+        it('should not create scheduler resources when enableScheduling is false', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+                admin: {
+                    enableScheduling: false,
+                },
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.resources.AdminScriptSchedulerRole).toBeUndefined();
+            expect(result.resources.AdminScriptScheduleGroup).toBeUndefined();
+            expect(result.environment.SCHEDULER_ROLE_ARN).toBeUndefined();
+            expect(result.environment.SCHEDULE_GROUP_NAME).toBeUndefined();
+        });
+
+        it('should not create scheduler resources when admin config is not provided', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.resources.AdminScriptSchedulerRole).toBeUndefined();
+            expect(result.resources.AdminScriptScheduleGroup).toBeUndefined();
+        });
+
+        it('should use skipEsbuild for all functions', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptExecutor.skipEsbuild).toBe(true);
+            expect(result.functions.adminScriptRouter.skipEsbuild).toBe(true);
+        });
+
+        it('should not attach Prisma layer when usePrismaLambdaLayer=false', async () => {
+            const appDefinition = {
+                usePrismaLambdaLayer: false,
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            expect(result.functions.adminScriptExecutor.layers).toBeUndefined();
+            expect(result.functions.adminScriptRouter.layers).toBeUndefined();
+        });
+
+        it('should handle multiple admin scripts', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'oauth-refresh' } },
+                    { Definition: { name: 'health-check' } },
+                    { Definition: { name: 'attio-healing' } },
+                ],
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            // Should still only create one queue and two functions
+            expect(result.resources.AdminScriptQueue).toBeDefined();
+            expect(result.functions.adminScriptExecutor).toBeDefined();
+            expect(result.functions.adminScriptRouter).toBeDefined();
+
+            // Should not create separate resources per script
+            expect(Object.keys(result.resources)).toHaveLength(1); // Only AdminScriptQueue
+            expect(Object.keys(result.functions)).toHaveLength(2); // Only executor and router
+        });
+
+        it('should configure scheduler role with correct trust policy', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+                admin: {
+                    enableScheduling: true,
+                },
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            const trustPolicy = result.resources.AdminScriptSchedulerRole.Properties.AssumeRolePolicyDocument;
+
+            expect(trustPolicy.Statement[0]).toEqual({
+                Effect: 'Allow',
+                Principal: { Service: 'scheduler.amazonaws.com' },
+                Action: 'sts:AssumeRole',
+            });
+        });
+
+        it('should configure scheduler role with Lambda invoke permission', async () => {
+            const appDefinition = {
+                adminScripts: [
+                    { Definition: { name: 'test-script' } },
+                ],
+                admin: {
+                    enableScheduling: true,
+                },
+            };
+
+            const result = await adminScriptBuilder.build(appDefinition, {});
+
+            const policies = result.resources.AdminScriptSchedulerRole.Properties.Policies;
+
+            expect(policies[0].PolicyName).toBe('InvokeLambda');
+            expect(policies[0].PolicyDocument.Statement[0]).toEqual({
+                Effect: 'Allow',
+                Action: 'lambda:InvokeFunction',
+                Resource: { 'Fn::GetAtt': ['AdminScriptExecutorLambdaFunction', 'Arn'] },
+            });
+        });
+    });
+
+    describe('getName()', () => {
+        it('should return AdminScriptBuilder', () => {
+            expect(adminScriptBuilder.getName()).toBe('AdminScriptBuilder');
+        });
+    });
+});

package/infrastructure/domains/admin-scripts/index.js

@@ -0,0 +1,5 @@
+const { AdminScriptBuilder } = require('./admin-script-builder');
+
+module.exports = {
+    AdminScriptBuilder
+};

package/infrastructure/domains/shared/types/app-definition.js

@@ -106,6 +106,25 @@
  * @property {string} Definition.name - Integration name
  */
 
+/**
+ * Admin script definition
+ * @typedef {Object} AdminScriptDefinition
+ * @property {Object} Definition - Static definition from script class
+ * @property {string} Definition.name - Script name identifier
+ * @property {string} Definition.version - Script version (semver)
+ * @property {string} [Definition.description] - Human-readable description
+ * @property {Object} [Definition.schedule] - Schedule configuration
+ * @property {boolean} [Definition.schedule.enabled] - Whether scheduling is enabled
+ * @property {string} [Definition.schedule.cronExpression] - Cron expression
+ */
+
+/**
+ * Admin configuration
+ * @typedef {Object} AdminConfig
+ * @property {boolean} [includeBuiltinScripts] - Whether to include built-in scripts
+ * @property {boolean} [enableScheduling] - Whether to enable EventBridge scheduling
+ */
+
 /**
  * Complete application definition
  * @typedef {Object} AppDefinition
@@ -122,6 +141,8 @@
  * @property {MigrationDefinition} [migrations] - Database migration configuration
  * @property {WebsocketDefinition} [websockets] - WebSocket API configuration
  * @property {IntegrationDefinition[]} [integrations] - Integration definitions
+ * @property {AdminScriptDefinition[]} [adminScripts] - Admin script definitions
+ * @property {AdminConfig} [admin] - Admin configuration
  *
  * @property {Object} [environment] - Environment variables
  */

package/infrastructure/infrastructure-composer.js

@@ -17,6 +17,7 @@ const { SsmBuilder } = require('./domains/parameters/ssm-builder');
 const { WebsocketBuilder } = require('./domains/integration/websocket-builder');
 const { IntegrationBuilder } = require('./domains/integration/integration-builder');
 const { SchedulerBuilder } = require('./domains/scheduler/scheduler-builder');
+const { AdminScriptBuilder } = require('./domains/admin-scripts/admin-script-builder');
 
 // Utilities
 const { modifyHandlerPaths } = require('./domains/shared/utilities/handler-path-resolver');
@@ -53,6 +54,7 @@ const composeServerlessDefinition = async (AppDefinition) => {
         new WebsocketBuilder(),
         new IntegrationBuilder(),
         new SchedulerBuilder(), // Add scheduler after IntegrationBuilder (depends on it)
+        new AdminScriptBuilder(),
     ]);
 
     // Build all infrastructure (orchestrator handles validation, dependencies, parallel execution)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.531.14108ff.0",
+  "version": "2.0.0--canary.517.aeeef23.0",
   "bin": {
     "frigg": "./frigg-cli/index.js"
   },
@@ -25,9 +25,9 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/core": "2.0.0--canary.531.14108ff.0",
-    "@friggframework/schemas": "2.0.0--canary.531.14108ff.0",
-    "@friggframework/test": "2.0.0--canary.531.14108ff.0",
+    "@friggframework/core": "2.0.0--canary.517.aeeef23.0",
+    "@friggframework/schemas": "2.0.0--canary.517.aeeef23.0",
+    "@friggframework/test": "2.0.0--canary.517.aeeef23.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -55,8 +55,8 @@
     "validate-npm-package-name": "^5.0.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.531.14108ff.0",
-    "@friggframework/prettier-config": "2.0.0--canary.531.14108ff.0",
+    "@friggframework/eslint-config": "2.0.0--canary.517.aeeef23.0",
+    "@friggframework/prettier-config": "2.0.0--canary.517.aeeef23.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -88,5 +88,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "14108ff456f4b351b9eacb214e86cf8b385d603b"
+  "gitHead": "aeeef23b75be72e029f84eb3ad392c01a7da0ed9"
 }