@mavogel/cdk-vscode-server 0.0.2

package/lib/vscode-server.js

@@ -0,0 +1,417 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VSCodeServer = exports.LinuxArchitectureType = exports.LinuxFlavorType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const cf = require("aws-cdk-lib/aws-cloudfront");
+const cfo = require("aws-cdk-lib/aws-cloudfront-origins");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const iam = require("aws-cdk-lib/aws-iam");
+const secretsmanager = require("aws-cdk-lib/aws-secretsmanager");
+const cdk_nag_1 = require("cdk-nag");
+const constructs_1 = require("constructs");
+const installer_1 = require("./installer/installer");
+const mappings_1 = require("./mappings");
+const prefixlist_retriever_1 = require("./prefixlist-retriever/prefixlist-retriever");
+const secret_retriever_1 = require("./secret-retriever/secret-retriever");
+/**
+ * The flavor of linux you want to run vscode server on
+ */
+var LinuxFlavorType;
+(function (LinuxFlavorType) {
+    LinuxFlavorType["UBUNTU_22"] = "ubuntu22";
+    LinuxFlavorType["UBUNTU_24"] = "ubuntu24";
+    LinuxFlavorType["AMAZON_LINUX_2023"] = "al2023";
+})(LinuxFlavorType || (exports.LinuxFlavorType = LinuxFlavorType = {}));
+/**
+ * The architecture of the cpu you want to run vscode server on
+ */
+var LinuxArchitectureType;
+(function (LinuxArchitectureType) {
+    LinuxArchitectureType["ARM"] = "arm";
+    LinuxArchitectureType["AMD64"] = "amd64";
+})(LinuxArchitectureType || (exports.LinuxArchitectureType = LinuxArchitectureType = {}));
+class VSCodeServer extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        // defaults
+        const vsCodeUser = props?.vscodeUser ?? 'participant';
+        const instanceName = props?.instanceName ?? 'VSCodeServer';
+        const instanceVolumeSize = props?.instanceVolumeSize ?? 40;
+        const homeFolder = props?.homeFolder ?? '/Workshop';
+        const instanceClass = props?.instanceClass ?? ec2.InstanceClass.M7G;
+        const instanceSize = props?.instanceSize ?? ec2.InstanceSize.XLARGE;
+        const instanceType = ec2.InstanceType.of(instanceClass, instanceSize);
+        const instanceOperatingSystem = props?.instanceOperatingSystem ?? LinuxFlavorType.UBUNTU_22;
+        const instanceCpuArchitecture = props?.instanceCpuArchitecture ?? LinuxArchitectureType.ARM;
+        const machineImageFromSsmParameter = (0, mappings_1.getAmiSSMParameterForLinuxArchitectureAndFlavor)(instanceCpuArchitecture, instanceOperatingSystem);
+        const additionalInstanceRolePolicies = props?.additionalInstanceRolePolicies ?? [];
+        let vscodePassword = props?.vscodePassword ?? '';
+        if ((vscodePassword == '')) {
+            // Create a secret which is then inject in the SSM document to install vscode server
+            const secret = new secretsmanager.Secret(this, 'password-secret', {
+                generateSecretString: {
+                    passwordLength: 16,
+                    secretStringTemplate: JSON.stringify({
+                        username: vsCodeUser,
+                    }),
+                    excludePunctuation: true,
+                    includeSpace: false,
+                    generateStringKey: 'password',
+                },
+            });
+            cdk_nag_1.NagSuppressions.addResourceSuppressions([
+                secret,
+            ], [
+                { id: 'AwsSolutions-SMG4', reason: 'For this tmp vc code server we do not need password rotation' },
+            ], true);
+            // Have a custom resource to pass the secret data on? -> yes because not resolvable on compile time
+            const secretRetriever = secret_retriever_1.SecretRetriever.new({
+                secretArn: secret.secretArn,
+            })._bind(this);
+            vscodePassword = secretRetriever.secretPasswordPlaintext;
+        }
+        // Create default vpc
+        const vpc = new ec2.Vpc(this, 'vpc', {
+            maxAzs: 2,
+            createInternetGateway: true,
+            subnetConfiguration: [
+                {
+                    name: 'public',
+                    subnetType: ec2.SubnetType.PUBLIC,
+                },
+            ],
+            enableDnsHostnames: true,
+            enableDnsSupport: true,
+        });
+        cdk_nag_1.NagSuppressions.addResourceSuppressions([
+            vpc,
+        ], [
+            { id: 'AwsSolutions-VPC7', reason: 'For this tmp vpc we do not need flow logs' },
+        ], true);
+        // Create a SecGroup associated withe the CF dist pList
+        const secGroup = new ec2.SecurityGroup(this, 'cf-to-server-sg', {
+            vpc,
+            description: 'SG for VSCodeServer - only allow CloudFront ingress',
+            securityGroupName: 'cloudfront-to-vscode-server',
+        });
+        const awsManagedPrefixList = new prefixlist_retriever_1.AwsManagedPrefixList(this, 'cf-prefixlistId', {
+            name: 'com.amazonaws.global.cloudfront.origin-facing',
+        });
+        cdk_nag_1.NagSuppressions.addResourceSuppressions([
+            awsManagedPrefixList,
+        ], [
+            { id: 'AwsSolutions-IAM5', reason: 'For this provider wildcards are fine' },
+        ], true);
+        secGroup.addIngressRule(ec2.Peer.prefixList(awsManagedPrefixList.prefixList.prefixListId), ec2.Port.tcp(80), 'Allow HTTP from com.amazonaws.global.cloudfront.origin-facing');
+        // Create an EC2 instance associated with the sec group + instance profile and role
+        const instanceRole = new iam.Role(this, 'server-instance-role', {
+            assumedBy: new iam.CompositePrincipal(new iam.ServicePrincipal('ec2.amazonaws.com'), new iam.ServicePrincipal('ssm.amazonaws.com')),
+            inlinePolicies: {
+                VSCodeInstanceInlinePolicy: new iam.PolicyDocument({
+                    statements: [
+                        new iam.PolicyStatement({
+                            sid: 'StsAccess',
+                            effect: iam.Effect.ALLOW,
+                            actions: [
+                                'sts:AssumeRole',
+                                'iam:AddRoleToInstanceProfile',
+                                'iam:AttachRolePolicy',
+                                'iam:CreateRole',
+                                'iam:CreateServiceLinkedRole',
+                                'iam:DeleteRole',
+                                'iam:DeleteRolePermissionsBoundary',
+                                'iam:DeleteRolePolicy',
+                                'iam:DeleteServiceLinkedRole',
+                                'iam:DetachRolePolicy',
+                                'iam:GetRole',
+                                'iam:GetRolePolicy',
+                                'iam:GetServiceLinkedRoleDeletionStatus',
+                                'iam:ListAttachedRolePolicies',
+                                'iam:ListInstanceProfilesForRole',
+                                'iam:ListRolePolicies',
+                                'iam:ListRoles',
+                                'iam:ListRoleTags',
+                                'iam:PutRolePermissionsBoundary',
+                                'iam:PutRolePolicy',
+                                'iam:RemoveRoleFromInstanceProfile',
+                                'iam:TagRole',
+                                'iam:UntagRole',
+                                'iam:UpdateAssumeRolePolicy',
+                                'iam:UpdateRole',
+                                'iam:UpdateRoleDescription',
+                            ],
+                            resources: [
+                                `arn:aws:iam::${aws_cdk_lib_1.Stack.of(this).account}:role/cdk-*`,
+                            ],
+                        }),
+                        new iam.PolicyStatement({
+                            effect: iam.Effect.ALLOW,
+                            actions: [
+                                'iam:PassRole',
+                            ],
+                            resources: [
+                                `arn:aws:iam::${aws_cdk_lib_1.Stack.of(this).account}:role/cdk-*`,
+                            ],
+                            conditions: {
+                                StringLike: {
+                                    'iam:PassedToService': 'cloudformation.amazonaws.com',
+                                },
+                            },
+                        }),
+                        new iam.PolicyStatement({
+                            effect: iam.Effect.ALLOW,
+                            actions: [
+                                'cloudformation:*',
+                            ],
+                            resources: [
+                                `arn:aws:cloudformation:*:${aws_cdk_lib_1.Stack.of(this).account}:stack/CDKToolkit/*`,
+                            ],
+                        }),
+                        new iam.PolicyStatement({
+                            effect: iam.Effect.ALLOW,
+                            actions: [
+                                'cloudformation:CreateChangeSet',
+                                'cloudformation:ExecuteChangeSet',
+                                'cloudformation:DeleteChangeSet',
+                            ],
+                            resources: ['*'],
+                        }),
+                        new iam.PolicyStatement({
+                            sid: 'S3Access',
+                            actions: [
+                                's3:*',
+                            ],
+                            resources: ['*'],
+                        }),
+                        new iam.PolicyStatement({
+                            sid: 'ECRAccess',
+                            effect: iam.Effect.ALLOW,
+                            actions: [
+                                'ecr:SetRepositoryPolicy',
+                                'ecr:GetLifecyclePolicy',
+                                'ecr:PutLifecyclePolicy',
+                                'ecr:PutImageScanningConfiguration',
+                                'ecr:DescribeRepositories',
+                                'ecr:CreateRepository',
+                                'ecr:DeleteRepository',
+                            ],
+                            resources: [
+                                `arn:aws:ecr:*:${aws_cdk_lib_1.Stack.of(this).account}:repository/cdk-*`,
+                            ],
+                        }),
+                        new iam.PolicyStatement({
+                            effect: iam.Effect.ALLOW,
+                            actions: [
+                                'ssm:GetParameter*',
+                                'ssm:PutParameter*',
+                                'ssm:DeleteParameter*',
+                            ],
+                            resources: [
+                                `arn:aws:ssm:*:${aws_cdk_lib_1.Stack.of(this).account}:parameter/cdk-bootstrap/*`,
+                            ],
+                        }),
+                        new iam.PolicyStatement({
+                            effect: iam.Effect.ALLOW,
+                            actions: [
+                                'ec2:DescribeInstances',
+                                'ec2:ModifyVolume',
+                                'ec2:DescribeVolumesModifications*',
+                            ],
+                            resources: ['*'],
+                        }),
+                        new iam.PolicyStatement({
+                            effect: iam.Effect.ALLOW,
+                            actions: [
+                                'codepipeline:EnableStageTransition',
+                                'codepipeline:DisableStageTransition',
+                                'codepipeline:StartPipelineExecution',
+                                'codepipeline:StopPipelineExecution',
+                                'codepipeline:UpdatePipeline',
+                            ],
+                            resources: [
+                                `arn:aws:codepipeline:*:${aws_cdk_lib_1.Stack.of(this).account}:*/*`,
+                            ],
+                        }),
+                        new iam.PolicyStatement({
+                            effect: iam.Effect.ALLOW,
+                            actions: [
+                                'kms:Decrypt',
+                            ],
+                            resources: [
+                                `arn:aws:kms:*:${aws_cdk_lib_1.Stack.of(this).account}:key/*`,
+                            ],
+                        }),
+                        ...additionalInstanceRolePolicies,
+                    ],
+                }),
+            },
+            managedPolicies: [
+                iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+                iam.ManagedPolicy.fromAwsManagedPolicyName('CloudWatchAgentServerPolicy'),
+                iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonQDeveloperAccess'),
+                iam.ManagedPolicy.fromAwsManagedPolicyName('ReadOnlyAccess'),
+            ],
+        });
+        cdk_nag_1.NagSuppressions.addResourceSuppressions([
+            instanceRole,
+        ], [
+            { id: 'AwsSolutions-IAM4', reason: 'For this tmp role we do not need to restrict managed policies' },
+            { id: 'AwsSolutions-IAM5', reason: 'For this tmp role the wildcards are fine' },
+        ], true);
+        const instance = new ec2.Instance(this, 'server-instance', {
+            vpc,
+            instanceName,
+            instanceType,
+            machineImage: ec2.MachineImage.fromSsmParameter(machineImageFromSsmParameter, {
+                os: ec2.OperatingSystemType.LINUX,
+            }),
+            requireImdsv2: true,
+            vpcSubnets: {
+                subnetType: ec2.SubnetType.PUBLIC,
+            },
+            associatePublicIpAddress: true,
+            detailedMonitoring: true,
+            blockDevices: [
+                {
+                    deviceName: '/dev/sda1',
+                    volume: ec2.BlockDeviceVolume.ebs(instanceVolumeSize, {
+                        volumeType: ec2.EbsDeviceVolumeType.GP3,
+                        encrypted: true,
+                        deleteOnTermination: true,
+                    }),
+                },
+            ],
+            role: instanceRole,
+            securityGroup: secGroup,
+            userData: ec2.UserData.custom(`
+        #cloud-config
+          hostname: ${instanceName}
+          runcmd:
+            - mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}
+      `),
+        });
+        cdk_nag_1.NagSuppressions.addResourceSuppressions([
+            instance,
+        ], [
+            { id: 'AwsSolutions-EC29', reason: 'For this tmp instance we do not need an asg' },
+        ], true);
+        // Create a CF distribution (special id) and special CachePolicy to instance
+        const cfCachePolicy = new cf.CachePolicy(this, 'cf-cache-policy', {
+            cachePolicyName: `cf-cache-policy-vscodeserver-${aws_cdk_lib_1.Stack.of(this).stackName}`,
+            comment: 'Cache policy for VSCodeServer',
+            minTtl: aws_cdk_lib_1.Duration.seconds(1),
+            maxTtl: aws_cdk_lib_1.Duration.seconds(31536000),
+            defaultTtl: aws_cdk_lib_1.Duration.seconds(86400),
+            cookieBehavior: cf.CacheCookieBehavior.all(),
+            enableAcceptEncodingGzip: false,
+            headerBehavior: {
+                behavior: 'whitelist',
+                headers: [
+                    'Accept-Charset',
+                    'Authorization',
+                    'Origin',
+                    'Accept',
+                    'Referer',
+                    'Host',
+                    'Accept-Language',
+                    'Accept-Encoding',
+                    'Accept-Datetime',
+                ],
+            },
+            queryStringBehavior: cf.CacheQueryStringBehavior.all(),
+        });
+        const origin = new cfo.HttpOrigin(instance.instancePublicDnsName, {
+            protocolPolicy: cf.OriginProtocolPolicy.HTTP_ONLY,
+            originId: `Cloudfront-${aws_cdk_lib_1.Stack.of(this).stackName}-${aws_cdk_lib_1.Stack.of(this).stackName}`,
+        });
+        const distribution = new cf.Distribution(this, 'cf-distribution', {
+            enabled: true,
+            httpVersion: cf.HttpVersion.HTTP2_AND_3,
+            // NOTE: 'Distributions that use the default CloudFront viewer certificate or use 'vip' for the 'SslSupportMethod'
+            // are non-compliant with this rule, as the minimum security policy is set to TLSv1 regardless
+            // of the specified 'MinimumProtocolVersion'
+            // minimumProtocolVersion: cf.SecurityPolicyProtocol.TLS_V1_2_2021,
+            comment: 'Distribution for VSCodeServer',
+            priceClass: cf.PriceClass.PRICE_CLASS_ALL,
+            defaultBehavior: {
+                allowedMethods: cf.AllowedMethods.ALLOW_ALL,
+                cachePolicy: cfCachePolicy,
+                originRequestPolicy: {
+                    // Managed-AllViewer - see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#:~:text=When%20using%20AWS,47e4%2Db989%2D5492eafa07d3
+                    originRequestPolicyId: '216adef6-5c7f-47e4-b989-5492eafa07d3',
+                },
+                viewerProtocolPolicy: cf.ViewerProtocolPolicy.ALLOW_ALL,
+                origin,
+            },
+            additionalBehaviors: {
+                '/proxy/*': {
+                    allowedMethods: cf.AllowedMethods.ALLOW_ALL,
+                    compress: false,
+                    // see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-cache-policies.html#managed-cache-policy-caching-disabled
+                    cachePolicy: cf.CachePolicy.CACHING_DISABLED,
+                    originRequestPolicy: {
+                        // Managed-AllViewer - see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#:~:text=When%20using%20AWS,47e4%2Db989%2D5492eafa07d3
+                        originRequestPolicyId: '216adef6-5c7f-47e4-b989-5492eafa07d3',
+                    },
+                    viewerProtocolPolicy: cf.ViewerProtocolPolicy.ALLOW_ALL,
+                    origin,
+                },
+            },
+        });
+        cdk_nag_1.NagSuppressions.addResourceSuppressions([
+            distribution,
+        ], [
+            { id: 'AwsSolutions-CFR1', reason: 'For this tmp distribution we do not need geo restrictions' },
+            { id: 'AwsSolutions-CFR2', reason: 'For this tmp distribution we do not need waf integration' },
+            { id: 'AwsSolutions-CFR3', reason: 'For this tmp distribution we do not need access logging enabled' },
+            { id: 'AwsSolutions-CFR4', reason: 'For this tmp distribution we do not need limit SSL protocols as we use the default viewer cert' },
+            { id: 'AwsSolutions-CFR5', reason: 'For this tmp distribution we do not need limit SSL protocols as we use the default viewer cert' },
+        ], true);
+        // Use a custom resource lambda to run the SSM document on the instance
+        switch (instanceOperatingSystem) {
+            case LinuxFlavorType.UBUNTU_22:
+            case LinuxFlavorType.UBUNTU_24:
+                installer_1.Installer.ubuntu({
+                    instanceId: instance.instanceId,
+                    vsCodeUser: vsCodeUser,
+                    vsCodePassword: vscodePassword,
+                    devServerBasePath: props?.devServerBasePath,
+                    devServerPort: props?.devServerPort,
+                    homeFolder: homeFolder,
+                })._bind(this);
+                break;
+            case LinuxFlavorType.AMAZON_LINUX_2023:
+                installer_1.Installer.amazonLinux2023({
+                    instanceId: instance.instanceId,
+                    vsCodeUser: vsCodeUser,
+                    vsCodePassword: vscodePassword,
+                    devServerBasePath: props?.devServerBasePath,
+                    devServerPort: props?.devServerPort,
+                    homeFolder: homeFolder,
+                })._bind(this);
+                break;
+            default:
+                throw new Error(`Unsupported Linux flavor: ${instanceOperatingSystem}`);
+        }
+        // so we pass the outer scope of this construct through the installer
+        // NOTE: maybe have a healhcheck CFN custom resource to see if the vscode server is healthy
+        // atm this is achieved by the integ tests
+        // Outputs
+        this.domainName = `https://${distribution.domainName}/?folder=${homeFolder}`;
+        new aws_cdk_lib_1.CfnOutput(this, 'domainName', {
+            description: 'The domain name of the distribution',
+            value: this.domainName,
+        });
+        this.password = vscodePassword;
+        new aws_cdk_lib_1.CfnOutput(this, 'password', {
+            description: 'The password for the VSCode server',
+            value: vscodePassword,
+        });
+    }
+}
+exports.VSCodeServer = VSCodeServer;
+_a = JSII_RTTI_SYMBOL_1;
+VSCodeServer[_a] = { fqn: "@mavogel/cdk-vscode-server.VSCodeServer", version: "0.0.2" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vscode-server.js","sourceRoot":"","sources":["../src/vscode-server.ts"],"names":[],"mappings":"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","sourcesContent":["import { CfnOutput, Duration, Stack } from 'aws-cdk-lib';\nimport * as cf from 'aws-cdk-lib/aws-cloudfront';\nimport * as cfo from 'aws-cdk-lib/aws-cloudfront-origins';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';\nimport { NagSuppressions } from 'cdk-nag';\nimport { Construct } from 'constructs';\nimport { Installer } from './installer/installer';\nimport { getAmiSSMParameterForLinuxArchitectureAndFlavor } from './mappings';\nimport { AwsManagedPrefixList } from './prefixlist-retriever/prefixlist-retriever';\nimport { SecretRetriever } from './secret-retriever/secret-retriever';\n\nexport interface VSCodeServerProps {\n  /**\n   * UserName for VSCode Server\n   *\n   * @default - participant\n   */\n  readonly vscodeUser?: string;\n\n  /**\n   * Password for VSCode Server\n   *\n   * @default - empty and will then be generated\n   */\n  readonly vscodePassword?: string;\n\n  /**\n   * VSCode Server EC2 instance name\n   *\n   * @default - VSCodeServer\n   */\n  readonly instanceName?: string;\n\n  /**\n   * VSCode Server EC2 instance volume size in GB\n   *\n   * @default - 40\n   */\n  readonly instanceVolumeSize?: number;\n\n  /**\n   * VSCode Server EC2 instance class\n   *\n   * @default - m7g\n   */\n  readonly instanceClass?: ec2.InstanceClass;\n\n  /**\n   * VSCode Server EC2 instance size\n   *\n   * @default - xlarge\n   */\n  readonly instanceSize?: ec2.InstanceSize;\n\n  /**\n   * VSCode Server EC2 operating system\n   *\n   * @default - Ubuntu-22\n   */\n  readonly instanceOperatingSystem?: LinuxFlavorType;\n\n  /**\n   * VSCode Server EC2 cpu architecture for the operating system\n   *\n   * @default - arm\n   */\n  readonly instanceCpuArchitecture?: LinuxArchitectureType;\n\n  /**\n   * Folder to open in VS Code server\n   *\n   * @default - /Workshop\n   */\n  readonly homeFolder?: string;\n\n  /**\n   * Base path for the application to be added to Nginx sites-available list\n   *\n   * @default - app\n   */\n  readonly devServerBasePath?: string;\n\n  /**\n   * Port for the DevServer\n   *\n   * @default - 8081\n   */\n  readonly devServerPort?: number;\n\n  /**\n   * Additional instance role policies\n   *\n   * @default - []\n   */\n  readonly additionalInstanceRolePolicies?: iam.PolicyStatement[];\n}\n\n/**\n * The flavor of linux you want to run vscode server on\n */\nexport enum LinuxFlavorType {\n  UBUNTU_22 = 'ubuntu22',\n  UBUNTU_24 = 'ubuntu24',\n  AMAZON_LINUX_2023 = 'al2023',\n}\n\n/**\n * The architecture of the cpu you want to run vscode server on\n */\nexport enum LinuxArchitectureType {\n  ARM = 'arm',\n  AMD64 = 'amd64',\n}\n\nexport class VSCodeServer extends Construct {\n  public readonly domainName: string;\n  public readonly password: string;\n\n  constructor(scope: Construct, id: string, props?: VSCodeServerProps) {\n    super(scope, id);\n\n    // defaults\n    const vsCodeUser = props?.vscodeUser ?? 'participant';\n    const instanceName = props?.instanceName ?? 'VSCodeServer';\n    const instanceVolumeSize = props?.instanceVolumeSize ?? 40;\n    const homeFolder = props?.homeFolder ?? '/Workshop';\n    const instanceClass = props?.instanceClass ?? ec2.InstanceClass.M7G;\n    const instanceSize = props?.instanceSize ?? ec2.InstanceSize.XLARGE;\n    const instanceType = ec2.InstanceType.of(instanceClass, instanceSize);\n    const instanceOperatingSystem = props?.instanceOperatingSystem ?? LinuxFlavorType.UBUNTU_22;\n    const instanceCpuArchitecture = props?.instanceCpuArchitecture ?? LinuxArchitectureType.ARM;\n    const machineImageFromSsmParameter = getAmiSSMParameterForLinuxArchitectureAndFlavor(instanceCpuArchitecture, instanceOperatingSystem);\n    const additionalInstanceRolePolicies = props?.additionalInstanceRolePolicies ?? [];\n\n    let vscodePassword = props?.vscodePassword ?? '';\n    if ((vscodePassword == '')) {\n      // Create a secret which is then inject in the SSM document to install vscode server\n      const secret = new secretsmanager.Secret(this, 'password-secret', {\n        generateSecretString: {\n          passwordLength: 16,\n          secretStringTemplate: JSON.stringify({\n            username: vsCodeUser,\n          }),\n          excludePunctuation: true,\n          includeSpace: false,\n          generateStringKey: 'password',\n        },\n      });\n      NagSuppressions.addResourceSuppressions([\n        secret,\n      ], [\n        { id: 'AwsSolutions-SMG4', reason: 'For this tmp vc code server we do not need password rotation' },\n      ], true);\n\n      // Have a custom resource to pass the secret data on? -> yes because not resolvable on compile time\n      const secretRetriever = SecretRetriever.new({\n        secretArn: secret.secretArn,\n      })._bind(this);\n\n      vscodePassword = secretRetriever.secretPasswordPlaintext;\n    }\n\n    // Create default vpc\n    const vpc = new ec2.Vpc(this, 'vpc', {\n      maxAzs: 2,\n      createInternetGateway: true,\n      subnetConfiguration: [\n        {\n          name: 'public',\n          subnetType: ec2.SubnetType.PUBLIC,\n        },\n      ],\n      enableDnsHostnames: true,\n      enableDnsSupport: true,\n    });\n    NagSuppressions.addResourceSuppressions([\n      vpc,\n    ], [\n      { id: 'AwsSolutions-VPC7', reason: 'For this tmp vpc we do not need flow logs' },\n    ], true);\n\n\n    // Create a SecGroup associated withe the CF dist pList\n    const secGroup = new ec2.SecurityGroup(this, 'cf-to-server-sg', {\n      vpc,\n      description: 'SG for VSCodeServer - only allow CloudFront ingress',\n      securityGroupName: 'cloudfront-to-vscode-server',\n    });\n\n    const awsManagedPrefixList = new AwsManagedPrefixList(this, 'cf-prefixlistId', {\n      name: 'com.amazonaws.global.cloudfront.origin-facing',\n    });\n    NagSuppressions.addResourceSuppressions([\n      awsManagedPrefixList,\n    ], [\n      { id: 'AwsSolutions-IAM5', reason: 'For this provider wildcards are fine' },\n    ], true);\n\n    secGroup.addIngressRule(\n      ec2.Peer.prefixList(awsManagedPrefixList.prefixList.prefixListId),\n      ec2.Port.tcp(80),\n      'Allow HTTP from com.amazonaws.global.cloudfront.origin-facing',\n    );\n\n    // Create an EC2 instance associated with the sec group + instance profile and role\n    const instanceRole = new iam.Role(this, 'server-instance-role', {\n      assumedBy: new iam.CompositePrincipal(\n        new iam.ServicePrincipal('ec2.amazonaws.com'),\n        new iam.ServicePrincipal('ssm.amazonaws.com'),\n      ),\n      inlinePolicies: {\n        VSCodeInstanceInlinePolicy: new iam.PolicyDocument({\n          statements: [\n            new iam.PolicyStatement({\n              sid: 'StsAccess',\n              effect: iam.Effect.ALLOW,\n              actions: [\n                'sts:AssumeRole',\n                'iam:AddRoleToInstanceProfile',\n                'iam:AttachRolePolicy',\n                'iam:CreateRole',\n                'iam:CreateServiceLinkedRole',\n                'iam:DeleteRole',\n                'iam:DeleteRolePermissionsBoundary',\n                'iam:DeleteRolePolicy',\n                'iam:DeleteServiceLinkedRole',\n                'iam:DetachRolePolicy',\n                'iam:GetRole',\n                'iam:GetRolePolicy',\n                'iam:GetServiceLinkedRoleDeletionStatus',\n                'iam:ListAttachedRolePolicies',\n                'iam:ListInstanceProfilesForRole',\n                'iam:ListRolePolicies',\n                'iam:ListRoles',\n                'iam:ListRoleTags',\n                'iam:PutRolePermissionsBoundary',\n                'iam:PutRolePolicy',\n                'iam:RemoveRoleFromInstanceProfile',\n                'iam:TagRole',\n                'iam:UntagRole',\n                'iam:UpdateAssumeRolePolicy',\n                'iam:UpdateRole',\n                'iam:UpdateRoleDescription',\n              ],\n              resources: [\n                `arn:aws:iam::${Stack.of(this).account}:role/cdk-*`,\n              ],\n            }),\n            new iam.PolicyStatement({\n              effect: iam.Effect.ALLOW,\n              actions: [\n                'iam:PassRole',\n              ],\n              resources: [\n                `arn:aws:iam::${Stack.of(this).account}:role/cdk-*`,\n              ],\n              conditions: {\n                StringLike: {\n                  'iam:PassedToService': 'cloudformation.amazonaws.com',\n                },\n              },\n            }),\n            new iam.PolicyStatement({\n              effect: iam.Effect.ALLOW,\n              actions: [\n                'cloudformation:*',\n              ],\n              resources: [\n                `arn:aws:cloudformation:*:${Stack.of(this).account}:stack/CDKToolkit/*`,\n              ],\n            }),\n            new iam.PolicyStatement({\n              effect: iam.Effect.ALLOW,\n              actions: [\n                'cloudformation:CreateChangeSet',\n                'cloudformation:ExecuteChangeSet',\n                'cloudformation:DeleteChangeSet',\n              ],\n              resources: ['*'],\n            }),\n            new iam.PolicyStatement({\n              sid: 'S3Access',\n              actions: [\n                's3:*',\n              ],\n              resources: ['*'],\n            }),\n            new iam.PolicyStatement({\n              sid: 'ECRAccess',\n              effect: iam.Effect.ALLOW,\n              actions: [\n                'ecr:SetRepositoryPolicy',\n                'ecr:GetLifecyclePolicy',\n                'ecr:PutLifecyclePolicy',\n                'ecr:PutImageScanningConfiguration',\n                'ecr:DescribeRepositories',\n                'ecr:CreateRepository',\n                'ecr:DeleteRepository',\n              ],\n              resources: [\n                `arn:aws:ecr:*:${Stack.of(this).account}:repository/cdk-*`,\n              ],\n            }),\n            new iam.PolicyStatement({\n              effect: iam.Effect.ALLOW,\n              actions: [\n                'ssm:GetParameter*',\n                'ssm:PutParameter*',\n                'ssm:DeleteParameter*',\n              ],\n              resources: [\n                `arn:aws:ssm:*:${Stack.of(this).account}:parameter/cdk-bootstrap/*`,\n              ],\n            }),\n            new iam.PolicyStatement({\n              effect: iam.Effect.ALLOW,\n              actions: [\n                'ec2:DescribeInstances',\n                'ec2:ModifyVolume',\n                'ec2:DescribeVolumesModifications*',\n              ],\n              resources: ['*'],\n            }),\n            new iam.PolicyStatement({\n              effect: iam.Effect.ALLOW,\n              actions: [\n                'codepipeline:EnableStageTransition',\n                'codepipeline:DisableStageTransition',\n                'codepipeline:StartPipelineExecution',\n                'codepipeline:StopPipelineExecution',\n                'codepipeline:UpdatePipeline',\n              ],\n              resources: [\n                `arn:aws:codepipeline:*:${Stack.of(this).account}:*/*`,\n              ],\n            }),\n            new iam.PolicyStatement({\n              effect: iam.Effect.ALLOW,\n              actions: [\n                'kms:Decrypt',\n              ],\n              resources: [\n                `arn:aws:kms:*:${Stack.of(this).account}:key/*`,\n              ],\n            }),\n            ...additionalInstanceRolePolicies,\n          ],\n        }),\n      },\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),\n        iam.ManagedPolicy.fromAwsManagedPolicyName('CloudWatchAgentServerPolicy'),\n        iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonQDeveloperAccess'),\n        iam.ManagedPolicy.fromAwsManagedPolicyName('ReadOnlyAccess'),\n      ],\n    });\n    NagSuppressions.addResourceSuppressions([\n      instanceRole,\n    ], [\n      { id: 'AwsSolutions-IAM4', reason: 'For this tmp role we do not need to restrict managed policies' },\n      { id: 'AwsSolutions-IAM5', reason: 'For this tmp role the wildcards are fine' },\n    ], true);\n\n    const instance = new ec2.Instance(this, 'server-instance', {\n      vpc,\n      instanceName,\n      instanceType,\n      machineImage: ec2.MachineImage.fromSsmParameter(\n        machineImageFromSsmParameter,\n        {\n          os: ec2.OperatingSystemType.LINUX,\n        },\n      ),\n      requireImdsv2: true,\n      vpcSubnets: {\n        subnetType: ec2.SubnetType.PUBLIC,\n      },\n      associatePublicIpAddress: true,\n      detailedMonitoring: true,\n      blockDevices: [\n        {\n          deviceName: '/dev/sda1',\n          volume: ec2.BlockDeviceVolume.ebs(instanceVolumeSize, {\n            volumeType: ec2.EbsDeviceVolumeType.GP3,\n            encrypted: true,\n            deleteOnTermination: true,\n          }),\n        },\n      ],\n      role: instanceRole,\n      securityGroup: secGroup,\n      userData: ec2.UserData.custom(`\n        #cloud-config\n          hostname: ${instanceName}\n          runcmd:\n            - mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}\n      `),\n    });\n    NagSuppressions.addResourceSuppressions([\n      instance,\n    ], [\n      { id: 'AwsSolutions-EC29', reason: 'For this tmp instance we do not need an asg' },\n    ], true);\n\n    // Create a CF distribution (special id) and special CachePolicy to instance\n    const cfCachePolicy = new cf.CachePolicy(this, 'cf-cache-policy', {\n      cachePolicyName: `cf-cache-policy-vscodeserver-${Stack.of(this).stackName}`,\n      comment: 'Cache policy for VSCodeServer',\n      minTtl: Duration.seconds(1),\n      maxTtl: Duration.seconds(31536000),\n      defaultTtl: Duration.seconds(86400),\n      cookieBehavior: cf.CacheCookieBehavior.all(),\n      enableAcceptEncodingGzip: false,\n      headerBehavior: {\n        behavior: 'whitelist',\n        headers: [\n          'Accept-Charset',\n          'Authorization',\n          'Origin',\n          'Accept',\n          'Referer',\n          'Host',\n          'Accept-Language',\n          'Accept-Encoding',\n          'Accept-Datetime',\n        ],\n      },\n      queryStringBehavior: cf.CacheQueryStringBehavior.all(),\n    });\n\n    const origin = new cfo.HttpOrigin(instance.instancePublicDnsName, {\n      protocolPolicy: cf.OriginProtocolPolicy.HTTP_ONLY,\n      originId: `Cloudfront-${Stack.of(this).stackName}-${Stack.of(this).stackName}`,\n    });\n\n    const distribution = new cf.Distribution(this, 'cf-distribution', {\n      enabled: true,\n      httpVersion: cf.HttpVersion.HTTP2_AND_3,\n      // NOTE: 'Distributions that use the default CloudFront viewer certificate or use 'vip' for the 'SslSupportMethod'\n      // are non-compliant with this rule, as the minimum security policy is set to TLSv1 regardless\n      // of the specified 'MinimumProtocolVersion'\n      // minimumProtocolVersion: cf.SecurityPolicyProtocol.TLS_V1_2_2021,\n      comment: 'Distribution for VSCodeServer',\n      priceClass: cf.PriceClass.PRICE_CLASS_ALL,\n      defaultBehavior: {\n        allowedMethods: cf.AllowedMethods.ALLOW_ALL,\n        cachePolicy: cfCachePolicy,\n        originRequestPolicy: {\n          // Managed-AllViewer - see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#:~:text=When%20using%20AWS,47e4%2Db989%2D5492eafa07d3\n          originRequestPolicyId: '216adef6-5c7f-47e4-b989-5492eafa07d3',\n        },\n        viewerProtocolPolicy: cf.ViewerProtocolPolicy.ALLOW_ALL,\n        origin,\n      },\n      additionalBehaviors: {\n        '/proxy/*': {\n          allowedMethods: cf.AllowedMethods.ALLOW_ALL,\n          compress: false,\n          // see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-cache-policies.html#managed-cache-policy-caching-disabled\n          cachePolicy: cf.CachePolicy.CACHING_DISABLED,\n          originRequestPolicy: {\n            // Managed-AllViewer - see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#:~:text=When%20using%20AWS,47e4%2Db989%2D5492eafa07d3\n            originRequestPolicyId: '216adef6-5c7f-47e4-b989-5492eafa07d3',\n          },\n          viewerProtocolPolicy: cf.ViewerProtocolPolicy.ALLOW_ALL,\n          origin,\n        },\n      },\n    });\n    NagSuppressions.addResourceSuppressions([\n      distribution,\n    ], [\n      { id: 'AwsSolutions-CFR1', reason: 'For this tmp distribution we do not need geo restrictions' },\n      { id: 'AwsSolutions-CFR2', reason: 'For this tmp distribution we do not need waf integration' },\n      { id: 'AwsSolutions-CFR3', reason: 'For this tmp distribution we do not need access logging enabled' },\n      { id: 'AwsSolutions-CFR4', reason: 'For this tmp distribution we do not need limit SSL protocols as we use the default viewer cert' },\n      { id: 'AwsSolutions-CFR5', reason: 'For this tmp distribution we do not need limit SSL protocols as we use the default viewer cert' },\n    ], true);\n\n    // Use a custom resource lambda to run the SSM document on the instance\n    switch (instanceOperatingSystem) {\n      case LinuxFlavorType.UBUNTU_22:\n      case LinuxFlavorType.UBUNTU_24:\n        Installer.ubuntu({\n          instanceId: instance.instanceId,\n          vsCodeUser: vsCodeUser,\n          vsCodePassword: vscodePassword,\n          devServerBasePath: props?.devServerBasePath,\n          devServerPort: props?.devServerPort,\n          homeFolder: homeFolder,\n        })._bind(this);\n        break;\n      case LinuxFlavorType.AMAZON_LINUX_2023:\n        Installer.amazonLinux2023({\n          instanceId: instance.instanceId,\n          vsCodeUser: vsCodeUser,\n          vsCodePassword: vscodePassword,\n          devServerBasePath: props?.devServerBasePath,\n          devServerPort: props?.devServerPort,\n          homeFolder: homeFolder,\n        })._bind(this);\n        break;\n      default:\n        throw new Error(`Unsupported Linux flavor: ${instanceOperatingSystem}`);\n    }\n    // so we pass the outer scope of this construct through the installer\n\n    // NOTE: maybe have a healhcheck CFN custom resource to see if the vscode server is healthy\n    // atm this is achieved by the integ tests\n\n    // Outputs\n    this.domainName = `https://${distribution.domainName}/?folder=${homeFolder}`;\n    new CfnOutput(this, 'domainName', {\n      description: 'The domain name of the distribution',\n      value: this.domainName,\n    });\n\n    this.password = vscodePassword;\n    new CfnOutput(this, 'password', {\n      description: 'The password for the VSCode server',\n      value: vscodePassword,\n    });\n  }\n}\n"]}

package/node_modules/boolbase/README.md

@@ -0,0 +1,10 @@
+#boolbase
+This very simple module provides two basic functions, one that always returns true (`trueFunc`) and one that always returns false (`falseFunc`).
+
+###WTF?
+
+By having only a single instance of these functions around, it's possible to do some nice optimizations. Eg. [`CSSselect`](https://github.com/fb55/CSSselect) uses these functions to determine whether a selector won't match any elements. If that's the case, the DOM doesn't even have to be touched.
+
+###And why is this a separate module?
+
+I'm trying to modularize `CSSselect` and most modules depend on these functions. IMHO, having a separate module is the easiest solution to this problem.

package/node_modules/boolbase/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+	trueFunc: function trueFunc(){
+		return true;
+	},
+	falseFunc: function falseFunc(){
+		return false;
+	}
+};

package/node_modules/boolbase/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "boolbase",
+  "version": "1.0.0",
+  "description": "two functions: One that returns true, one that returns false",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fb55/boolbase"
+  },
+  "keywords": [
+    "boolean",
+    "function"
+  ],
+  "author": "Felix Boehm <me@feedic.com>",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/fb55/boolbase/issues"
+  },
+  "homepage": "https://github.com/fb55/boolbase"
+}

package/node_modules/css-select/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) Felix Böhm
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.