fix: adding some improvements to isAmazonLinux2 check

laileni-aws · laileni-aws · commit 9a70f75971fe · 2025-09-19T16:12:52.000-07:00
diff --git a/packages/core/src/shared/vscode/env.ts b/packages/core/src/shared/vscode/env.ts
@@ -149,7 +149,34 @@ export function hasSageMakerEnvVars(): boolean {
  * This function detects if we're actually running on AL2, not just if the host is AL2.
  * In containerized environments, we check the container's OS, not the host's.
  *
- * Example: `5.10.220-188.869.amzn2int.x86_64` or `5.10.236-227.928.amzn2.x86_64` (Cloud Dev Machine)
+ * Detection Process (in order):
+ * 1. Returns false for web environments (browser-based)
+ * 2. Returns false for SageMaker environments (even if host is AL2)
+ * 3. Checks `/etc/image-id` for Amazon Linux specific identification
+ *    - Most reliable method for Amazon Linux systems
+ *    - Contains `image_name="Amazon Linux 2"` for AL2
+ *    - Returns false for Amazon Linux 2023 or other versions
+ * 4. Checks `/etc/os-release` with fallback to `/usr/lib/os-release`
+ *    - Standard Linux OS identification files
+ *    - Explicitly checks for and rejects Amazon Linux 2023
+ *    - Looks for `ID="amzn"` and `VERSION_ID="2"` for AL2
+ * 5. Falls back to kernel version check as last resort
+ *    - Checks for `.amzn2.` or `.amzn2int.` in kernel release
+ *    - Only used if file-based detection fails or confirms AL2
+ *
+ * This approach ensures correct detection in:
+ * - Containerized environments (detects container OS, not host)
+ * - Web/browser environments (returns false)
+ * - Amazon Linux 2023 systems (properly distinguished from AL2)
+ * - SageMaker environments (returns false)
+ *
+ * References:
+ * - https://docs.aws.amazon.com/linux/al2/ug/ident-amazon-linux-specific.html
+ * - https://docs.aws.amazon.com/linux/al2/ug/ident-os-release.html
+ *
+ * Example kernel versions:
+ * - `5.10.220-188.869.amzn2int.x86_64` (internal AL2)
+ * - `5.10.236-227.928.amzn2.x86_64` (Cloud Dev Machine)
  */
 export function isAmazonLinux2() {
     // Skip AL2 detection for web environments
@@ -164,44 +191,81 @@ export function isAmazonLinux2() {
         return false
     }
 
+    // Only proceed with file checks on Linux platforms
+    if (process.platform !== 'linux') {
+        return false
+    }
+
     // For containerized environments, check the actual container OS
     // not the host kernel version
     try {
         const fs = require('fs')
-        if (fs.existsSync('/etc/os-release')) {
-            const osRelease = fs.readFileSync('/etc/os-release', 'utf8')
 
-            // Check if this is Amazon Linux 2023 (not AL2)
-            if (osRelease.includes('VERSION_ID="2023"') || osRelease.includes('PLATFORM_ID="platform:al2023"')) {
-                // This is Amazon Linux 2023, not AL2
-                return false
+        // First, try Amazon Linux specific file /etc/image-id. This is the most reliable way to identify Amazon Linux
+        if (fs.existsSync('/etc/image-id')) {
+            try {
+                const imageId = fs.readFileSync('/etc/image-id', 'utf8')
+                // Check if this is Amazon Linux 2 (not 2023 or other versions)
+                // Example content: image_name="Amazon Linux 2"
+                if (imageId.includes('image_name="Amazon Linux 2"')) {
+                    return true
+                }
+                // If it's Amazon Linux but not version 2, return false
+                if (imageId.includes('image_name="Amazon Linux')) {
+                    return false
+                }
+            } catch (e) {
+                // Continue to other checks if we can't read the file
+                getLogger().error(`Checking for Amazon Linux specific file /etc/image-id failed with error: ${e}`)
             }
+        }
 
-            // Check if this is actually Amazon Linux 2
-            // Must be specifically version 2, not 2023 or other versions
-            const isAL2 =
-                osRelease.includes('Amazon Linux 2') ||
-                (osRelease.includes('ID="amzn"') && osRelease.includes('VERSION_ID="2"'))
-
-            // If we found os-release file, trust its content over kernel version
-            if (!isAL2) {
-                // Explicitly not AL2 based on os-release
-                return false
+        // Check /etc/os-release with fallback to /usr/lib/os-release as per https://docs.aws.amazon.com/linux/al2/ug/ident-os-release.html
+        const osReleasePaths = ['/etc/os-release', '/usr/lib/os-release']
+        for (const osReleasePath of osReleasePaths) {
+            if (fs.existsSync(osReleasePath)) {
+                try {
+                    const osRelease = fs.readFileSync(osReleasePath, 'utf8')
+
+                    // Check if this is Amazon Linux 2023 (not AL2)
+                    if (
+                        osRelease.includes('VERSION_ID="2023"') ||
+                        osRelease.includes('PLATFORM_ID="platform:al2023"')
+                    ) {
+                        // This is Amazon Linux 2023, not AL2
+                        return false
+                    }
+
+                    // Check if this is actually Amazon Linux 2
+                    // Must be specifically version 2, not 2023 or other versions
+                    const isAL2 =
+                        osRelease.includes('Amazon Linux 2') ||
+                        (osRelease.includes('ID="amzn"') && osRelease.includes('VERSION_ID="2"'))
+
+                    // If we found os-release file, trust its content over kernel version
+                    if (!isAL2) {
+                        // Explicitly not AL2 based on os-release
+                        return false
+                    }
+                    // If it is AL2 according to os-release, continue to kernel check for confirmation
+                    break // Found and processed os-release, no need to check fallback
+                } catch (e) {
+                    // Continue to next path or fallback check
+                    getLogger().error(`Checking for Amazon Linux 2023 (not AL2) failed with error: ${e}`)
+                }
             }
-            // If it is AL2 according to os-release, continue to kernel check for confirmation
         }
     } catch (e) {
-        // If we can't read the file, fall back to the os.release() check
+        // If we can't read the files, fall back to the os.release() check
         // This might happen in some restricted environments
         getLogger().error(`Checking the current environment failed with error: ${e}`)
     }
 
     // Check kernel version as a fallback or confirmation
-    // This should only be trusted if we couldn't determine from /etc/os-release
-    // or if /etc/os-release confirmed it's AL2
+    // This should only be trusted if we couldn't determine from files above
+    // or if files confirmed it's AL2
     const kernelRelease = os.release()
-    const hasAL2Kernel =
-        (kernelRelease.includes('.amzn2int.') || kernelRelease.includes('.amzn2.')) && process.platform === 'linux'
+    const hasAL2Kernel = kernelRelease.includes('.amzn2int.') || kernelRelease.includes('.amzn2.')
 
     return hasAL2Kernel
 }
diff --git a/packages/core/src/test/shared/vscode/env.test.ts b/packages/core/src/test/shared/vscode/env.test.ts
@@ -12,6 +12,7 @@ import os from 'os'
 import fs from '../../../shared/fs/fs'
 import vscode from 'vscode'
 import { getComputeEnvType } from '../../../shared/telemetry/util'
+import * as globals from '../../../shared/extensionGlobals'
 
 describe('env', function () {
     // create a sinon sandbox instance and instantiate in a beforeEach
@@ -97,18 +98,183 @@ describe('env', function () {
         assert.strictEqual(isBeta(), expected)
     })
 
-    it('isAmazonLinux2', function () {
-        sandbox.stub(process, 'platform').value('linux')
-        const versionStub = stubOsVersion('5.10.220-188.869.amzn2int.x86_64')
+    describe('isAmazonLinux2', function () {
+        let fsExistsStub: sinon.SinonStub
+        let fsReadFileStub: sinon.SinonStub
+        let isWebStub: sinon.SinonStub
+        let platformStub: sinon.SinonStub
+        let osReleaseStub: sinon.SinonStub
+        let requireStub: sinon.SinonStub
+
+        beforeEach(function () {
+            // Default stubs
+            platformStub = sandbox.stub(process, 'platform').value('linux')
+            osReleaseStub = stubOsVersion('5.10.220-188.869.amzn2int.x86_64')
+            isWebStub = sandbox.stub(globals, 'isWeb').returns(false)
+
+            // Mock fs module
+            const fsMock = {
+                existsSync: sandbox.stub().returns(false),
+                readFileSync: sandbox.stub().returns(''),
+            }
+            fsExistsStub = fsMock.existsSync
+            fsReadFileStub = fsMock.readFileSync
+
+            // Stub the global require function to return our mocked fs
+            requireStub = sandbox.stub(global, 'require').callThrough()
+            requireStub.withArgs('fs').returns(fsMock)
+        })
 
-        // Test with actual AL2 kernel
-        assert.strictEqual(isAmazonLinux2(), true)
+        it('returns false in web environment', function () {
+            isWebStub.returns(true)
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
+
+        it('returns false in SageMaker environment with SAGEMAKER_APP_TYPE', function () {
+            sandbox.stub(process.env, 'SAGEMAKER_APP_TYPE').value('JupyterLab')
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
 
-        versionStub.returns('5.10.236-227.928.amzn2.x86_64')
-        assert.strictEqual(isAmazonLinux2(), true)
+        it('returns false in SageMaker environment with SM_APP_TYPE', function () {
+            sandbox.stub(process.env, 'SM_APP_TYPE').value('JupyterLab')
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
+
+        it('returns false in SageMaker environment with SERVICE_NAME', function () {
+            sandbox.stub(process.env, 'SERVICE_NAME').value('SageMakerUnifiedStudio')
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
 
-        versionStub.returns('5.10.220-188.869.NOT_INTERNAL.x86_64')
-        assert.strictEqual(isAmazonLinux2(), false)
+        it('returns false when /etc/os-release indicates Ubuntu in container', function () {
+            fsExistsStub.returns(true)
+            fsReadFileStub.returns(`
+NAME="Ubuntu"
+VERSION="20.04.6 LTS (Focal Fossa)"
+ID=ubuntu
+ID_LIKE=debian
+PRETTY_NAME="Ubuntu 20.04.6 LTS"
+VERSION_ID="20.04"
+            `)
+
+            // Even with AL2 kernel (host is AL2), should return false (container is Ubuntu)
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
+
+        it('returns false when /etc/os-release indicates Amazon Linux 2023', function () {
+            fsExistsStub.returns(true)
+            fsReadFileStub.returns(`
+NAME="Amazon Linux"
+VERSION="2023"
+ID="amzn"
+ID_LIKE="fedora"
+VERSION_ID="2023"
+PLATFORM_ID="platform:al2023"
+PRETTY_NAME="Amazon Linux 2023"
+            `)
+
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
+
+        it('returns true when /etc/os-release indicates Amazon Linux 2', function () {
+            fsExistsStub.returns(true)
+            fsReadFileStub.returns(`
+NAME="Amazon Linux 2"
+VERSION="2"
+ID="amzn"
+ID_LIKE="centos rhel fedora"
+VERSION_ID="2"
+PRETTY_NAME="Amazon Linux 2"
+            `)
+
+            assert.strictEqual(isAmazonLinux2(), true)
+        })
+
+        it('returns true when /etc/os-release has ID="amzn" and VERSION_ID="2"', function () {
+            fsExistsStub.returns(true)
+            fsReadFileStub.returns(`
+NAME="Amazon Linux"
+VERSION="2"
+ID="amzn"
+VERSION_ID="2"
+            `)
+
+            assert.strictEqual(isAmazonLinux2(), true)
+        })
+
+        it('returns false when /etc/os-release indicates CentOS', function () {
+            fsExistsStub.returns(true)
+            fsReadFileStub.returns(`
+NAME="CentOS Linux"
+VERSION="7 (Core)"
+ID="centos"
+ID_LIKE="rhel fedora"
+VERSION_ID="7"
+            `)
+
+            // Even with AL2 kernel
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
+
+        it('falls back to kernel check when /etc/os-release does not exist', function () {
+            fsExistsStub.returns(false)
+
+            // Test with AL2 kernel
+            assert.strictEqual(isAmazonLinux2(), true)
+
+            // Test with non-AL2 kernel
+            osReleaseStub.returns('5.10.220-188.869.NOT_INTERNAL.x86_64')
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
+
+        it('falls back to kernel check when /etc/os-release read fails', function () {
+            fsExistsStub.returns(true)
+            fsReadFileStub.throws(new Error('Permission denied'))
+
+            // Should fall back to kernel check
+            assert.strictEqual(isAmazonLinux2(), true)
+        })
+
+        it('returns true with .amzn2. kernel pattern', function () {
+            fsExistsStub.returns(false)
+            osReleaseStub.returns('5.10.236-227.928.amzn2.x86_64')
+            assert.strictEqual(isAmazonLinux2(), true)
+        })
+
+        it('returns true with .amzn2int. kernel pattern', function () {
+            fsExistsStub.returns(false)
+            osReleaseStub.returns('5.10.220-188.869.amzn2int.x86_64')
+            assert.strictEqual(isAmazonLinux2(), true)
+        })
+
+        it('returns false with non-AL2 kernel', function () {
+            fsExistsStub.returns(false)
+            osReleaseStub.returns('5.15.0-91-generic')
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
+
+        it('returns false on non-Linux platforms', function () {
+            platformStub.value('darwin')
+            fsExistsStub.returns(false)
+            assert.strictEqual(isAmazonLinux2(), false)
+
+            platformStub.value('win32')
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
+
+        it('returns false when container OS is different from host OS', function () {
+            // Scenario: Host is AL2 (kernel shows AL2) but container is Ubuntu
+            fsExistsStub.returns(true)
+            fsReadFileStub.returns(`
+NAME="Ubuntu"
+VERSION="22.04"
+ID=ubuntu
+VERSION_ID="22.04"
+            `)
+            osReleaseStub.returns('5.10.220-188.869.amzn2int.x86_64') // AL2 kernel from host
+
+            // Should trust container OS over kernel
+            assert.strictEqual(isAmazonLinux2(), false)
+        })
     })
 
     it('isCloudDesktop', async function () {
