@friggframework/admin-scripts 2.0.0--canary.517.41839c5.0

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

@@ -0,0 +1,49 @@
+const { createAdminScriptCommands } = require('@friggframework/core/application/commands/admin-script-commands');
+
+/**
+ * Admin API Key Authentication Middleware
+ *
+ * Validates admin API keys for script endpoints.
+ * Expects: Authorization: Bearer <api-key>
+ */
+async function adminAuthMiddleware(req, res, next) {
+    try {
+        const authHeader = req.headers.authorization;
+
+        if (!authHeader || !authHeader.startsWith('Bearer ')) {
+            return res.status(401).json({
+                error: 'Missing or invalid Authorization header',
+                code: 'MISSING_AUTH'
+            });
+        }
+
+        const apiKey = authHeader.substring(7); // Remove 'Bearer '
+        const commands = createAdminScriptCommands();
+        const result = await commands.validateAdminApiKey(apiKey);
+
+        if (result.error) {
+            return res.status(result.error).json({
+                error: result.reason,
+                code: result.code
+            });
+        }
+
+        // Attach validated key info to request for audit trail
+        req.adminApiKey = result.apiKey;
+        req.adminAudit = {
+            apiKeyName: result.apiKey.name,
+            apiKeyLast4: result.apiKey.keyLast4,
+            ipAddress: req.ip || req.connection?.remoteAddress || 'unknown'
+        };
+
+        next();
+    } catch (error) {
+        console.error('Admin auth middleware error:', error);
+        res.status(500).json({
+            error: 'Authentication failed',
+            code: 'AUTH_ERROR'
+        });
+    }
+}
+
+module.exports = { adminAuthMiddleware };

package/src/infrastructure/admin-script-router.js

@@ -0,0 +1,311 @@
+const express = require('express');
+const serverless = require('serverless-http');
+const { adminAuthMiddleware } = require('./admin-auth-middleware');
+const { getScriptFactory } = require('../application/script-factory');
+const { createScriptRunner } = require('../application/script-runner');
+const { createAdminScriptCommands } = require('@friggframework/core/application/commands/admin-script-commands');
+const { QueuerUtil } = require('@friggframework/core/queues');
+const { createSchedulerAdapter } = require('../adapters/scheduler-adapter-factory');
+const { ScheduleManagementUseCase } = require('../application/schedule-management-use-case');
+
+const router = express.Router();
+
+// Apply auth middleware to all admin routes
+router.use(adminAuthMiddleware);
+
+/**
+ * Create ScheduleManagementUseCase instance
+ * @private
+ */
+function createScheduleManagementUseCase() {
+    return new ScheduleManagementUseCase({
+        commands: createAdminScriptCommands(),
+        schedulerAdapter: createSchedulerAdapter(),
+        scriptFactory: getScriptFactory(),
+    });
+}
+
+/**
+ * GET /admin/scripts
+ * List all registered scripts
+ */
+router.get('/scripts', async (req, res) => {
+    try {
+        const factory = getScriptFactory();
+        const scripts = factory.getAll();
+
+        res.json({
+            scripts: scripts.map((s) => ({
+                name: s.name,
+                version: s.definition.version,
+                description: s.definition.description,
+                category: s.definition.display?.category || 'custom',
+                requiresIntegrationFactory:
+                    s.definition.config?.requiresIntegrationFactory || false,
+                schedule: s.definition.schedule || null,
+            })),
+        });
+    } catch (error) {
+        console.error('Error listing scripts:', error);
+        res.status(500).json({ error: 'Failed to list scripts' });
+    }
+});
+
+/**
+ * GET /admin/scripts/:scriptName
+ * Get script details
+ */
+router.get('/scripts/:scriptName', async (req, res) => {
+    try {
+        const { scriptName } = req.params;
+        const factory = getScriptFactory();
+
+        if (!factory.has(scriptName)) {
+            return res.status(404).json({
+                error: `Script "${scriptName}" not found`,
+                code: 'SCRIPT_NOT_FOUND',
+            });
+        }
+
+        const scriptClass = factory.get(scriptName);
+        const definition = scriptClass.Definition;
+
+        res.json({
+            name: definition.name,
+            version: definition.version,
+            description: definition.description,
+            inputSchema: definition.inputSchema,
+            outputSchema: definition.outputSchema,
+            config: definition.config,
+            display: definition.display,
+            schedule: definition.schedule,
+        });
+    } catch (error) {
+        console.error('Error getting script:', error);
+        res.status(500).json({ error: 'Failed to get script details' });
+    }
+});
+
+/**
+ * POST /admin/scripts/:scriptName/execute
+ * Execute a script (sync, async, or dry-run)
+ */
+router.post('/scripts/:scriptName/execute', async (req, res) => {
+    try {
+        const { scriptName } = req.params;
+        const { params = {}, mode = 'async', dryRun = false } = req.body;
+        const factory = getScriptFactory();
+
+        if (!factory.has(scriptName)) {
+            return res.status(404).json({
+                error: `Script "${scriptName}" not found`,
+                code: 'SCRIPT_NOT_FOUND',
+            });
+        }
+
+        // Dry-run always executes synchronously
+        if (dryRun) {
+            const runner = createScriptRunner();
+            const result = await runner.execute(scriptName, params, {
+                trigger: 'MANUAL',
+                mode: 'sync',
+                dryRun: true,
+                audit: req.adminAudit,
+            });
+            return res.json(result);
+        }
+
+        if (mode === 'sync') {
+            // Synchronous execution - wait for result
+            const runner = createScriptRunner();
+            const result = await runner.execute(scriptName, params, {
+                trigger: 'MANUAL',
+                mode: 'sync',
+                audit: req.adminAudit,
+            });
+            return res.json(result);
+        }
+
+        // Async execution - queue and return immediately
+        const commands = createAdminScriptCommands();
+        const execution = await commands.createScriptExecution({
+            scriptName,
+            scriptVersion: factory.get(scriptName).Definition.version,
+            trigger: 'MANUAL',
+            mode: 'async',
+            input: params,
+            audit: req.adminAudit,
+        });
+
+        // Queue the execution
+        await QueuerUtil.send(
+            {
+                scriptName,
+                executionId: execution.id,
+                trigger: 'MANUAL',
+                params,
+            },
+            process.env.ADMIN_SCRIPT_QUEUE_URL
+        );
+
+        res.status(202).json({
+            executionId: execution.id,
+            status: 'PENDING',
+            scriptName,
+            message: 'Script queued for execution',
+        });
+    } catch (error) {
+        console.error('Error executing script:', error);
+        res.status(500).json({ error: 'Failed to execute script' });
+    }
+});
+
+/**
+ * GET /admin/executions/:executionId
+ * Get execution status
+ */
+router.get('/executions/:executionId', async (req, res) => {
+    try {
+        const { executionId } = req.params;
+        const commands = createAdminScriptCommands();
+        const execution = await commands.findScriptExecutionById(executionId);
+
+        if (execution.error) {
+            return res.status(execution.error).json({
+                error: execution.reason,
+                code: execution.code,
+            });
+        }
+
+        res.json(execution);
+    } catch (error) {
+        console.error('Error getting execution:', error);
+        res.status(500).json({ error: 'Failed to get execution' });
+    }
+});
+
+/**
+ * GET /admin/executions
+ * List recent executions
+ */
+router.get('/executions', async (req, res) => {
+    try {
+        const { scriptName, status, limit = 50 } = req.query;
+        const commands = createAdminScriptCommands();
+
+        const executions = await commands.findRecentExecutions({
+            scriptName,
+            status,
+            limit: Number.parseInt(limit, 10),
+        });
+
+        res.json({ executions });
+    } catch (error) {
+        console.error('Error listing executions:', error);
+        res.status(500).json({ error: 'Failed to list executions' });
+    }
+});
+
+/**
+ * GET /admin/scripts/:scriptName/schedule
+ * Get effective schedule (DB override > Definition default > none)
+ */
+router.get('/scripts/:scriptName/schedule', async (req, res) => {
+    try {
+        const { scriptName } = req.params;
+        const useCase = createScheduleManagementUseCase();
+
+        const result = await useCase.getEffectiveSchedule(scriptName);
+
+        res.json({
+            source: result.source,
+            scriptName,
+            ...result.schedule,
+        });
+    } catch (error) {
+        if (error.code === 'SCRIPT_NOT_FOUND') {
+            return res.status(404).json({
+                error: error.message,
+                code: error.code,
+            });
+        }
+        console.error('Error getting schedule:', error);
+        res.status(500).json({ error: 'Failed to get schedule' });
+    }
+});
+
+/**
+ * PUT /admin/scripts/:scriptName/schedule
+ * Create or update schedule override
+ */
+router.put('/scripts/:scriptName/schedule', async (req, res) => {
+    try {
+        const { scriptName } = req.params;
+        const { enabled, cronExpression, timezone } = req.body;
+        const useCase = createScheduleManagementUseCase();
+
+        const result = await useCase.upsertSchedule(scriptName, {
+            enabled,
+            cronExpression,
+            timezone,
+        });
+
+        res.json({
+            success: result.success,
+            schedule: {
+                source: 'database',
+                ...result.schedule,
+            },
+            ...(result.schedulerWarning && { schedulerWarning: result.schedulerWarning }),
+        });
+    } catch (error) {
+        if (error.code === 'SCRIPT_NOT_FOUND') {
+            return res.status(404).json({
+                error: error.message,
+                code: error.code,
+            });
+        }
+        if (error.code === 'INVALID_INPUT') {
+            return res.status(400).json({
+                error: error.message,
+                code: error.code,
+            });
+        }
+        console.error('Error updating schedule:', error);
+        res.status(500).json({ error: 'Failed to update schedule' });
+    }
+});
+
+/**
+ * DELETE /admin/scripts/:scriptName/schedule
+ * Remove schedule override (revert to Definition default)
+ */
+router.delete('/scripts/:scriptName/schedule', async (req, res) => {
+    try {
+        const { scriptName } = req.params;
+        const useCase = createScheduleManagementUseCase();
+
+        const result = await useCase.deleteSchedule(scriptName);
+
+        res.json(result);
+    } catch (error) {
+        if (error.code === 'SCRIPT_NOT_FOUND') {
+            return res.status(404).json({
+                error: error.message,
+                code: error.code,
+            });
+        }
+        console.error('Error deleting schedule:', error);
+        res.status(500).json({ error: 'Failed to delete schedule' });
+    }
+});
+
+// Create Express app
+const app = express();
+app.use(express.json());
+app.use('/admin', router);
+
+// Export for Lambda
+const handler = serverless(app);
+
+module.exports = { router, app, handler };

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

@@ -0,0 +1,75 @@
+const { createScriptRunner } = require('../application/script-runner');
+const { createAdminScriptCommands } = require('@friggframework/core/application/commands/admin-script-commands');
+
+/**
+ * SQS Queue Worker Lambda Handler
+ *
+ * Processes script execution messages from AdminScriptQueue
+ */
+async function handler(event) {
+    const results = [];
+
+    for (const record of event.Records) {
+        const message = JSON.parse(record.body);
+        const { scriptName, executionId, trigger, params } = message;
+
+        console.log(`Processing script: ${scriptName}, executionId: ${executionId}`);
+
+        try {
+            const runner = createScriptRunner();
+            const commands = createAdminScriptCommands();
+
+            // If executionId provided (async from API), update existing record
+            if (executionId) {
+                await commands.updateScriptExecutionStatus(executionId, 'RUNNING');
+            }
+
+            const result = await runner.execute(scriptName, params, {
+                trigger: trigger || 'QUEUE',
+                mode: 'async',
+                executionId, // Reuse existing if provided
+            });
+
+            console.log(
+                `Script completed: ${scriptName}, status: ${result.status}`
+            );
+            results.push({
+                scriptName,
+                status: result.status,
+                executionId: result.executionId,
+            });
+        } catch (error) {
+            console.error(`Script failed: ${scriptName}`, error);
+
+            // Try to update execution status if we have an ID
+            if (executionId) {
+                const commands = createAdminScriptCommands();
+                await commands
+                    .completeScriptExecution(executionId, {
+                        status: 'FAILED',
+                        error: {
+                            name: error.name,
+                            message: error.message,
+                            stack: error.stack,
+                        },
+                    })
+                    .catch((e) =>
+                        console.error('Failed to update execution:', e)
+                    );
+            }
+
+            results.push({
+                scriptName,
+                status: 'FAILED',
+                error: error.message,
+            });
+        }
+    }
+
+    return {
+        statusCode: 200,
+        body: JSON.stringify({ processed: results.length, results }),
+    };
+}
+
+module.exports = { handler };