projen-pipelines 0.2.12 → 0.2.14

package/lib/drift/detect-drift.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriftDetector = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+class DriftDetector {
+    constructor(options) {
+        this.results = [];
+        this.options = {
+            timeout: 30,
+            failOnDrift: true,
+            ...options,
+        };
+    }
+    async run() {
+        console.log(`Starting drift detection in region ${this.options.region}`);
+        try {
+            const stacks = await this.getStacksToCheck();
+            for (const stackName of stacks) {
+                await this.checkStackDrift(stackName);
+            }
+            this.printSummary();
+            this.saveResults();
+            if (this.shouldFail()) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error('Fatal error during drift detection:', error);
+            process.exit(2);
+        }
+    }
+    async getStacksToCheck() {
+        if (this.options.stackNames && this.options.stackNames.length > 0) {
+            return this.options.stackNames;
+        }
+        console.log('Getting all stacks in the region...');
+        const output = (0, child_process_1.execSync)(`aws cloudformation list-stacks --region ${this.options.region} --stack-status-filter CREATE_COMPLETE UPDATE_COMPLETE --query 'StackSummaries[].StackName' --output json`, { encoding: 'utf8' });
+        return JSON.parse(output);
+    }
+    async checkStackDrift(stackName) {
+        console.log(`\nChecking drift for stack: ${stackName}`);
+        const result = {
+            stackName,
+            driftStatus: 'NOT_CHECKED',
+        };
+        try {
+            // Start drift detection
+            const driftId = await this.startDriftDetection(stackName);
+            console.log(`Started drift detection with ID: ${driftId}`);
+            // Wait for completion
+            const driftStatus = await this.waitForDriftDetection(driftId);
+            result.driftStatus = driftStatus;
+            if (driftStatus === 'DRIFTED') {
+                result.driftedResources = await this.getDriftedResources(stackName);
+                console.log(`DRIFT DETECTED in stack ${stackName}!`);
+                // Handle known drift errors
+                result.knownErrorsHandled = await this.handleKnownDriftErrors(result.driftedResources);
+                // Print drift details
+                this.printDriftDetails(result);
+            }
+            else if (driftStatus === 'IN_SYNC') {
+                console.log(`Stack ${stackName} is in sync`);
+            }
+        }
+        catch (error) {
+            console.error(`Error checking drift for stack ${stackName}:`, error.message);
+            result.error = error.message;
+        }
+        this.results.push(result);
+    }
+    async startDriftDetection(stackName) {
+        const output = (0, child_process_1.execSync)(`aws cloudformation detect-stack-drift --stack-name ${stackName} --region ${this.options.region} --query 'StackDriftDetectionId' --output text`, { encoding: 'utf8' });
+        return output.trim();
+    }
+    async waitForDriftDetection(driftId) {
+        const timeout = this.options.timeout * 60; // Convert to seconds
+        const startTime = Date.now();
+        while (true) {
+            const elapsed = Math.floor((Date.now() - startTime) / 1000);
+            if (elapsed > timeout) {
+                throw new Error(`Drift detection timed out after ${this.options.timeout} minutes`);
+            }
+            const output = (0, child_process_1.execSync)(`aws cloudformation describe-stack-drift-detection-status --stack-drift-detection-id ${driftId} --region ${this.options.region} --output json`, { encoding: 'utf8' });
+            const status = JSON.parse(output);
+            console.log(`Drift detection status: ${status.DetectionStatus} (${elapsed}s elapsed)`);
+            if (status.DetectionStatus === 'DETECTION_COMPLETE') {
+                return status.StackDriftStatus;
+            }
+            else if (status.DetectionStatus === 'DETECTION_FAILED') {
+                throw new Error(`Drift detection failed: ${status.DetectionStatusReason}`);
+            }
+            // Wait 10 seconds before checking again
+            await new Promise(resolve => setTimeout(resolve, 10000));
+        }
+    }
+    async getDriftedResources(stackName) {
+        const output = (0, child_process_1.execSync)(`aws cloudformation describe-stack-resource-drifts --stack-name ${stackName} --region ${this.options.region} --stack-resource-drift-status-filters MODIFIED DELETED --output json`, { encoding: 'utf8' });
+        const response = JSON.parse(output);
+        return response.StackResourceDrifts.map((drift) => ({
+            logicalResourceId: drift.LogicalResourceId,
+            resourceType: drift.ResourceType,
+            stackResourceDriftStatus: drift.StackResourceDriftStatus,
+            propertyDifferences: drift.PropertyDifferences?.map((diff) => ({
+                propertyPath: diff.PropertyPath,
+                expectedValue: diff.ExpectedValue,
+                actualValue: diff.ActualValue,
+                differenceType: diff.DifferenceType,
+            })),
+        }));
+    }
+    /**
+     * Handle known drift errors for specific resources
+     * This method can be extended later to implement custom logic for known issues
+     */
+    async handleKnownDriftErrors(driftedResources) {
+        const knownErrors = [];
+        if (!driftedResources) {
+            return knownErrors;
+        }
+        for (const _resource of driftedResources) {
+            // TODO: Implement custom logic here for known drift errors
+            // Example structure for handling known errors:
+            // Check for Lambda runtime drift (common issue)
+            // if (resource.resourceType === 'AWS::Lambda::Function' && resource.propertyDifferences) {
+            //   const runtimeDrift = resource.propertyDifferences.find(diff =>
+            //     diff.propertyPath === '/Runtime' || diff.propertyPath === 'Runtime',
+            //   );
+            //   if (runtimeDrift) {
+            //     knownErrors.push({
+            //       resourceId: resource.logicalResourceId,
+            //       errorType: 'lambda-runtime-drift',
+            //       originalError: runtimeDrift,
+            //       handled: false, // Will be implemented later
+            //       message: 'Lambda runtime drift detected - manual implementation needed',
+            //     });
+            //   }
+            // }
+            // // Check for auto-scaling related drift
+            // if (resource.resourceType.includes('AutoScaling') && resource.propertyDifferences) {
+            //   knownErrors.push({
+            //     resourceId: resource.logicalResourceId,
+            //     errorType: 'autoscaling-drift',
+            //     originalError: resource.propertyDifferences,
+            //     handled: false, // Will be implemented later
+            //     message: 'Auto-scaling drift detected - manual implementation needed',
+            //   });
+            // }
+            // Add more patterns here as needed
+        }
+        return knownErrors;
+    }
+    printDriftDetails(result) {
+        if (!result.driftedResources || result.driftedResources.length === 0) {
+            return;
+        }
+        console.log('\nDrifted resources:');
+        console.log('=================');
+        for (const resource of result.driftedResources) {
+            console.log(`\n- ${resource.logicalResourceId} (${resource.resourceType})`);
+            console.log(`  Status: ${resource.stackResourceDriftStatus}`);
+            if (resource.propertyDifferences) {
+                console.log('  Property differences:');
+                for (const diff of resource.propertyDifferences) {
+                    console.log(`    ${diff.propertyPath}:`);
+                    console.log(`      Expected: ${diff.expectedValue}`);
+                    console.log(`      Actual: ${diff.actualValue}`);
+                    console.log(`      Type: ${diff.differenceType}`);
+                }
+            }
+        }
+    }
+    printSummary() {
+        console.log('\n========== DRIFT DETECTION SUMMARY ==========');
+        const driftedStacks = this.results.filter(r => r.driftStatus === 'DRIFTED');
+        const syncedStacks = this.results.filter(r => r.driftStatus === 'IN_SYNC');
+        const errorStacks = this.results.filter(r => r.error);
+        console.log(`Total stacks checked: ${this.results.length}`);
+        console.log(`In sync: ${syncedStacks.length}`);
+        console.log(`Drifted: ${driftedStacks.length}`);
+        console.log(`Errors: ${errorStacks.length}`);
+        if (driftedStacks.length > 0) {
+            console.log('\nDrifted stacks:');
+            for (const stack of driftedStacks) {
+                const resourceCount = stack.driftedResources?.length || 0;
+                console.log(`  - ${stack.stackName} (${resourceCount} resources)`);
+            }
+        }
+        if (errorStacks.length > 0) {
+            console.log('\nStacks with errors:');
+            for (const stack of errorStacks) {
+                console.log(`  - ${stack.stackName}: ${stack.error}`);
+            }
+        }
+    }
+    saveResults() {
+        const outputFile = process.env.DRIFT_DETECTION_OUTPUT || 'drift-detection-results.json';
+        (0, fs_1.writeFileSync)(outputFile, JSON.stringify(this.results, null, 2));
+        console.log(`\nResults saved to: ${outputFile}`);
+    }
+    shouldFail() {
+        if (!this.options.failOnDrift) {
+            return false;
+        }
+        return this.results.some(r => r.driftStatus === 'DRIFTED');
+    }
+}
+exports.DriftDetector = DriftDetector;
+// Parse command line arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+        region: process.env.AWS_REGION || 'us-east-1',
+    };
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case '--region':
+                options.region = args[++i];
+                break;
+            case '--stacks':
+                options.stackNames = args[++i].split(',');
+                break;
+            case '--timeout':
+                options.timeout = parseInt(args[++i]);
+                break;
+            case '--no-fail-on-drift':
+                options.failOnDrift = false;
+                break;
+            default:
+                console.error(`Unknown argument: ${args[i]}`);
+                printUsage();
+                process.exit(1);
+        }
+    }
+    return options;
+}
+function printUsage() {
+    console.log(`
+Usage: detect-drift.ts [options]
+
+Options:
+  --region <region>           AWS region (default: us-east-1 or AWS_REGION env var)
+  --stacks <stack1,stack2>    Comma-separated list of stack names (default: all stacks)
+  --timeout <minutes>         Timeout in minutes (default: 30)
+  --no-fail-on-drift         Don't exit with error code if drift is detected
+
+Environment variables:
+  AWS_REGION                  Default AWS region
+  DRIFT_DETECTION_OUTPUT      Output file path (default: drift-detection-results.json)
+`);
+}
+// Main entry point
+if (require.main === module) {
+    const options = parseArgs();
+    const detector = new DriftDetector(options);
+    detector.run().catch(console.error);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"detect-drift.js","sourceRoot":"","sources":["../../src/drift/detect-drift.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\nimport { execSync } from 'child_process';\nimport { writeFileSync } from 'fs';\n\ninterface DriftDetectionOptions {\n  region: string;\n  stackNames?: string[];\n  timeout?: number;\n  failOnDrift?: boolean;\n}\n\ninterface DriftResult {\n  stackName: string;\n  driftStatus: 'IN_SYNC' | 'DRIFTED' | 'UNKNOWN' | 'NOT_CHECKED';\n  driftedResources?: DriftedResource[];\n  error?: string;\n  knownErrorsHandled?: KnownErrorResult[];\n}\n\ninterface KnownErrorResult {\n  readonly resourceId: string;\n  readonly errorType: string;\n  readonly originalError: any;\n  readonly handled: boolean;\n  readonly message?: string;\n}\n\ninterface DriftedResource {\n  readonly logicalResourceId: string;\n  readonly resourceType: string;\n  readonly stackResourceDriftStatus: string;\n  readonly propertyDifferences?: PropertyDifference[];\n}\n\ninterface PropertyDifference {\n  readonly propertyPath: string;\n  readonly expectedValue: string;\n  readonly actualValue: string;\n  readonly differenceType: string;\n}\n\nclass DriftDetector {\n  private readonly options: DriftDetectionOptions;\n  private readonly results: DriftResult[] = [];\n\n  constructor(options: DriftDetectionOptions) {\n    this.options = {\n      timeout: 30,\n      failOnDrift: true,\n      ...options,\n    };\n  }\n\n  public async run(): Promise<void> {\n    console.log(`Starting drift detection in region ${this.options.region}`);\n\n    try {\n      const stacks = await this.getStacksToCheck();\n\n      for (const stackName of stacks) {\n        await this.checkStackDrift(stackName);\n      }\n\n      this.printSummary();\n      this.saveResults();\n\n      if (this.shouldFail()) {\n        process.exit(1);\n      }\n    } catch (error) {\n      console.error('Fatal error during drift detection:', error);\n      process.exit(2);\n    }\n  }\n\n  private async getStacksToCheck(): Promise<string[]> {\n    if (this.options.stackNames && this.options.stackNames.length > 0) {\n      return this.options.stackNames;\n    }\n\n    console.log('Getting all stacks in the region...');\n    const output = execSync(\n      `aws cloudformation list-stacks --region ${this.options.region} --stack-status-filter CREATE_COMPLETE UPDATE_COMPLETE --query 'StackSummaries[].StackName' --output json`,\n      { encoding: 'utf8' },\n    );\n\n    return JSON.parse(output);\n  }\n\n  private async checkStackDrift(stackName: string): Promise<void> {\n    console.log(`\\nChecking drift for stack: ${stackName}`);\n\n    const result: DriftResult = {\n      stackName,\n      driftStatus: 'NOT_CHECKED',\n    };\n\n    try {\n      // Start drift detection\n      const driftId = await this.startDriftDetection(stackName);\n      console.log(`Started drift detection with ID: ${driftId}`);\n\n      // Wait for completion\n      const driftStatus = await this.waitForDriftDetection(driftId);\n      result.driftStatus = driftStatus;\n\n      if (driftStatus === 'DRIFTED') {\n        result.driftedResources = await this.getDriftedResources(stackName);\n        console.log(`DRIFT DETECTED in stack ${stackName}!`);\n\n        // Handle known drift errors\n        result.knownErrorsHandled = await this.handleKnownDriftErrors(result.driftedResources);\n\n        // Print drift details\n        this.printDriftDetails(result);\n      } else if (driftStatus === 'IN_SYNC') {\n        console.log(`Stack ${stackName} is in sync`);\n      }\n    } catch (error: any) {\n      console.error(`Error checking drift for stack ${stackName}:`, error.message);\n      result.error = error.message;\n    }\n\n    this.results.push(result);\n  }\n\n  private async startDriftDetection(stackName: string): Promise<string> {\n    const output = execSync(\n      `aws cloudformation detect-stack-drift --stack-name ${stackName} --region ${this.options.region} --query 'StackDriftDetectionId' --output text`,\n      { encoding: 'utf8' },\n    );\n\n    return output.trim();\n  }\n\n  private async waitForDriftDetection(driftId: string): Promise<'IN_SYNC' | 'DRIFTED' | 'UNKNOWN' | 'NOT_CHECKED'> {\n    const timeout = this.options.timeout! * 60; // Convert to seconds\n    const startTime = Date.now();\n\n    while (true) {\n      const elapsed = Math.floor((Date.now() - startTime) / 1000);\n\n      if (elapsed > timeout) {\n        throw new Error(`Drift detection timed out after ${this.options.timeout} minutes`);\n      }\n\n      const output = execSync(\n        `aws cloudformation describe-stack-drift-detection-status --stack-drift-detection-id ${driftId} --region ${this.options.region} --output json`,\n        { encoding: 'utf8' },\n      );\n\n      const status = JSON.parse(output);\n      console.log(`Drift detection status: ${status.DetectionStatus} (${elapsed}s elapsed)`);\n\n      if (status.DetectionStatus === 'DETECTION_COMPLETE') {\n        return status.StackDriftStatus as 'IN_SYNC' | 'DRIFTED' | 'UNKNOWN' | 'NOT_CHECKED';\n      } else if (status.DetectionStatus === 'DETECTION_FAILED') {\n        throw new Error(`Drift detection failed: ${status.DetectionStatusReason}`);\n      }\n\n      // Wait 10 seconds before checking again\n      await new Promise(resolve => setTimeout(resolve, 10000));\n    }\n  }\n\n  private async getDriftedResources(stackName: string): Promise<DriftedResource[]> {\n    const output = execSync(\n      `aws cloudformation describe-stack-resource-drifts --stack-name ${stackName} --region ${this.options.region} --stack-resource-drift-status-filters MODIFIED DELETED --output json`,\n      { encoding: 'utf8' },\n    );\n\n    const response = JSON.parse(output);\n    return response.StackResourceDrifts.map((drift: any) => ({\n      logicalResourceId: drift.LogicalResourceId,\n      resourceType: drift.ResourceType,\n      stackResourceDriftStatus: drift.StackResourceDriftStatus,\n      propertyDifferences: drift.PropertyDifferences?.map((diff: any) => ({\n        propertyPath: diff.PropertyPath,\n        expectedValue: diff.ExpectedValue,\n        actualValue: diff.ActualValue,\n        differenceType: diff.DifferenceType,\n      })),\n    }));\n  }\n\n  /**\n   * Handle known drift errors for specific resources\n   * This method can be extended later to implement custom logic for known issues\n   */\n  private async handleKnownDriftErrors(driftedResources?: DriftedResource[]): Promise<KnownErrorResult[]> {\n    const knownErrors: KnownErrorResult[] = [];\n\n    if (!driftedResources) {\n      return knownErrors;\n    }\n\n    for (const _resource of driftedResources) {\n\n      // TODO: Implement custom logic here for known drift errors\n      // Example structure for handling known errors:\n\n      // Check for Lambda runtime drift (common issue)\n      // if (resource.resourceType === 'AWS::Lambda::Function' && resource.propertyDifferences) {\n      //   const runtimeDrift = resource.propertyDifferences.find(diff =>\n      //     diff.propertyPath === '/Runtime' || diff.propertyPath === 'Runtime',\n      //   );\n\n      //   if (runtimeDrift) {\n      //     knownErrors.push({\n      //       resourceId: resource.logicalResourceId,\n      //       errorType: 'lambda-runtime-drift',\n      //       originalError: runtimeDrift,\n      //       handled: false, // Will be implemented later\n      //       message: 'Lambda runtime drift detected - manual implementation needed',\n      //     });\n      //   }\n      // }\n\n      // // Check for auto-scaling related drift\n      // if (resource.resourceType.includes('AutoScaling') && resource.propertyDifferences) {\n      //   knownErrors.push({\n      //     resourceId: resource.logicalResourceId,\n      //     errorType: 'autoscaling-drift',\n      //     originalError: resource.propertyDifferences,\n      //     handled: false, // Will be implemented later\n      //     message: 'Auto-scaling drift detected - manual implementation needed',\n      //   });\n      // }\n\n      // Add more patterns here as needed\n    }\n\n    return knownErrors;\n  }\n\n  private printDriftDetails(result: DriftResult): void {\n    if (!result.driftedResources || result.driftedResources.length === 0) {\n      return;\n    }\n\n    console.log('\\nDrifted resources:');\n    console.log('=================');\n\n    for (const resource of result.driftedResources) {\n      console.log(`\\n- ${resource.logicalResourceId} (${resource.resourceType})`);\n      console.log(`  Status: ${resource.stackResourceDriftStatus}`);\n\n      if (resource.propertyDifferences) {\n        console.log('  Property differences:');\n        for (const diff of resource.propertyDifferences) {\n          console.log(`    ${diff.propertyPath}:`);\n          console.log(`      Expected: ${diff.expectedValue}`);\n          console.log(`      Actual: ${diff.actualValue}`);\n          console.log(`      Type: ${diff.differenceType}`);\n        }\n      }\n    }\n  }\n\n  private printSummary(): void {\n    console.log('\\n========== DRIFT DETECTION SUMMARY ==========');\n\n    const driftedStacks = this.results.filter(r => r.driftStatus === 'DRIFTED');\n    const syncedStacks = this.results.filter(r => r.driftStatus === 'IN_SYNC');\n    const errorStacks = this.results.filter(r => r.error);\n\n    console.log(`Total stacks checked: ${this.results.length}`);\n    console.log(`In sync: ${syncedStacks.length}`);\n    console.log(`Drifted: ${driftedStacks.length}`);\n    console.log(`Errors: ${errorStacks.length}`);\n\n    if (driftedStacks.length > 0) {\n      console.log('\\nDrifted stacks:');\n      for (const stack of driftedStacks) {\n        const resourceCount = stack.driftedResources?.length || 0;\n        console.log(`  - ${stack.stackName} (${resourceCount} resources)`);\n      }\n    }\n\n    if (errorStacks.length > 0) {\n      console.log('\\nStacks with errors:');\n      for (const stack of errorStacks) {\n        console.log(`  - ${stack.stackName}: ${stack.error}`);\n      }\n    }\n  }\n\n  private saveResults(): void {\n    const outputFile = process.env.DRIFT_DETECTION_OUTPUT || 'drift-detection-results.json';\n    writeFileSync(outputFile, JSON.stringify(this.results, null, 2));\n    console.log(`\\nResults saved to: ${outputFile}`);\n  }\n\n  private shouldFail(): boolean {\n    if (!this.options.failOnDrift) {\n      return false;\n    }\n\n    return this.results.some(r => r.driftStatus === 'DRIFTED');\n  }\n}\n\n// Parse command line arguments\nfunction parseArgs(): DriftDetectionOptions {\n  const args = process.argv.slice(2);\n  const options: DriftDetectionOptions = {\n    region: process.env.AWS_REGION || 'us-east-1',\n  };\n\n  for (let i = 0; i < args.length; i++) {\n    switch (args[i]) {\n      case '--region':\n        options.region = args[++i];\n        break;\n      case '--stacks':\n        options.stackNames = args[++i].split(',');\n        break;\n      case '--timeout':\n        options.timeout = parseInt(args[++i]);\n        break;\n      case '--no-fail-on-drift':\n        options.failOnDrift = false;\n        break;\n      default:\n        console.error(`Unknown argument: ${args[i]}`);\n        printUsage();\n        process.exit(1);\n    }\n  }\n\n  return options;\n}\n\nfunction printUsage(): void {\n  console.log(`\nUsage: detect-drift.ts [options]\n\nOptions:\n  --region <region>           AWS region (default: us-east-1 or AWS_REGION env var)\n  --stacks <stack1,stack2>    Comma-separated list of stack names (default: all stacks)\n  --timeout <minutes>         Timeout in minutes (default: 30)\n  --no-fail-on-drift         Don't exit with error code if drift is detected\n\nEnvironment variables:\n  AWS_REGION                  Default AWS region\n  DRIFT_DETECTION_OUTPUT      Output file path (default: drift-detection-results.json)\n`);\n}\n\n// Main entry point\nif (require.main === module) {\n  const options = parseArgs();\n  const detector = new DriftDetector(options);\n  detector.run().catch(console.error);\n}\n\nexport { DriftDetector, DriftDetectionOptions, DriftResult, KnownErrorResult, DriftedResource };"]}

package/lib/drift/github.d.ts

@@ -0,0 +1,21 @@
+import { Project } from 'projen';
+import { DriftDetectionWorkflow, DriftDetectionWorkflowOptions } from './base';
+export interface GitHubDriftDetectionWorkflowOptions extends DriftDetectionWorkflowOptions {
+    /**
+     * Additional permissions for GitHub workflow
+     */
+    readonly permissions?: Record<string, string>;
+    /**
+     * Whether to create issues on drift detection
+     * @default false
+     */
+    readonly createIssues?: boolean;
+}
+export declare class GitHubDriftDetectionWorkflow extends DriftDetectionWorkflow {
+    private readonly permissions?;
+    private readonly createIssues;
+    private readonly workflow;
+    constructor(project: Project, options: GitHubDriftDetectionWorkflowOptions);
+    private generateIssueCreationScript;
+    private generateSummaryScript;
+}

package/lib/drift/github.js

@@ -0,0 +1,232 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubDriftDetectionWorkflow = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+const base_1 = require("./base");
+const step_1 = require("./step");
+class GitHubDriftDetectionWorkflow extends base_1.DriftDetectionWorkflow {
+    constructor(project, options) {
+        super(project, options);
+        this.permissions = options.permissions;
+        this.createIssues = options.createIssues ?? false;
+        this.workflow = this.project.github.addWorkflow('drift-detection');
+        this.workflow.on({
+            schedule: [{
+                    cron: this.schedule,
+                }],
+            workflowDispatch: {
+                inputs: {
+                    stage: {
+                        description: 'Stage to check for drift (leave empty for all)',
+                        required: false,
+                        type: 'choice',
+                        options: this.stages.map(s => s.name),
+                    },
+                },
+            },
+        });
+        // Add job for each stage
+        for (const stage of this.stages) {
+            const jobId = `drift-${stage.name}`.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+            const driftStep = new step_1.DriftDetectionStep(this.project, stage).toGithub();
+            this.workflow.addJob(jobId, {
+                name: `Drift Detection - ${stage.name}`,
+                runsOn: ['ubuntu-latest'],
+                if: `\${{ github.event_name == 'schedule' || github.event.inputs.stage == '' || github.event.inputs.stage == '${stage.name}' }}`,
+                env: driftStep.env,
+                permissions: {
+                    contents: workflows_model_1.JobPermission.READ,
+                    ...(driftStep.permissions ?? {}),
+                    ...(this.createIssues ? { issues: workflows_model_1.JobPermission.WRITE } : {}),
+                    ...this.permissions,
+                },
+                steps: [
+                    {
+                        name: 'Checkout',
+                        uses: 'actions/checkout@v4',
+                    },
+                    {
+                        name: 'Setup Node.js',
+                        uses: 'actions/setup-node@v4',
+                        with: {
+                            'node-version': '20',
+                        },
+                    },
+                    {
+                        name: 'Install dependencies',
+                        run: 'npm ci',
+                    },
+                    ...driftStep.steps,
+                    {
+                        name: 'Upload results',
+                        uses: 'actions/upload-artifact@v4',
+                        with: {
+                            name: `drift-results-${stage.name}`,
+                            path: `drift-results-${stage.name}.json`,
+                        },
+                    },
+                    ...(this.createIssues ? [{
+                            name: 'Create Issue on Drift',
+                            if: 'steps.drift.outcome == \'failure\' && github.event_name == \'schedule\'',
+                            uses: 'actions/github-script@v7',
+                            with: {
+                                script: this.generateIssueCreationScript(stage),
+                            },
+                        }] : []),
+                ],
+            });
+        }
+        // Add summary job
+        if (this.stages.length > 0) {
+            this.workflow.addJob('drift-summary', {
+                name: 'Drift Detection Summary',
+                runsOn: ['ubuntu-latest'],
+                permissions: {
+                    contents: workflows_model_1.JobPermission.READ,
+                },
+                needs: this.stages.map(stage => `drift-${stage.name}`),
+                steps: [
+                    {
+                        name: 'Download all artifacts',
+                        uses: 'actions/download-artifact@v4',
+                        with: {
+                            path: 'drift-results',
+                        },
+                    },
+                    {
+                        name: 'Generate summary',
+                        run: this.generateSummaryScript(),
+                    },
+                ],
+            });
+        }
+    }
+    generateIssueCreationScript(stage) {
+        return `
+const fs = require('fs');
+const resultsFile = 'drift-results-${stage.name}.json';
+
+if (!fs.existsSync(resultsFile)) {
+  console.log('No results file found');
+  return;
+}
+
+const results = JSON.parse(fs.readFileSync(resultsFile, 'utf8'));
+const driftedStacks = results.filter(r => r.driftStatus === 'DRIFTED');
+
+if (driftedStacks.length === 0) {
+  console.log('No drift detected');
+  return;
+}
+
+const title = 'Drift Detected in ${stage.name}';
+const body = \`## Drift Detection Report
+
+**Stage:** ${stage.name}
+**Region:** ${stage.region}
+**Time:** \${new Date().toISOString()}
+
+### Summary
+- Total stacks checked: \${results.length}
+- Drifted stacks: \${driftedStacks.length}
+
+### Drifted Stacks
+\${driftedStacks.map(stack => {
+  const resources = stack.driftedResources || [];
+  return \`#### \${stack.stackName}
+- Drifted resources: \${resources.length}
+\${resources.map(r => \`  - \${r.logicalResourceId} (\${r.resourceType})\`).join('\\n')}
+\`;
+}).join('\\n')}
+
+### Action Required
+Please review the drifted resources and either:
+1. Update the infrastructure code to match the actual state
+2. Restore the resources to match the expected state
+
+[View workflow run](\${context.serverUrl}/\${context.repo.owner}/\${context.repo.repo}/actions/runs/\${context.runId})
+\`;
+
+// Check if issue already exists
+const issues = await github.rest.issues.listForRepo({
+  owner: context.repo.owner,
+  repo: context.repo.repo,
+  state: 'open',
+  labels: ['drift-detection', '${stage.name}'],
+});
+
+if (issues.data.length === 0) {
+  await github.rest.issues.create({
+    owner: context.repo.owner,
+    repo: context.repo.repo,
+    title,
+    body,
+    labels: ['drift-detection', '${stage.name}'],
+  });
+} else {
+  // Update existing issue
+  const issue = issues.data[0];
+  await github.rest.issues.createComment({
+    owner: context.repo.owner,
+    repo: context.repo.repo,
+    issue_number: issue.number,
+    body: body,
+  });
+}
+`;
+    }
+    generateSummaryScript() {
+        return `
+#!/bin/bash
+echo "## Drift Detection Summary" >> $GITHUB_STEP_SUMMARY
+echo "" >> $GITHUB_STEP_SUMMARY
+
+total_stacks=0
+total_drifted=0
+total_errors=0
+
+for file in drift-results-*.json; do
+  if [[ -f "$file" ]]; then
+    stage=$(basename $(dirname "$file"))
+    echo "### Stage: $stage" >> $GITHUB_STEP_SUMMARY
+    
+    # Parse JSON and generate summary
+    jq -r '
+      . as $results |
+      "- Total stacks: " + ($results | length | tostring) + "\\n" +
+      "- Drifted: " + ([$results[] | select(.driftStatus == "DRIFTED")] | length | tostring) + "\\n" +
+      "- Errors: " + ([$results[] | select(.error)] | length | tostring) + "\\n" +
+      ([$results[] | select(.driftStatus == "DRIFTED")] | 
+        if length > 0 then
+          "\\n**Drifted stacks:**\\n" + 
+          (map("  - " + .stackName + " (" + ((.driftedResources // []) | length | tostring) + " resources)") | join("\\n"))
+        else "" end)
+    ' "$file" >> $GITHUB_STEP_SUMMARY
+    
+    echo "" >> $GITHUB_STEP_SUMMARY
+    
+    # Count totals
+    total_stacks=$((total_stacks + $(jq 'length' "$file")))
+    total_drifted=$((total_drifted + $(jq '[.[] | select(.driftStatus == "DRIFTED")] | length' "$file")))
+    total_errors=$((total_errors + $(jq '[.[] | select(.error)] | length' "$file")))
+  fi
+done
+
+echo "### Overall Summary" >> $GITHUB_STEP_SUMMARY
+echo "- Total stacks checked: $total_stacks" >> $GITHUB_STEP_SUMMARY
+echo "- Total drifted stacks: $total_drifted" >> $GITHUB_STEP_SUMMARY
+echo "- Total errors: $total_errors" >> $GITHUB_STEP_SUMMARY
+
+if [[ $total_drifted -gt 0 ]]; then
+  echo "" >> $GITHUB_STEP_SUMMARY
+  echo "⚠️ **Action required:** Drift detected in $total_drifted stacks" >> $GITHUB_STEP_SUMMARY
+fi
+`;
+    }
+}
+exports.GitHubDriftDetectionWorkflow = GitHubDriftDetectionWorkflow;
+_a = JSII_RTTI_SYMBOL_1;
+GitHubDriftDetectionWorkflow[_a] = { fqn: "projen-pipelines.GitHubDriftDetectionWorkflow", version: "0.2.14" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"github.js","sourceRoot":"","sources":["../../src/drift/github.ts"],"names":[],"mappings":"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","sourcesContent":["import { Project } from 'projen';\nimport { GitHubProject, GithubWorkflow } from 'projen/lib/github';\nimport { JobPermission } from 'projen/lib/github/workflows-model';\nimport { DriftDetectionWorkflow, DriftDetectionWorkflowOptions, DriftDetectionStageOptions } from './base';\nimport { DriftDetectionStep } from './step';\n\nexport interface GitHubDriftDetectionWorkflowOptions extends DriftDetectionWorkflowOptions {\n  /**\n   * Additional permissions for GitHub workflow\n   */\n  readonly permissions?: Record<string, string>;\n\n  /**\n   * Whether to create issues on drift detection\n   * @default false\n   */\n  readonly createIssues?: boolean;\n}\n\nexport class GitHubDriftDetectionWorkflow extends DriftDetectionWorkflow {\n  private readonly permissions?: Record<string, string>;\n  private readonly createIssues: boolean;\n  private readonly workflow: GithubWorkflow;\n\n  constructor(project: Project, options: GitHubDriftDetectionWorkflowOptions) {\n    super(project, options);\n    this.permissions = options.permissions;\n    this.createIssues = options.createIssues ?? false;\n\n    this.workflow = (this.project as GitHubProject).github!.addWorkflow('drift-detection');\n    this.workflow.on({\n      schedule: [{\n        cron: this.schedule,\n      }],\n      workflowDispatch: {\n        inputs: {\n          stage: {\n            description: 'Stage to check for drift (leave empty for all)',\n            required: false,\n            type: 'choice',\n            options: this.stages.map(s => s.name),\n          },\n        },\n      },\n    });\n\n    // Add job for each stage\n    for (const stage of this.stages) {\n      const jobId = `drift-${stage.name}`.toLowerCase().replace(/[^a-z0-9-]/g, '-');\n\n      const driftStep = new DriftDetectionStep(this.project, stage).toGithub();\n\n      this.workflow.addJob(jobId, {\n        name: `Drift Detection - ${stage.name}`,\n        runsOn: ['ubuntu-latest'],\n        if: `\\${{ github.event_name == 'schedule' || github.event.inputs.stage == '' || github.event.inputs.stage == '${stage.name}' }}`,\n        env: driftStep.env,\n        permissions: {\n          contents: JobPermission.READ,\n          ...(driftStep.permissions ?? {}),\n          ...(this.createIssues ? { issues: JobPermission.WRITE } : {}),\n          ...this.permissions,\n        },\n        steps: [\n          {\n            name: 'Checkout',\n            uses: 'actions/checkout@v4',\n          },\n          {\n            name: 'Setup Node.js',\n            uses: 'actions/setup-node@v4',\n            with: {\n              'node-version': '20',\n            },\n          },\n          {\n            name: 'Install dependencies',\n            run: 'npm ci',\n          },\n          ...driftStep.steps,\n          {\n            name: 'Upload results',\n            uses: 'actions/upload-artifact@v4',\n            with: {\n              name: `drift-results-${stage.name}`,\n              path: `drift-results-${stage.name}.json`,\n            },\n          },\n          ...(this.createIssues ? [{\n            name: 'Create Issue on Drift',\n            if: 'steps.drift.outcome == \\'failure\\' && github.event_name == \\'schedule\\'',\n            uses: 'actions/github-script@v7',\n            with: {\n              script: this.generateIssueCreationScript(stage),\n            },\n          }] : []),\n        ],\n      });\n    }\n\n    // Add summary job\n    if (this.stages.length > 0) {\n      this.workflow.addJob('drift-summary', {\n        name: 'Drift Detection Summary',\n        runsOn: ['ubuntu-latest'],\n        permissions: {\n          contents: JobPermission.READ,\n        },\n        needs: this.stages.map(stage => `drift-${stage.name}`),\n        steps: [\n          {\n            name: 'Download all artifacts',\n            uses: 'actions/download-artifact@v4',\n            with: {\n              path: 'drift-results',\n            },\n          },\n          {\n            name: 'Generate summary',\n            run: this.generateSummaryScript(),\n          },\n        ],\n      });\n    }\n  }\n\n  private generateIssueCreationScript(stage: DriftDetectionStageOptions): string {\n    return `\nconst fs = require('fs');\nconst resultsFile = 'drift-results-${stage.name}.json';\n\nif (!fs.existsSync(resultsFile)) {\n  console.log('No results file found');\n  return;\n}\n\nconst results = JSON.parse(fs.readFileSync(resultsFile, 'utf8'));\nconst driftedStacks = results.filter(r => r.driftStatus === 'DRIFTED');\n\nif (driftedStacks.length === 0) {\n  console.log('No drift detected');\n  return;\n}\n\nconst title = 'Drift Detected in ${stage.name}';\nconst body = \\`## Drift Detection Report\n\n**Stage:** ${stage.name}\n**Region:** ${stage.region}\n**Time:** \\${new Date().toISOString()}\n\n### Summary\n- Total stacks checked: \\${results.length}\n- Drifted stacks: \\${driftedStacks.length}\n\n### Drifted Stacks\n\\${driftedStacks.map(stack => {\n  const resources = stack.driftedResources || [];\n  return \\`#### \\${stack.stackName}\n- Drifted resources: \\${resources.length}\n\\${resources.map(r => \\`  - \\${r.logicalResourceId} (\\${r.resourceType})\\`).join('\\\\n')}\n\\`;\n}).join('\\\\n')}\n\n### Action Required\nPlease review the drifted resources and either:\n1. Update the infrastructure code to match the actual state\n2. Restore the resources to match the expected state\n\n[View workflow run](\\${context.serverUrl}/\\${context.repo.owner}/\\${context.repo.repo}/actions/runs/\\${context.runId})\n\\`;\n\n// Check if issue already exists\nconst issues = await github.rest.issues.listForRepo({\n  owner: context.repo.owner,\n  repo: context.repo.repo,\n  state: 'open',\n  labels: ['drift-detection', '${stage.name}'],\n});\n\nif (issues.data.length === 0) {\n  await github.rest.issues.create({\n    owner: context.repo.owner,\n    repo: context.repo.repo,\n    title,\n    body,\n    labels: ['drift-detection', '${stage.name}'],\n  });\n} else {\n  // Update existing issue\n  const issue = issues.data[0];\n  await github.rest.issues.createComment({\n    owner: context.repo.owner,\n    repo: context.repo.repo,\n    issue_number: issue.number,\n    body: body,\n  });\n}\n`;\n  }\n\n  private generateSummaryScript(): string {\n    return `\n#!/bin/bash\necho \"## Drift Detection Summary\" >> $GITHUB_STEP_SUMMARY\necho \"\" >> $GITHUB_STEP_SUMMARY\n\ntotal_stacks=0\ntotal_drifted=0\ntotal_errors=0\n\nfor file in drift-results-*.json; do\n  if [[ -f \"$file\" ]]; then\n    stage=$(basename $(dirname \"$file\"))\n    echo \"### Stage: $stage\" >> $GITHUB_STEP_SUMMARY\n    \n    # Parse JSON and generate summary\n    jq -r '\n      . as $results |\n      \"- Total stacks: \" + ($results | length | tostring) + \"\\\\n\" +\n      \"- Drifted: \" + ([$results[] | select(.driftStatus == \"DRIFTED\")] | length | tostring) + \"\\\\n\" +\n      \"- Errors: \" + ([$results[] | select(.error)] | length | tostring) + \"\\\\n\" +\n      ([$results[] | select(.driftStatus == \"DRIFTED\")] | \n        if length > 0 then\n          \"\\\\n**Drifted stacks:**\\\\n\" + \n          (map(\"  - \" + .stackName + \" (\" + ((.driftedResources // []) | length | tostring) + \" resources)\") | join(\"\\\\n\"))\n        else \"\" end)\n    ' \"$file\" >> $GITHUB_STEP_SUMMARY\n    \n    echo \"\" >> $GITHUB_STEP_SUMMARY\n    \n    # Count totals\n    total_stacks=$((total_stacks + $(jq 'length' \"$file\")))\n    total_drifted=$((total_drifted + $(jq '[.[] | select(.driftStatus == \"DRIFTED\")] | length' \"$file\")))\n    total_errors=$((total_errors + $(jq '[.[] | select(.error)] | length' \"$file\")))\n  fi\ndone\n\necho \"### Overall Summary\" >> $GITHUB_STEP_SUMMARY\necho \"- Total stacks checked: $total_stacks\" >> $GITHUB_STEP_SUMMARY\necho \"- Total drifted stacks: $total_drifted\" >> $GITHUB_STEP_SUMMARY\necho \"- Total errors: $total_errors\" >> $GITHUB_STEP_SUMMARY\n\nif [[ $total_drifted -gt 0 ]]; then\n  echo \"\" >> $GITHUB_STEP_SUMMARY\n  echo \"⚠️ **Action required:** Drift detected in $total_drifted stacks\" >> $GITHUB_STEP_SUMMARY\nfi\n`;\n  }\n\n}"]}

package/lib/drift/gitlab.d.ts

@@ -0,0 +1,20 @@
+import { Project } from 'projen';
+import { DriftDetectionWorkflow, DriftDetectionWorkflowOptions } from './base';
+export interface GitLabDriftDetectionWorkflowOptions extends DriftDetectionWorkflowOptions {
+    /**
+     * GitLab runner tags
+     */
+    readonly runnerTags?: string[];
+    /**
+     * Docker image to use for drift detection
+     * @default "node:18"
+     */
+    readonly image?: string;
+}
+export declare class GitLabDriftDetectionWorkflow extends DriftDetectionWorkflow {
+    private readonly runnerTags;
+    private readonly image;
+    private readonly config;
+    constructor(project: Project, options: GitLabDriftDetectionWorkflowOptions);
+    private generateSummaryScript;
+}