@friggframework/admin-scripts 2.0.0--canary.522.923dfae.0 → 2.0.0--canary.517.1687d70.0

package/index.js

@@ -8,11 +8,17 @@
 // Application Services
 const { ScriptFactory, getScriptFactory, createScriptFactory } = require('./src/application/script-factory');
 const { AdminScriptBase } = require('./src/application/admin-script-base');
-const { AdminFriggCommands, createAdminFriggCommands } = require('./src/application/admin-frigg-commands');
+const {
+    AdminScriptContext,
+    createAdminScriptContext,
+    // Legacy aliases (deprecated)
+    AdminFriggCommands,
+    createAdminFriggCommands,
+} = require('./src/application/admin-frigg-commands');
 const { ScriptRunner, createScriptRunner } = require('./src/application/script-runner');
 
 // Infrastructure
-const { adminAuthMiddleware } = require('./src/infrastructure/admin-auth-middleware');
+const { validateAdminApiKey } = require('./src/infrastructure/admin-auth-middleware');
 const { router, app, handler: routerHandler } = require('./src/infrastructure/admin-script-router');
 const { handler: executorHandler } = require('./src/infrastructure/script-executor-handler');
 
@@ -30,7 +36,6 @@ const { AWSSchedulerAdapter } = require('./src/adapters/aws-scheduler-adapter');
 const { LocalSchedulerAdapter } = require('./src/adapters/local-scheduler-adapter');
 const {
     createSchedulerAdapter,
-    detectSchedulerAdapterType,
 } = require('./src/adapters/scheduler-adapter-factory');
 
 module.exports = {
@@ -39,13 +44,16 @@ module.exports = {
     ScriptFactory,
     getScriptFactory,
     createScriptFactory,
+    AdminScriptContext,
+    createAdminScriptContext,
+    // Legacy aliases (deprecated)
     AdminFriggCommands,
     createAdminFriggCommands,
     ScriptRunner,
     createScriptRunner,
 
     // Infrastructure layer
-    adminAuthMiddleware,
+    validateAdminApiKey,
     router,
     app,
     routerHandler,
@@ -62,5 +70,4 @@ module.exports = {
     AWSSchedulerAdapter,
     LocalSchedulerAdapter,
     createSchedulerAdapter,
-    detectSchedulerAdapterType,
 };

package/package.json

@@ -1,27 +1,21 @@
 {
     "name": "@friggframework/admin-scripts",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.522.923dfae.0",
+    "version": "2.0.0--canary.517.1687d70.0",
     "description": "Admin Script Runner for Frigg - Execute maintenance and operational scripts in hosted environments",
     "dependencies": {
         "@aws-sdk/client-scheduler": "^3.588.0",
-        "@friggframework/core": "2.0.0--canary.522.923dfae.0",
-        "bcryptjs": "^2.4.3",
+        "@friggframework/core": "2.0.0--canary.517.1687d70.0",
         "express": "^4.18.2",
-        "lodash": "4.17.21",
-        "mongoose": "6.11.6",
-        "serverless-http": "^3.2.0",
-        "uuid": "^9.0.1"
+        "serverless-http": "^3.2.0"
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.522.923dfae.0",
-        "@friggframework/prettier-config": "2.0.0--canary.522.923dfae.0",
-        "@friggframework/test": "2.0.0--canary.522.923dfae.0",
-        "chai": "^4.3.6",
+        "@friggframework/eslint-config": "2.0.0--canary.517.1687d70.0",
+        "@friggframework/prettier-config": "2.0.0--canary.517.1687d70.0",
+        "@friggframework/test": "2.0.0--canary.517.1687d70.0",
         "eslint": "^8.22.0",
         "jest": "^29.7.0",
         "prettier": "^2.7.1",
-        "sinon": "^16.1.1",
         "supertest": "^7.1.4"
     },
     "scripts": {
@@ -49,5 +43,5 @@
         "maintenance",
         "operations"
     ],
-    "gitHead": "923dfaebed139e79450165c5e2ecf11ef7cbcd40"
+    "gitHead": "1687d704a5eed1b0de52275200a579399722813d"
 }

package/src/adapters/__tests__/aws-scheduler-adapter.test.js

@@ -18,34 +18,28 @@ jest.mock('@aws-sdk/client-scheduler', () => {
     };
 });
 
+const defaultParams = {
+    targetLambdaArn: 'arn:aws:lambda:us-east-1:123456789012:function:admin-script-executor',
+    scheduleGroupName: 'frigg-admin-scripts',
+    roleArn: 'arn:aws:iam::123456789012:role/test-role',
+};
+
 describe('AWSSchedulerAdapter', () => {
     let adapter;
     let mockSend;
-    let originalEnv;
-
-    beforeAll(() => {
-        originalEnv = { ...process.env };
-    });
+    const originalEnv = process.env;
 
     beforeEach(() => {
         jest.clearAllMocks();
-
-        // Reset environment variables
-        process.env.AWS_REGION = 'us-east-1';
-        process.env.SCHEDULE_GROUP_NAME = 'test-schedule-group';
-        process.env.SCHEDULER_ROLE_ARN = 'arn:aws:iam::123456789012:role/test-role';
-        process.env.ADMIN_SCRIPT_LAMBDA_ARN = 'arn:aws:lambda:us-east-1:123456789012:function:test-executor';
+        process.env = { ...originalEnv, AWS_REGION: 'us-east-1' };
 
         const sdk = require('@aws-sdk/client-scheduler');
         mockSend = sdk._mockSend;
 
-        adapter = new AWSSchedulerAdapter({
-            targetLambdaArn: 'arn:aws:lambda:us-east-1:123456789012:function:admin-script-executor',
-            scheduleGroupName: 'frigg-admin-scripts',
-        });
+        adapter = new AWSSchedulerAdapter({ ...defaultParams });
     });
 
-    afterAll(() => {
+    afterEach(() => {
         process.env = originalEnv;
     });
 
@@ -60,35 +54,46 @@ describe('AWSSchedulerAdapter', () => {
     });
 
     describe('Constructor', () => {
-        it('should use provided configuration', () => {
+        it('should use provided configuration and AWS_REGION from env', () => {
+            process.env.AWS_REGION = 'eu-west-1';
             const customAdapter = new AWSSchedulerAdapter({
-                region: 'eu-west-1',
                 targetLambdaArn: 'arn:aws:lambda:eu-west-1:123456789012:function:custom',
                 scheduleGroupName: 'custom-group',
+                roleArn: 'arn:aws:iam::123456789012:role/custom-role',
             });
 
             expect(customAdapter.region).toBe('eu-west-1');
             expect(customAdapter.targetLambdaArn).toBe('arn:aws:lambda:eu-west-1:123456789012:function:custom');
             expect(customAdapter.scheduleGroupName).toBe('custom-group');
+            expect(customAdapter.roleArn).toBe('arn:aws:iam::123456789012:role/custom-role');
         });
 
-        it('should use environment variables as fallback', () => {
-            const envAdapter = new AWSSchedulerAdapter();
-
-            expect(envAdapter.region).toBe('us-east-1');
-            expect(envAdapter.targetLambdaArn).toBe('arn:aws:lambda:us-east-1:123456789012:function:test-executor');
-            expect(envAdapter.scheduleGroupName).toBe('test-schedule-group');
+        it('should throw if AWS_REGION is not set', () => {
+            delete process.env.AWS_REGION;
+            expect(() => new AWSSchedulerAdapter({
+                ...defaultParams,
+            })).toThrow('AWSSchedulerAdapter requires AWS_REGION environment variable');
         });
 
-        it('should use defaults when no config or env vars', () => {
-            delete process.env.AWS_REGION;
-            delete process.env.SCHEDULE_GROUP_NAME;
-            delete process.env.ADMIN_SCRIPT_LAMBDA_ARN;
+        it('should throw if targetLambdaArn is missing', () => {
+            expect(() => new AWSSchedulerAdapter({
+                scheduleGroupName: defaultParams.scheduleGroupName,
+                roleArn: defaultParams.roleArn,
+            })).toThrow('AWSSchedulerAdapter requires targetLambdaArn');
+        });
 
-            const defaultAdapter = new AWSSchedulerAdapter();
+        it('should throw if scheduleGroupName is missing', () => {
+            expect(() => new AWSSchedulerAdapter({
+                targetLambdaArn: defaultParams.targetLambdaArn,
+                roleArn: defaultParams.roleArn,
+            })).toThrow('AWSSchedulerAdapter requires scheduleGroupName');
+        });
 
-            expect(defaultAdapter.region).toBe('us-east-1');
-            expect(defaultAdapter.scheduleGroupName).toBe('frigg-admin-scripts');
+        it('should throw if roleArn is missing', () => {
+            expect(() => new AWSSchedulerAdapter({
+                targetLambdaArn: defaultParams.targetLambdaArn,
+                scheduleGroupName: defaultParams.scheduleGroupName,
+            })).toThrow('AWSSchedulerAdapter requires roleArn');
         });
     });
 
@@ -139,7 +144,7 @@ describe('AWSSchedulerAdapter', () => {
             });
         });
 
-        it('should configure target with Lambda ARN and role', async () => {
+        it('should configure target with Lambda ARN and constructor roleArn', async () => {
             mockSend.mockResolvedValue({
                 ScheduleArn: 'arn:aws:scheduler:us-east-1:123456789012:schedule/frigg-admin-scripts/frigg-script-test-script',
             });
@@ -154,6 +159,26 @@ describe('AWSSchedulerAdapter', () => {
             expect(command.params.Target.RoleArn).toBe('arn:aws:iam::123456789012:role/test-role');
         });
 
+        it('should use roleArn from constructor, not process.env', async () => {
+            const customRoleArn = 'arn:aws:iam::999999999999:role/custom-scheduler-role';
+            const customAdapter = new AWSSchedulerAdapter({
+                ...defaultParams,
+                roleArn: customRoleArn,
+            });
+
+            mockSend.mockResolvedValue({
+                ScheduleArn: 'arn:aws:scheduler:us-east-1:123456789012:schedule/frigg-admin-scripts/frigg-script-test-script',
+            });
+
+            await customAdapter.createSchedule({
+                scriptName: 'test-script',
+                cronExpression: 'cron(0 0 * * ? *)',
+            });
+
+            const command = mockSend.mock.calls[0][0];
+            expect(command.params.Target.RoleArn).toBe(customRoleArn);
+        });
+
         it('should enable schedule by default', async () => {
             mockSend.mockResolvedValue({
                 ScheduleArn: 'arn:aws:scheduler:us-east-1:123456789012:schedule/frigg-admin-scripts/frigg-script-test-script',
@@ -181,6 +206,43 @@ describe('AWSSchedulerAdapter', () => {
             const command = mockSend.mock.calls[0][0];
             expect(command.params.FlexibleTimeWindow).toEqual({ Mode: 'OFF' });
         });
+
+        it('should fall back to UpdateScheduleCommand on ConflictException', async () => {
+            const conflictError = new Error('Schedule already exists');
+            conflictError.name = 'ConflictException';
+
+            mockSend
+                .mockRejectedValueOnce(conflictError)
+                .mockResolvedValueOnce({
+                    ScheduleArn: 'arn:aws:scheduler:us-east-1:123456789012:schedule/frigg-admin-scripts/frigg-script-test-script',
+                });
+
+            const result = await adapter.createSchedule({
+                scriptName: 'test-script',
+                cronExpression: 'cron(0 0 * * ? *)',
+            });
+
+            expect(result).toEqual({
+                scheduleArn: 'arn:aws:scheduler:us-east-1:123456789012:schedule/frigg-admin-scripts/frigg-script-test-script',
+                scheduleName: 'frigg-script-test-script',
+            });
+
+            expect(mockSend).toHaveBeenCalledTimes(2);
+            expect(mockSend.mock.calls[0][0]._type).toBe('CreateScheduleCommand');
+            expect(mockSend.mock.calls[1][0]._type).toBe('UpdateScheduleCommand');
+        });
+
+        it('should rethrow non-conflict errors', async () => {
+            const otherError = new Error('Access denied');
+            otherError.name = 'AccessDeniedException';
+
+            mockSend.mockRejectedValue(otherError);
+
+            await expect(adapter.createSchedule({
+                scriptName: 'test-script',
+                cronExpression: 'cron(0 0 * * ? *)',
+            })).rejects.toThrow('Access denied');
+        });
     });
 
     describe('deleteSchedule()', () => {
@@ -301,9 +363,7 @@ describe('AWSSchedulerAdapter', () => {
 
     describe('Lazy SDK loading', () => {
         it('should load AWS SDK on first client access', () => {
-            const newAdapter = new AWSSchedulerAdapter({
-                targetLambdaArn: 'arn:aws:lambda:us-east-1:123456789012:function:test',
-            });
+            const newAdapter = new AWSSchedulerAdapter({ ...defaultParams });
 
             expect(newAdapter.scheduler).toBeNull();
 

package/src/adapters/__tests__/local-scheduler-adapter.test.js

@@ -210,12 +210,12 @@ describe('LocalSchedulerAdapter', () => {
             const schedules = await adapter.listSchedules();
 
             expect(schedules).toHaveLength(3);
-            expect(schedules.map((s) => s.scriptName)).toContain('script-1');
-            expect(schedules.map((s) => s.scriptName)).toContain('script-2');
-            expect(schedules.map((s) => s.scriptName)).toContain('script-3');
+            expect(schedules.map((s) => s.Name)).toContain('frigg-script-script-1');
+            expect(schedules.map((s) => s.Name)).toContain('frigg-script-script-2');
+            expect(schedules.map((s) => s.Name)).toContain('frigg-script-script-3');
         });
 
-        it('should include all schedule properties', async () => {
+        it('should include all schedule properties in normalized format', async () => {
             await adapter.createSchedule({
                 scriptName: 'test-script',
                 cronExpression: '0 0 * * *',
@@ -226,14 +226,11 @@ describe('LocalSchedulerAdapter', () => {
             const schedules = await adapter.listSchedules();
 
             expect(schedules[0]).toMatchObject({
-                scriptName: 'test-script',
-                cronExpression: '0 0 * * *',
-                timezone: 'America/New_York',
-                input: { key: 'value' },
-                enabled: true,
+                Name: 'frigg-script-test-script',
+                State: 'ENABLED',
+                ScheduleExpression: '0 0 * * *',
+                ScheduleExpressionTimezone: 'America/New_York',
             });
-            expect(schedules[0]).toHaveProperty('createdAt');
-            expect(schedules[0]).toHaveProperty('updatedAt');
         });
     });
 

package/src/adapters/__tests__/scheduler-adapter-factory.test.js

@@ -1,7 +1,4 @@
-const {
-    createSchedulerAdapter,
-    detectSchedulerAdapterType,
-} = require('../scheduler-adapter-factory');
+const { createSchedulerAdapter } = require('../scheduler-adapter-factory');
 const { AWSSchedulerAdapter } = require('../aws-scheduler-adapter');
 const { LocalSchedulerAdapter } = require('../local-scheduler-adapter');
 
@@ -17,71 +14,56 @@ jest.mock('@aws-sdk/client-scheduler', () => ({
     ListSchedulesCommand: jest.fn(),
 }));
 
-describe('Scheduler Adapter Factory', () => {
-    let originalEnv;
+const awsAdapterParams = {
+    targetLambdaArn: 'arn:aws:lambda:us-east-1:123456789012:function:test',
+    scheduleGroupName: 'test-group',
+    roleArn: 'arn:aws:iam::123456789012:role/test-role',
+};
 
-    beforeAll(() => {
-        originalEnv = { ...process.env };
-    });
+describe('Scheduler Adapter Factory', () => {
+    const originalEnv = process.env;
 
     beforeEach(() => {
-        // Reset environment variables
-        delete process.env.SCHEDULER_ADAPTER;
-        delete process.env.STAGE;
-        delete process.env.NODE_ENV;
+        process.env = { ...originalEnv, AWS_REGION: 'us-east-1' };
     });
 
-    afterAll(() => {
+    afterEach(() => {
         process.env = originalEnv;
     });
 
     describe('createSchedulerAdapter()', () => {
-        it('should create local adapter by default', () => {
-            const adapter = createSchedulerAdapter();
+        it('should throw if type is not provided', () => {
+            expect(() => createSchedulerAdapter()).toThrow();
+        });
 
-            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
-            expect(adapter.getName()).toBe('local-cron');
+        it('should throw if type is not provided in options object', () => {
+            expect(() => createSchedulerAdapter({})).toThrow();
         });
 
-        it('should create local adapter when explicitly specified', () => {
+        it('should create local adapter when type is "local"', () => {
             const adapter = createSchedulerAdapter({ type: 'local' });
 
             expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+            expect(adapter.getName()).toBe('local-cron');
         });
 
         it('should create AWS adapter when type is "aws"', () => {
-            const adapter = createSchedulerAdapter({ type: 'aws' });
+            const adapter = createSchedulerAdapter({ type: 'aws', ...awsAdapterParams });
 
             expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
             expect(adapter.getName()).toBe('aws-eventbridge-scheduler');
         });
 
         it('should create AWS adapter when type is "eventbridge"', () => {
-            const adapter = createSchedulerAdapter({ type: 'eventbridge' });
-
-            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
-        });
-
-        it('should use SCHEDULER_ADAPTER env variable', () => {
-            process.env.SCHEDULER_ADAPTER = 'aws';
-
-            const adapter = createSchedulerAdapter();
+            const adapter = createSchedulerAdapter({ type: 'eventbridge', ...awsAdapterParams });
 
             expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
         });
 
-        it('should allow explicit type to override env variable', () => {
-            process.env.SCHEDULER_ADAPTER = 'aws';
-
-            const adapter = createSchedulerAdapter({ type: 'local' });
-
-            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
-        });
-
         it('should handle case-insensitive type values', () => {
-            const adapter1 = createSchedulerAdapter({ type: 'AWS' });
+            const adapter1 = createSchedulerAdapter({ type: 'AWS', ...awsAdapterParams });
             const adapter2 = createSchedulerAdapter({ type: 'LOCAL' });
-            const adapter3 = createSchedulerAdapter({ type: 'EventBridge' });
+            const adapter3 = createSchedulerAdapter({ type: 'EventBridge', ...awsAdapterParams });
 
             expect(adapter1).toBeInstanceOf(AWSSchedulerAdapter);
             expect(adapter2).toBeInstanceOf(LocalSchedulerAdapter);
@@ -91,17 +73,29 @@ describe('Scheduler Adapter Factory', () => {
         it('should pass AWS configuration to AWS adapter', () => {
             const config = {
                 type: 'aws',
-                region: 'eu-west-1',
                 targetLambdaArn: 'arn:aws:lambda:eu-west-1:123456789012:function:test',
                 scheduleGroupName: 'custom-group',
+                roleArn: 'arn:aws:iam::123456789012:role/custom-role',
             };
 
             const adapter = createSchedulerAdapter(config);
 
             expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
-            expect(adapter.region).toBe('eu-west-1');
+            expect(adapter.region).toBe('us-east-1'); // From process.env.AWS_REGION
             expect(adapter.targetLambdaArn).toBe('arn:aws:lambda:eu-west-1:123456789012:function:test');
             expect(adapter.scheduleGroupName).toBe('custom-group');
+            expect(adapter.roleArn).toBe('arn:aws:iam::123456789012:role/custom-role');
+        });
+
+        it('should pass roleArn through to AWS adapter', () => {
+            const adapter = createSchedulerAdapter({
+                type: 'aws',
+                ...awsAdapterParams,
+                roleArn: 'arn:aws:iam::999999999999:role/scheduler-role',
+            });
+
+            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
+            expect(adapter.roleArn).toBe('arn:aws:iam::999999999999:role/scheduler-role');
         });
 
         it('should ignore AWS config for local adapter', () => {
@@ -116,142 +110,8 @@ describe('Scheduler Adapter Factory', () => {
             expect(adapter.region).toBeUndefined();
         });
 
-        it('should handle unknown adapter type by creating local adapter', () => {
-            const adapter = createSchedulerAdapter({ type: 'unknown-type' });
-
-            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
-        });
-    });
-
-    describe('detectSchedulerAdapterType()', () => {
-        it('should return "local" by default', () => {
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('local');
-        });
-
-        it('should return env SCHEDULER_ADAPTER when set', () => {
-            process.env.SCHEDULER_ADAPTER = 'aws';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('aws');
-        });
-
-        it('should return "aws" for production stage', () => {
-            process.env.STAGE = 'production';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('aws');
-        });
-
-        it('should return "aws" for prod stage', () => {
-            process.env.STAGE = 'prod';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('aws');
-        });
-
-        it('should return "aws" for staging stage', () => {
-            process.env.STAGE = 'staging';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('aws');
-        });
-
-        it('should return "aws" for stage stage', () => {
-            process.env.STAGE = 'stage';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('aws');
-        });
-
-        it('should handle case-insensitive stage values', () => {
-            process.env.STAGE = 'PRODUCTION';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('aws');
-        });
-
-        it('should return "local" for dev stage', () => {
-            process.env.STAGE = 'dev';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('local');
-        });
-
-        it('should return "local" for development stage', () => {
-            process.env.STAGE = 'development';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('local');
-        });
-
-        it('should return "local" for test stage', () => {
-            process.env.STAGE = 'test';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('local');
-        });
-
-        it('should return "local" for local stage', () => {
-            process.env.STAGE = 'local';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('local');
-        });
-
-        it('should use NODE_ENV as fallback for STAGE', () => {
-            delete process.env.STAGE;
-            process.env.NODE_ENV = 'production';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('aws');
-        });
-
-        it('should prioritize explicit SCHEDULER_ADAPTER over auto-detection', () => {
-            process.env.SCHEDULER_ADAPTER = 'local';
-            process.env.STAGE = 'production';
-
-            const type = detectSchedulerAdapterType();
-
-            expect(type).toBe('local');
-        });
-    });
-
-    describe('Integration with createSchedulerAdapter', () => {
-        it('should auto-detect and create AWS adapter in production', () => {
-            process.env.STAGE = 'production';
-
-            const adapter = createSchedulerAdapter();
-
-            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
-        });
-
-        it('should auto-detect and create local adapter in development', () => {
-            process.env.STAGE = 'development';
-
-            const adapter = createSchedulerAdapter();
-
-            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
-        });
-
-        it('should allow explicit override of auto-detection', () => {
-            process.env.STAGE = 'production';
-
-            const adapter = createSchedulerAdapter({ type: 'local' });
-
-            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+        it('should throw for unknown adapter type', () => {
+            expect(() => createSchedulerAdapter({ type: 'unknown-type' })).toThrow();
         });
     });
 });

package/src/adapters/aws-scheduler-adapter.js

@@ -25,12 +25,19 @@ function loadSchedulerSDK() {
  * Supports cron expressions, timezone configuration, and Lambda invocation.
  */
 class AWSSchedulerAdapter extends SchedulerAdapter {
-    constructor({ region, credentials, targetLambdaArn, scheduleGroupName } = {}) {
+    constructor({ credentials, targetLambdaArn, scheduleGroupName, roleArn } = {}) {
         super();
-        this.region = region || process.env.AWS_REGION || 'us-east-1';
+        if (!targetLambdaArn) throw new Error('AWSSchedulerAdapter requires targetLambdaArn');
+        if (!scheduleGroupName) throw new Error('AWSSchedulerAdapter requires scheduleGroupName');
+        if (!roleArn) throw new Error('AWSSchedulerAdapter requires roleArn');
+        // Region inherits from the service (set by Lambda runtime, same for all AWS resources)
+        const region = process.env.AWS_REGION;
+        if (!region) throw new Error('AWSSchedulerAdapter requires AWS_REGION environment variable');
+        this.region = region;
         this.credentials = credentials;
-        this.targetLambdaArn = targetLambdaArn || process.env.ADMIN_SCRIPT_LAMBDA_ARN;
-        this.scheduleGroupName = scheduleGroupName || process.env.SCHEDULE_GROUP_NAME || 'frigg-admin-scripts';
+        this.targetLambdaArn = targetLambdaArn;
+        this.scheduleGroupName = scheduleGroupName;
+        this.roleArn = roleArn;
         this.scheduler = null;
     }
 
@@ -53,7 +60,7 @@ class AWSSchedulerAdapter extends SchedulerAdapter {
         const client = this.getSchedulerClient();
         const scheduleName = `frigg-script-${scriptName}`;
 
-        const command = new CreateScheduleCommand({
+        const scheduleParams = {
             Name: scheduleName,
             GroupName: this.scheduleGroupName,
             ScheduleExpression: cronExpression,
@@ -61,7 +68,7 @@ class AWSSchedulerAdapter extends SchedulerAdapter {
             FlexibleTimeWindow: { Mode: 'OFF' },
             Target: {
                 Arn: this.targetLambdaArn,
-                RoleArn: process.env.SCHEDULER_ROLE_ARN,
+                RoleArn: this.roleArn,
                 Input: JSON.stringify({
                     scriptName,
                     trigger: 'SCHEDULED',
@@ -69,13 +76,24 @@ class AWSSchedulerAdapter extends SchedulerAdapter {
                 }),
             },
             State: 'ENABLED',
-        });
-
-        const response = await client.send(command);
-        return {
-            scheduleArn: response.ScheduleArn,
-            scheduleName: scheduleName,
         };
+
+        try {
+            const response = await client.send(new CreateScheduleCommand(scheduleParams));
+            return {
+                scheduleArn: response.ScheduleArn,
+                scheduleName: scheduleName,
+            };
+        } catch (error) {
+            if (error.name === 'ConflictException') {
+                const response = await client.send(new UpdateScheduleCommand(scheduleParams));
+                return {
+                    scheduleArn: response.ScheduleArn,
+                    scheduleName: scheduleName,
+                };
+            }
+            throw error;
+        }
     }
 
     async deleteSchedule(scriptName) {