fix(action): use aws sdk to remove dependence on aws cli (#701)

Co-authored-by: danadajian <danadajian@users.noreply.github.com>

Author: danadajian

action/dist/main.js

@@ -5,6 +5,7 @@
   "dependencies": {
     "@actions/core": "3.0.0",
     "@actions/github": "9.0.0",
+    "@aws-sdk/client-s3": "^3.705.0",
     "bluebird": "3.7.2",
     "glob": "13.0.0"
   },

action/dist/main.js.map

@@ -1,12 +1,17 @@
 import { info, getInput } from '@actions/core';
-import { exec } from '@actions/exec';
+import { rm } from 'fs/promises';
 
 const post = async () => {
   info('Cleaning up screenshots directory...');
 
   const screenshotsDirectory = getInput('screenshots-directory');
 
-  await exec(`rm -rf ${screenshotsDirectory}`);
+  try {
+    await rm(screenshotsDirectory, { recursive: true, force: true });
+  } catch (error) {
+    // Directory might not exist, which is fine
+    info(`Could not remove directory: ${error}`);
+  }
 
   info('Cleanup complete!');
 };

action/dist/post.js

@@ -16,6 +16,7 @@ import { octokit } from './octokit';
 import { context } from '@actions/github';
 import * as path from 'path';
 import { sync } from 'glob';
+import { unlinkSync } from 'fs';
 import { createGithubComment } from './comment';
 import { getLatestVisualRegressionStatus } from './get-latest-visual-regression-status';
 import {
@@ -62,6 +63,7 @@ export const run = async () => {
   const newFilePaths = filesInScreenshotDirectory.filter(file =>
     file.endsWith('new.png')
   );
+
   const diffFileCount = diffFilePaths.reduce((count, diffPath) => {
     if (
       newFilePaths.some(
@@ -70,9 +72,12 @@ export const run = async () => {
     ) {
       return count + 1;
     }
-    exec(`rm ${diffPath}`);
+    // Delete orphaned diff files (no corresponding new file)
+    unlinkSync(diffPath);
+
     return count;
   }, 0);
+
   const newFileCount = newFilePaths.length;
 
   if (numVisualTestFailures > diffFileCount) {

action/dist/post.js.map

@@ -1,5 +1,10 @@
-import { exec } from '@actions/exec';
 import { getInput, info } from '@actions/core';
+import {
+  S3Client,
+  ListObjectsV2Command,
+  GetObjectCommand,
+  PutObjectCommand
+} from '@aws-sdk/client-s3';
 import {
   BASE_IMAGE_NAME,
   BASE_IMAGES_DIRECTORY,
@@ -8,62 +13,172 @@ import {
 } from 'shared';
 import { map } from 'bluebird';
 import * as path from 'path';
+import * as fs from 'fs';
+import { promises as fsPromises } from 'fs';
+import { glob } from 'glob';
+import { Readable } from 'stream';
+
+const s3Client = new S3Client();
+
+async function checkS3PrefixExists(
+  bucketName: string,
+  prefix: string
+): Promise<boolean> {
+  try {
+    const command = new ListObjectsV2Command({
+      Bucket: bucketName,
+      Prefix: prefix,
+      MaxKeys: 1
+    });
+    const response = await s3Client.send(command);
+    return (response.Contents?.length ?? 0) > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function downloadS3Directory(
+  bucketName: string,
+  s3Prefix: string,
+  localDir: string
+): Promise<void> {
+  const command = new ListObjectsV2Command({
+    Bucket: bucketName,
+    Prefix: s3Prefix
+  });
+
+  const response = await s3Client.send(command);
+  const objects = response.Contents ?? [];
+
+  await map(objects, async object => {
+    if (!object.Key) return;
+
+    const relativePath = object.Key.substring(s3Prefix.length);
+    const localFilePath = path.join(localDir, relativePath);
+
+    await fsPromises.mkdir(path.dirname(localFilePath), { recursive: true });
+
+    const getCommand = new GetObjectCommand({
+      Bucket: bucketName,
+      Key: object.Key
+    });
+
+    const { Body } = await s3Client.send(getCommand);
+    if (Body instanceof Readable) {
+      const writeStream = fs.createWriteStream(localFilePath);
+      await new Promise((resolve, reject) => {
+        Body.pipe(writeStream).on('finish', resolve).on('error', reject);
+      });
+    }
+  });
+}
+
+async function uploadLocalDirectory(
+  localDir: string,
+  bucketName: string,
+  s3Prefix: string
+): Promise<void> {
+  const files = await glob('**/*', {
+    cwd: localDir,
+    nodir: true,
+    absolute: false
+  });
+
+  await map(files, async file => {
+    const localFilePath = path.join(localDir, file);
+    const s3Key = path.join(s3Prefix, file);
+
+    const fileContent = await fsPromises.readFile(localFilePath);
+
+    const command = new PutObjectCommand({
+      Bucket: bucketName,
+      Key: s3Key,
+      Body: fileContent
+    });
+
+    await s3Client.send(command);
+  });
+}
+
+async function uploadSingleFile(
+  localFilePath: string,
+  bucketName: string,
+  s3Key: string
+): Promise<void> {
+  const fileContent = await fsPromises.readFile(localFilePath);
+
+  const command = new PutObjectCommand({
+    Bucket: bucketName,
+    Key: s3Key,
+    Body: fileContent
+  });
+
+  await s3Client.send(command);
+}
 
 export const downloadBaseImages = async () => {
   const bucketName = getInput('bucket-name', { required: true });
   const screenshotsDirectory = getInput('screenshots-directory');
-  const baseImageExitCode = await exec(
-    `aws s3 ls s3://${bucketName}/${BASE_IMAGES_DIRECTORY}/`,
-    [],
-    { ignoreReturnCode: true }
+
+  const prefixExists = await checkS3PrefixExists(
+    bucketName,
+    `${BASE_IMAGES_DIRECTORY}/`
   );
-  if (baseImageExitCode !== 0) {
+
+  if (!prefixExists) {
     info(
       `Base images directory does not exist in bucket ${bucketName}. Skipping download.`
     );
-    await exec(`mkdir -p ${screenshotsDirectory}`);
+    await fsPromises.mkdir(screenshotsDirectory, { recursive: true });
     return;
   }
 
   const packagePaths = getInput('package-paths')?.split(',');
   if (packagePaths) {
     return Promise.all(
       packagePaths.map(packagePath =>
-        exec(
-          `aws s3 cp s3://${bucketName}/${BASE_IMAGES_DIRECTORY}/${packagePath} ${screenshotsDirectory}/${packagePath} --recursive`
+        downloadS3Directory(
+          bucketName,
+          `${BASE_IMAGES_DIRECTORY}/${packagePath}/`,
+          path.join(screenshotsDirectory, packagePath)
         )
       )
     );
   }
 
-  return exec(
-    `aws s3 cp s3://${bucketName}/${BASE_IMAGES_DIRECTORY} ${screenshotsDirectory} --recursive`
+  return downloadS3Directory(
+    bucketName,
+    `${BASE_IMAGES_DIRECTORY}/`,
+    screenshotsDirectory
   );
 };
 
 export const uploadAllImages = async (hash: string) => {
   const bucketName = getInput('bucket-name', { required: true });
   const screenshotsDirectory = getInput('screenshots-directory');
   const packagePaths = getInput('package-paths')?.split(',');
+
   if (packagePaths) {
     return map(packagePaths, packagePath =>
-      exec(
-        `aws s3 cp ${screenshotsDirectory}/${packagePath} s3://${bucketName}/${NEW_IMAGES_DIRECTORY}/${hash}/${packagePath} --recursive`
+      uploadLocalDirectory(
+        path.join(screenshotsDirectory, packagePath),
+        bucketName,
+        `${NEW_IMAGES_DIRECTORY}/${hash}/${packagePath}/`
       )
     );
   }
 
-  return exec(
-    `aws s3 cp ${screenshotsDirectory} s3://${bucketName}/${NEW_IMAGES_DIRECTORY}/${hash} --recursive`
+  return uploadLocalDirectory(
+    screenshotsDirectory,
+    bucketName,
+    `${NEW_IMAGES_DIRECTORY}/${hash}/`
   );
 };
 
 export const uploadBaseImages = async (newFilePaths: string[]) => {
   const bucketName = getInput('bucket-name', { required: true });
   return map(newFilePaths, newFilePath =>
-    exec(
-      `aws s3 cp ${newFilePath} s3://${bucketName}/${buildBaseImagePath(newFilePath)}`
-    )
+    uploadSingleFile(newFilePath, bucketName, buildBaseImagePath(newFilePath))
   );
 };