native build

.github/workflows/beta-release.yml

@@ -5,11 +5,7 @@ on:
   workflow_dispatch:
 
 jobs:
-  get-configs:
-    uses: ./.github/workflows/configs.yml
-
   create-beta-tag:
-    needs: [get-configs]
     runs-on: ubuntu-latest
     permissions:
       contents: write

.github/workflows/configs.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     env:
       NODE_VERSION: '22.x'
-      GO_VERSION: '1.25.x'
+      GO_VERSION: '1.25.4'
     outputs:
       node-version: ${{ env.NODE_VERSION }}
       go-version: ${{ env.GO_VERSION }}

.github/workflows/release.yml

@@ -58,142 +58,220 @@
             exit 1
           fi
 
-  build-and-test:
+  #  build-and-test:
+  #    needs: [ get-configs, version-and-tag ]
+  #    uses: ./.github/workflows/build-and-test.yml
+  #    strategy:
+  #      fail-fast: true
+  #      matrix:
+  #        os: [ ubuntu-22.04, windows-latest, macos-latest ]
+  #    with:
+  #      ref: ${{ needs.version-and-tag.outputs.tag }}
+  #      runs-on: ${{ matrix.os }}
+
+  bundle-linux:
     needs: [ get-configs, version-and-tag ]
-    uses: ./.github/workflows/build-and-test.yml
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
-        os: [ ubuntu-22.04, windows-latest, macos-latest ]
-    with:
-      ref: ${{ needs.version-and-tag.outputs.tag }}
-      runs-on: ${{ matrix.os }}
+        include:
+          - { arch: "x64", docker-platform: "linux/amd64", go-arch: "amd64", use_qemu: false, node-version: "18" }
+          - { arch: "x64", docker-platform: "linux/amd64", go-arch: "amd64", use_qemu: false, node-version: "20" }
+          - { arch: "x64", docker-platform: "linux/amd64", go-arch: "amd64", use_qemu: false, node-version: "22" }
+          - { arch: "arm64", docker-platform: "linux/arm64", go-arch: "arm64", use_qemu: true, node-version: "18" }
+          - { arch: "arm64", docker-platform: "linux/arm64", go-arch: "arm64", use_qemu: true, node-version: "20" }
+          - { arch: "arm64", docker-platform: "linux/arm64", go-arch: "arm64", use_qemu: true, node-version: "22" }
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ needs.version-and-tag.outputs.tag }}
+          fetch-tags: true
+
+      - name: Set release asset name
+        id: set-asset-name
+        shell: bash
+        run: |
+          APP_NAME=${{ needs.get-configs.outputs.app-name }}
+          VERSION=$(node -p "require('./package.json').version")
+          NODE_VERSION=${{ matrix.node-version }}
+          NODE_MAJOR=$(echo $NODE_VERSION | cut -d. -f1)
+
+          TAG=${{ needs.version-and-tag.outputs.tag }}
+          if [[ "$TAG" =~ -alpha$ ]]; then
+            FILE_NAME="${APP_NAME}-${VERSION}-alpha-linux-${{ matrix.arch }}-node${NODE_MAJOR}.zip"
+          elif [[ "$TAG" =~ -beta$ ]]; then
+            FILE_NAME="${APP_NAME}-${VERSION}-beta-linux-${{ matrix.arch }}-node${NODE_MAJOR}.zip"
+          else
+            FILE_NAME="${APP_NAME}-${VERSION}-linux-${{ matrix.arch }}-node${NODE_MAJOR}.zip"
+          fi
+
+          ASSET_NAME=$(echo "$FILE_NAME" | tr '[:upper:]' '[:lower:]')
+          echo "ASSET_NAME=${ASSET_NAME}" >> $GITHUB_OUTPUT
+
+      - name: Set up QEMU
+        if: matrix.use_qemu
+        uses: docker/setup-qemu-action@v3
+
+      - name: Build in Container
+        run: |
+          docker run --rm -v ${{ github.workspace }}:/work -w /work \
+            --platform ${{ matrix.docker-platform }} \
+            amazonlinux:2023 \
+            /bin/bash -c '
+              set -ex
+              yum install -y curl make gcc-c++ python3 tar gzip wget
+
+              wget -q https://go.dev/dl/go${{ needs.get-configs.outputs.go-version }}.linux-${{ matrix.go-arch }}.tar.gz
+              tar -C /usr/local -xzf go${{ needs.get-configs.outputs.go-version }}.linux-${{ matrix.go-arch }}.tar.gz
+              export PATH=$PATH:/usr/local/go/bin
+
+              curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
+              export NVM_DIR="$HOME/.nvm"
+              . "$NVM_DIR/nvm.sh"
+              nvm install ${{ matrix.node-version }}
+              npm install -g npm@latest
+
+              npm ci
+
+              TAG="${{ needs.version-and-tag.outputs.tag }}"
+              if [[ "$TAG" =~ -alpha$ ]]; then
+                npm run bundle:alpha
+              elif [[ "$TAG" =~ -beta$ ]]; then
+                npm run bundle:beta
+              else
+                npm run bundle:prod
+              fi
+
+              GOARCH=${{ matrix.go-arch }} go build -C ./cfn-init/cmd -v -o ../../bundle/production/bin/cfn-init
+              cp ./cfn-init/THIRD-PARTY-LICENSES.txt ./bundle/production/bin/
+
+              cd ./bundle/production && zip -r ../../${{ steps.set-asset-name.outputs.ASSET_NAME }} .
+            '
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ steps.set-asset-name.outputs.ASSET_NAME }}
+          path: ${{ steps.set-asset-name.outputs.ASSET_NAME }}
+          if-no-files-found: error
 
   bundle:
-    needs: [ get-configs, version-and-tag, build-and-test ]
+    needs: [ get-configs, version-and-tag ]
     strategy:
       fail-fast: true
       matrix:
         include:
-          - { os: "ubuntu-22.04", arch: "x64", platform: "linux", go-arch: "amd64", node-version: "18.x" }
-          - { os: "ubuntu-22.04", arch: "x64", platform: "linux", go-arch: "amd64", node-version: "20.x" }
-          - { os: "ubuntu-22.04", arch: "x64", platform: "linux", go-arch: "amd64", node-version: "22.x" }
-          - { os: "ubuntu-22.04", arch: "arm64", platform: "linux", go-arch: "arm64", node-version: "18.x" }
-          - { os: "ubuntu-22.04", arch: "arm64", platform: "linux", go-arch: "arm64", node-version: "20.x" }
-          - { os: "ubuntu-22.04", arch: "arm64", platform: "linux", go-arch: "arm64", node-version: "22.x" }
-          - { os: "ubuntu-22.04", arch: "arm", platform: "linux", go-arch: "arm", node-version: "18.x" }
-          - { os: "ubuntu-22.04", arch: "arm", platform: "linux", go-arch: "arm", node-version: "20.x" }
-          - { os: "ubuntu-22.04", arch: "arm", platform: "linux", go-arch: "arm", node-version: "22.x" }
           - { os: "macos-latest", arch: "x64", platform: "darwin", go-arch: "amd64", node-version: "18.x" }
           - { os: "macos-latest", arch: "x64", platform: "darwin", go-arch: "amd64", node-version: "20.x" }
           - { os: "macos-latest", arch: "x64", platform: "darwin", go-arch: "amd64", node-version: "22.x" }
           - { os: "macos-latest", arch: "arm64", platform: "darwin", go-arch: "arm64", node-version: "18.x" }
           - { os: "macos-latest", arch: "arm64", platform: "darwin", go-arch: "arm64", node-version: "20.x" }
           - { os: "macos-latest", arch: "arm64", platform: "darwin", go-arch: "arm64", node-version: "22.x" }
           - { os: "windows-latest", arch: "x64", platform: "win32", go-arch: "amd64", node-version: "18.x" }
           - { os: "windows-latest", arch: "x64", platform: "win32", go-arch: "amd64", node-version: "20.x" }
           - { os: "windows-latest", arch: "x64", platform: "win32", go-arch: "amd64", node-version: "22.x" }
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v5
         with:
           ref: ${{ needs.version-and-tag.outputs.tag }}
           fetch-tags: true
 
       - name: Git Status
         shell: bash
         run: echo "Bundling from branch=$(git rev-parse --abbrev-ref HEAD), commit=$(git rev-parse HEAD), tag=$(git describe --tags --exact-match)"
 
       - name: Setup Node.js ${{ matrix.node-version }} (${{ runner.os }})
         uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
           cache: 'npm'
 
       - name: Setup Go ${{ needs.get-configs.outputs.go-version }} (${{ runner.os }})
         uses: actions/setup-go@v4
         with:
           go-version: ${{ needs.get-configs.outputs.go-version }}
           cache: true
 
       - name: Install Dependencies
         run: npm ci
 
       - name: Bundle (${{ matrix.platform }}-${{ matrix.arch }})
         shell: bash
         run: |
           TAG=${{ needs.version-and-tag.outputs.tag }}
           if [[ "$TAG" =~ -alpha$ ]]; then
-            npm run bundle:alpha -- --env platform=${{ matrix.platform }} --env arch=${{ matrix.arch }}
+            npm run bundle:alpha
           elif [[ "$TAG" =~ -beta$ ]]; then
-            npm run bundle:beta -- --env platform=${{ matrix.platform }} --env arch=${{ matrix.arch }}
+            npm run bundle:beta
           else
-            npm run bundle:prod -- --env platform=${{ matrix.platform }} --env arch=${{ matrix.arch }}
+            npm run bundle:prod
           fi
 
       - name: Bundle Go
         shell: bash
         env:
           GOPROXY: direct
         run: |
           if [[ "${{ runner.os }}" == "Windows" ]]; then
             GOARCH=${{ matrix.go-arch }} go build -C ./cfn-init/cmd -v -o ../../bundle/production/bin/cfn-init.exe
           else
             GOARCH=${{ matrix.go-arch }} go build -C ./cfn-init/cmd -v -o ../../bundle/production/bin/cfn-init
           fi
           cp ./cfn-init/THIRD-PARTY-LICENSES.txt ./bundle/production/bin/
 
       - name: Set release asset name
         id: set-asset-name
         shell: bash
         run: |
           APP_NAME=${{ needs.get-configs.outputs.app-name }}
           VERSION=$(node -p "require('./package.json').version")
           PLATFORM=${{ matrix.platform }}
           ARCH=${{ matrix.arch }}
           NODE_VERSION=${{ matrix.node-version }}
           NODE_MAJOR=$(echo $NODE_VERSION | cut -d. -f1)
 
           TAG=${{ needs.version-and-tag.outputs.tag }}
           if [[ "$TAG" =~ -alpha$ ]]; then
             FILE_NAME="${APP_NAME}-${VERSION}-alpha-${PLATFORM}-${ARCH}-node${NODE_MAJOR}.zip"
           elif [[ "$TAG" =~ -beta$ ]]; then
             FILE_NAME="${APP_NAME}-${VERSION}-beta-${PLATFORM}-${ARCH}-node${NODE_MAJOR}.zip"
           else
             FILE_NAME="${APP_NAME}-${VERSION}-${PLATFORM}-${ARCH}-node${NODE_MAJOR}.zip"
           fi
 
           ASSET_NAME=$(echo "$FILE_NAME" | tr '[:upper:]' '[:lower:]')
           echo "ASSET_NAME=${ASSET_NAME}"
           echo "ASSET_NAME=${ASSET_NAME}" >> $GITHUB_OUTPUT
 
       - name: Create Zip (Unix)
         if: runner.os != 'Windows'
         env:
           ASSET_NAME: ${{ steps.set-asset-name.outputs.ASSET_NAME }}
         run: |
           chmod -R 777 ./bundle/production
           echo "Creating zip: ${{ env.ASSET_NAME }}"
           (cd ./bundle/production && zip -r ../../${{ env.ASSET_NAME }} .)
 
       - name: Create Zip (Windows)
         if: runner.os == 'Windows'
         env:
           ASSET_NAME: ${{ steps.set-asset-name.outputs.ASSET_NAME }}
         run: |
           icacls ./bundle/production /grant Everyone:F /T
           echo "Creating zip: ${{ env.ASSET_NAME }}"
           Compress-Archive -Path ./bundle/production/* -DestinationPath ./${{ env.ASSET_NAME }}
 
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
           name: ${{ steps.set-asset-name.outputs.ASSET_NAME }}
           path: ${{ steps.set-asset-name.outputs.ASSET_NAME }}
           if-no-files-found: error
 
   release:
-    needs: [ version-and-tag, bundle ]
+    needs: [ version-and-tag, bundle-linux, bundle ]
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -203,6 +281,9 @@
         with:
           path: artifacts
 
+      - name: List artifacts
+        run: ls -R artifacts/
+
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
         with:

webpack.config.js

@@ -54,7 +54,7 @@ function generateExternals() {
 
 const EXTERNALS = generateExternals();
 
-function createPlugins(isDevelopment, outputPath, mode, env, targetPlatform, targetArch) {
+function createPlugins(isDevelopment, outputPath, mode, env) {
     const plugins = [];
 
     plugins.push(
@@ -90,7 +90,6 @@ function createPlugins(isDevelopment, outputPath, mode, env, targetPlatform, tar
                 compiler.hooks.beforeRun.tapAsync('InstallDependencies', (compilation, callback) => {
                     try {
                         console.log('[InstallDependencies] Starting dependency installation...');
-                        console.log(`[InstallDependencies] Target: ${targetPlatform}-${targetArch}`);
 
                         const tmpPkg = {
                             ...Package,
@@ -112,10 +111,11 @@ function createPlugins(isDevelopment, outputPath, mode, env, targetPlatform, tar
 
                         console.log('[InstallDependencies] Running npm ci --omit=dev');
                         execSync('npm ci --omit=dev', { cwd: tmpDir, stdio: 'inherit' });
+
+                        console.log('[InstallDependencies] Rebuilding tree-sitter-json from source...');
+                        execSync('npm rebuild tree-sitter-json --build-from-source', { cwd: tmpDir, stdio: 'inherit' });
+
                         const otherDeps = Object.entries(Package.nativePrebuilds)
-                            .filter(([key, _version]) => {
-                                return key.endsWith(`${targetPlatform}-${targetArch}`);
-                            })
                             .map(([key, version]) => {
                                 return `${key}@${version}`;
                             })
@@ -130,43 +130,6 @@ function createPlugins(isDevelopment, outputPath, mode, env, targetPlatform, tar
                     }
                 });
 
-                compiler.hooks.afterEmit.tap('CleanUnusedNativeModules', () => {
-                    console.log('[CleanUnusedNativeModules] Starting cleanup of unused native modules...');
-
-                    const nodeModulesPath = path.join(outputPath, 'node_modules');
-
-                    if (!fs.existsSync(nodeModulesPath)) {
-                        console.log('[CleanUnusedNativeModules] No node_modules found, skipping cleanup');
-                        return;
-                    }
-
-                    function cleanPlatformDirs(dir) {
-                        if (!fs.existsSync(dir)) return;
-
-                        const entries = fs.readdirSync(dir, { withFileTypes: true });
-                        for (const entry of entries) {
-                            if (!entry.isDirectory()) continue;
-
-                            const entryPath = path.join(dir, entry.name);
-                            const isPlatformDir = PLATFORMS.some((p) => entry.name.includes(`${p}-`));
-                            const shouldKeep = entry.name.includes(`${targetPlatform}-${targetArch}`);
-
-                            if (isPlatformDir && !shouldKeep) {
-                                console.log(`[CleanUnusedNativeModules] Deleted: ${entryPath}`);
-                                fs.rmSync(entryPath, { recursive: true, force: true });
-                            } else if (entry.name === 'prebuilds') {
-                                console.log(`[CleanUnusedNativeModules] Scanning prebuilds: ${entryPath}`);
-                                cleanPlatformDirs(entryPath);
-                            } else {
-                                cleanPlatformDirs(entryPath);
-                            }
-                        }
-                    }
-
-                    cleanPlatformDirs(nodeModulesPath);
-                    console.log('[CleanUnusedNativeModules] Cleanup complete');
-                });
-
                 compiler.hooks.done.tap('CleanupTemp', () => {
                     console.log('[CleanupTemp] Cleaning up temporary files...');
                     if (fs.existsSync(tmpDir)) {
@@ -334,6 +297,6 @@ module.exports = (env = {}) => {
                 chunks: 'all',
             },
         },
-        plugins: createPlugins(isDevelopment, outputPath, mode, awsEnv, targetPlatform, targetArch),
+        plugins: createPlugins(isDevelopment, outputPath, mode, awsEnv),
     };
 };