@mavogel/cdk-vscode-server 0.0.59 → 0.0.61

package/assets/idle-monitor/idle-monitor.lambda/index.js

@@ -0,0 +1,110 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/idle-monitor/idle-monitor.lambda.ts
+var idle_monitor_lambda_exports = {};
+__export(idle_monitor_lambda_exports, {
+  handler: () => handler
+});
+module.exports = __toCommonJS(idle_monitor_lambda_exports);
+var import_client_cloudwatch = require("@aws-sdk/client-cloudwatch");
+var import_client_ec2 = require("@aws-sdk/client-ec2");
+var cloudwatch = new import_client_cloudwatch.CloudWatchClient({});
+var ec2 = new import_client_ec2.EC2Client({});
+var INSTANCE_ID = process.env.INSTANCE_ID;
+var DISTRIBUTION_ID = process.env.DISTRIBUTION_ID;
+var IDLE_TIMEOUT_MINUTES = parseInt(process.env.IDLE_TIMEOUT_MINUTES || "30");
+var handler = async (event) => {
+  console.log("IdleMonitor triggered", { event, INSTANCE_ID, DISTRIBUTION_ID, IDLE_TIMEOUT_MINUTES });
+  try {
+    const endTime = /* @__PURE__ */ new Date();
+    const startTime = new Date(endTime.getTime() - IDLE_TIMEOUT_MINUTES * 60 * 1e3);
+    const metricsCommand = new import_client_cloudwatch.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);
+    const describeCommand = new import_client_ec2.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);
+    const transitionalStates = ["pending", "stopping", "shutting-down", "rebooting"];
+    if (transitionalStates.includes(instanceState || "")) {
+      console.log(`Instance is in transitional state '${instanceState}', skipping idle check`);
+      return;
+    }
+    if (instanceState === "running" && process.env.SKIP_STATUS_CHECKS !== "true") {
+      const statusCommand = new import_client_ec2.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
+        });
+        if (systemStatus !== "ok" || instanceCheckStatus !== "ok") {
+          console.log("Instance status checks are not passing, skipping idle check");
+          return;
+        }
+      } else {
+        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)");
+    }
+    if (requestCount === 0 && instanceState === "running") {
+      console.log("No activity detected, stopping instance");
+      const stopCommand = new import_client_ec2.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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handler
+});

package/assets/status-check/status-check.lambda/index.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/status-check/status-check.lambda.ts
+var status_check_lambda_exports = {};
+__export(status_check_lambda_exports, {
+  handler: () => handler
+});
+module.exports = __toCommonJS(status_check_lambda_exports);
+var import_client_dynamodb = require("@aws-sdk/client-dynamodb");
+var import_client_ec2 = require("@aws-sdk/client-ec2");
+var import_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
+var ec2 = new import_client_ec2.EC2Client({});
+var ddbClient = new import_client_dynamodb.DynamoDBClient({});
+var ddb = import_lib_dynamodb.DynamoDBDocumentClient.from(ddbClient);
+var TABLE_NAME = process.env.TABLE_NAME;
+var 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 {
+    if (isStartRequest) {
+      console.log("Starting instance:", instanceId);
+      const startCommand = new import_client_ec2.StartInstancesCommand({
+        InstanceIds: [instanceId]
+      });
+      await ec2.send(startCommand);
+      await ddb.send(new import_lib_dynamodb.UpdateCommand({
+        TableName: TABLE_NAME,
+        Key: { instanceId },
+        UpdateExpression: "SET instanceState = :state, lastActivityTime = :time",
+        ExpressionAttributeValues: {
+          ":state": "starting",
+          ":time": (/* @__PURE__ */ 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
+        })
+      };
+    }
+    const statusCommand = new import_client_ec2.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 (state === "running") {
+      await ddb.send(new import_lib_dynamodb.UpdateCommand({
+        TableName: TABLE_NAME,
+        Key: { instanceId },
+        UpdateExpression: "SET instanceState = :state, lastActivityTime = :time",
+        ExpressionAttributeValues: {
+          ":state": "running",
+          ":time": (/* @__PURE__ */ 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" })
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handler
+});

package/examples/auto-stop/main.ts

@@ -0,0 +1,75 @@
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+import {
+  LinuxArchitectureType,
+  LinuxFlavorType,
+  VSCodeServer,
+} from '../../src/index';
+
+/**
+ * Example: VS Code Server with Auto-Stop Functionality
+ *
+ * This example demonstrates how to configure automatic instance stopping
+ * to save costs when the VS Code Server is idle.
+ *
+ * Cost Savings:
+ * - Without auto-stop: m7g.xlarge running 24/7 = ~$120/month
+ * - With auto-stop (8 hours/day, 5 days/week): ~$30/month
+ * - Savings: ~$90/month (75% reduction)
+ *
+ * How it works:
+ * 1. CloudWatch monitors request metrics from CloudFront
+ * 2. EventBridge triggers IdleMonitor Lambda every 5 minutes (configurable)
+ * 3. If no requests detected for 30 minutes (configurable), instance stops
+ * 4. Elastic IP ensures consistent addressing across stop/start cycles
+ * 5. Manual restart via AWS Console or CLI when needed
+ *
+ * Note: This is ideal for development and workshop environments where
+ * the server is not actively used 24/7.
+ */
+export class AutoStopExampleStack extends Stack {
+  constructor(scope: Construct, id: string, props: StackProps = {}) {
+    super(scope, id, props);
+
+    new VSCodeServer(this, 'vscode-auto-stop', {
+      // Instance configuration
+      instanceClass: ec2.InstanceClass.M7G,
+      instanceSize: ec2.InstanceSize.XLARGE,
+      instanceVolumeSize: 40,
+      instanceOperatingSystem: LinuxFlavorType.UBUNTU_22,
+      instanceCpuArchitecture: LinuxArchitectureType.ARM,
+
+      // 🔥 Auto-Stop Configuration
+      enableAutoStop: true, // Enable automatic instance stop when idle
+
+      // Stop instance after 30 minutes of no activity (default)
+      // Adjust based on your usage patterns:
+      // - Development: 15-30 minutes
+      // - Workshops: 30-60 minutes
+      // - Demo environments: 60-120 minutes
+      idleTimeoutMinutes: 30,
+
+      // Check for idle activity every 5 minutes (default)
+      // Lower values = faster detection but more Lambda invocations
+      // Higher values = slower detection but fewer Lambda invocations
+      idleCheckIntervalMinutes: 5,
+
+      // Additional configuration
+      additionalTags: {
+        Environment: 'Development',
+        CostCenter: 'Engineering',
+        AutoStop: 'Enabled',
+      },
+    });
+  }
+}
+
+const env = {
+  account: process.env.CDK_DEFAULT_ACCOUNT || '123456789012',
+  region: process.env.CDK_DEFAULT_REGION || 'eu-west-1',
+};
+
+const app = new App();
+new AutoStopExampleStack(app, 'vscode-auto-stop-example', { env });
+app.synth();

package/integ-tests/functions/idle-test-handler.ts

@@ -0,0 +1,178 @@
+import { EC2Client, DescribeInstancesCommand, StartInstancesCommand } from '@aws-sdk/client-ec2';
+import { EventBridgeClient, DisableRuleCommand } from '@aws-sdk/client-eventbridge';
+
+const ec2 = new EC2Client({});
+const eventBridge = new EventBridgeClient({});
+
+interface IdleTestEvent {
+  testPhase: 'verify-auto-stop' | 'disable-idle-monitor' | 'start-instance';
+  domainName?: string;
+  instanceId?: string;
+  idleTimeoutMinutes?: number;
+  idleMonitorRuleName?: string;
+}
+
+/**
+ * Integration test handler for stop-on-idle functionality
+ *
+ * This Lambda function tests the stop-on-idle workflow:
+ * 1. verify-auto-stop: Instance stops after being idle
+ * 2. disable-idle-monitor: Disable EventBridge rule to prevent re-stopping
+ * 3. start-instance: Start the instance and wait for running state
+ *
+ * Note: Login verification is handled by a separate login-handler Lambda
+ */
+export const handler = async (event: IdleTestEvent): Promise<string> => {
+  console.log('Idle test event:', JSON.stringify(event, null, 2));
+
+  const { testPhase, instanceId, idleTimeoutMinutes = 5, idleMonitorRuleName } = event;
+
+  try {
+    if (testPhase === 'verify-auto-stop') {
+      if (!instanceId) throw new Error('instanceId is required for verify-auto-stop');
+      return await verifyAutoStop(instanceId, idleTimeoutMinutes);
+    } else if (testPhase === 'disable-idle-monitor') {
+      if (!idleMonitorRuleName) throw new Error('idleMonitorRuleName is required for disable-idle-monitor');
+      return await disableIdleMonitor(idleMonitorRuleName);
+    } else if (testPhase === 'start-instance') {
+      if (!instanceId) throw new Error('instanceId is required for start-instance');
+      return await startInstance(instanceId);
+    } else {
+      throw new Error(`Unknown test phase: ${testPhase}`);
+    }
+  } catch (error) {
+    console.error('Test failed:', error);
+    throw error;
+  }
+};
+
+/**
+ * Verify auto-stop functionality
+ *
+ * Test flow:
+ * 1. Wait for instance to be in 'running' state (if not already)
+ * 2. Poll for 'stopped' state as IdleMonitor detects inactivity
+ *
+ * How IdleMonitor works with skipStatusChecks=true:
+ * - Runs every 1 minute (EventBridge schedule)
+ * - Checks CloudFront metrics for the LAST N minutes (idleTimeoutMinutes)
+ * - After deployment with 0 requests, stops the instance immediately (no status check wait)
+ * - Expected stop time: 1-4 minutes (waiting for IdleMonitor to run and detect no activity)
+ *
+ * CRITICAL: This test has 120s assertion timeout, so all waits must fit within that
+ */
+async function verifyAutoStop(instanceId: string, idleTimeoutMinutes: number): Promise<string> {
+  console.log(`Starting auto-stop verification for instance ${instanceId}`);
+  console.log(`Idle timeout: ${idleTimeoutMinutes} minutes`);
+
+  // Step 1: Poll for stopped state
+  // With skipStatusChecks=true, IdleMonitor should stop the instance within 90 seconds:
+  // - IdleMonitor runs every 1 minute
+  // - No status check wait needed
+  // - Instance stops immediately when IdleMonitor detects 0 requests
+  console.log('Step 2: Polling for stopped state (IdleMonitor should stop it within 100s with skipStatusChecks)...');
+  await waitForInstanceState(instanceId, 'stopped', 100); // 100s max (fits in 120s assertion timeout)
+
+  console.log('✅ Auto-stop verification successful: instance stopped after idle timeout');
+  return 'STOPPED';
+}
+
+/**
+ * Get current instance state
+ */
+async function getInstanceState(instanceId: string): Promise<string> {
+  const command = new DescribeInstancesCommand({
+    InstanceIds: [instanceId],
+  });
+
+  const response = await ec2.send(command);
+  const instance = response.Reservations?.[0]?.Instances?.[0];
+
+  if (!instance) {
+    throw new Error(`Instance ${instanceId} not found`);
+  }
+
+  const state = instance.State?.Name || 'unknown';
+  console.log(`Instance ${instanceId} state: ${state}`);
+  return state;
+}
+
+/**
+ * Wait for instance to reach a specific state
+ * Polls every 30 seconds up to maxWaitSeconds
+ */
+async function waitForInstanceState(
+  instanceId: string,
+  targetState: string,
+  maxWaitSeconds: number,
+): Promise<void> {
+  const pollIntervalMs = 30000; // 30 seconds
+  const maxAttempts = Math.ceil(maxWaitSeconds / (pollIntervalMs / 1000));
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    console.log(`Polling attempt ${attempt}/${maxAttempts}...`);
+
+    const currentState = await getInstanceState(instanceId);
+
+    if (currentState === targetState) {
+      console.log(`✅ Instance reached target state: ${targetState}`);
+      return;
+    }
+
+    console.log(`Instance state is ${currentState}, waiting for ${targetState}...`);
+
+    if (attempt < maxAttempts) {
+      await sleep(pollIntervalMs);
+    }
+  }
+
+  throw new Error(
+    `Timeout: Instance did not reach state '${targetState}' within ${maxWaitSeconds} seconds`,
+  );
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Disable the IdleMonitor EventBridge rule
+ * This prevents the instance from being stopped again after we start it
+ */
+async function disableIdleMonitor(ruleName: string): Promise<string> {
+  console.log(`Disabling IdleMonitor EventBridge rule: ${ruleName}`);
+
+  const command = new DisableRuleCommand({
+    Name: ruleName,
+  });
+
+  await eventBridge.send(command);
+
+  console.log('✅ IdleMonitor EventBridge rule disabled successfully');
+  return 'DISABLED';
+}
+
+/**
+ * Start the EC2 instance and wait for it to be running
+ */
+async function startInstance(instanceId: string): Promise<string> {
+  console.log(`Starting instance: ${instanceId}`);
+
+  // Start the instance
+  const startCommand = new StartInstancesCommand({
+    InstanceIds: [instanceId],
+  });
+
+  await ec2.send(startCommand);
+  console.log('Instance start command sent');
+
+  // Wait for instance to be running (max 2 minutes)
+  console.log('Waiting for instance to be running...');
+  await waitForInstanceState(instanceId, 'running', 120);
+
+  console.log('✅ Instance started successfully and is running');
+  return 'RUNNING';
+}

package/integ-tests/functions/login-handler.ts

@@ -1,5 +1,11 @@
 import { parse } from 'node-html-parser';
 
+/**
+ * Login handler with retry logic for instance startup
+ *
+ * Retries up to 20 times with 15-second intervals (5 minutes total)
+ * to allow time for EC2 instance startup and VS Code Server initialization
+ */
 export const handler = async (event: any) => {
   const domainName = event.domainName || 'test-domain';
   const password = event.password || 'test-password';
@@ -8,52 +14,75 @@ export const handler = async (event: any) => {
     event,
   });
 
-  let htmlContent: string = '';
-  try {
-    if (!domainName || !password) {
-      throw new Error('Domain name and password are required');
-    }
+  const maxRetries = 20;
+  const retryDelayMs = 15000; // 15 seconds
 
-    const url = domainName.startsWith('http') ? domainName : `https://${domainName}`;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    log({ message: `Login attempt ${attempt}/${maxRetries}` });
 
-    // No logs due to error 'Response object is too long'
-    // https://github.com/aws/aws-cdk/issues/24490
-    // log({ message: 'Fetching document', url })
-    const response = await fetch(url);
-    // log({ message: 'Got response' })
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
+    try {
+      if (!domainName || !password) {
+        throw new Error('Domain name and password are required');
+      }
+
+      const url = domainName.startsWith('http') ? domainName : `https://${domainName}`;
 
-    htmlContent = await response.text();
-    // log({ message: 'Got HTML content' })
+      const response = await fetch(url);
 
-    // log({ message: 'Parsing HTML' })
-    const root = parse(htmlContent);
+      if (!response.ok) {
+        log({ message: `HTTP ${response.status}, retrying...` });
+        if (attempt < maxRetries) {
+          await sleep(retryDelayMs);
+          continue;
+        }
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
 
-    // log({ message: 'Querying document' })
-    const centerContainer = root.querySelector('.center-container');
+      const htmlContent = await response.text();
+      const root = parse(htmlContent);
+      const centerContainer = root.querySelector('.center-container');
+
+      if (!centerContainer) {
+        log({ message: 'Center container not found yet, retrying...' });
+        if (attempt < maxRetries) {
+          await sleep(retryDelayMs);
+          continue;
+        }
+        error({
+          message: 'Center container NOT found after all retries',
+          htmlContent,
+        });
+        return 'NOK';
+      }
+
+      log({ message: `Found center container on attempt ${attempt}. TADA` });
+      return 'OK';
+    } catch (err) {
+      log({
+        message: `Attempt ${attempt} failed`,
+        error: err instanceof Error ? err.message : String(err),
+      });
+
+      if (attempt < maxRetries) {
+        await sleep(retryDelayMs);
+        continue;
+      }
 
-    if (!centerContainer) {
       error({
-        message: 'Center container NOT found. See retrieved htmlContent',
-        htmlContent,
+        message: 'All retry attempts failed',
+        err,
       });
       return 'NOK';
     }
-
-    log({ message: 'Found center container. TADA' });
-    return 'OK';
-  } catch (err) {
-    error({
-      message: 'Error fetching or processing document',
-      err,
-      htmlContent,
-    });
-    return 'NOK';
   }
+
+  return 'NOK';
 };
 
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
 function log(msg: any) {
   console.log(JSON.stringify(msg));
 }

package/integ-tests/integ.al2023.ts.snapshot/read.13497.1.lock

@@ -0,0 +1 @@
+13497

package/integ-tests/integ.custom-domain.ts.snapshot/read.13497.1.lock

@@ -0,0 +1 @@
+13497