@mavogel/cdk-vscode-server 0.0.60 → 0.0.62

package/lib/idle-monitor/idle-monitor.lambda.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const client_cloudwatch_1 = require("@aws-sdk/client-cloudwatch");
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const cloudwatch = new client_cloudwatch_1.CloudWatchClient({});
+const ec2 = new client_ec2_1.EC2Client({});
+const INSTANCE_ID = process.env.INSTANCE_ID;
+const DISTRIBUTION_ID = process.env.DISTRIBUTION_ID;
+const IDLE_TIMEOUT_MINUTES = parseInt(process.env.IDLE_TIMEOUT_MINUTES || '30');
+const handler = async (event) => {
+    console.log('IdleMonitor triggered', { event, INSTANCE_ID, DISTRIBUTION_ID, IDLE_TIMEOUT_MINUTES });
+    try {
+        // 1. Get CloudFront request count for the idle timeout period
+        const endTime = new Date();
+        const startTime = new Date(endTime.getTime() - IDLE_TIMEOUT_MINUTES * 60 * 1000);
+        const metricsCommand = new client_cloudwatch_1.GetMetricStatisticsCommand({
+            Namespace: 'AWS/CloudFront',
+            MetricName: 'Requests',
+            Dimensions: [
+                {
+                    Name: 'DistributionId',
+                    Value: DISTRIBUTION_ID,
+                },
+            ],
+            StartTime: startTime,
+            EndTime: endTime,
+            Period: IDLE_TIMEOUT_MINUTES * 60,
+            Statistics: ['Sum'],
+        });
+        const metricsResponse = await cloudwatch.send(metricsCommand);
+        const requestCount = metricsResponse.Datapoints?.[0]?.Sum || 0;
+        console.log('CloudFront request count:', requestCount);
+        // 2. Get current instance state
+        const describeCommand = new client_ec2_1.DescribeInstancesCommand({
+            InstanceIds: [INSTANCE_ID],
+        });
+        const describeResponse = await ec2.send(describeCommand);
+        const instanceState = describeResponse.Reservations?.[0]?.Instances?.[0]?.State?.Name;
+        console.log('Current instance state:', instanceState);
+        // 3. Skip if instance is in a transitional state (starting, stopping, pending)
+        const transitionalStates = ['pending', 'stopping', 'shutting-down', 'rebooting'];
+        if (transitionalStates.includes(instanceState || '')) {
+            console.log(`Instance is in transitional state '${instanceState}', skipping idle check`);
+            return;
+        }
+        // 3.1 Skip if instance status checks are failing or initializing
+        // Can be disabled for integration tests via SKIP_STATUS_CHECKS env var
+        if (instanceState === 'running' && process.env.SKIP_STATUS_CHECKS !== 'true') {
+            const statusCommand = new client_ec2_1.DescribeInstanceStatusCommand({
+                InstanceIds: [INSTANCE_ID],
+                IncludeAllInstances: false, // Only return running instances with status info
+            });
+            const statusResponse = await ec2.send(statusCommand);
+            const instanceStatus = statusResponse.InstanceStatuses?.[0];
+            if (instanceStatus) {
+                const systemStatus = instanceStatus.SystemStatus?.Status;
+                const instanceCheckStatus = instanceStatus.InstanceStatus?.Status;
+                console.log('Instance status checks:', {
+                    systemStatus,
+                    instanceCheckStatus,
+                });
+                // Skip if any status check is not 'ok'
+                if (systemStatus !== 'ok' || instanceCheckStatus !== 'ok') {
+                    console.log('Instance status checks are not passing, skipping idle check');
+                    return;
+                }
+            }
+            else {
+                // No status information available yet (instance just started)
+                console.log('Instance status information not available yet, skipping idle check');
+                return;
+            }
+        }
+        else if (process.env.SKIP_STATUS_CHECKS === 'true' && instanceState === 'running') {
+            console.log('Status check verification skipped (SKIP_STATUS_CHECKS=true)');
+        }
+        // 4. If no requests and instance is running, stop it
+        if (requestCount === 0 && instanceState === 'running') {
+            console.log('No activity detected, stopping instance');
+            const stopCommand = new client_ec2_1.StopInstancesCommand({
+                InstanceIds: [INSTANCE_ID],
+            });
+            await ec2.send(stopCommand);
+            console.log('Instance stopped successfully');
+        }
+        else if (requestCount > 0) {
+            console.log('Activity detected, instance will remain running');
+        }
+    }
+    catch (error) {
+        console.error('Error in IdleMonitor:', error);
+        throw error;
+    }
+};
+exports.handler = handler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"idle-monitor.lambda.js","sourceRoot":"","sources":["../../src/idle-monitor/idle-monitor.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import { CloudWatchClient, GetMetricStatisticsCommand } from '@aws-sdk/client-cloudwatch';\nimport { EC2Client, DescribeInstancesCommand, DescribeInstanceStatusCommand, StopInstancesCommand } from '@aws-sdk/client-ec2';\nimport type { ScheduledEvent } from 'aws-lambda';\n\nconst cloudwatch = new CloudWatchClient({});\nconst ec2 = new EC2Client({});\n\nconst INSTANCE_ID = process.env.INSTANCE_ID!;\nconst DISTRIBUTION_ID = process.env.DISTRIBUTION_ID!;\nconst IDLE_TIMEOUT_MINUTES = parseInt(process.env.IDLE_TIMEOUT_MINUTES || '30');\n\nexport const handler = async (event: ScheduledEvent): Promise<void> => {\n  console.log('IdleMonitor triggered', { event, INSTANCE_ID, DISTRIBUTION_ID, IDLE_TIMEOUT_MINUTES });\n\n  try {\n    // 1. Get CloudFront request count for the idle timeout period\n    const endTime = new Date();\n    const startTime = new Date(endTime.getTime() - IDLE_TIMEOUT_MINUTES * 60 * 1000);\n\n    const metricsCommand = new GetMetricStatisticsCommand({\n      Namespace: 'AWS/CloudFront',\n      MetricName: 'Requests',\n      Dimensions: [\n        {\n          Name: 'DistributionId',\n          Value: DISTRIBUTION_ID,\n        },\n      ],\n      StartTime: startTime,\n      EndTime: endTime,\n      Period: IDLE_TIMEOUT_MINUTES * 60,\n      Statistics: ['Sum'],\n    });\n\n    const metricsResponse = await cloudwatch.send(metricsCommand);\n    const requestCount = metricsResponse.Datapoints?.[0]?.Sum || 0;\n\n    console.log('CloudFront request count:', requestCount);\n\n    // 2. Get current instance state\n    const describeCommand = new DescribeInstancesCommand({\n      InstanceIds: [INSTANCE_ID],\n    });\n    const describeResponse = await ec2.send(describeCommand);\n    const instanceState = describeResponse.Reservations?.[0]?.Instances?.[0]?.State?.Name;\n\n    console.log('Current instance state:', instanceState);\n\n    // 3. Skip if instance is in a transitional state (starting, stopping, pending)\n    const transitionalStates = ['pending', 'stopping', 'shutting-down', 'rebooting'];\n    if (transitionalStates.includes(instanceState || '')) {\n      console.log(`Instance is in transitional state '${instanceState}', skipping idle check`);\n      return;\n    }\n\n    // 3.1 Skip if instance status checks are failing or initializing\n    // Can be disabled for integration tests via SKIP_STATUS_CHECKS env var\n    if (instanceState === 'running' && process.env.SKIP_STATUS_CHECKS !== 'true') {\n      const statusCommand = new DescribeInstanceStatusCommand({\n        InstanceIds: [INSTANCE_ID],\n        IncludeAllInstances: false, // Only return running instances with status info\n      });\n      const statusResponse = await ec2.send(statusCommand);\n      const instanceStatus = statusResponse.InstanceStatuses?.[0];\n\n      if (instanceStatus) {\n        const systemStatus = instanceStatus.SystemStatus?.Status;\n        const instanceCheckStatus = instanceStatus.InstanceStatus?.Status;\n\n        console.log('Instance status checks:', {\n          systemStatus,\n          instanceCheckStatus,\n        });\n\n        // Skip if any status check is not 'ok'\n        if (systemStatus !== 'ok' || instanceCheckStatus !== 'ok') {\n          console.log('Instance status checks are not passing, skipping idle check');\n          return;\n        }\n      } else {\n        // No status information available yet (instance just started)\n        console.log('Instance status information not available yet, skipping idle check');\n        return;\n      }\n    } else if (process.env.SKIP_STATUS_CHECKS === 'true' && instanceState === 'running') {\n      console.log('Status check verification skipped (SKIP_STATUS_CHECKS=true)');\n    }\n\n    // 4. If no requests and instance is running, stop it\n    if (requestCount === 0 && instanceState === 'running') {\n      console.log('No activity detected, stopping instance');\n\n      const stopCommand = new StopInstancesCommand({\n        InstanceIds: [INSTANCE_ID],\n      });\n      await ec2.send(stopCommand);\n\n      console.log('Instance stopped successfully');\n    } else if (requestCount > 0) {\n      console.log('Activity detected, instance will remain running');\n    }\n  } catch (error) {\n    console.error('Error in IdleMonitor:', error);\n    throw error;\n  }\n};\n"]}

package/lib/index.d.ts

@@ -1 +1,3 @@
 export * from './vscode-server';
+export * from './idle-monitor/idle-monitor';
+export * from './status-check/status-check';

package/lib/index.js

@@ -15,4 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./vscode-server"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGtEQUFnQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdnNjb2RlLXNlcnZlcic7XG4iXX0=
+__exportStar(require("./idle-monitor/idle-monitor"), exports);
+__exportStar(require("./status-check/status-check"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGtEQUFnQztBQUNoQyw4REFBNEM7QUFDNUMsOERBQTRDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi92c2NvZGUtc2VydmVyJztcbmV4cG9ydCAqIGZyb20gJy4vaWRsZS1tb25pdG9yL2lkbGUtbW9uaXRvcic7XG5leHBvcnQgKiBmcm9tICcuL3N0YXR1cy1jaGVjay9zdGF0dXMtY2hlY2snO1xuIl19

package/lib/status-check/status-check-function.d.ts

@@ -0,0 +1,13 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for StatusCheckFunction
+ */
+export interface StatusCheckFunctionProps extends lambda.FunctionOptions {
+}
+/**
+ * An AWS Lambda function which executes src/status-check/status-check.
+ */
+export declare class StatusCheckFunction extends lambda.Function {
+    constructor(scope: Construct, id: string, props?: StatusCheckFunctionProps);
+}

package/lib/status-check/status-check-function.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCheckFunction = void 0;
+// ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+const path = require("path");
+const lambda = require("aws-cdk-lib/aws-lambda");
+/**
+ * An AWS Lambda function which executes src/status-check/status-check.
+ */
+class StatusCheckFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/status-check/status-check.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs20.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../assets/status-check/status-check.lambda')),
+        });
+    }
+}
+exports.StatusCheckFunction = StatusCheckFunction;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/status-check/status-check.d.ts

@@ -0,0 +1,36 @@
+import { RestApi } from 'aws-cdk-lib/aws-apigateway';
+import { ITable } from 'aws-cdk-lib/aws-dynamodb';
+import { IInstance } from 'aws-cdk-lib/aws-ec2';
+import { Function as LambdaFunction } from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for StatusCheckApi construct
+ */
+export interface StatusCheckApiProps {
+    /**
+     * The EC2 instance to check status for
+     */
+    readonly instance: IInstance;
+    /**
+     * DynamoDB table for tracking instance state
+     */
+    readonly stateTable: ITable;
+}
+/**
+ * API Gateway endpoint for checking instance status, used by resume page for polling
+ */
+export declare class StatusCheckApi extends Construct {
+    /**
+     * The API Gateway REST API
+     */
+    readonly api: RestApi;
+    /**
+     * The URL of the status check API endpoint
+     */
+    readonly apiUrl: string;
+    /**
+     * The Lambda function that handles status check requests
+     */
+    readonly function: LambdaFunction;
+    constructor(scope: Construct, id: string, props: StatusCheckApiProps);
+}

package/lib/status-check/status-check.js

@@ -0,0 +1,109 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCheckApi = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const cdk_nag_1 = require("cdk-nag");
+const constructs_1 = require("constructs");
+/**
+ * API Gateway endpoint for checking instance status, used by resume page for polling
+ */
+class StatusCheckApi extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.function = new aws_lambda_1.Function(this, 'Function', {
+            runtime: aws_lambda_1.Runtime.NODEJS_20_X,
+            handler: 'index.handler',
+            code: aws_lambda_1.Code.fromAsset(path.join(__dirname, '../../assets/status-check/status-check.lambda')),
+            timeout: aws_cdk_lib_1.Duration.seconds(10),
+            memorySize: 128,
+            environment: {
+                TABLE_NAME: props.stateTable.tableName,
+            },
+        });
+        // Grant permissions
+        props.stateTable.grantReadWriteData(this.function);
+        this.function.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: [
+                'ec2:DescribeInstanceStatus',
+                'ec2:DescribeInstances',
+                'ec2:StartInstances', // Allow starting instances for resume functionality
+            ],
+            resources: [
+                `arn:aws:ec2:${aws_cdk_lib_1.Stack.of(this).region}:${aws_cdk_lib_1.Stack.of(this).account}:instance/${props.instance.instanceId}`,
+            ],
+        }));
+        // Create API Gateway
+        this.api = new aws_apigateway_1.RestApi(this, 'Api', {
+            restApiName: 'VSCodeStatusCheckApi',
+            description: 'API for checking VS Code Server instance status',
+            defaultCorsPreflightOptions: {
+                allowOrigins: aws_apigateway_1.Cors.ALL_ORIGINS,
+                allowMethods: aws_apigateway_1.Cors.ALL_METHODS,
+            },
+        });
+        const statusResource = this.api.root.addResource('status');
+        const instanceResource = statusResource.addResource('{instanceId}');
+        // GET /status/{instanceId} - Check instance status
+        instanceResource.addMethod('GET', new aws_apigateway_1.LambdaIntegration(this.function));
+        // POST /status/{instanceId}/start - Start stopped instance
+        const startResource = instanceResource.addResource('start');
+        startResource.addMethod('POST', new aws_apigateway_1.LambdaIntegration(this.function));
+        this.apiUrl = this.api.url;
+        // CDK-nag suppressions
+        cdk_nag_1.NagSuppressions.addResourceSuppressions(this.function, [
+            {
+                id: 'AwsSolutions-IAM4',
+                reason: 'Managed policies acceptable for workshop Lambda functions',
+            },
+            {
+                id: 'AwsSolutions-L1',
+                reason: 'Latest runtime not required for this function',
+            },
+        ], true);
+        cdk_nag_1.NagSuppressions.addResourceSuppressions(this.api, [
+            {
+                id: 'AwsSolutions-APIG2',
+                reason: 'Request validation not required for this simple API',
+            },
+            {
+                id: 'AwsSolutions-IAM4',
+                reason: 'Managed policies acceptable for workshop API Gateway',
+            },
+            {
+                id: 'AwsSolutions-APIG4',
+                reason: 'Authorization not required for status check endpoint',
+            },
+            {
+                id: 'AwsSolutions-COG4',
+                reason: 'Cognito not required for this workshop API',
+            },
+            {
+                id: 'AwsSolutions-APIG1',
+                reason: 'Access logging not required for workshop environment',
+            },
+            {
+                id: 'AwsSolutions-APIG3',
+                reason: 'WAF not required for this workshop API',
+            },
+            {
+                id: 'AwsSolutions-APIG6',
+                reason: 'CloudWatch logging not required for workshop environment',
+            },
+            {
+                id: 'AwsSolutions-IAM5',
+                reason: 'Wildcard permissions acceptable for workshop API Gateway execution role',
+                appliesTo: ['Resource::*'],
+            },
+        ], true);
+    }
+}
+exports.StatusCheckApi = StatusCheckApi;
+_a = JSII_RTTI_SYMBOL_1;
+StatusCheckApi[_a] = { fqn: "@mavogel/cdk-vscode-server.StatusCheckApi", version: "0.0.62" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status-check.js","sourceRoot":"","sources":["../../src/status-check/status-check.ts"],"names":[],"mappings":";;;;;AAAA,6BAA6B;AAC7B,6CAA8C;AAC9C,+DAA8E;AAG9E,iDAAsD;AACtD,uDAAmF;AACnF,qCAA0C;AAC1C,2CAAuC;AAgBvC;;GAEG;AACH,MAAa,cAAe,SAAQ,sBAAS;IAc3C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA0B;QAClE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,QAAQ,GAAG,IAAI,qBAAc,CAAC,IAAI,EAAE,UAAU,EAAE;YACnD,OAAO,EAAE,oBAAO,CAAC,WAAW;YAC5B,OAAO,EAAE,eAAe;YACxB,IAAI,EAAE,iBAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,+CAA+C,CAAC,CAAC;YAC3F,OAAO,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7B,UAAU,EAAE,GAAG;YACf,WAAW,EAAE;gBACX,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,SAAS;aACvC;SACF,CAAC,CAAC;QAEH,oBAAoB;QACpB,KAAK,CAAC,UAAU,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEnD,IAAI,CAAC,QAAQ,CAAC,eAAe,CAC3B,IAAI,yBAAe,CAAC;YAClB,OAAO,EAAE;gBACP,4BAA4B;gBAC5B,uBAAuB;gBACvB,oBAAoB,EAAE,oDAAoD;aAC3E;YACD,SAAS,EAAE;gBACT,eAAe,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,IAAI,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,aAAa,KAAK,CAAC,QAAQ,CAAC,UAAU,EAAE;aACvG;SACF,CAAC,CACH,CAAC;QAEF,qBAAqB;QACrB,IAAI,CAAC,GAAG,GAAG,IAAI,wBAAO,CAAC,IAAI,EAAE,KAAK,EAAE;YAClC,WAAW,EAAE,sBAAsB;YACnC,WAAW,EAAE,iDAAiD;YAC9D,2BAA2B,EAAE;gBAC3B,YAAY,EAAE,qBAAI,CAAC,WAAW;gBAC9B,YAAY,EAAE,qBAAI,CAAC,WAAW;aAC/B;SACF,CAAC,CAAC;QAEH,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC3D,MAAM,gBAAgB,GAAG,cAAc,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;QAEpE,mDAAmD;QACnD,gBAAgB,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,kCAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QAExE,2DAA2D;QAC3D,MAAM,aAAa,GAAG,gBAAgB,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC5D,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,kCAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QAEtE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;QAE3B,uBAAuB;QACvB,yBAAe,CAAC,uBAAuB,CACrC,IAAI,CAAC,QAAQ,EACb;YACE;gBACE,EAAE,EAAE,mBAAmB;gBACvB,MAAM,EAAE,2DAA2D;aACpE;YACD;gBACE,EAAE,EAAE,iBAAiB;gBACrB,MAAM,EAAE,+CAA+C;aACxD;SACF,EACD,IAAI,CACL,CAAC;QAEF,yBAAe,CAAC,uBAAuB,CACrC,IAAI,CAAC,GAAG,EACR;YACE;gBACE,EAAE,EAAE,oBAAoB;gBACxB,MAAM,EAAE,qDAAqD;aAC9D;YACD;gBACE,EAAE,EAAE,mBAAmB;gBACvB,MAAM,EAAE,sDAAsD;aAC/D;YACD;gBACE,EAAE,EAAE,oBAAoB;gBACxB,MAAM,EAAE,sDAAsD;aAC/D;YACD;gBACE,EAAE,EAAE,mBAAmB;gBACvB,MAAM,EAAE,4CAA4C;aACrD;YACD;gBACE,EAAE,EAAE,oBAAoB;gBACxB,MAAM,EAAE,sDAAsD;aAC/D;YACD;gBACE,EAAE,EAAE,oBAAoB;gBACxB,MAAM,EAAE,wCAAwC;aACjD;YACD;gBACE,EAAE,EAAE,oBAAoB;gBACxB,MAAM,EAAE,0DAA0D;aACnE;YACD;gBACE,EAAE,EAAE,mBAAmB;gBACvB,MAAM,EAAE,yEAAyE;gBACjF,SAAS,EAAE,CAAC,aAAa,CAAC;aAC3B;SACF,EACD,IAAI,CACL,CAAC;IACJ,CAAC;;AAzHH,wCA0HC","sourcesContent":["import * as path from 'path';\nimport { Duration, Stack } from 'aws-cdk-lib';\nimport { RestApi, LambdaIntegration, Cors } from 'aws-cdk-lib/aws-apigateway';\nimport { ITable } from 'aws-cdk-lib/aws-dynamodb';\nimport { IInstance } from 'aws-cdk-lib/aws-ec2';\nimport { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Runtime, Code, Function as LambdaFunction } from 'aws-cdk-lib/aws-lambda';\nimport { NagSuppressions } from 'cdk-nag';\nimport { Construct } from 'constructs';\n\n/**\n * Props for StatusCheckApi construct\n */\nexport interface StatusCheckApiProps {\n  /**\n   * The EC2 instance to check status for\n   */\n  readonly instance: IInstance;\n  /**\n   * DynamoDB table for tracking instance state\n   */\n  readonly stateTable: ITable;\n}\n\n/**\n * API Gateway endpoint for checking instance status, used by resume page for polling\n */\nexport class StatusCheckApi extends Construct {\n  /**\n   * The API Gateway REST API\n   */\n  public readonly api: RestApi;\n  /**\n   * The URL of the status check API endpoint\n   */\n  public readonly apiUrl: string;\n  /**\n   * The Lambda function that handles status check requests\n   */\n  public readonly function: LambdaFunction;\n\n  constructor(scope: Construct, id: string, props: StatusCheckApiProps) {\n    super(scope, id);\n\n    this.function = new LambdaFunction(this, 'Function', {\n      runtime: Runtime.NODEJS_20_X,\n      handler: 'index.handler',\n      code: Code.fromAsset(path.join(__dirname, '../../assets/status-check/status-check.lambda')),\n      timeout: Duration.seconds(10),\n      memorySize: 128,\n      environment: {\n        TABLE_NAME: props.stateTable.tableName,\n      },\n    });\n\n    // Grant permissions\n    props.stateTable.grantReadWriteData(this.function);\n\n    this.function.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          'ec2:DescribeInstanceStatus',\n          'ec2:DescribeInstances',\n          'ec2:StartInstances', // Allow starting instances for resume functionality\n        ],\n        resources: [\n          `arn:aws:ec2:${Stack.of(this).region}:${Stack.of(this).account}:instance/${props.instance.instanceId}`,\n        ],\n      }),\n    );\n\n    // Create API Gateway\n    this.api = new RestApi(this, 'Api', {\n      restApiName: 'VSCodeStatusCheckApi',\n      description: 'API for checking VS Code Server instance status',\n      defaultCorsPreflightOptions: {\n        allowOrigins: Cors.ALL_ORIGINS,\n        allowMethods: Cors.ALL_METHODS,\n      },\n    });\n\n    const statusResource = this.api.root.addResource('status');\n    const instanceResource = statusResource.addResource('{instanceId}');\n\n    // GET /status/{instanceId} - Check instance status\n    instanceResource.addMethod('GET', new LambdaIntegration(this.function));\n\n    // POST /status/{instanceId}/start - Start stopped instance\n    const startResource = instanceResource.addResource('start');\n    startResource.addMethod('POST', new LambdaIntegration(this.function));\n\n    this.apiUrl = this.api.url;\n\n    // CDK-nag suppressions\n    NagSuppressions.addResourceSuppressions(\n      this.function,\n      [\n        {\n          id: 'AwsSolutions-IAM4',\n          reason: 'Managed policies acceptable for workshop Lambda functions',\n        },\n        {\n          id: 'AwsSolutions-L1',\n          reason: 'Latest runtime not required for this function',\n        },\n      ],\n      true,\n    );\n\n    NagSuppressions.addResourceSuppressions(\n      this.api,\n      [\n        {\n          id: 'AwsSolutions-APIG2',\n          reason: 'Request validation not required for this simple API',\n        },\n        {\n          id: 'AwsSolutions-IAM4',\n          reason: 'Managed policies acceptable for workshop API Gateway',\n        },\n        {\n          id: 'AwsSolutions-APIG4',\n          reason: 'Authorization not required for status check endpoint',\n        },\n        {\n          id: 'AwsSolutions-COG4',\n          reason: 'Cognito not required for this workshop API',\n        },\n        {\n          id: 'AwsSolutions-APIG1',\n          reason: 'Access logging not required for workshop environment',\n        },\n        {\n          id: 'AwsSolutions-APIG3',\n          reason: 'WAF not required for this workshop API',\n        },\n        {\n          id: 'AwsSolutions-APIG6',\n          reason: 'CloudWatch logging not required for workshop environment',\n        },\n        {\n          id: 'AwsSolutions-IAM5',\n          reason: 'Wildcard permissions acceptable for workshop API Gateway execution role',\n          appliesTo: ['Resource::*'],\n        },\n      ],\n      true,\n    );\n  }\n}\n"]}

package/lib/status-check/status-check.lambda.d.ts

@@ -0,0 +1,2 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+export declare const handler: (event: APIGatewayProxyEvent) => Promise<APIGatewayProxyResult>;

package/lib/status-check/status-check.lambda.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const ec2 = new client_ec2_1.EC2Client({});
+const ddbClient = new client_dynamodb_1.DynamoDBClient({});
+const ddb = lib_dynamodb_1.DynamoDBDocumentClient.from(ddbClient);
+const TABLE_NAME = process.env.TABLE_NAME;
+const handler = async (event) => {
+    console.log('StatusCheck/Start triggered', { event });
+    const instanceId = event.pathParameters?.instanceId;
+    const isStartRequest = event.resource?.includes('/start') && event.httpMethod === 'POST';
+    if (!instanceId) {
+        return {
+            statusCode: 400,
+            headers: {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*',
+            },
+            body: JSON.stringify({ error: 'Missing instanceId' }),
+        };
+    }
+    try {
+        // Handle POST /status/{instanceId}/start - Start instance
+        if (isStartRequest) {
+            console.log('Starting instance:', instanceId);
+            const startCommand = new client_ec2_1.StartInstancesCommand({
+                InstanceIds: [instanceId],
+            });
+            await ec2.send(startCommand);
+            // Update DynamoDB state
+            await ddb.send(new lib_dynamodb_1.UpdateCommand({
+                TableName: TABLE_NAME,
+                Key: { instanceId },
+                UpdateExpression: 'SET instanceState = :state, lastActivityTime = :time',
+                ExpressionAttributeValues: {
+                    ':state': 'starting',
+                    ':time': new Date().toISOString(),
+                },
+            }));
+            return {
+                statusCode: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                },
+                body: JSON.stringify({
+                    message: 'Instance start initiated',
+                    state: 'starting',
+                    instanceId,
+                }),
+            };
+        }
+        // Handle GET /status/{instanceId} - Check status
+        const statusCommand = new client_ec2_1.DescribeInstanceStatusCommand({
+            InstanceIds: [instanceId],
+            IncludeAllInstances: true,
+        });
+        const statusResponse = await ec2.send(statusCommand);
+        const instanceStatus = statusResponse.InstanceStatuses?.[0];
+        const state = instanceStatus?.InstanceState?.Name || 'unknown';
+        console.log('Instance state:', state);
+        // If running, update DynamoDB
+        if (state === 'running') {
+            await ddb.send(new lib_dynamodb_1.UpdateCommand({
+                TableName: TABLE_NAME,
+                Key: { instanceId },
+                UpdateExpression: 'SET instanceState = :state, lastActivityTime = :time',
+                ExpressionAttributeValues: {
+                    ':state': 'running',
+                    ':time': new Date().toISOString(),
+                },
+            }));
+        }
+        return {
+            statusCode: 200,
+            headers: {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*',
+                'Cache-Control': 'no-cache, no-store, must-revalidate',
+            },
+            body: JSON.stringify({
+                state,
+                ready: state === 'running',
+                instanceId,
+            }),
+        };
+    }
+    catch (error) {
+        console.error('Error in status check/start:', error);
+        return {
+            statusCode: 500,
+            headers: {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*',
+            },
+            body: JSON.stringify({ error: 'Internal server error' }),
+        };
+    }
+};
+exports.handler = handler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status-check.lambda.js","sourceRoot":"","sources":["../../src/status-check/status-check.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import { DynamoDBClient } from '@aws-sdk/client-dynamodb';\nimport { EC2Client, DescribeInstanceStatusCommand, StartInstancesCommand } from '@aws-sdk/client-ec2';\nimport { DynamoDBDocumentClient, UpdateCommand } from '@aws-sdk/lib-dynamodb';\nimport type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';\n\nconst ec2 = new EC2Client({});\nconst ddbClient = new DynamoDBClient({});\nconst ddb = DynamoDBDocumentClient.from(ddbClient);\n\nconst TABLE_NAME = process.env.TABLE_NAME!;\n\nexport const handler = async (\n  event: APIGatewayProxyEvent,\n): Promise<APIGatewayProxyResult> => {\n  console.log('StatusCheck/Start triggered', { event });\n\n  const instanceId = event.pathParameters?.instanceId;\n  const isStartRequest = event.resource?.includes('/start') && event.httpMethod === 'POST';\n\n  if (!instanceId) {\n    return {\n      statusCode: 400,\n      headers: {\n        'Content-Type': 'application/json',\n        'Access-Control-Allow-Origin': '*',\n      },\n      body: JSON.stringify({ error: 'Missing instanceId' }),\n    };\n  }\n\n  try {\n    // Handle POST /status/{instanceId}/start - Start instance\n    if (isStartRequest) {\n      console.log('Starting instance:', instanceId);\n\n      const startCommand = new StartInstancesCommand({\n        InstanceIds: [instanceId],\n      });\n\n      await ec2.send(startCommand);\n\n      // Update DynamoDB state\n      await ddb.send(new UpdateCommand({\n        TableName: TABLE_NAME,\n        Key: { instanceId },\n        UpdateExpression: 'SET instanceState = :state, lastActivityTime = :time',\n        ExpressionAttributeValues: {\n          ':state': 'starting',\n          ':time': new Date().toISOString(),\n        },\n      }));\n\n      return {\n        statusCode: 200,\n        headers: {\n          'Content-Type': 'application/json',\n          'Access-Control-Allow-Origin': '*',\n        },\n        body: JSON.stringify({\n          message: 'Instance start initiated',\n          state: 'starting',\n          instanceId,\n        }),\n      };\n    }\n\n    // Handle GET /status/{instanceId} - Check status\n    const statusCommand = new DescribeInstanceStatusCommand({\n      InstanceIds: [instanceId],\n      IncludeAllInstances: true,\n    });\n\n    const statusResponse = await ec2.send(statusCommand);\n    const instanceStatus = statusResponse.InstanceStatuses?.[0];\n    const state = instanceStatus?.InstanceState?.Name || 'unknown';\n\n    console.log('Instance state:', state);\n\n    // If running, update DynamoDB\n    if (state === 'running') {\n      await ddb.send(new UpdateCommand({\n        TableName: TABLE_NAME,\n        Key: { instanceId },\n        UpdateExpression: 'SET instanceState = :state, lastActivityTime = :time',\n        ExpressionAttributeValues: {\n          ':state': 'running',\n          ':time': new Date().toISOString(),\n        },\n      }));\n    }\n\n    return {\n      statusCode: 200,\n      headers: {\n        'Content-Type': 'application/json',\n        'Access-Control-Allow-Origin': '*',\n        'Cache-Control': 'no-cache, no-store, must-revalidate',\n      },\n      body: JSON.stringify({\n        state,\n        ready: state === 'running',\n        instanceId,\n      }),\n    };\n  } catch (error) {\n    console.error('Error in status check/start:', error);\n\n    return {\n      statusCode: 500,\n      headers: {\n        'Content-Type': 'application/json',\n        'Access-Control-Allow-Origin': '*',\n      },\n      body: JSON.stringify({ error: 'Internal server error' }),\n    };\n  }\n};\n"]}

package/lib/vscode-server.d.ts

@@ -1,6 +1,7 @@
 import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import { Construct } from 'constructs';
+import { IdleMonitor } from './idle-monitor/idle-monitor';
 /**
  * Properties for the VSCodeServer construct
  */
@@ -118,6 +119,39 @@ export interface VSCodeServerProps {
      * @default false
      */
     readonly autoCreateCertificate?: boolean;
+    /**
+     * Enable automatic instance stop when idle
+     * Monitors CloudFront metrics and stops the EC2 instance after specified idle time
+     *
+     * @default false
+     */
+    readonly enableAutoStop?: boolean;
+    /**
+     * Minutes of inactivity before stopping the instance
+     * Only applies when enableAutoStop is true
+     *
+     * @default 30
+     */
+    readonly idleTimeoutMinutes?: number;
+    /**
+     * How often to check for idle activity (in minutes)
+     * Only applies when enableAutoStop is true
+     *
+     * @default 5 - Check every 5 minutes
+     */
+    readonly idleCheckIntervalMinutes?: number;
+    /**
+     * Skip instance status checks in IdleMonitor
+     * When true, IdleMonitor will stop idle instances even if status checks haven't passed
+     * This is useful for integration tests where status check initialization time
+     * exceeds the test timeout limits
+     *
+     * WARNING: For testing only - in production, you should wait for status checks
+     * to pass before stopping instances to avoid stopping unhealthy instances
+     *
+     * @default false
+     */
+    readonly skipStatusChecks?: boolean;
 }
 /**
  * The flavor of linux you want to run vscode server on
@@ -161,5 +195,13 @@ export declare class VSCodeServer extends Construct {
      * The password to login to the server
      */
     readonly password: string;
+    /**
+     * The EC2 instance running VS Code Server
+     */
+    readonly instance: ec2.IInstance;
+    /**
+     * The IdleMonitor construct (only present if enableAutoStop is true)
+     */
+    readonly idleMonitor?: IdleMonitor;
     constructor(scope: Construct, id: string, props?: VSCodeServerProps);
 }