@mavogel/cdk-vscode-server 0.0.62 → 0.0.64

package/lib/installer/installer.js

@@ -19,7 +19,7 @@ class Installer {
                     documentName = options.documentName;
                 }
                 else {
-                    const document = this.createSSMDocument(scope, devServerBasePath, devServerPort, options.vsCodeUser, options.homeFolder, vscode_server_1.LinuxFlavorType.UBUNTU_22, options.customDomainName);
+                    const document = this.createSSMDocument(scope, devServerBasePath, devServerPort, options.vsCodeUser, options.homeFolder, options.linuxFlavorType, options.customDomainName, options.repoUrl, options.assetZipS3Path, options.branchZipS3Path, options.folderZipS3Path);
                     documentName = document.name;
                 }
                 const cloudWatchLogGroupName = options.cloudWatchLogGroupName ?? `/aws/ssm/${documentName}`;
@@ -45,7 +45,7 @@ class Installer {
                     documentName = options.documentName;
                 }
                 else {
-                    const document = this.createSSMDocument(scope, devServerBasePath, devServerPort, options.vsCodeUser, options.homeFolder, vscode_server_1.LinuxFlavorType.AMAZON_LINUX_2023, options.customDomainName);
+                    const document = this.createSSMDocument(scope, devServerBasePath, devServerPort, options.vsCodeUser, options.homeFolder, vscode_server_1.LinuxFlavorType.AMAZON_LINUX_2023, options.customDomainName, options.repoUrl, options.assetZipS3Path, options.branchZipS3Path, options.folderZipS3Path);
                     documentName = document.name;
                 }
                 const cloudWatchLogGroupName = options.cloudWatchLogGroupName ?? `/aws/ssm/${documentName}`;
@@ -65,7 +65,403 @@ class Installer {
      * @internal
      */
     constructor() { }
-    createSSMDocument(scope, devServerBasePath, devServerPort, vsCodeUser, homeFolder, linuxFlavor, customDomainName) {
+    /**
+     * Creates the InstallCloudWatchAgent step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createInstallCloudWatchAgentStep() {
+        return {
+            action: 'aws:configurePackage',
+            name: 'InstallCloudWatchAgent',
+            inputs: {
+                name: 'AmazonCloudWatchAgent',
+                action: 'Install',
+            },
+        };
+    }
+    /**
+     * Creates the ConfigureCloudWatchAgent step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createConfigureCloudWatchAgentStep() {
+        return {
+            action: 'aws:runDocument',
+            name: 'ConfigureCloudWatchAgent',
+            inputs: {
+                documentType: 'SSMDocument',
+                documentPath: 'AmazonCloudWatch-ManageAgent',
+                documentParameters: {
+                    action: 'configure',
+                    mode: 'ec2',
+                    optionalConfigurationSource: 'default',
+                    optionalRestart: 'yes',
+                },
+            },
+        };
+    }
+    /**
+     * Creates the UpdateProfile step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createUpdateProfileStep(vsCodeUser, region, account) {
+        return {
+            action: 'aws:runShellScript',
+            name: 'UpdateProfile',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    'echo LANG=en_US.utf-8 >> /etc/environment',
+                    'echo LC_ALL=en_US.UTF-8 >> /etc/environment',
+                    `echo 'PATH=$PATH:/home/${vsCodeUser}/.local/bin' >> /home/${vsCodeUser}/.bashrc`,
+                    `echo 'export PATH' >> /home/${vsCodeUser}/.bashrc`,
+                    `echo 'export AWS_REGION=${region}' >> /home/${vsCodeUser}/.bashrc`,
+                    `echo 'export AWS_ACCOUNTID=${account}' >> /home/${vsCodeUser}/.bashrc`,
+                    `echo 'export NEXT_TELEMETRY_DISABLED=1' >> /home/${vsCodeUser}/.bashrc`,
+                    `echo "export PS1='\\[\\033[01;32m\\]\\u:\\[\\033[01;34m\\]\\w\\[\\033[00m\\]\\$ '" >> /home/${vsCodeUser}/.bashrc`,
+                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
+                ],
+            },
+        };
+    }
+    /**
+     * Creates the InstallAWSCLI step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createInstallAWSCLIStep(vsCodeUser) {
+        return {
+            action: 'aws:runShellScript',
+            name: 'InstallAWSCLI',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    'mkdir -p /tmp',
+                    'curl -fsSL https://awscli.amazonaws.com/awscli-exe-linux-$(uname -m).zip -o /tmp/aws-cli.zip',
+                    `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/aws-cli.zip`,
+                    'unzip -q -d /tmp /tmp/aws-cli.zip',
+                    'sudo /tmp/aws/install',
+                    'rm -rf /tmp/aws',
+                    'echo "AWS CLI installed. Checking configuration"',
+                    'aws --version',
+                ],
+            },
+        };
+    }
+    /**
+     * Creates the CloneRepo step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createCloneRepoStep(vsCodeUser, homeFolder) {
+        return {
+            action: 'aws:runShellScript',
+            name: 'CloneRepo',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    `if [[ -z "{{ RepoUrl }}" ]]
+then
+  echo "No Repo"
+else
+  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}
+  sudo -u ${vsCodeUser} git clone {{ RepoUrl }} ${homeFolder}
+  echo "Repo {{ RepoUrl }} cloned. Checking configuration"
+  ls -la ${homeFolder}
+  sudo -u ${vsCodeUser} git -C ${homeFolder} remote -v
+fi`,
+                ],
+            },
+        };
+    }
+    /**
+     * Creates the DownloadAssets step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createDownloadAssetsStep(vsCodeUser, homeFolder) {
+        return {
+            action: 'aws:runShellScript',
+            name: 'DownloadAssets',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    `if [[ -z "{{ AssetZipS3Path }}" ]]
+then
+  echo "No assets"
+else
+  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}
+  mkdir -p /tmp
+  aws s3 cp s3://{{ AssetZipS3Path }} /tmp/asset.zip
+  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/asset.zip
+  unzip -o /tmp/asset.zip -d ${homeFolder}
+  chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}
+  if  [[ -d ${homeFolder}/.git ]]
+  then
+    sudo -u ${vsCodeUser} git -C ${homeFolder} add .
+    sudo -u ${vsCodeUser} git -C ${homeFolder} commit -m 'chore: workshop commit'
+  else
+    sudo -u ${vsCodeUser} git -C ${homeFolder} init
+    sudo -u ${vsCodeUser} git -C ${homeFolder} add .
+    sudo -u ${vsCodeUser} git -C ${homeFolder} commit -m 'chore: initial commit'
+  fi
+  echo "Assets downloaded. Checking configuration: ${homeFolder}"
+  ls -la ${homeFolder}
+  sudo -u ${vsCodeUser} git -C ${homeFolder} branch
+fi`,
+                ],
+            },
+        };
+    }
+    /**
+     * Creates the DownloadFolders step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createDownloadFoldersStep(vsCodeUser, homeFolder) {
+        return {
+            action: 'aws:runShellScript',
+            name: 'DownloadFolders',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    `if [[ -z "{{ FolderZipS3Path }}" ]]
+then
+  echo "No folders"
+else
+  rm -rf /tmp/folder
+  mkdir -p /tmp/folder && chown -R ${vsCodeUser}:${vsCodeUser} /tmp/folder
+  aws s3 cp s3://{{ FolderZipS3Path }} /tmp/asset-folder.zip
+  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/asset-folder.zip
+  unzip -o /tmp/asset-folder.zip -d /tmp/folder
+  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/folder
+  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}
+  cd "${homeFolder}" && cd ..
+  if [[ $(pwd) ==  "/" ]]
+  then
+    targetRootFolder=""
+  else
+    targetRootFolder=$(pwd)
+    chown -R ${vsCodeUser}:${vsCodeUser} .
+  fi
+  find "/tmp/folder" -maxdepth 1 -mindepth 1 -type d | while read sourceFolder; do
+    folder="$(basename $sourceFolder)"
+    echo "Processing folder: $folder"
+    targetFolder=$targetRootFolder/$folder
+    if [[ $targetRootFolder == "" ]]
+    then
+      mv $sourceFolder /
+    else
+      mv $sourceFolder $targetRootFolder
+    fi
+    chown -R ${vsCodeUser}:${vsCodeUser} $targetFolder
+    sudo -u ${vsCodeUser} git -C $targetFolder init
+    sudo -u ${vsCodeUser} git -C $targetFolder add .
+    sudo -u ${vsCodeUser} git -C $targetFolder commit -m "chore: initial commit"
+    echo "Folder downloaded. Checking configuration: $targetFolder"
+    ls -la $targetFolder
+  done
+  rm -rf /tmp/folder
+fi`,
+                ],
+            },
+        };
+    }
+    /**
+     * Creates the InstallCDK step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createInstallCDKStep() {
+        return {
+            action: 'aws:runShellScript',
+            name: 'InstallCDK',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    'npm install -g aws-cdk',
+                    'echo "AWS CDK installed. Checking configuration"',
+                    'cdk --version',
+                ],
+            },
+        };
+    }
+    /**
+     * Creates the InstallQCLI step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createInstallQCLIStep(vsCodeUser) {
+        return {
+            action: 'aws:runShellScript',
+            name: 'InstallQCLI',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    'curl --proto \'=https\' --tlsv1.2 -sSf "https://desktop-release.q.us-east-1.amazonaws.com/latest/q-$(uname -m)-linux.zip" -o /tmp/q.zip',
+                    `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/q.zip`,
+                    'unzip -q -d /tmp /tmp/q.zip',
+                    `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/q`,
+                    'chmod +x /tmp/q/install.sh',
+                    `sudo -u ${vsCodeUser} /tmp/q/install.sh --no-confirm`,
+                    'rm -rf /tmp/q',
+                    'q --version',
+                    'echo "Amazon Q CLI installed"',
+                ],
+            },
+        };
+    }
+    /**
+     * Creates the Installuv step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createInstalluvStep(vsCodeUser) {
+        return {
+            action: 'aws:runShellScript',
+            name: 'Installuv',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    `sudo -u ${vsCodeUser} --login curl -fsSL https://astral.sh/uv/install.sh -o /tmp/uv_install.sh`,
+                    `sudo -u ${vsCodeUser} --login bash /tmp/uv_install.sh`,
+                    `if uv generate-shell-completion bash &>/dev/null; then
+  echo 'eval "$(uv generate-shell-completion bash)"' >> /home/${vsCodeUser}/.bashrc
+fi`,
+                    `if uvx generate-shell-completion bash &>/dev/null; then
+  echo 'eval "$(uvx generate-shell-completion bash)"' >> /home/${vsCodeUser}/.bashrc
+fi`,
+                    'echo "uv installed. Checking configuration"',
+                    `sudo -u ${vsCodeUser} --login uv --version`,
+                ],
+            },
+        };
+    }
+    /**
+     * Creates the ConfigureCodeServer step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createConfigureCodeServerStep(vsCodeUser, homeFolder, devServerBasePath, devServerPort, serverNameDirective) {
+        return {
+            action: 'aws:runShellScript',
+            name: 'ConfigureCodeServer',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    `export HOME=/home/${vsCodeUser}`,
+                    'curl -fsSL https://code-server.dev/install.sh | sh -s -- --version 4.100.3',
+                    `systemctl enable --now code-server@${vsCodeUser} 2>&1`,
+                    `tee /etc/nginx/conf.d/code-server.conf <<EOF
+server {
+    listen 80;
+    listen [::]:80;
+    # server_name \\$\\{CloudFrontDistribution.DomainName\\};
+    ${serverNameDirective}
+    location / {
+      proxy_pass http://localhost:8080/;
+      proxy_set_header Host \\$host;
+      proxy_set_header Upgrade \\$http_upgrade;
+      proxy_set_header Connection upgrade;
+      proxy_set_header Accept-Encoding gzip;
+    }
+    location /${devServerBasePath} {
+      proxy_pass http://localhost:${devServerPort}/${devServerBasePath};
+      proxy_set_header Host \\$host;
+      proxy_set_header Upgrade \\$http_upgrade;
+      proxy_set_header Connection upgrade;
+      proxy_set_header Accept-Encoding gzip;
+    }
+}
+EOF`,
+                    `mkdir -p /home/${vsCodeUser}/.config/code-server`,
+                    `tee /home/${vsCodeUser}/.config/code-server/config.yaml <<EOF
+cert: false
+auth: password
+hashed-password: "$(echo -n {{ VSCodePassword }} | argon2 $(openssl rand -base64 12) -e)"
+EOF`,
+                    `mkdir -p /home/${vsCodeUser}/.local/share/code-server/User/`,
+                    `touch /home/${vsCodeUser}/.hushlogin`,
+                    `mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}`,
+                    `tee /home/${vsCodeUser}/.local/share/code-server/User/settings.json <<EOF
+{
+  "extensions.autoUpdate": false,
+  "extensions.autoCheckUpdates": false,
+  "telemetry.telemetryLevel": "off",
+  "security.workspace.trust.startupPrompt": "never",
+  "security.workspace.trust.enabled": false,
+  "security.workspace.trust.banner": "never",
+  "security.workspace.trust.emptyWindow": false,
+  "auto-run-command.rules": [
+    {
+      "command": "workbench.action.terminal.new"
+    }
+  ]
+}
+EOF`,
+                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
+                    `systemctl restart code-server@${vsCodeUser}`,
+                    'systemctl restart nginx',
+                    `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.aws-toolkit-vscode --force`,
+                    `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.amazon-q-vscode --force`,
+                    `sudo -u ${vsCodeUser} --login code-server --install-extension ms-vscode.live-server --force`,
+                    `sudo -u ${vsCodeUser} --login code-server --install-extension synedra.auto-run-command --force`,
+                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
+                    'echo "Nginx installed. Checking configuration"',
+                    'nginx -t 2>&1',
+                    'systemctl status nginx',
+                    'echo "CodeServer installed. Checking configuration"',
+                    'code-server -v',
+                    `systemctl status code-server@${vsCodeUser}`,
+                ],
+            },
+        };
+    }
+    /**
+     * Creates the DownloadBranches step for SSM document
+     * This step is identical for both Ubuntu and Amazon Linux
+     */
+    createDownloadBranchesStep(vsCodeUser, homeFolder) {
+        return {
+            action: 'aws:runShellScript',
+            name: 'DownloadBranches',
+            inputs: {
+                runCommand: [
+                    '#!/bin/bash',
+                    `if [[ -z "{{ BranchZipS3Path }}" ]]
+then
+  echo "No branches"
+else
+  rm -rf /tmp/branch
+  rm -rf /tmp/git
+  mkdir -p /tmp/branch && chown -R ${vsCodeUser}:${vsCodeUser} /tmp/branch
+  mkdir -p /tmp/git && chown -R ${vsCodeUser}:${vsCodeUser} /tmp/git
+  aws s3 cp s3://{{ BranchZipS3Path }} /tmp/asset-branch.zip
+  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/asset-branch.zip
+  unzip -o /tmp/asset-branch.zip -d /tmp/branch
+  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/branch
+  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}
+  sudo -u ${vsCodeUser} git -C ${homeFolder} init
+  mv ${homeFolder}/.git /tmp/git
+  rm -rf ${homeFolder}
+  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}
+  mv /tmp/git/.git ${homeFolder}
+  find /tmp/branch -maxdepth 1 -mindepth 1 -type d | while read sourceFolder; do
+    branch="$(basename $sourceFolder)"
+    echo "Processing branch: $branch"
+    sudo -u ${vsCodeUser} git -C ${homeFolder} checkout -b $branch 2>&1
+    cp -a $sourceFolder/. ${homeFolder}
+    sudo -u ${vsCodeUser} git -C ${homeFolder} add .
+    sudo -u ${vsCodeUser} git -C ${homeFolder} commit -m "chore: initial commit $branch"
+    mv ${homeFolder}/.git /tmp/git
+    rm -rf ${homeFolder}
+    mkdir ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}
+    mv /tmp/git/.git ${homeFolder}
+  done
+  sudo -u ${vsCodeUser} git -C ${homeFolder} checkout main 2>&1
+  sudo -u ${vsCodeUser} git -C ${homeFolder} restore .
+  rm -rf /tmp/branch
+  rm -rf /tmp/git
+  echo "Branches downloaded. Checking configuration: ${homeFolder}"
+  sudo -u ${vsCodeUser} git -C ${homeFolder} branch
+  ls -la ${homeFolder}
+fi`,
+                ],
+            },
+        };
+    }
+    createSSMDocument(scope, devServerBasePath, devServerPort, vsCodeUser, homeFolder, linuxFlavor, customDomainName, repoUrl, assetZipS3Path, branchZipS3Path, folderZipS3Path) {
         // Generate nginx server_name directive based on custom domain
         const serverNameDirective = customDomainName
             ? `server_name *.cloudfront.net ${customDomainName};`
@@ -74,6 +470,7 @@ class Installer {
         switch (linuxFlavor) {
             case vscode_server_1.LinuxFlavorType.UBUNTU_22:
             case vscode_server_1.LinuxFlavorType.UBUNTU_24:
+            case vscode_server_1.LinuxFlavorType.UBUNTU_25:
                 // Create an SSM document with multiple actions to install the software
                 ssmDocument = new ssm.CfnDocument(scope, 'ssm-document-ubuntu', {
                     name: `vscode-server-ubuntu-${core_1.Stack.of(scope).stackName}`,
@@ -88,45 +485,37 @@ class Installer {
                             },
                             NodeVersion: {
                                 type: 'String',
-                                default: '20',
-                                allowedValues: ['22', '20', '18'],
+                                default: '22',
+                                allowedValues: ['24', '22', '20', '18'],
+                            },
+                            RepoUrl: {
+                                type: 'String',
+                                default: repoUrl ?? '',
+                            },
+                            AssetZipS3Path: {
+                                type: 'String',
+                                default: assetZipS3Path ?? '',
                             },
-                            DotNetVersion: {
+                            BranchZipS3Path: {
                                 type: 'String',
-                                default: '8.0',
-                                allowedValues: ['8.0', '7.0'],
+                                default: branchZipS3Path ?? '',
+                            },
+                            FolderZipS3Path: {
+                                type: 'String',
+                                default: folderZipS3Path ?? '',
                             },
                         },
                         // all mainSteps scripts are in in /var/lib/amazon/ssm/<instanceid>/document/orchestration/<uuid>/<StepName>/_script.sh
                         mainSteps: [
-                            {
-                                action: 'aws:configurePackage',
-                                name: 'InstallCloudWatchAgent',
-                                inputs: {
-                                    name: 'AmazonCloudWatchAgent',
-                                    action: 'Install',
-                                },
-                            },
-                            {
-                                action: 'aws:runDocument',
-                                name: 'ConfigureCloudWatchAgent',
-                                inputs: {
-                                    documentType: 'SSMDocument',
-                                    documentPath: 'AmazonCloudWatch-ManageAgent',
-                                    documentParameters: {
-                                        action: 'configure',
-                                        mode: 'ec2',
-                                        optionalConfigurationSource: 'default',
-                                        optionalRestart: 'yes',
-                                    },
-                                },
-                            },
+                            this.createInstallCloudWatchAgentStep(),
+                            this.createConfigureCloudWatchAgentStep(),
                             {
                                 action: 'aws:runShellScript',
                                 name: 'InstallAptPackagesApt',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
+                                        'dpkg --configure -a',
                                         'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q apt-utils',
                                         'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q needrestart unattended-upgrades',
                                         "sed -i 's/#$nrconf{kernelhints} = -1;/$nrconf{kernelhints} = 0;/' /etc/needrestart/needrestart.conf",
@@ -143,7 +532,8 @@ class Installer {
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q curl gnupg whois argon2 openssl locales locales-all unzip apt-transport-https ca-certificates software-properties-common nginx',
+                                        'dpkg --configure -a',
+                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q curl gnupg whois argon2 unzip nginx openssl locales locales-all apt-transport-https ca-certificates software-properties-common',
                                     ],
                                 },
                             },
@@ -153,68 +543,69 @@ class Installer {
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        "echo 'Adding user: ${VSCodeUser}'",
-                                        `adduser --disabled-password --gecos '' ${vsCodeUser}`,
-                                        `echo "${vsCodeUser}:{{ VSCodePassword }}" | chpasswd`,
-                                        `usermod -aG sudo ${vsCodeUser}`,
+                                        'dpkg --configure -a',
+                                        `if [[ "${vsCodeUser}" == "ubuntu" ]]
+then
+  echo 'Using existing user: ${vsCodeUser}'
+else
+  echo 'Adding user: ${vsCodeUser}'
+  adduser --disabled-password --gecos '' ${vsCodeUser}
+  echo "${vsCodeUser}:{{ VSCodePassword }}" | chpasswd
+  usermod -aG sudo ${vsCodeUser}
+fi`,
                                         `tee /etc/sudoers.d/91-vscode-user <<EOF
 ${vsCodeUser} ALL=(ALL) NOPASSWD:ALL
 EOF`,
                                         `mkdir -p /home/${vsCodeUser} && chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
+                                        `mkdir -p /home/${vsCodeUser}/.local/bin && chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
                                         'echo "User added. Checking configuration"',
                                         `getent passwd ${vsCodeUser}`,
                                     ],
                                 },
                             },
+                            this.createUpdateProfileStep(vsCodeUser, core_1.Stack.of(scope).region, core_1.Stack.of(scope).account),
+                            this.createInstallAWSCLIStep(vsCodeUser),
                             {
                                 action: 'aws:runShellScript',
-                                name: 'InstallNodeApt',
-                                inputs: {
-                                    runCommand: [
-                                        '#!/bin/bash',
-                                        'curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /usr/share/keyrings/nodesource.gpg',
-                                        'echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/nodesource.gpg] https://deb.nodesource.com/node_{{ NodeVersion }}.x nodistro main" > /etc/apt/sources.list.d/nodesource.list',
-                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q nodejs',
-                                        'npm install -g npm@latest',
-                                        'echo "Node and npm installed. Checking configuration"',
-                                        'node -v',
-                                        'npm -v',
-                                    ],
-                                },
-                            },
-                            {
-                                action: 'aws:runShellScript',
-                                name: 'InstallDockerApt',
+                                name: 'InstallGitApt',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg',
-                                        'echo "deb [signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release --codename --short) stable" > /etc/apt/sources.list.d/docker.list',
-                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q docker-ce docker-ce-cli containerd.io',
-                                        `systemctl restart code-server@${vsCodeUser}.service`,
-                                        'systemctl start docker.service',
-                                        'echo "Docker installed. Checking configuration"',
-                                        'docker --version',
-                                        'systemctl status docker.service',
+                                        'dpkg --configure -a',
+                                        'add-apt-repository ppa:git-core/ppa',
+                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q git',
+                                        `sudo -u ${vsCodeUser} git config --global user.email "participant@example.com"`,
+                                        `sudo -u ${vsCodeUser} git config --global user.name "Workshop Participant"`,
+                                        `sudo -u ${vsCodeUser} git config --global init.defaultBranch "main"`,
+                                        'echo "Git installed. Checking configuration"',
+                                        'git --version',
                                     ],
                                 },
                             },
+                            this.createCloneRepoStep(vsCodeUser, homeFolder),
+                            this.createDownloadAssetsStep(vsCodeUser, homeFolder),
+                            this.createDownloadFoldersStep(vsCodeUser, homeFolder),
+                            this.createDownloadBranchesStep(vsCodeUser, homeFolder),
+                            this.createConfigureCodeServerStep(vsCodeUser, homeFolder, devServerBasePath, devServerPort, serverNameDirective),
                             {
                                 action: 'aws:runShellScript',
-                                name: 'InstallGitApt',
+                                name: 'InstallNodeApt',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'add-apt-repository ppa:git-core/ppa',
-                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q git',
-                                        `sudo -u ${vsCodeUser} git config --global user.email "${vsCodeUser}@example.com"`,
-                                        `sudo -u ${vsCodeUser} git config --global user.name "Workshop ${vsCodeUser}"`,
-                                        `sudo -u ${vsCodeUser} git config --global init.defaultBranch "main"`,
-                                        'echo "Git installed. Checking configuration"',
-                                        'git --version',
+                                        'curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /usr/share/keyrings/nodesource.gpg',
+                                        'echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/nodesource.gpg] https://deb.nodesource.com/node_{{ NodeVersion }}.x nodistro main" > /etc/apt/sources.list.d/nodesource.list',
+                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q nodejs',
+                                        'npm install -g npm@latest',
+                                        'echo "Node and npm installed. Checking configuration"',
+                                        'node -v',
+                                        'npm -v',
                                     ],
                                 },
                             },
+                            this.createInstallCDKStep(),
+                            this.createInstallQCLIStep(vsCodeUser),
+                            this.createInstalluvStep(vsCodeUser),
                             {
                                 action: 'aws:runShellScript',
                                 name: 'InstallPythonApt',
@@ -224,11 +615,20 @@ EOF`,
                                         // Ubuntu 24 default is Python 3.12
                                         // The default installed Python version will map to Python3
                                         '#!/bin/bash',
+                                        'dpkg --configure -a',
                                         'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q python3-pip python3-venv python3-boto3 python3-pytest',
                                         `echo 'alias pytest=pytest-3' >> /home/${vsCodeUser}/.bashrc`,
-                                        `systemctl restart code-server@${vsCodeUser}.service`,
                                         'systemctl start multipathd.service packagekit.service',
                                         'systemctl restart unattended-upgrades.service',
+                                        'systemctl restart networkd-dispatcher.service',
+                                        `sudo -u ${vsCodeUser} --login code-server --install-extension ms-python.python --force`,
+                                        `if [ -f /home/${vsCodeUser}/.local/share/code-server/User/settings.json ]; then
+  sed -i "2i\\\\  \\"python.testing.pytestEnabled\\": true," /home/${vsCodeUser}/.local/share/code-server/User/settings.json
+else
+  echo '{
+    "python.testing.pytestEnabled": true
+  }' > /home/${vsCodeUser}/.local/share/code-server/User/settings.json
+fi`,
                                         'echo "Python and Pip installed. Checking configuration"',
                                         'python3 --version',
                                         'pip3 --version',
@@ -237,121 +637,75 @@ EOF`,
                             },
                             {
                                 action: 'aws:runShellScript',
-                                name: 'InstallAWSCLI',
+                                name: 'InstallJavaApt',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'curl -fsSL https://awscli.amazonaws.com/awscli-exe-linux-$(uname -m).zip -o /tmp/aws-cli.zip',
-                                        'unzip -q -d /tmp /tmp/aws-cli.zip',
-                                        'sudo /tmp/aws/install',
-                                        'rm -rf /tmp/aws',
-                                        'echo "AWS CLI installed. Checking configuration"',
-                                        'aws --version',
+                                        'dpkg --configure -a',
+                                        'curl -fsSL https://apt.corretto.aws/corretto.key | gpg --dearmor -o /usr/share/keyrings/corretto-keyring.gpg',
+                                        'echo "deb [signed-by=/usr/share/keyrings/corretto-keyring.gpg] https://apt.corretto.aws stable main" > /etc/apt/sources.list.d/corretto.list',
+                                        'DEBIAN_FRONTEND=noninteractive apt-get update',
+                                        'DEBIAN_FRONTEND=noninteractive apt-get install -y -q java-21-amazon-corretto-jdk java-17-amazon-corretto-jdk java-1.8.0-amazon-corretto-jdk maven',
+                                        `echo 'export JAVA_8_HOME=$(update-alternatives --list java | grep "java-1.8.0-amazon-corretto" | head -1)' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_8_PATH=$(update-alternatives --list java | grep "java-1.8.0-amazon-corretto" | head -1)' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_17_PATH=$(update-alternatives --list java | grep "java-17-amazon-corretto" | head -1)' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_17_HOME=$(update-alternatives --list java | grep "java-17-amazon-corretto" | head -1)' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_21_PATH=$(update-alternatives --list java | grep "java-21-amazon-corretto" | head -1)' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_21_HOME=$(update-alternatives --list java | grep "java-21-amazon-corretto" | head -1)' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_HOME=$(update-alternatives --list java | grep "java-21-amazon-corretto" | head -1)' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export PATH=$PATH:$JAVA_HOME/bin:/usr/share/maven/bin' >> /home/${vsCodeUser}/.bashrc`,
+                                        `sudo -u ${vsCodeUser} --login code-server --install-extension vscjava.vscode-java-pack --force`,
+                                        'echo "Java and Maven installed. Checking configuration"',
+                                        'java -version 2>&1',
+                                        'mvn --version',
+                                        'update-alternatives --list java',
                                     ],
                                 },
                             },
                             {
                                 action: 'aws:runShellScript',
-                                name: 'ConfigureCodeServer',
+                                name: 'InstallDotnetApt',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        `export HOME=/home/${vsCodeUser}`,
-                                        'curl -fsSL https://code-server.dev/install.sh | bash -s -- 2>&1',
-                                        `systemctl enable --now code-server@${vsCodeUser} 2>&1`,
-                                        `tee /etc/nginx/conf.d/code-server.conf <<EOF
-server {
-    listen 80;
-    listen [::]:80;
-    # server_name distribution.distributionDomainName;
-    ${serverNameDirective}
-    location / {
-      proxy_pass http://localhost:8080/;
-      proxy_set_header Host \\$host;
-      proxy_set_header Upgrade \\$http_upgrade;
-      proxy_set_header Connection upgrade;
-      proxy_set_header Accept-Encoding gzip;
-    }
-    location /${devServerBasePath} {
-      proxy_pass http://localhost:${devServerPort}/${devServerBasePath};
-      proxy_set_header Host \\$host;
-      proxy_set_header Upgrade \\$http_upgrade;
-      proxy_set_header Connection upgrade;
-      proxy_set_header Accept-Encoding gzip;
-    }
-}
-EOF`,
-                                        `mkdir -p /home/${vsCodeUser}/.config/code-server`,
-                                        `tee /home/${vsCodeUser}/.config/code-server/config.yaml <<EOF
-cert: false
-auth: password
-hashed-password: "$(echo -n {{ VSCodePassword }} | argon2 $(openssl rand -base64 12) -e)"
-EOF`,
-                                        `mkdir -p /home/${vsCodeUser}/.local/share/code-server/User/`,
-                                        `touch /home/${vsCodeUser}/.hushlogin`,
-                                        `mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}`,
-                                        `tee /home/${vsCodeUser}/.local/share/code-server/User/settings.json <<EOF
-{
-  "extensions.autoUpdate": false,
-  "extensions.autoCheckUpdates": false,
-  "telemetry.telemetryLevel": "off",
-  "security.workspace.trust.startupPrompt": "never",
-  "security.workspace.trust.enabled": false,
-  "security.workspace.trust.banner": "never",
-  "security.workspace.trust.emptyWindow": false,
-  "python.testing.pytestEnabled": true,
-  "auto-run-command.rules": [
-    {
-      "command": "workbench.action.terminal.new"
-    }
-  ]
-}
-EOF`,
-                                        `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
-                                        `systemctl restart code-server@${vsCodeUser}`,
-                                        'systemctl restart nginx',
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.aws-toolkit-vscode --force`,
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.amazon-q-vscode --force`,
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension synedra.auto-run-command --force`,
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension vscjava.vscode-java-pack --force`,
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension ms-vscode.live-server --force`,
+                                        'dpkg --configure -a',
+                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q dotnet-sdk-8.0',
+                                        'dotnet tool install -g Microsoft.Web.LibraryManager.Cli',
+                                        `echo 'PATH=$PATH:/home/${vsCodeUser}/.dotnet/tools' >> /home/${vsCodeUser}/.bashrc`,
                                         `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
-                                        'echo "Nginx installed. Checking configuration"',
-                                        'nginx -t 2>&1',
-                                        'systemctl status nginx',
-                                        'echo "CodeServer installed. Checking configuration"',
-                                        'code-server -v',
-                                        `systemctl status code-server@${vsCodeUser}`,
+                                        'echo "Dotnet installed. Checking configuration"',
+                                        'dotnet --list-sdks',
                                     ],
                                 },
                             },
                             {
                                 action: 'aws:runShellScript',
-                                name: 'UpdateProfile',
+                                name: 'InstallDockerApt',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'echo LANG=en_US.utf-8 >> /etc/environment',
-                                        'echo LC_ALL=en_US.UTF-8 >> /etc/environment',
-                                        `echo 'PATH=$PATH:/home/${vsCodeUser}/.local/bin' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo 'export PATH' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo 'export AWS_REGION=${core_1.Stack.of(scope).region}' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo 'export AWS_ACCOUNTID=${core_1.Stack.of(scope).account}' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo 'export NEXT_TELEMETRY_DISABLED=1' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo "export PS1='\\[\\033[01;32m\\]\\u:\\[\\033[01;34m\\]\\w\\[\\033[00m\\]\\$ '" >> /home/${vsCodeUser}/.bashrc`,
-                                        `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
+                                        'curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg',
+                                        'echo "deb [signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release --codename --short) stable" > /etc/apt/sources.list.d/docker.list',
+                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q docker-ce docker-ce-cli containerd.io',
+                                        `usermod -aG docker ${vsCodeUser}`,
+                                        `systemctl restart code-server@${vsCodeUser}.service`,
+                                        'systemctl start docker.service',
+                                        'echo "Docker installed. Checking configuration"',
+                                        'docker --version',
+                                        'systemctl status docker.service',
                                     ],
                                 },
                             },
                             {
                                 action: 'aws:runShellScript',
-                                name: 'InstallCDK',
+                                name: 'InstallGolangApt',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'npm install -g aws-cdk',
-                                        'echo "AWS CDK installed. Checking configuration"',
-                                        'cdk --version',
+                                        'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q golang',
+                                        `echo 'PATH=$PATH:/home/${vsCodeUser}/go/bin' >> /home/${vsCodeUser}/.bashrc`,
+                                        'echo "Golang installed. Checking configuration"',
+                                        'go version',
                                     ],
                                 },
                             },
@@ -373,39 +727,30 @@ EOF`,
                             },
                             NodeVersion: {
                                 type: 'String',
-                                default: '20',
-                                allowedValues: ['22', '20', '18'],
+                                default: '22',
+                                allowedValues: ['24', '22', '20', '18'],
+                            },
+                            RepoUrl: {
+                                type: 'String',
+                                default: repoUrl ?? '',
                             },
-                            DotNetVersion: {
+                            AssetZipS3Path: {
                                 type: 'String',
-                                default: '8.0',
-                                allowedValues: ['8.0', '7.0'],
+                                default: assetZipS3Path ?? '',
+                            },
+                            BranchZipS3Path: {
+                                type: 'String',
+                                default: branchZipS3Path ?? '',
+                            },
+                            FolderZipS3Path: {
+                                type: 'String',
+                                default: folderZipS3Path ?? '',
                             },
                         },
                         // all mainSteps scripts are in in /var/lib/amazon/ssm/<instanceid>/document/orchestration/<uuid>/<StepName>/_script.sh
                         mainSteps: [
-                            {
-                                action: 'aws:configurePackage',
-                                name: 'InstallCloudWatchAgent',
-                                inputs: {
-                                    name: 'AmazonCloudWatchAgent',
-                                    action: 'Install',
-                                },
-                            },
-                            {
-                                action: 'aws:runDocument',
-                                name: 'ConfigureCloudWatchAgent',
-                                inputs: {
-                                    documentType: 'SSMDocument',
-                                    documentPath: 'AmazonCloudWatch-ManageAgent',
-                                    documentParameters: {
-                                        action: 'configure',
-                                        mode: 'ec2',
-                                        optionalConfigurationSource: 'default',
-                                        optionalRestart: 'yes',
-                                    },
-                                },
-                            },
+                            this.createInstallCloudWatchAgentStep(),
+                            this.createConfigureCloudWatchAgentStep(),
                             {
                                 action: 'aws:runShellScript',
                                 name: 'InstallBasePackagesDnf',
@@ -422,24 +767,55 @@ EOF`,
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        `echo 'Adding user: ${vsCodeUser}'`,
-                                        `adduser -c '' ${vsCodeUser}`,
-                                        `passwd -l ${vsCodeUser}`,
-                                        `echo "${vsCodeUser}:{{ VSCodePassword }}" | chpasswd`,
-                                        `usermod -aG wheel ${vsCodeUser}`,
+                                        `if [[ "${vsCodeUser}" == "ec2-user" ]]
+then
+  echo 'Using existing user: ${vsCodeUser}'
+else
+  echo 'Adding user: ${vsCodeUser}'
+  adduser -c '' ${vsCodeUser}
+  passwd -l ${vsCodeUser}
+  echo "${vsCodeUser}:{{ VSCodePassword }}" | chpasswd
+  usermod -aG wheel ${vsCodeUser}
+fi`,
+                                        `tee /etc/sudoers.d/91-vscode-user <<EOF
+${vsCodeUser} ALL=(ALL) NOPASSWD:ALL
+EOF`,
+                                        `mkdir -p /home/${vsCodeUser} && chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
+                                        `mkdir -p /home/${vsCodeUser}/.local/bin && chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
                                         'echo "User added. Checking configuration"',
                                         `getent passwd ${vsCodeUser}`,
                                     ],
                                 },
                             },
+                            this.createUpdateProfileStep(vsCodeUser, core_1.Stack.of(scope).region, core_1.Stack.of(scope).account),
+                            this.createInstallAWSCLIStep(vsCodeUser),
+                            {
+                                action: 'aws:runShellScript',
+                                name: 'InstallGitDnf',
+                                inputs: {
+                                    runCommand: [
+                                        '#!/bin/bash',
+                                        'dnf install -y git',
+                                        `sudo -u ${vsCodeUser} git config --global user.email "participant@example.com"`,
+                                        `sudo -u ${vsCodeUser} git config --global user.name "Workshop Participant"`,
+                                        `sudo -u ${vsCodeUser} git config --global init.defaultBranch "main"`,
+                                        'echo "Git installed. Checking configuration"',
+                                        'git --version',
+                                    ],
+                                },
+                            },
+                            this.createCloneRepoStep(vsCodeUser, homeFolder),
+                            this.createDownloadAssetsStep(vsCodeUser, homeFolder),
+                            this.createDownloadFoldersStep(vsCodeUser, homeFolder),
+                            this.createDownloadBranchesStep(vsCodeUser, homeFolder),
+                            this.createConfigureCodeServerStep(vsCodeUser, homeFolder, devServerBasePath, devServerPort, serverNameDirective),
                             {
                                 action: 'aws:runShellScript',
                                 name: 'InstallNodeDnf',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'dnf install -y nodejs20 npm',
-                                        'ln -s -f /usr/bin/node-20 /usr/bin/node',
+                                        'dnf install -y nodejs npm',
                                         'npm install -g npm@latest',
                                         'echo "Node and npm installed. Checking configuration"',
                                         'node -v',
@@ -449,32 +825,49 @@ EOF`,
                             },
                             {
                                 action: 'aws:runShellScript',
-                                name: 'InstallDockerDnf',
+                                name: 'InstallCDK',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'dnf install -y docker',
-                                        `usermod -aG docker ${vsCodeUser}`,
-                                        `systemctl restart code-server@${vsCodeUser}.service`,
-                                        'systemctl start docker.service',
-                                        'echo "Docker installed. Checking configuration"',
-                                        'docker --version',
-                                        'systemctl status docker.service',
+                                        'npm install -g aws-cdk',
+                                        'echo "AWS CDK installed. Checking configuration"',
+                                        'cdk --version',
                                     ],
                                 },
                             },
                             {
                                 action: 'aws:runShellScript',
-                                name: 'InstallGitDnf',
+                                name: 'InstallQCLI',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'dnf install -y git',
-                                        `sudo -u ${vsCodeUser} git config --global user.email "${vsCodeUser}@example.com"`,
-                                        `sudo -u ${vsCodeUser} git config --global user.name "Workshop ${vsCodeUser}"`,
-                                        `sudo -u ${vsCodeUser} git config --global init.defaultBranch "main"`,
-                                        'echo "Git installed. Checking configuration"',
-                                        'git --version',
+                                        'curl --proto \'=https\' --tlsv1.2 -sSf "https://desktop-release.q.us-east-1.amazonaws.com/latest/q-$(uname -m)-linux.zip" -o /tmp/q.zip',
+                                        `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/q.zip`,
+                                        'unzip -q -d /tmp /tmp/q.zip',
+                                        `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/q`,
+                                        'chmod +x /tmp/q/install.sh',
+                                        `sudo -u ${vsCodeUser} /tmp/q/install.sh --no-confirm`,
+                                        'rm -rf /tmp/q',
+                                        'echo "Amazon Q CLI installed"',
+                                    ],
+                                },
+                            },
+                            {
+                                action: 'aws:runShellScript',
+                                name: 'Installuv',
+                                inputs: {
+                                    runCommand: [
+                                        '#!/bin/bash',
+                                        `sudo -u ${vsCodeUser} --login curl -fsSL https://astral.sh/uv/install.sh -o /tmp/uv_install.sh`,
+                                        `sudo -u ${vsCodeUser} --login bash /tmp/uv_install.sh`,
+                                        `if uv generate-shell-completion bash &>/dev/null; then
+  echo 'eval "$(uv generate-shell-completion bash)"' >> /home/${vsCodeUser}/.bashrc
+fi`,
+                                        `if uvx generate-shell-completion bash &>/dev/null; then
+  echo 'eval "$(uvx generate-shell-completion bash)"' >> /home/${vsCodeUser}/.bashrc
+fi`,
+                                        'echo "uv installed. Checking configuration"',
+                                        `sudo -u ${vsCodeUser} --login uv --version`,
                                     ],
                                 },
                             },
@@ -494,130 +887,83 @@ EOF`,
                                         "echo 'alias=python3=python3.11' >> ~/.bashrc",
                                         "echo 'alias pip3=pip3.11' >> ~/.bashrc",
                                         'python3.11 -m pip install --upgrade pip 2>&1',
+                                        `sudo -u ${vsCodeUser} --login code-server --install-extension ms-python.python --force`,
+                                        `if [ -f /home/${vsCodeUser}/.local/share/code-server/User/settings.json ]; then
+  sed -i "2i\\\\  \\"python.testing.pytestEnabled\\": true," /home/${vsCodeUser}/.local/share/code-server/User/settings.json
+else
+  echo '{
+    "python.testing.pytestEnabled": true
+  }' > /home/${vsCodeUser}/.local/share/code-server/User/settings.json
+fi`,
                                         'echo "Python and Pip installed. Checking configuration"',
                                         'python3.11 --version',
                                         'python3.11 -m pip --version 2>&1',
                                     ],
                                 },
                             },
-                            // add go, dotnet
                             {
                                 action: 'aws:runShellScript',
-                                name: 'InstallAWSCLI',
+                                name: 'InstallJavaDnf',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'curl -fsSL https://awscli.amazonaws.com/awscli-exe-linux-$(uname -m).zip -o /tmp/aws-cli.zip',
-                                        'unzip -q -d /tmp /tmp/aws-cli.zip',
-                                        'sudo /tmp/aws/install',
-                                        'rm -rf /tmp/aws',
-                                        'echo "AWS CLI installed. Checking configuration"',
-                                        'aws --version',
+                                        'dnf install -y java-21-amazon-corretto java-17-amazon-corretto java-1.8.0-amazon-corretto maven',
+                                        `echo 'export JAVA_8_HOME=/usr/lib/jvm/java-1.8.0-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_8_PATH=/usr/lib/jvm/java-1.8.0-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_17_PATH=/usr/lib/jvm/java-17-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_17_HOME=/usr/lib/jvm/java-17-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_21_PATH=/usr/lib/jvm/java-21-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_21_HOME=/usr/lib/jvm/java-21-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export JAVA_HOME=/usr/lib/jvm/java-21-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,
+                                        `echo 'export PATH=$PATH:$JAVA_HOME/bin:/usr/share/maven/bin' >> /home/${vsCodeUser}/.bashrc`,
+                                        `sudo -u ${vsCodeUser} --login code-server --install-extension vscjava.vscode-java-pack --force`,
+                                        'echo "Java and Maven installed. Checking configuration"',
+                                        'java -version 2>&1',
+                                        'mvn --version',
                                     ],
                                 },
                             },
                             {
                                 action: 'aws:runShellScript',
-                                name: 'ConfigureCodeServer',
+                                name: 'InstallDotnetDnf',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        `export HOME=/home/${vsCodeUser}`,
-                                        'curl -fsSL https://code-server.dev/install.sh | bash -s -- 2>&1',
-                                        `systemctl enable --now code-server@${vsCodeUser} 2>&1`,
-                                        `tee /etc/nginx/conf.d/code-server.conf <<EOF
-server {
-    listen 80;
-    listen [::]:80;
-    # server_name distribution.distributionDomainName;
-    ${serverNameDirective}
-    location / {
-      proxy_pass http://localhost:8080/;
-      proxy_set_header Host \\$host;
-      proxy_set_header Upgrade \\$http_upgrade;
-      proxy_set_header Connection upgrade;
-      proxy_set_header Accept-Encoding gzip;
-    }
-    location /${devServerBasePath} {
-      proxy_pass http://localhost:${devServerPort}/${devServerBasePath};
-      proxy_set_header Host \\$host;
-      proxy_set_header Upgrade \\$http_upgrade;
-      proxy_set_header Connection upgrade;
-      proxy_set_header Accept-Encoding gzip;
-    }
-}
-EOF`,
-                                        `mkdir -p /home/${vsCodeUser}/.config/code-server`,
-                                        `tee /home/${vsCodeUser}/.config/code-server/config.yaml <<EOF
-cert: false
-auth: password
-hashed-password: "$(echo -n {{ VSCodePassword }} | argon2 $(openssl rand -base64 12) -e)"
-EOF`,
-                                        `mkdir -p /home/${vsCodeUser}/.local/share/code-server/User/`,
-                                        `touch /home/${vsCodeUser}/.hushlogin`,
-                                        `mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}`,
-                                        `tee /home/${vsCodeUser}/.local/share/code-server/User/settings.json <<EOF
-{
-  "extensions.autoUpdate": false,
-  "extensions.autoCheckUpdates": false,
-  "telemetry.telemetryLevel": "off",
-  "security.workspace.trust.startupPrompt": "never",
-  "security.workspace.trust.enabled": false,
-  "security.workspace.trust.banner": "never",
-  "security.workspace.trust.emptyWindow": false,
-  "python.testing.pytestEnabled": true,
-  "auto-run-command.rules": [
-    {
-      "command": "workbench.action.terminal.new"
-    }
-  ]
-}
-EOF`,
-                                        `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
-                                        `systemctl restart code-server@${vsCodeUser}`,
-                                        'systemctl restart nginx',
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.aws-toolkit-vscode --force`,
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.amazon-q-vscode --force`,
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension synedra.auto-run-command --force`,
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension vscjava.vscode-java-pack --force`,
-                                        `sudo -u ${vsCodeUser} --login code-server --install-extension ms-vscode.live-server --force`,
+                                        'dnf install -y dotnet-sdk-8.0',
+                                        'dotnet tool install -g Microsoft.Web.LibraryManager.Cli',
+                                        `echo 'PATH=$PATH:/home/${vsCodeUser}/.dotnet/tools' >> /home/${vsCodeUser}/.bashrc`,
                                         `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
-                                        'echo "Nginx installed. Checking configuration"',
-                                        'nginx -t 2>&1',
-                                        'systemctl status nginx',
-                                        'echo "CodeServer installed. Checking configuration"',
-                                        'code-server -v',
-                                        `systemctl status code-server@${vsCodeUser}`,
+                                        'echo "Dotnet installed. Checking configuration"',
+                                        'dotnet --list-sdks',
                                     ],
                                 },
                             },
                             {
                                 action: 'aws:runShellScript',
-                                name: 'UpdateProfile',
+                                name: 'InstallDockerDnf',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'echo LANG=en_US.utf-8 >> /etc/environment',
-                                        'echo LC_ALL=en_US.UTF-8 >> /etc/environment',
-                                        `echo 'PATH=$PATH:/home/${vsCodeUser}/.local/bin' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo 'export PATH' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo 'export AWS_REGION=${core_1.Stack.of(scope).region}' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo 'export AWS_ACCOUNTID=${core_1.Stack.of(scope).account}' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo 'export NEXT_TELEMETRY_DISABLED=1' >> /home/${vsCodeUser}/.bashrc`,
-                                        `echo "export PS1='\\[\\033[01;32m\\]\\u:\\[\\033[01;34m\\]\\w\\[\\033[00m\\]\\$ '" >> /home/${vsCodeUser}/.bashrc`,
-                                        `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,
+                                        'dnf install -y docker',
+                                        `usermod -aG docker ${vsCodeUser}`,
+                                        `systemctl restart code-server@${vsCodeUser}.service`,
+                                        'systemctl start docker.service',
+                                        'echo "Docker installed. Checking configuration"',
+                                        'docker --version',
+                                        'systemctl status docker.service',
                                     ],
                                 },
                             },
                             {
                                 action: 'aws:runShellScript',
-                                name: 'InstallCDK',
+                                name: 'InstallGolangDnf',
                                 inputs: {
                                     runCommand: [
                                         '#!/bin/bash',
-                                        'npm install -g aws-cdk',
-                                        'echo "AWS CDK installed. Checking configuration"',
-                                        'cdk --version',
+                                        'dnf install -y golang',
+                                        `echo 'PATH=$PATH:/home/${vsCodeUser}/go/bin' >> /home/${vsCodeUser}/.bashrc`,
+                                        'echo "Golang installed. Checking configuration"',
+                                        'go version',
                                     ],
                                 },
                             },
@@ -636,7 +982,7 @@ class CustomResourceInstaller extends Installer {
     constructor(scope, options) {
         super();
         const onEvent = new installer_function_1.InstallerFunction(scope, 'InstallerOnEventHandler', {
-            timeout: core_1.Duration.seconds(300), // TODO configurable
+            timeout: core_1.Duration.minutes(15), // 15 minutes to allow for VS Code Server installation
             memorySize: 512, // TODO configurable
         });
         cdk_nag_1.NagSuppressions.addResourceSuppressions([onEvent], [
@@ -664,14 +1010,26 @@ class CustomResourceInstaller extends Installer {
             resource: 'instance',
             resourceName: options.instanceId,
         }, core_1.Stack.of(scope));
+        // SendCommand supports resource-level permissions
         onEvent.addToRolePolicy(new aws_iam_1.PolicyStatement({
-            actions: [
-                'ssm:SendCommand',
-                'ssm:GetCommandInvocation',
-                'ssm:ListCommandInvocations',
-            ],
+            actions: ['ssm:SendCommand'],
             resources: [documentArn, cwManageAgentArn, targetEc2InstanceArn],
         }));
+        // GetCommandInvocation and ListCommandInvocations require wildcard resources
+        // They don't support resource-level permissions
+        onEvent.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: ['ssm:GetCommandInvocation', 'ssm:ListCommandInvocations'],
+            resources: ['*'],
+        }));
+        // Suppress cdk-nag warning for wildcard permissions on GetCommandInvocation
+        // These SSM actions don't support resource-level permissions per AWS documentation
+        cdk_nag_1.NagSuppressions.addResourceSuppressions(onEvent, [
+            {
+                id: 'AwsSolutions-IAM5',
+                reason: 'ssm:GetCommandInvocation and ssm:ListCommandInvocations do not support resource-level permissions and require wildcard resources',
+                appliesTo: ['Resource::*'],
+            },
+        ], true);
         const provider = new custom_resources_1.Provider(scope, 'InstallerProvider', {
             onEventHandler: onEvent,
         });
@@ -692,7 +1050,7 @@ class CustomResourceInstaller extends Installer {
         new core_1.CustomResource(scope, 'SSMInstallerCustomResource', {
             serviceToken: provider.serviceToken,
             properties: {
-                ServiceTimeout: 305, // TODO configurable
+                ServiceTimeout: core_1.Duration.minutes(15).toSeconds() + 5, // Lambda timeout + 5 seconds buffer
                 InstanceId: options.instanceId,
                 DocumentName: options.documentName,
                 CloudWatchLogGroupName: options.cloudWatchLogGroupName,
@@ -702,4 +1060,4 @@ class CustomResourceInstaller extends Installer {
     }
     _bind() { }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"installer.js","sourceRoot":"","sources":["../../src/installer/installer.ts"],"names":[],"mappings":"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","sourcesContent":["import { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Function } from 'aws-cdk-lib/aws-lambda';\nimport * as ssm from 'aws-cdk-lib/aws-ssm';\nimport { Arn, CustomResource, Duration, Stack } from 'aws-cdk-lib/core';\nimport { Provider } from 'aws-cdk-lib/custom-resources';\nimport { NagSuppressions } from 'cdk-nag';\nimport { Construct } from 'constructs';\nimport { InstallerFunction } from './installer-function';\nimport { LinuxFlavorType } from '../vscode-server';\n\ninterface InstallerOptionsBase {\n  /**\n   * The ec2 instance id to install the ssm document on\n   */\n  readonly instanceId: string;\n\n  /**\n   * The name of the custom ssm document to install.\n   *\n   * @default the ssm document of the construct\n   */\n  readonly documentName?: string;\n\n  /**\n   * The name of the cloudwatch log group for the install logs\n   *\n   * @default /aws/ssm/${documentName}\n   */\n  readonly cloudWatchLogGroupName?: string;\n\n  /**\n   * The name of the user under which the vscode server runs\n   */\n  readonly vsCodeUser: string;\n\n  /**\n   * The password of the user under which the vscode server runs\n   */\n  readonly vsCodePassword: string;\n\n  /**\n   * The home folder of the user under which the vscode server runs\n   */\n  readonly homeFolder: string;\n\n  /**\n   * The base rest path vs code server will run\n   *\n   * @default app\n   */\n  readonly devServerBasePath?: string;\n\n  /**\n   * The port vscoder server will be served in the instance\n   *\n   * @default 8081\n   */\n  readonly devServerPort?: number;\n\n  /**\n   * The custom domain name for the VS Code server\n   * Used to configure nginx server_name directive\n   *\n   * @default - uses *.cloudfront.net only\n   */\n  readonly customDomainName?: string;\n}\n\nexport interface InstallerOptions extends InstallerOptionsBase {}\n\nexport abstract class Installer {\n  public static ubuntu(options: InstallerOptions): Installer {\n    return new (class extends Installer {\n      public _bind(scope: Construct): Installer {\n        let documentName;\n        const devServerBasePath = options.devServerBasePath ?? 'app';\n        const devServerPort = options.devServerPort ?? 8081;\n        if (options.documentName && options.documentName != '') {\n          documentName = options.documentName;\n        } else {\n          const document = this.createSSMDocument(\n            scope,\n            devServerBasePath,\n            devServerPort,\n            options.vsCodeUser,\n            options.homeFolder,\n            LinuxFlavorType.UBUNTU_22,\n            options.customDomainName,\n          );\n          documentName = document.name!;\n        }\n\n        const cloudWatchLogGroupName =\n          options.cloudWatchLogGroupName ?? `/aws/ssm/${documentName}`;\n\n        const installer = new CustomResourceInstaller(scope, {\n          instanceId: options.instanceId,\n          documentName: documentName,\n          cloudWatchLogGroupName: cloudWatchLogGroupName,\n          vsCodeUser: options.vsCodeUser,\n          vsCodePassword: options.vsCodePassword,\n          homeFolder: options.homeFolder,\n        });\n\n        return installer;\n      }\n    })();\n  }\n\n  public static amazonLinux2023(options: InstallerOptions): Installer {\n    return new (class extends Installer {\n      public _bind(scope: Construct): Installer {\n        let documentName;\n        const devServerBasePath = options.devServerBasePath ?? 'app';\n        const devServerPort = options.devServerPort ?? 8081;\n        if (options.documentName && options.documentName != '') {\n          documentName = options.documentName;\n        } else {\n          const document = this.createSSMDocument(\n            scope,\n            devServerBasePath,\n            devServerPort,\n            options.vsCodeUser,\n            options.homeFolder,\n            LinuxFlavorType.AMAZON_LINUX_2023,\n            options.customDomainName,\n          );\n          documentName = document.name!;\n        }\n\n        const cloudWatchLogGroupName =\n          options.cloudWatchLogGroupName ?? `/aws/ssm/${documentName}`;\n\n        const installer = new CustomResourceInstaller(scope, {\n          instanceId: options.instanceId,\n          documentName: documentName,\n          cloudWatchLogGroupName: cloudWatchLogGroupName,\n          vsCodeUser: options.vsCodeUser,\n          vsCodePassword: options.vsCodePassword,\n          homeFolder: options.homeFolder,\n        });\n\n        return installer;\n      }\n    })();\n  }\n\n  public instanceId!: string;\n  public documentName!: string;\n  public cloudWatchLogGroupName!: string;\n  public vsCodePassword!: string;\n  public vsCodePasswordTest!: string;\n\n  /**\n   * @internal\n   */\n  protected constructor() {}\n\n  /**\n   * @internal\n   */\n  public abstract _bind(scope: Construct): any;\n\n  private createSSMDocument(\n    scope: Construct,\n    devServerBasePath: string,\n    devServerPort: number,\n    vsCodeUser: string,\n    homeFolder: string,\n    linuxFlavor: LinuxFlavorType,\n    customDomainName?: string,\n  ): ssm.CfnDocument {\n    // Generate nginx server_name directive based on custom domain\n    const serverNameDirective = customDomainName\n      ? `server_name *.cloudfront.net ${customDomainName};`\n      : 'server_name *.cloudfront.net;';\n\n    let ssmDocument: ssm.CfnDocument;\n    switch (linuxFlavor) {\n      case LinuxFlavorType.UBUNTU_22:\n      case LinuxFlavorType.UBUNTU_24:\n        // Create an SSM document with multiple actions to install the software\n        ssmDocument = new ssm.CfnDocument(scope, 'ssm-document-ubuntu', {\n          name: `vscode-server-ubuntu-${Stack.of(scope).stackName}`,\n          documentType: 'Command',\n          content: {\n            schemaVersion: '2.2',\n            description: 'Bootstrap VSCode code-server instance',\n            parameters: {\n              VSCodePassword: {\n                type: 'String',\n                default: Stack.of(scope).stackId,\n              },\n              NodeVersion: {\n                type: 'String',\n                default: '20',\n                allowedValues: ['22', '20', '18'],\n              },\n              DotNetVersion: {\n                type: 'String',\n                default: '8.0',\n                allowedValues: ['8.0', '7.0'],\n              },\n            },\n            // all mainSteps scripts are in in /var/lib/amazon/ssm/<instanceid>/document/orchestration/<uuid>/<StepName>/_script.sh\n            mainSteps: [\n              {\n                action: 'aws:configurePackage',\n                name: 'InstallCloudWatchAgent',\n                inputs: {\n                  name: 'AmazonCloudWatchAgent',\n                  action: 'Install',\n                },\n              },\n              {\n                action: 'aws:runDocument',\n                name: 'ConfigureCloudWatchAgent',\n                inputs: {\n                  documentType: 'SSMDocument',\n                  documentPath: 'AmazonCloudWatch-ManageAgent',\n                  documentParameters: {\n                    action: 'configure',\n                    mode: 'ec2',\n                    optionalConfigurationSource: 'default',\n                    optionalRestart: 'yes',\n                  },\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallAptPackagesApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q apt-utils',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q needrestart unattended-upgrades',\n                    \"sed -i 's/#$nrconf{kernelhints} = -1;/$nrconf{kernelhints} = 0;/' /etc/needrestart/needrestart.conf\",\n                    \"sed -i 's/#$nrconf{verbosity} = 2;/$nrconf{verbosity} = 0;/' /etc/needrestart/needrestart.conf\",\n                    \"sed -i \\\"s/#\\$nrconf{restart} = 'i';/\\$nrconf{restart} = 'a';/\\\" /etc/needrestart/needrestart.conf\",\n                    'echo \"Apt helper packages added. Checking configuration\"',\n                    'cat /etc/needrestart/needrestart.conf',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallBasePackagesApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q curl gnupg whois argon2 openssl locales locales-all unzip apt-transport-https ca-certificates software-properties-common nginx',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'AddUserApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    \"echo 'Adding user: ${VSCodeUser}'\",\n                    `adduser --disabled-password --gecos '' ${vsCodeUser}`,\n                    `echo \"${vsCodeUser}:{{ VSCodePassword }}\" | chpasswd`,\n                    `usermod -aG sudo ${vsCodeUser}`,\n                    `tee /etc/sudoers.d/91-vscode-user <<EOF\n${vsCodeUser} ALL=(ALL) NOPASSWD:ALL\nEOF`,\n                    `mkdir -p /home/${vsCodeUser} && chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    'echo \"User added. Checking configuration\"',\n                    `getent passwd ${vsCodeUser}`,\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallNodeApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /usr/share/keyrings/nodesource.gpg',\n                    'echo \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/nodesource.gpg] https://deb.nodesource.com/node_{{ NodeVersion }}.x nodistro main\" > /etc/apt/sources.list.d/nodesource.list',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q nodejs',\n                    'npm install -g npm@latest',\n                    'echo \"Node and npm installed. Checking configuration\"',\n                    'node -v',\n                    'npm -v',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallDockerApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg',\n                    'echo \"deb [signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release --codename --short) stable\" > /etc/apt/sources.list.d/docker.list',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q docker-ce docker-ce-cli containerd.io',\n                    `systemctl restart code-server@${vsCodeUser}.service`,\n                    'systemctl start docker.service',\n                    'echo \"Docker installed. Checking configuration\"',\n                    'docker --version',\n                    'systemctl status docker.service',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallGitApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'add-apt-repository ppa:git-core/ppa',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q git',\n                    `sudo -u ${vsCodeUser} git config --global user.email \"${vsCodeUser}@example.com\"`,\n                    `sudo -u ${vsCodeUser} git config --global user.name \"Workshop ${vsCodeUser}\"`,\n                    `sudo -u ${vsCodeUser} git config --global init.defaultBranch \"main\"`,\n                    'echo \"Git installed. Checking configuration\"',\n                    'git --version',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallPythonApt',\n                inputs: {\n                  runCommand: [\n                    // Ubuntu 22 default is Python 3.10\n                    // Ubuntu 24 default is Python 3.12\n                    // The default installed Python version will map to Python3\n                    '#!/bin/bash',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q python3-pip python3-venv python3-boto3 python3-pytest',\n                    `echo 'alias pytest=pytest-3' >> /home/${vsCodeUser}/.bashrc`,\n                    `systemctl restart code-server@${vsCodeUser}.service`,\n                    'systemctl start multipathd.service packagekit.service',\n                    'systemctl restart unattended-upgrades.service',\n                    'echo \"Python and Pip installed. Checking configuration\"',\n                    'python3 --version',\n                    'pip3 --version',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallAWSCLI',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'curl -fsSL https://awscli.amazonaws.com/awscli-exe-linux-$(uname -m).zip -o /tmp/aws-cli.zip',\n                    'unzip -q -d /tmp /tmp/aws-cli.zip',\n                    'sudo /tmp/aws/install',\n                    'rm -rf /tmp/aws',\n                    'echo \"AWS CLI installed. Checking configuration\"',\n                    'aws --version',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'ConfigureCodeServer',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    `export HOME=/home/${vsCodeUser}`,\n                    'curl -fsSL https://code-server.dev/install.sh | bash -s -- 2>&1',\n                    `systemctl enable --now code-server@${vsCodeUser} 2>&1`,\n                    `tee /etc/nginx/conf.d/code-server.conf <<EOF\nserver {\n    listen 80;\n    listen [::]:80;\n    # server_name distribution.distributionDomainName;\n    ${serverNameDirective}\n    location / {\n      proxy_pass http://localhost:8080/;\n      proxy_set_header Host \\\\$host;\n      proxy_set_header Upgrade \\\\$http_upgrade;\n      proxy_set_header Connection upgrade;\n      proxy_set_header Accept-Encoding gzip;\n    }\n    location /${devServerBasePath} {\n      proxy_pass http://localhost:${devServerPort}/${devServerBasePath};\n      proxy_set_header Host \\\\$host;\n      proxy_set_header Upgrade \\\\$http_upgrade;\n      proxy_set_header Connection upgrade;\n      proxy_set_header Accept-Encoding gzip;\n    }\n}\nEOF`,\n                    `mkdir -p /home/${vsCodeUser}/.config/code-server`,\n                    `tee /home/${vsCodeUser}/.config/code-server/config.yaml <<EOF\ncert: false\nauth: password\nhashed-password: \"$(echo -n {{ VSCodePassword }} | argon2 $(openssl rand -base64 12) -e)\"\nEOF`,\n                    `mkdir -p /home/${vsCodeUser}/.local/share/code-server/User/`,\n                    `touch /home/${vsCodeUser}/.hushlogin`,\n                    `mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}`,\n                    `tee /home/${vsCodeUser}/.local/share/code-server/User/settings.json <<EOF\n{\n  \"extensions.autoUpdate\": false,\n  \"extensions.autoCheckUpdates\": false,\n  \"telemetry.telemetryLevel\": \"off\",\n  \"security.workspace.trust.startupPrompt\": \"never\",\n  \"security.workspace.trust.enabled\": false,\n  \"security.workspace.trust.banner\": \"never\",\n  \"security.workspace.trust.emptyWindow\": false,\n  \"python.testing.pytestEnabled\": true,\n  \"auto-run-command.rules\": [\n    {\n      \"command\": \"workbench.action.terminal.new\"\n    }\n  ]\n}\nEOF`,\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    `systemctl restart code-server@${vsCodeUser}`,\n                    'systemctl restart nginx',\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.aws-toolkit-vscode --force`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.amazon-q-vscode --force`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension synedra.auto-run-command --force`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension vscjava.vscode-java-pack --force`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension ms-vscode.live-server --force`,\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    'echo \"Nginx installed. Checking configuration\"',\n                    'nginx -t 2>&1',\n                    'systemctl status nginx',\n                    'echo \"CodeServer installed. Checking configuration\"',\n                    'code-server -v',\n                    `systemctl status code-server@${vsCodeUser}`,\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'UpdateProfile',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'echo LANG=en_US.utf-8 >> /etc/environment',\n                    'echo LC_ALL=en_US.UTF-8 >> /etc/environment',\n                    `echo 'PATH=$PATH:/home/${vsCodeUser}/.local/bin' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export PATH' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export AWS_REGION=${Stack.of(scope).region}' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export AWS_ACCOUNTID=${Stack.of(scope).account}' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export NEXT_TELEMETRY_DISABLED=1' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo \"export PS1='\\\\[\\\\033[01;32m\\\\]\\\\u:\\\\[\\\\033[01;34m\\\\]\\\\w\\\\[\\\\033[00m\\\\]\\\\$ '\" >> /home/${vsCodeUser}/.bashrc`,\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallCDK',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'npm install -g aws-cdk',\n                    'echo \"AWS CDK installed. Checking configuration\"',\n                    'cdk --version',\n                  ],\n                },\n              },\n            ],\n          },\n        });\n        break;\n      case LinuxFlavorType.AMAZON_LINUX_2023:\n        ssmDocument = new ssm.CfnDocument(scope, 'ssm-document-al2023', {\n          name: `vscode-server-al2023-${Stack.of(scope).stackName}`,\n          documentType: 'Command',\n          content: {\n            schemaVersion: '2.2',\n            description: 'Bootstrap VSCode code-server instance',\n            parameters: {\n              VSCodePassword: {\n                type: 'String',\n                default: Stack.of(scope).stackId,\n              },\n              NodeVersion: {\n                type: 'String',\n                default: '20',\n                allowedValues: ['22', '20', '18'],\n              },\n              DotNetVersion: {\n                type: 'String',\n                default: '8.0',\n                allowedValues: ['8.0', '7.0'],\n              },\n            },\n            // all mainSteps scripts are in in /var/lib/amazon/ssm/<instanceid>/document/orchestration/<uuid>/<StepName>/_script.sh\n            mainSteps: [\n              {\n                action: 'aws:configurePackage',\n                name: 'InstallCloudWatchAgent',\n                inputs: {\n                  name: 'AmazonCloudWatchAgent',\n                  action: 'Install',\n                },\n              },\n              {\n                action: 'aws:runDocument',\n                name: 'ConfigureCloudWatchAgent',\n                inputs: {\n                  documentType: 'SSMDocument',\n                  documentPath: 'AmazonCloudWatch-ManageAgent',\n                  documentParameters: {\n                    action: 'configure',\n                    mode: 'ec2',\n                    optionalConfigurationSource: 'default',\n                    optionalRestart: 'yes',\n                  },\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallBasePackagesDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y --allowerasing whois argon2 unzip nginx curl gnupg openssl',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'AddUserDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    `echo 'Adding user: ${vsCodeUser}'`,\n                    `adduser -c '' ${vsCodeUser}`,\n                    `passwd -l ${vsCodeUser}`,\n                    `echo \"${vsCodeUser}:{{ VSCodePassword }}\" | chpasswd`,\n                    `usermod -aG wheel ${vsCodeUser}`,\n                    'echo \"User added. Checking configuration\"',\n                    `getent passwd ${vsCodeUser}`,\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallNodeDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y nodejs20 npm',\n                    'ln -s -f /usr/bin/node-20 /usr/bin/node',\n                    'npm install -g npm@latest',\n                    'echo \"Node and npm installed. Checking configuration\"',\n                    'node -v',\n                    'npm -v',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallDockerDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y docker',\n                    `usermod -aG docker ${vsCodeUser}`,\n                    `systemctl restart code-server@${vsCodeUser}.service`,\n                    'systemctl start docker.service',\n                    'echo \"Docker installed. Checking configuration\"',\n                    'docker --version',\n                    'systemctl status docker.service',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallGitDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y git',\n                    `sudo -u ${vsCodeUser} git config --global user.email \"${vsCodeUser}@example.com\"`,\n                    `sudo -u ${vsCodeUser} git config --global user.name \"Workshop ${vsCodeUser}\"`,\n                    `sudo -u ${vsCodeUser} git config --global init.defaultBranch \"main\"`,\n                    'echo \"Git installed. Checking configuration\"',\n                    'git --version',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallPythonDnf',\n                inputs: {\n                  runCommand: [\n                    // AL2023 currently ships with Python 3.9 preinstalled, but 3.11 is available in the repository\n                    // Install 3.11 alongside 3.9 and setup some alias so that 3.11 is loaded when participant runs Python3\n                    // If Python 3.12 become available, update below\n                    '#!/bin/bash',\n                    'dnf install -y python3.11 python3.11-pip python3-virtualenv python3-pytest python3-boto3',\n                    `echo 'alias pytest=pytest-3' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'alias python3=python3.11' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'alias pip3=pip3.11' >> /home/${vsCodeUser}/.bashrc`,\n                    \"echo 'alias=python3=python3.11' >> ~/.bashrc\",\n                    \"echo 'alias pip3=pip3.11' >> ~/.bashrc\",\n                    'python3.11 -m pip install --upgrade pip 2>&1',\n                    'echo \"Python and Pip installed. Checking configuration\"',\n                    'python3.11 --version',\n                    'python3.11 -m pip --version 2>&1',\n                  ],\n                },\n              },\n              // add go, dotnet\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallAWSCLI',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'curl -fsSL https://awscli.amazonaws.com/awscli-exe-linux-$(uname -m).zip -o /tmp/aws-cli.zip',\n                    'unzip -q -d /tmp /tmp/aws-cli.zip',\n                    'sudo /tmp/aws/install',\n                    'rm -rf /tmp/aws',\n                    'echo \"AWS CLI installed. Checking configuration\"',\n                    'aws --version',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'ConfigureCodeServer',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    `export HOME=/home/${vsCodeUser}`,\n                    'curl -fsSL https://code-server.dev/install.sh | bash -s -- 2>&1',\n                    `systemctl enable --now code-server@${vsCodeUser} 2>&1`,\n                    `tee /etc/nginx/conf.d/code-server.conf <<EOF\nserver {\n    listen 80;\n    listen [::]:80;\n    # server_name distribution.distributionDomainName;\n    ${serverNameDirective}\n    location / {\n      proxy_pass http://localhost:8080/;\n      proxy_set_header Host \\\\$host;\n      proxy_set_header Upgrade \\\\$http_upgrade;\n      proxy_set_header Connection upgrade;\n      proxy_set_header Accept-Encoding gzip;\n    }\n    location /${devServerBasePath} {\n      proxy_pass http://localhost:${devServerPort}/${devServerBasePath};\n      proxy_set_header Host \\\\$host;\n      proxy_set_header Upgrade \\\\$http_upgrade;\n      proxy_set_header Connection upgrade;\n      proxy_set_header Accept-Encoding gzip;\n    }\n}\nEOF`,\n                    `mkdir -p /home/${vsCodeUser}/.config/code-server`,\n                    `tee /home/${vsCodeUser}/.config/code-server/config.yaml <<EOF\ncert: false\nauth: password\nhashed-password: \"$(echo -n {{ VSCodePassword }} | argon2 $(openssl rand -base64 12) -e)\"\nEOF`,\n                    `mkdir -p /home/${vsCodeUser}/.local/share/code-server/User/`,\n                    `touch /home/${vsCodeUser}/.hushlogin`,\n                    `mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}`,\n                    `tee /home/${vsCodeUser}/.local/share/code-server/User/settings.json <<EOF\n{\n  \"extensions.autoUpdate\": false,\n  \"extensions.autoCheckUpdates\": false,\n  \"telemetry.telemetryLevel\": \"off\",\n  \"security.workspace.trust.startupPrompt\": \"never\",\n  \"security.workspace.trust.enabled\": false,\n  \"security.workspace.trust.banner\": \"never\",\n  \"security.workspace.trust.emptyWindow\": false,\n  \"python.testing.pytestEnabled\": true,\n  \"auto-run-command.rules\": [\n    {\n      \"command\": \"workbench.action.terminal.new\"\n    }\n  ]\n}\nEOF`,\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    `systemctl restart code-server@${vsCodeUser}`,\n                    'systemctl restart nginx',\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.aws-toolkit-vscode --force`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.amazon-q-vscode --force`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension synedra.auto-run-command --force`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension vscjava.vscode-java-pack --force`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension ms-vscode.live-server --force`,\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    'echo \"Nginx installed. Checking configuration\"',\n                    'nginx -t 2>&1',\n                    'systemctl status nginx',\n                    'echo \"CodeServer installed. Checking configuration\"',\n                    'code-server -v',\n                    `systemctl status code-server@${vsCodeUser}`,\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'UpdateProfile',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'echo LANG=en_US.utf-8 >> /etc/environment',\n                    'echo LC_ALL=en_US.UTF-8 >> /etc/environment',\n                    `echo 'PATH=$PATH:/home/${vsCodeUser}/.local/bin' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export PATH' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export AWS_REGION=${Stack.of(scope).region}' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export AWS_ACCOUNTID=${Stack.of(scope).account}' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export NEXT_TELEMETRY_DISABLED=1' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo \"export PS1='\\\\[\\\\033[01;32m\\\\]\\\\u:\\\\[\\\\033[01;34m\\\\]\\\\w\\\\[\\\\033[00m\\\\]\\\\$ '\" >> /home/${vsCodeUser}/.bashrc`,\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallCDK',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'npm install -g aws-cdk',\n                    'echo \"AWS CDK installed. Checking configuration\"',\n                    'cdk --version',\n                  ],\n                },\n              },\n            ],\n          },\n        });\n        break;\n      default:\n        throw new Error(`Unsupported Linux flavor: ${linuxFlavor}`);\n    }\n\n    return ssmDocument;\n  }\n}\n\ninterface CustomResourceInstallerOptions extends InstallerOptions {}\n\nclass CustomResourceInstaller extends Installer {\n  constructor(scope: Construct, options: CustomResourceInstallerOptions) {\n    super();\n\n    const onEvent: Function = new InstallerFunction(\n      scope,\n      'InstallerOnEventHandler',\n      {\n        timeout: Duration.seconds(300), // TODO configurable\n        memorySize: 512, // TODO configurable\n      },\n    );\n    NagSuppressions.addResourceSuppressions(\n      [onEvent],\n      [\n        {\n          id: 'AwsSolutions-IAM4',\n          reason:\n            'For this event handler we do not need to restrict managed policies',\n        },\n        {\n          id: 'AwsSolutions-L1',\n          reason: 'For this lambda the latest runtime is not needed',\n        },\n      ],\n      true,\n    );\n\n    const documentArn = Arn.format(\n      {\n        service: 'ssm',\n        resource: 'document',\n        resourceName: options.documentName,\n      },\n      Stack.of(scope),\n    );\n\n    const cwManageAgentArn = Arn.format(\n      {\n        service: 'ssm',\n        resource: 'document',\n        resourceName: 'AmazonCloudWatch-ManageAgent',\n      },\n      Stack.of(scope),\n    );\n\n    const targetEc2InstanceArn = Arn.format(\n      {\n        service: 'ec2',\n        resource: 'instance',\n        resourceName: options.instanceId,\n      },\n      Stack.of(scope),\n    );\n\n    onEvent.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          'ssm:SendCommand',\n          'ssm:GetCommandInvocation',\n          'ssm:ListCommandInvocations',\n        ],\n        resources: [documentArn, cwManageAgentArn, targetEc2InstanceArn],\n      }),\n    );\n\n    const provider = new Provider(scope, 'InstallerProvider', {\n      onEventHandler: onEvent,\n    });\n    NagSuppressions.addResourceSuppressions(\n      [provider],\n      [\n        {\n          id: 'AwsSolutions-IAM4',\n          reason:\n            'For this provider we do not need to restrict managed policies',\n        },\n        {\n          id: 'AwsSolutions-IAM5',\n          reason: 'For this provider wildcards are fine',\n        },\n        {\n          id: 'AwsSolutions-L1',\n          reason: 'For this provider the latest runtime is not needed',\n        },\n      ],\n      true,\n    );\n\n    new CustomResource(scope, 'SSMInstallerCustomResource', {\n      serviceToken: provider.serviceToken,\n      properties: {\n        ServiceTimeout: 305, // TODO configurable\n        InstanceId: options.instanceId,\n        DocumentName: options.documentName,\n        CloudWatchLogGroupName: options.cloudWatchLogGroupName,\n        VSCodePassword: options.vsCodePassword,\n      },\n    });\n  }\n\n  public _bind() {}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"installer.js","sourceRoot":"","sources":["../../src/installer/installer.ts"],"names":[],"mappings":"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","sourcesContent":["import { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Function } from 'aws-cdk-lib/aws-lambda';\nimport * as ssm from 'aws-cdk-lib/aws-ssm';\nimport { Arn, CustomResource, Duration, Stack } from 'aws-cdk-lib/core';\nimport { Provider } from 'aws-cdk-lib/custom-resources';\nimport { NagSuppressions } from 'cdk-nag';\nimport { Construct } from 'constructs';\nimport { InstallerFunction } from './installer-function';\nimport { LinuxFlavorType } from '../vscode-server';\n\ninterface InstallerOptionsBase {\n  /**\n   * The ec2 instance id to install the ssm document on\n   */\n  readonly instanceId: string;\n\n  /**\n   * The name of the custom ssm document to install.\n   *\n   * @default the ssm document of the construct\n   */\n  readonly documentName?: string;\n\n  /**\n   * The name of the cloudwatch log group for the install logs\n   *\n   * @default /aws/ssm/${documentName}\n   */\n  readonly cloudWatchLogGroupName?: string;\n\n  /**\n   * The name of the user under which the vscode server runs\n   */\n  readonly vsCodeUser: string;\n\n  /**\n   * The password of the user under which the vscode server runs\n   */\n  readonly vsCodePassword: string;\n\n  /**\n   * The home folder of the user under which the vscode server runs\n   */\n  readonly homeFolder: string;\n\n  /**\n   * The base rest path vs code server will run\n   *\n   * @default app\n   */\n  readonly devServerBasePath?: string;\n\n  /**\n   * The port vscoder server will be served in the instance\n   *\n   * @default 8081\n   */\n  readonly devServerPort?: number;\n\n  /**\n   * The custom domain name for the VS Code server\n   * Used to configure nginx server_name directive\n   *\n   * @default - uses *.cloudfront.net only\n   */\n  readonly customDomainName?: string;\n\n  /**\n   * The Linux flavor type for the instance\n   */\n  readonly linuxFlavorType: LinuxFlavorType;\n\n  /**\n   * Remote git repository URL to clone into the home folder.\n   *\n   * If provided, the repository will be cloned into the user's home folder during instance setup.\n   * Useful for pre-populating workshop environments with starter code.\n   *\n   * @example 'https://github.com/aws-samples/my-workshop-repo.git'\n   * @default - no repo cloned\n   */\n  readonly repoUrl?: string;\n\n  /**\n   * S3 path to a zip file containing assets to extract into the home folder.\n   *\n   * The zip contents will be extracted to the user's home folder and committed to git.\n   * Use this to provide workshop materials, sample data, or configuration files.\n   *\n   * @example 'my-workshop-bucket/assets/workshop-materials.zip'\n   * @default - no assets downloaded\n   */\n  readonly assetZipS3Path?: string;\n\n  /**\n   * S3 path to a zip file containing git branches to create in the home folder repository.\n   *\n   * Each top-level folder in the zip becomes a separate git branch with that folder's contents.\n   * Ideal for creating step-by-step workshop branches (e.g., step-1, step-2, solution).\n   *\n   * @example 'my-workshop-bucket/branches/lab-branches.zip' (containing folders: step-1/, step-2/, solution/)\n   * @default - no branches created\n   */\n  readonly branchZipS3Path?: string;\n\n  /**\n   * S3 path to a zip file containing multiple folders to create as separate git repositories.\n   *\n   * Each top-level folder in the zip becomes a separate subfolder in the parent directory,\n   * initialized as its own git repository. Useful for multi-project workshops.\n   *\n   * @example 'my-workshop-bucket/folders/workshop-projects.zip' (containing folders: frontend/, backend/, infrastructure/)\n   * @default - no folders created\n   */\n  readonly folderZipS3Path?: string;\n}\n\nexport interface InstallerOptions extends InstallerOptionsBase {}\n\nexport abstract class Installer {\n  public static ubuntu(options: InstallerOptions): Installer {\n    return new (class extends Installer {\n      public _bind(scope: Construct): Installer {\n        let documentName;\n        const devServerBasePath = options.devServerBasePath ?? 'app';\n        const devServerPort = options.devServerPort ?? 8081;\n        if (options.documentName && options.documentName != '') {\n          documentName = options.documentName;\n        } else {\n          const document = this.createSSMDocument(\n            scope,\n            devServerBasePath,\n            devServerPort,\n            options.vsCodeUser,\n            options.homeFolder,\n            options.linuxFlavorType,\n            options.customDomainName,\n            options.repoUrl,\n            options.assetZipS3Path,\n            options.branchZipS3Path,\n            options.folderZipS3Path,\n          );\n          documentName = document.name!;\n        }\n\n        const cloudWatchLogGroupName =\n          options.cloudWatchLogGroupName ?? `/aws/ssm/${documentName}`;\n\n        const installer = new CustomResourceInstaller(scope, {\n          instanceId: options.instanceId,\n          documentName: documentName,\n          cloudWatchLogGroupName: cloudWatchLogGroupName,\n          vsCodeUser: options.vsCodeUser,\n          vsCodePassword: options.vsCodePassword,\n          homeFolder: options.homeFolder,\n        });\n\n        return installer;\n      }\n    })();\n  }\n\n  public static amazonLinux2023(options: InstallerOptions): Installer {\n    return new (class extends Installer {\n      public _bind(scope: Construct): Installer {\n        let documentName;\n        const devServerBasePath = options.devServerBasePath ?? 'app';\n        const devServerPort = options.devServerPort ?? 8081;\n        if (options.documentName && options.documentName != '') {\n          documentName = options.documentName;\n        } else {\n          const document = this.createSSMDocument(\n            scope,\n            devServerBasePath,\n            devServerPort,\n            options.vsCodeUser,\n            options.homeFolder,\n            LinuxFlavorType.AMAZON_LINUX_2023,\n            options.customDomainName,\n            options.repoUrl,\n            options.assetZipS3Path,\n            options.branchZipS3Path,\n            options.folderZipS3Path,\n          );\n          documentName = document.name!;\n        }\n\n        const cloudWatchLogGroupName =\n          options.cloudWatchLogGroupName ?? `/aws/ssm/${documentName}`;\n\n        const installer = new CustomResourceInstaller(scope, {\n          instanceId: options.instanceId,\n          documentName: documentName,\n          cloudWatchLogGroupName: cloudWatchLogGroupName,\n          vsCodeUser: options.vsCodeUser,\n          vsCodePassword: options.vsCodePassword,\n          homeFolder: options.homeFolder,\n        });\n\n        return installer;\n      }\n    })();\n  }\n\n  public instanceId!: string;\n  public documentName!: string;\n  public cloudWatchLogGroupName!: string;\n  public vsCodePassword!: string;\n  public vsCodePasswordTest!: string;\n\n  /**\n   * @internal\n   */\n  protected constructor() {}\n\n  /**\n   * @internal\n   */\n  public abstract _bind(scope: Construct): any;\n\n  /**\n   * Creates the InstallCloudWatchAgent step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createInstallCloudWatchAgentStep(): any {\n    return {\n      action: 'aws:configurePackage',\n      name: 'InstallCloudWatchAgent',\n      inputs: {\n        name: 'AmazonCloudWatchAgent',\n        action: 'Install',\n      },\n    };\n  }\n\n  /**\n   * Creates the ConfigureCloudWatchAgent step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createConfigureCloudWatchAgentStep(): any {\n    return {\n      action: 'aws:runDocument',\n      name: 'ConfigureCloudWatchAgent',\n      inputs: {\n        documentType: 'SSMDocument',\n        documentPath: 'AmazonCloudWatch-ManageAgent',\n        documentParameters: {\n          action: 'configure',\n          mode: 'ec2',\n          optionalConfigurationSource: 'default',\n          optionalRestart: 'yes',\n        },\n      },\n    };\n  }\n\n  /**\n   * Creates the UpdateProfile step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createUpdateProfileStep(vsCodeUser: string, region: string, account: string): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'UpdateProfile',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          'echo LANG=en_US.utf-8 >> /etc/environment',\n          'echo LC_ALL=en_US.UTF-8 >> /etc/environment',\n          `echo 'PATH=$PATH:/home/${vsCodeUser}/.local/bin' >> /home/${vsCodeUser}/.bashrc`,\n          `echo 'export PATH' >> /home/${vsCodeUser}/.bashrc`,\n          `echo 'export AWS_REGION=${region}' >> /home/${vsCodeUser}/.bashrc`,\n          `echo 'export AWS_ACCOUNTID=${account}' >> /home/${vsCodeUser}/.bashrc`,\n          `echo 'export NEXT_TELEMETRY_DISABLED=1' >> /home/${vsCodeUser}/.bashrc`,\n          `echo \"export PS1='\\\\[\\\\033[01;32m\\\\]\\\\u:\\\\[\\\\033[01;34m\\\\]\\\\w\\\\[\\\\033[00m\\\\]\\\\$ '\" >> /home/${vsCodeUser}/.bashrc`,\n          `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n        ],\n      },\n    };\n  }\n\n  /**\n   * Creates the InstallAWSCLI step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createInstallAWSCLIStep(vsCodeUser: string): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'InstallAWSCLI',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          'mkdir -p /tmp',\n          'curl -fsSL https://awscli.amazonaws.com/awscli-exe-linux-$(uname -m).zip -o /tmp/aws-cli.zip',\n          `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/aws-cli.zip`,\n          'unzip -q -d /tmp /tmp/aws-cli.zip',\n          'sudo /tmp/aws/install',\n          'rm -rf /tmp/aws',\n          'echo \"AWS CLI installed. Checking configuration\"',\n          'aws --version',\n        ],\n      },\n    };\n  }\n\n  /**\n   * Creates the CloneRepo step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createCloneRepoStep(vsCodeUser: string, homeFolder: string): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'CloneRepo',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          `if [[ -z \"{{ RepoUrl }}\" ]]\nthen\n  echo \"No Repo\"\nelse\n  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}\n  sudo -u ${vsCodeUser} git clone {{ RepoUrl }} ${homeFolder}\n  echo \"Repo {{ RepoUrl }} cloned. Checking configuration\"\n  ls -la ${homeFolder}\n  sudo -u ${vsCodeUser} git -C ${homeFolder} remote -v\nfi`,\n        ],\n      },\n    };\n  }\n\n  /**\n   * Creates the DownloadAssets step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createDownloadAssetsStep(vsCodeUser: string, homeFolder: string): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'DownloadAssets',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          `if [[ -z \"{{ AssetZipS3Path }}\" ]]\nthen\n  echo \"No assets\"\nelse\n  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}\n  mkdir -p /tmp\n  aws s3 cp s3://{{ AssetZipS3Path }} /tmp/asset.zip\n  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/asset.zip\n  unzip -o /tmp/asset.zip -d ${homeFolder}\n  chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}\n  if  [[ -d ${homeFolder}/.git ]]\n  then\n    sudo -u ${vsCodeUser} git -C ${homeFolder} add .\n    sudo -u ${vsCodeUser} git -C ${homeFolder} commit -m 'chore: workshop commit'\n  else\n    sudo -u ${vsCodeUser} git -C ${homeFolder} init\n    sudo -u ${vsCodeUser} git -C ${homeFolder} add .\n    sudo -u ${vsCodeUser} git -C ${homeFolder} commit -m 'chore: initial commit'\n  fi\n  echo \"Assets downloaded. Checking configuration: ${homeFolder}\"\n  ls -la ${homeFolder}\n  sudo -u ${vsCodeUser} git -C ${homeFolder} branch\nfi`,\n        ],\n      },\n    };\n  }\n\n  /**\n   * Creates the DownloadFolders step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createDownloadFoldersStep(vsCodeUser: string, homeFolder: string): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'DownloadFolders',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          `if [[ -z \"{{ FolderZipS3Path }}\" ]]\nthen\n  echo \"No folders\"\nelse\n  rm -rf /tmp/folder\n  mkdir -p /tmp/folder && chown -R ${vsCodeUser}:${vsCodeUser} /tmp/folder\n  aws s3 cp s3://{{ FolderZipS3Path }} /tmp/asset-folder.zip\n  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/asset-folder.zip\n  unzip -o /tmp/asset-folder.zip -d /tmp/folder\n  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/folder\n  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}\n  cd \"${homeFolder}\" && cd ..\n  if [[ $(pwd) ==  \"/\" ]]\n  then\n    targetRootFolder=\"\"\n  else\n    targetRootFolder=$(pwd)\n    chown -R ${vsCodeUser}:${vsCodeUser} .\n  fi\n  find \"/tmp/folder\" -maxdepth 1 -mindepth 1 -type d | while read sourceFolder; do\n    folder=\"$(basename $sourceFolder)\"\n    echo \"Processing folder: $folder\"\n    targetFolder=$targetRootFolder/$folder\n    if [[ $targetRootFolder == \"\" ]]\n    then\n      mv $sourceFolder /\n    else\n      mv $sourceFolder $targetRootFolder\n    fi\n    chown -R ${vsCodeUser}:${vsCodeUser} $targetFolder\n    sudo -u ${vsCodeUser} git -C $targetFolder init\n    sudo -u ${vsCodeUser} git -C $targetFolder add .\n    sudo -u ${vsCodeUser} git -C $targetFolder commit -m \"chore: initial commit\"\n    echo \"Folder downloaded. Checking configuration: $targetFolder\"\n    ls -la $targetFolder\n  done\n  rm -rf /tmp/folder\nfi`,\n        ],\n      },\n    };\n  }\n\n  /**\n   * Creates the InstallCDK step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createInstallCDKStep(): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'InstallCDK',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          'npm install -g aws-cdk',\n          'echo \"AWS CDK installed. Checking configuration\"',\n          'cdk --version',\n        ],\n      },\n    };\n  }\n\n  /**\n   * Creates the InstallQCLI step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createInstallQCLIStep(vsCodeUser: string): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'InstallQCLI',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          'curl --proto \\'=https\\' --tlsv1.2 -sSf \"https://desktop-release.q.us-east-1.amazonaws.com/latest/q-$(uname -m)-linux.zip\" -o /tmp/q.zip',\n          `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/q.zip`,\n          'unzip -q -d /tmp /tmp/q.zip',\n          `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/q`,\n          'chmod +x /tmp/q/install.sh',\n          `sudo -u ${vsCodeUser} /tmp/q/install.sh --no-confirm`,\n          'rm -rf /tmp/q',\n          'q --version',\n          'echo \"Amazon Q CLI installed\"',\n        ],\n      },\n    };\n  }\n\n  /**\n   * Creates the Installuv step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createInstalluvStep(vsCodeUser: string): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'Installuv',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          `sudo -u ${vsCodeUser} --login curl -fsSL https://astral.sh/uv/install.sh -o /tmp/uv_install.sh`,\n          `sudo -u ${vsCodeUser} --login bash /tmp/uv_install.sh`,\n          `if uv generate-shell-completion bash &>/dev/null; then\n  echo 'eval \"$(uv generate-shell-completion bash)\"' >> /home/${vsCodeUser}/.bashrc\nfi`,\n          `if uvx generate-shell-completion bash &>/dev/null; then\n  echo 'eval \"$(uvx generate-shell-completion bash)\"' >> /home/${vsCodeUser}/.bashrc\nfi`,\n          'echo \"uv installed. Checking configuration\"',\n          `sudo -u ${vsCodeUser} --login uv --version`,\n        ],\n      },\n    };\n  }\n\n  /**\n   * Creates the ConfigureCodeServer step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createConfigureCodeServerStep(\n    vsCodeUser: string,\n    homeFolder: string,\n    devServerBasePath: string,\n    devServerPort: number,\n    serverNameDirective: string,\n  ): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'ConfigureCodeServer',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          `export HOME=/home/${vsCodeUser}`,\n          'curl -fsSL https://code-server.dev/install.sh | sh -s -- --version 4.100.3',\n          `systemctl enable --now code-server@${vsCodeUser} 2>&1`,\n          `tee /etc/nginx/conf.d/code-server.conf <<EOF\nserver {\n    listen 80;\n    listen [::]:80;\n    # server_name \\\\$\\\\{CloudFrontDistribution.DomainName\\\\};\n    ${serverNameDirective}\n    location / {\n      proxy_pass http://localhost:8080/;\n      proxy_set_header Host \\\\$host;\n      proxy_set_header Upgrade \\\\$http_upgrade;\n      proxy_set_header Connection upgrade;\n      proxy_set_header Accept-Encoding gzip;\n    }\n    location /${devServerBasePath} {\n      proxy_pass http://localhost:${devServerPort}/${devServerBasePath};\n      proxy_set_header Host \\\\$host;\n      proxy_set_header Upgrade \\\\$http_upgrade;\n      proxy_set_header Connection upgrade;\n      proxy_set_header Accept-Encoding gzip;\n    }\n}\nEOF`,\n          `mkdir -p /home/${vsCodeUser}/.config/code-server`,\n          `tee /home/${vsCodeUser}/.config/code-server/config.yaml <<EOF\ncert: false\nauth: password\nhashed-password: \"$(echo -n {{ VSCodePassword }} | argon2 $(openssl rand -base64 12) -e)\"\nEOF`,\n          `mkdir -p /home/${vsCodeUser}/.local/share/code-server/User/`,\n          `touch /home/${vsCodeUser}/.hushlogin`,\n          `mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}`,\n          `tee /home/${vsCodeUser}/.local/share/code-server/User/settings.json <<EOF\n{\n  \"extensions.autoUpdate\": false,\n  \"extensions.autoCheckUpdates\": false,\n  \"telemetry.telemetryLevel\": \"off\",\n  \"security.workspace.trust.startupPrompt\": \"never\",\n  \"security.workspace.trust.enabled\": false,\n  \"security.workspace.trust.banner\": \"never\",\n  \"security.workspace.trust.emptyWindow\": false,\n  \"auto-run-command.rules\": [\n    {\n      \"command\": \"workbench.action.terminal.new\"\n    }\n  ]\n}\nEOF`,\n          `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n          `systemctl restart code-server@${vsCodeUser}`,\n          'systemctl restart nginx',\n          `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.aws-toolkit-vscode --force`,\n          `sudo -u ${vsCodeUser} --login code-server --install-extension AmazonWebServices.amazon-q-vscode --force`,\n          `sudo -u ${vsCodeUser} --login code-server --install-extension ms-vscode.live-server --force`,\n          `sudo -u ${vsCodeUser} --login code-server --install-extension synedra.auto-run-command --force`,\n          `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n          'echo \"Nginx installed. Checking configuration\"',\n          'nginx -t 2>&1',\n          'systemctl status nginx',\n          'echo \"CodeServer installed. Checking configuration\"',\n          'code-server -v',\n          `systemctl status code-server@${vsCodeUser}`,\n        ],\n      },\n    };\n  }\n\n  /**\n   * Creates the DownloadBranches step for SSM document\n   * This step is identical for both Ubuntu and Amazon Linux\n   */\n  private createDownloadBranchesStep(vsCodeUser: string, homeFolder: string): any {\n    return {\n      action: 'aws:runShellScript',\n      name: 'DownloadBranches',\n      inputs: {\n        runCommand: [\n          '#!/bin/bash',\n          `if [[ -z \"{{ BranchZipS3Path }}\" ]]\nthen\n  echo \"No branches\"\nelse\n  rm -rf /tmp/branch\n  rm -rf /tmp/git\n  mkdir -p /tmp/branch && chown -R ${vsCodeUser}:${vsCodeUser} /tmp/branch\n  mkdir -p /tmp/git && chown -R ${vsCodeUser}:${vsCodeUser} /tmp/git\n  aws s3 cp s3://{{ BranchZipS3Path }} /tmp/asset-branch.zip\n  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/asset-branch.zip\n  unzip -o /tmp/asset-branch.zip -d /tmp/branch\n  chown -R ${vsCodeUser}:${vsCodeUser} /tmp/branch\n  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}\n  sudo -u ${vsCodeUser} git -C ${homeFolder} init\n  mv ${homeFolder}/.git /tmp/git\n  rm -rf ${homeFolder}\n  mkdir -p ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}\n  mv /tmp/git/.git ${homeFolder}\n  find /tmp/branch -maxdepth 1 -mindepth 1 -type d | while read sourceFolder; do\n    branch=\"$(basename $sourceFolder)\"\n    echo \"Processing branch: $branch\"\n    sudo -u ${vsCodeUser} git -C ${homeFolder} checkout -b $branch 2>&1\n    cp -a $sourceFolder/. ${homeFolder}\n    sudo -u ${vsCodeUser} git -C ${homeFolder} add .\n    sudo -u ${vsCodeUser} git -C ${homeFolder} commit -m \"chore: initial commit $branch\"\n    mv ${homeFolder}/.git /tmp/git\n    rm -rf ${homeFolder}\n    mkdir ${homeFolder} && chown -R ${vsCodeUser}:${vsCodeUser} ${homeFolder}\n    mv /tmp/git/.git ${homeFolder}\n  done\n  sudo -u ${vsCodeUser} git -C ${homeFolder} checkout main 2>&1\n  sudo -u ${vsCodeUser} git -C ${homeFolder} restore .\n  rm -rf /tmp/branch\n  rm -rf /tmp/git\n  echo \"Branches downloaded. Checking configuration: ${homeFolder}\"\n  sudo -u ${vsCodeUser} git -C ${homeFolder} branch\n  ls -la ${homeFolder}\nfi`,\n        ],\n      },\n    };\n  }\n\n  private createSSMDocument(\n    scope: Construct,\n    devServerBasePath: string,\n    devServerPort: number,\n    vsCodeUser: string,\n    homeFolder: string,\n    linuxFlavor: LinuxFlavorType,\n    customDomainName?: string,\n    repoUrl?: string,\n    assetZipS3Path?: string,\n    branchZipS3Path?: string,\n    folderZipS3Path?: string,\n  ): ssm.CfnDocument {\n    // Generate nginx server_name directive based on custom domain\n    const serverNameDirective = customDomainName\n      ? `server_name *.cloudfront.net ${customDomainName};`\n      : 'server_name *.cloudfront.net;';\n\n    let ssmDocument: ssm.CfnDocument;\n    switch (linuxFlavor) {\n      case LinuxFlavorType.UBUNTU_22:\n      case LinuxFlavorType.UBUNTU_24:\n      case LinuxFlavorType.UBUNTU_25:\n        // Create an SSM document with multiple actions to install the software\n        ssmDocument = new ssm.CfnDocument(scope, 'ssm-document-ubuntu', {\n          name: `vscode-server-ubuntu-${Stack.of(scope).stackName}`,\n          documentType: 'Command',\n          content: {\n            schemaVersion: '2.2',\n            description: 'Bootstrap VSCode code-server instance',\n            parameters: {\n              VSCodePassword: {\n                type: 'String',\n                default: Stack.of(scope).stackId,\n              },\n              NodeVersion: {\n                type: 'String',\n                default: '22',\n                allowedValues: ['24', '22', '20', '18'],\n              },\n              RepoUrl: {\n                type: 'String',\n                default: repoUrl ?? '',\n              },\n              AssetZipS3Path: {\n                type: 'String',\n                default: assetZipS3Path ?? '',\n              },\n              BranchZipS3Path: {\n                type: 'String',\n                default: branchZipS3Path ?? '',\n              },\n              FolderZipS3Path: {\n                type: 'String',\n                default: folderZipS3Path ?? '',\n              },\n            },\n            // all mainSteps scripts are in in /var/lib/amazon/ssm/<instanceid>/document/orchestration/<uuid>/<StepName>/_script.sh\n            mainSteps: [\n              this.createInstallCloudWatchAgentStep(),\n              this.createConfigureCloudWatchAgentStep(),\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallAptPackagesApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dpkg --configure -a',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q apt-utils',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q needrestart unattended-upgrades',\n                    \"sed -i 's/#$nrconf{kernelhints} = -1;/$nrconf{kernelhints} = 0;/' /etc/needrestart/needrestart.conf\",\n                    \"sed -i 's/#$nrconf{verbosity} = 2;/$nrconf{verbosity} = 0;/' /etc/needrestart/needrestart.conf\",\n                    \"sed -i \\\"s/#\\$nrconf{restart} = 'i';/\\$nrconf{restart} = 'a';/\\\" /etc/needrestart/needrestart.conf\",\n                    'echo \"Apt helper packages added. Checking configuration\"',\n                    'cat /etc/needrestart/needrestart.conf',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallBasePackagesApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dpkg --configure -a',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q curl gnupg whois argon2 unzip nginx openssl locales locales-all apt-transport-https ca-certificates software-properties-common',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'AddUserApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dpkg --configure -a',\n                    `if [[ \"${vsCodeUser}\" == \"ubuntu\" ]]\nthen\n  echo 'Using existing user: ${vsCodeUser}'\nelse\n  echo 'Adding user: ${vsCodeUser}'\n  adduser --disabled-password --gecos '' ${vsCodeUser}\n  echo \"${vsCodeUser}:{{ VSCodePassword }}\" | chpasswd\n  usermod -aG sudo ${vsCodeUser}\nfi`,\n                    `tee /etc/sudoers.d/91-vscode-user <<EOF\n${vsCodeUser} ALL=(ALL) NOPASSWD:ALL\nEOF`,\n                    `mkdir -p /home/${vsCodeUser} && chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    `mkdir -p /home/${vsCodeUser}/.local/bin && chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    'echo \"User added. Checking configuration\"',\n                    `getent passwd ${vsCodeUser}`,\n                  ],\n                },\n              },\n              this.createUpdateProfileStep(vsCodeUser, Stack.of(scope).region, Stack.of(scope).account),\n              this.createInstallAWSCLIStep(vsCodeUser),\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallGitApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dpkg --configure -a',\n                    'add-apt-repository ppa:git-core/ppa',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q git',\n                    `sudo -u ${vsCodeUser} git config --global user.email \"participant@example.com\"`,\n                    `sudo -u ${vsCodeUser} git config --global user.name \"Workshop Participant\"`,\n                    `sudo -u ${vsCodeUser} git config --global init.defaultBranch \"main\"`,\n                    'echo \"Git installed. Checking configuration\"',\n                    'git --version',\n                  ],\n                },\n              },\n              this.createCloneRepoStep(vsCodeUser, homeFolder),\n              this.createDownloadAssetsStep(vsCodeUser, homeFolder),\n              this.createDownloadFoldersStep(vsCodeUser, homeFolder),\n              this.createDownloadBranchesStep(vsCodeUser, homeFolder),\n              this.createConfigureCodeServerStep(vsCodeUser, homeFolder, devServerBasePath, devServerPort, serverNameDirective),\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallNodeApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /usr/share/keyrings/nodesource.gpg',\n                    'echo \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/nodesource.gpg] https://deb.nodesource.com/node_{{ NodeVersion }}.x nodistro main\" > /etc/apt/sources.list.d/nodesource.list',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q nodejs',\n                    'npm install -g npm@latest',\n                    'echo \"Node and npm installed. Checking configuration\"',\n                    'node -v',\n                    'npm -v',\n                  ],\n                },\n              },\n              this.createInstallCDKStep(),\n              this.createInstallQCLIStep(vsCodeUser),\n              this.createInstalluvStep(vsCodeUser),\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallPythonApt',\n                inputs: {\n                  runCommand: [\n                    // Ubuntu 22 default is Python 3.10\n                    // Ubuntu 24 default is Python 3.12\n                    // The default installed Python version will map to Python3\n                    '#!/bin/bash',\n                    'dpkg --configure -a',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q python3-pip python3-venv python3-boto3 python3-pytest',\n                    `echo 'alias pytest=pytest-3' >> /home/${vsCodeUser}/.bashrc`,\n                    'systemctl start multipathd.service packagekit.service',\n                    'systemctl restart unattended-upgrades.service',\n                    'systemctl restart networkd-dispatcher.service',\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension ms-python.python --force`,\n                    `if [ -f /home/${vsCodeUser}/.local/share/code-server/User/settings.json ]; then\n  sed -i \"2i\\\\\\\\  \\\\\"python.testing.pytestEnabled\\\\\": true,\" /home/${vsCodeUser}/.local/share/code-server/User/settings.json\nelse\n  echo '{\n    \"python.testing.pytestEnabled\": true\n  }' > /home/${vsCodeUser}/.local/share/code-server/User/settings.json\nfi`,\n                    'echo \"Python and Pip installed. Checking configuration\"',\n                    'python3 --version',\n                    'pip3 --version',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallJavaApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dpkg --configure -a',\n                    'curl -fsSL https://apt.corretto.aws/corretto.key | gpg --dearmor -o /usr/share/keyrings/corretto-keyring.gpg',\n                    'echo \"deb [signed-by=/usr/share/keyrings/corretto-keyring.gpg] https://apt.corretto.aws stable main\" > /etc/apt/sources.list.d/corretto.list',\n                    'DEBIAN_FRONTEND=noninteractive apt-get update',\n                    'DEBIAN_FRONTEND=noninteractive apt-get install -y -q java-21-amazon-corretto-jdk java-17-amazon-corretto-jdk java-1.8.0-amazon-corretto-jdk maven',\n                    `echo 'export JAVA_8_HOME=$(update-alternatives --list java | grep \"java-1.8.0-amazon-corretto\" | head -1)' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_8_PATH=$(update-alternatives --list java | grep \"java-1.8.0-amazon-corretto\" | head -1)' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_17_PATH=$(update-alternatives --list java | grep \"java-17-amazon-corretto\" | head -1)' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_17_HOME=$(update-alternatives --list java | grep \"java-17-amazon-corretto\" | head -1)' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_21_PATH=$(update-alternatives --list java | grep \"java-21-amazon-corretto\" | head -1)' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_21_HOME=$(update-alternatives --list java | grep \"java-21-amazon-corretto\" | head -1)' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_HOME=$(update-alternatives --list java | grep \"java-21-amazon-corretto\" | head -1)' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export PATH=$PATH:$JAVA_HOME/bin:/usr/share/maven/bin' >> /home/${vsCodeUser}/.bashrc`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension vscjava.vscode-java-pack --force`,\n                    'echo \"Java and Maven installed. Checking configuration\"',\n                    'java -version 2>&1',\n                    'mvn --version',\n                    'update-alternatives --list java',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallDotnetApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dpkg --configure -a',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q dotnet-sdk-8.0',\n                    'dotnet tool install -g Microsoft.Web.LibraryManager.Cli',\n                    `echo 'PATH=$PATH:/home/${vsCodeUser}/.dotnet/tools' >> /home/${vsCodeUser}/.bashrc`,\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    'echo \"Dotnet installed. Checking configuration\"',\n                    'dotnet --list-sdks',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallDockerApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg',\n                    'echo \"deb [signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release --codename --short) stable\" > /etc/apt/sources.list.d/docker.list',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q docker-ce docker-ce-cli containerd.io',\n                    `usermod -aG docker ${vsCodeUser}`,\n                    `systemctl restart code-server@${vsCodeUser}.service`,\n                    'systemctl start docker.service',\n                    'echo \"Docker installed. Checking configuration\"',\n                    'docker --version',\n                    'systemctl status docker.service',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallGolangApt',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'apt-get -q update && DEBIAN_FRONTEND=noninteractive apt-get install -y -q golang',\n                    `echo 'PATH=$PATH:/home/${vsCodeUser}/go/bin' >> /home/${vsCodeUser}/.bashrc`,\n                    'echo \"Golang installed. Checking configuration\"',\n                    'go version',\n                  ],\n                },\n              },\n            ],\n          },\n        });\n        break;\n      case LinuxFlavorType.AMAZON_LINUX_2023:\n        ssmDocument = new ssm.CfnDocument(scope, 'ssm-document-al2023', {\n          name: `vscode-server-al2023-${Stack.of(scope).stackName}`,\n          documentType: 'Command',\n          content: {\n            schemaVersion: '2.2',\n            description: 'Bootstrap VSCode code-server instance',\n            parameters: {\n              VSCodePassword: {\n                type: 'String',\n                default: Stack.of(scope).stackId,\n              },\n              NodeVersion: {\n                type: 'String',\n                default: '22',\n                allowedValues: ['24', '22', '20', '18'],\n              },\n              RepoUrl: {\n                type: 'String',\n                default: repoUrl ?? '',\n              },\n              AssetZipS3Path: {\n                type: 'String',\n                default: assetZipS3Path ?? '',\n              },\n              BranchZipS3Path: {\n                type: 'String',\n                default: branchZipS3Path ?? '',\n              },\n              FolderZipS3Path: {\n                type: 'String',\n                default: folderZipS3Path ?? '',\n              },\n            },\n            // all mainSteps scripts are in in /var/lib/amazon/ssm/<instanceid>/document/orchestration/<uuid>/<StepName>/_script.sh\n            mainSteps: [\n              this.createInstallCloudWatchAgentStep(),\n              this.createConfigureCloudWatchAgentStep(),\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallBasePackagesDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y --allowerasing whois argon2 unzip nginx curl gnupg openssl',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'AddUserDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    `if [[ \"${vsCodeUser}\" == \"ec2-user\" ]]\nthen\n  echo 'Using existing user: ${vsCodeUser}'\nelse\n  echo 'Adding user: ${vsCodeUser}'\n  adduser -c '' ${vsCodeUser}\n  passwd -l ${vsCodeUser}\n  echo \"${vsCodeUser}:{{ VSCodePassword }}\" | chpasswd\n  usermod -aG wheel ${vsCodeUser}\nfi`,\n                    `tee /etc/sudoers.d/91-vscode-user <<EOF\n${vsCodeUser} ALL=(ALL) NOPASSWD:ALL\nEOF`,\n                    `mkdir -p /home/${vsCodeUser} && chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    `mkdir -p /home/${vsCodeUser}/.local/bin && chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    'echo \"User added. Checking configuration\"',\n                    `getent passwd ${vsCodeUser}`,\n                  ],\n                },\n              },\n              this.createUpdateProfileStep(vsCodeUser, Stack.of(scope).region, Stack.of(scope).account),\n              this.createInstallAWSCLIStep(vsCodeUser),\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallGitDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y git',\n                    `sudo -u ${vsCodeUser} git config --global user.email \"participant@example.com\"`,\n                    `sudo -u ${vsCodeUser} git config --global user.name \"Workshop Participant\"`,\n                    `sudo -u ${vsCodeUser} git config --global init.defaultBranch \"main\"`,\n                    'echo \"Git installed. Checking configuration\"',\n                    'git --version',\n                  ],\n                },\n              },\n              this.createCloneRepoStep(vsCodeUser, homeFolder),\n              this.createDownloadAssetsStep(vsCodeUser, homeFolder),\n              this.createDownloadFoldersStep(vsCodeUser, homeFolder),\n              this.createDownloadBranchesStep(vsCodeUser, homeFolder),\n              this.createConfigureCodeServerStep(vsCodeUser, homeFolder, devServerBasePath, devServerPort, serverNameDirective),\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallNodeDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y nodejs npm',\n                    'npm install -g npm@latest',\n                    'echo \"Node and npm installed. Checking configuration\"',\n                    'node -v',\n                    'npm -v',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallCDK',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'npm install -g aws-cdk',\n                    'echo \"AWS CDK installed. Checking configuration\"',\n                    'cdk --version',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallQCLI',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'curl --proto \\'=https\\' --tlsv1.2 -sSf \"https://desktop-release.q.us-east-1.amazonaws.com/latest/q-$(uname -m)-linux.zip\" -o /tmp/q.zip',\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/q.zip`,\n                    'unzip -q -d /tmp /tmp/q.zip',\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /tmp/q`,\n                    'chmod +x /tmp/q/install.sh',\n                    `sudo -u ${vsCodeUser} /tmp/q/install.sh --no-confirm`,\n                    'rm -rf /tmp/q',\n                    'echo \"Amazon Q CLI installed\"',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'Installuv',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    `sudo -u ${vsCodeUser} --login curl -fsSL https://astral.sh/uv/install.sh -o /tmp/uv_install.sh`,\n                    `sudo -u ${vsCodeUser} --login bash /tmp/uv_install.sh`,\n                    `if uv generate-shell-completion bash &>/dev/null; then\n  echo 'eval \"$(uv generate-shell-completion bash)\"' >> /home/${vsCodeUser}/.bashrc\nfi`,\n                    `if uvx generate-shell-completion bash &>/dev/null; then\n  echo 'eval \"$(uvx generate-shell-completion bash)\"' >> /home/${vsCodeUser}/.bashrc\nfi`,\n                    'echo \"uv installed. Checking configuration\"',\n                    `sudo -u ${vsCodeUser} --login uv --version`,\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallPythonDnf',\n                inputs: {\n                  runCommand: [\n                    // AL2023 currently ships with Python 3.9 preinstalled, but 3.11 is available in the repository\n                    // Install 3.11 alongside 3.9 and setup some alias so that 3.11 is loaded when participant runs Python3\n                    // If Python 3.12 become available, update below\n                    '#!/bin/bash',\n                    'dnf install -y python3.11 python3.11-pip python3-virtualenv python3-pytest python3-boto3',\n                    `echo 'alias pytest=pytest-3' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'alias python3=python3.11' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'alias pip3=pip3.11' >> /home/${vsCodeUser}/.bashrc`,\n                    \"echo 'alias=python3=python3.11' >> ~/.bashrc\",\n                    \"echo 'alias pip3=pip3.11' >> ~/.bashrc\",\n                    'python3.11 -m pip install --upgrade pip 2>&1',\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension ms-python.python --force`,\n                    `if [ -f /home/${vsCodeUser}/.local/share/code-server/User/settings.json ]; then\n  sed -i \"2i\\\\\\\\  \\\\\"python.testing.pytestEnabled\\\\\": true,\" /home/${vsCodeUser}/.local/share/code-server/User/settings.json\nelse\n  echo '{\n    \"python.testing.pytestEnabled\": true\n  }' > /home/${vsCodeUser}/.local/share/code-server/User/settings.json\nfi`,\n                    'echo \"Python and Pip installed. Checking configuration\"',\n                    'python3.11 --version',\n                    'python3.11 -m pip --version 2>&1',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallJavaDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y java-21-amazon-corretto java-17-amazon-corretto java-1.8.0-amazon-corretto maven',\n                    `echo 'export JAVA_8_HOME=/usr/lib/jvm/java-1.8.0-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_8_PATH=/usr/lib/jvm/java-1.8.0-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_17_PATH=/usr/lib/jvm/java-17-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_17_HOME=/usr/lib/jvm/java-17-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_21_PATH=/usr/lib/jvm/java-21-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_21_HOME=/usr/lib/jvm/java-21-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export JAVA_HOME=/usr/lib/jvm/java-21-amazon-corretto' >> /home/${vsCodeUser}/.bashrc`,\n                    `echo 'export PATH=$PATH:$JAVA_HOME/bin:/usr/share/maven/bin' >> /home/${vsCodeUser}/.bashrc`,\n                    `sudo -u ${vsCodeUser} --login code-server --install-extension vscjava.vscode-java-pack --force`,\n                    'echo \"Java and Maven installed. Checking configuration\"',\n                    'java -version 2>&1',\n                    'mvn --version',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallDotnetDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y dotnet-sdk-8.0',\n                    'dotnet tool install -g Microsoft.Web.LibraryManager.Cli',\n                    `echo 'PATH=$PATH:/home/${vsCodeUser}/.dotnet/tools' >> /home/${vsCodeUser}/.bashrc`,\n                    `chown -R ${vsCodeUser}:${vsCodeUser} /home/${vsCodeUser}`,\n                    'echo \"Dotnet installed. Checking configuration\"',\n                    'dotnet --list-sdks',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallDockerDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y docker',\n                    `usermod -aG docker ${vsCodeUser}`,\n                    `systemctl restart code-server@${vsCodeUser}.service`,\n                    'systemctl start docker.service',\n                    'echo \"Docker installed. Checking configuration\"',\n                    'docker --version',\n                    'systemctl status docker.service',\n                  ],\n                },\n              },\n              {\n                action: 'aws:runShellScript',\n                name: 'InstallGolangDnf',\n                inputs: {\n                  runCommand: [\n                    '#!/bin/bash',\n                    'dnf install -y golang',\n                    `echo 'PATH=$PATH:/home/${vsCodeUser}/go/bin' >> /home/${vsCodeUser}/.bashrc`,\n                    'echo \"Golang installed. Checking configuration\"',\n                    'go version',\n                  ],\n                },\n              },\n            ],\n          },\n        });\n        break;\n      default:\n        throw new Error(`Unsupported Linux flavor: ${linuxFlavor}`);\n    }\n\n    return ssmDocument;\n  }\n}\n\ninterface CustomResourceInstallerOptions {\n  /**\n   * The ec2 instance id to install the ssm document on\n   */\n  readonly instanceId: string;\n\n  /**\n   * The name of the custom ssm document to install.\n   */\n  readonly documentName: string;\n\n  /**\n   * The name of the cloudwatch log group for the install logs\n   */\n  readonly cloudWatchLogGroupName: string;\n\n  /**\n   * The name of the user under which the vscode server runs\n   */\n  readonly vsCodeUser: string;\n\n  /**\n   * The password of the user under which the vscode server runs\n   */\n  readonly vsCodePassword: string;\n\n  /**\n   * The home folder of the user under which the vscode server runs\n   */\n  readonly homeFolder: string;\n}\n\nclass CustomResourceInstaller extends Installer {\n  constructor(scope: Construct, options: CustomResourceInstallerOptions) {\n    super();\n\n    const onEvent: Function = new InstallerFunction(\n      scope,\n      'InstallerOnEventHandler',\n      {\n        timeout: Duration.minutes(15), // 15 minutes to allow for VS Code Server installation\n        memorySize: 512, // TODO configurable\n      },\n    );\n    NagSuppressions.addResourceSuppressions(\n      [onEvent],\n      [\n        {\n          id: 'AwsSolutions-IAM4',\n          reason:\n            'For this event handler we do not need to restrict managed policies',\n        },\n        {\n          id: 'AwsSolutions-L1',\n          reason: 'For this lambda the latest runtime is not needed',\n        },\n      ],\n      true,\n    );\n\n    const documentArn = Arn.format(\n      {\n        service: 'ssm',\n        resource: 'document',\n        resourceName: options.documentName,\n      },\n      Stack.of(scope),\n    );\n\n    const cwManageAgentArn = Arn.format(\n      {\n        service: 'ssm',\n        resource: 'document',\n        resourceName: 'AmazonCloudWatch-ManageAgent',\n      },\n      Stack.of(scope),\n    );\n\n    const targetEc2InstanceArn = Arn.format(\n      {\n        service: 'ec2',\n        resource: 'instance',\n        resourceName: options.instanceId,\n      },\n      Stack.of(scope),\n    );\n\n    // SendCommand supports resource-level permissions\n    onEvent.addToRolePolicy(\n      new PolicyStatement({\n        actions: ['ssm:SendCommand'],\n        resources: [documentArn, cwManageAgentArn, targetEc2InstanceArn],\n      }),\n    );\n\n    // GetCommandInvocation and ListCommandInvocations require wildcard resources\n    // They don't support resource-level permissions\n    onEvent.addToRolePolicy(\n      new PolicyStatement({\n        actions: ['ssm:GetCommandInvocation', 'ssm:ListCommandInvocations'],\n        resources: ['*'],\n      }),\n    );\n\n    // Suppress cdk-nag warning for wildcard permissions on GetCommandInvocation\n    // These SSM actions don't support resource-level permissions per AWS documentation\n    NagSuppressions.addResourceSuppressions(\n      onEvent,\n      [\n        {\n          id: 'AwsSolutions-IAM5',\n          reason:\n            'ssm:GetCommandInvocation and ssm:ListCommandInvocations do not support resource-level permissions and require wildcard resources',\n          appliesTo: ['Resource::*'],\n        },\n      ],\n      true,\n    );\n\n    const provider = new Provider(scope, 'InstallerProvider', {\n      onEventHandler: onEvent,\n    });\n    NagSuppressions.addResourceSuppressions(\n      [provider],\n      [\n        {\n          id: 'AwsSolutions-IAM4',\n          reason:\n            'For this provider we do not need to restrict managed policies',\n        },\n        {\n          id: 'AwsSolutions-IAM5',\n          reason: 'For this provider wildcards are fine',\n        },\n        {\n          id: 'AwsSolutions-L1',\n          reason: 'For this provider the latest runtime is not needed',\n        },\n      ],\n      true,\n    );\n\n    new CustomResource(scope, 'SSMInstallerCustomResource', {\n      serviceToken: provider.serviceToken,\n      properties: {\n        ServiceTimeout: Duration.minutes(15).toSeconds() + 5, // Lambda timeout + 5 seconds buffer\n        InstanceId: options.instanceId,\n        DocumentName: options.documentName,\n        CloudWatchLogGroupName: options.cloudWatchLogGroupName,\n        VSCodePassword: options.vsCodePassword,\n      },\n    });\n  }\n\n  public _bind() {}\n}\n"]}