chore: update GitHub artifact client

Signed-off-by: Keith Zantow <kzantow@gmail.com>

package.json

@@ -34,7 +34,7 @@
   "author": "Keith Zantow <keith.zantow@anchore.com>",
   "license": "Apache-2.0",
   "dependencies": {
-    "@actions/artifact": "^1.1.1",
+    "@actions/artifact": "^2.1.7",
     "@actions/core": "^1.10.0",
     "@actions/exec": "^1.1.1",
     "@actions/github": "^5.1.1",

src/github/GithubClient.ts

@@ -1,8 +1,4 @@
-import {
-  create as createArtifactClient,
-  UploadOptions,
-} from "@actions/artifact";
-import { DownloadHttpClient } from "@actions/artifact/lib/internal/download-http-client";
+import artifactClient, { UploadArtifactOptions } from "@actions/artifact";
 import * as core from "@actions/core";
 import * as github from "@actions/github";
 import { GitHub } from "@actions/github/lib/utils";
@@ -137,34 +133,41 @@ export class GithubClient {
   /**
    * Lists the workflow artifacts for the current workflow
    */
-  async listWorkflowArtifacts(): Promise<Artifact[]> {
+  async listCurrentWorkflowArtifacts(): Promise<Artifact[]> {
     // The REST listWorkflowRunArtifacts endpoint does not seem to work during
-    // the workflow run, presumably the are available afterwards much like the
-    // Github UI only shows artifacts after completion of a run, so we have
+    // the workflow run, presumably they are available afterward, much like the
+    // GitHub UI only shows artifacts after completion of a run, so we have
     // to do a little bit of hackery here. We _could_ download all artifacts
     // using a supported API, but internally it's using this anyway
-    const downloadClient = new DownloadHttpClient();
-    const response = await downloadClient.listArtifacts();
+    const response = await artifactClient.listArtifacts();
 
-    debugLog("listWorkflowArtifacts response:", response);
+    debugLog("listCurrentWorkflowArtifacts response:", response);
 
-    return response.value;
+    return response.artifacts;
   }
 
   /**
    * Downloads a workflow artifact for the current workflow run
    * @param name artifact name
    * @param id specified if using a workflow run artifact
+   * @return full path to the artifact
    */
   async downloadWorkflowArtifact({ name, id }: Artifact): Promise<string> {
     if (id) {
       return this.downloadWorkflowRunArtifact({ artifactId: id });
     }
-    const client = createArtifactClient();
     const tempPath = fs.mkdtempSync(path.join(os.tmpdir(), "sbom-action-"));
-    const response = await suppressOutput(async () =>
-      client.downloadArtifact(name, tempPath)
-    );
+    const response = await suppressOutput(async () => {
+      const response = await artifactClient.getArtifact(name);
+      return await artifactClient.downloadArtifact(response.artifact.id, {
+        path: tempPath,
+      });
+    });
+
+    if (!response.downloadPath) {
+      debugLog("downloadArtifact response empty", response);
+      return "";
+    }
 
     debugLog(
       "downloadArtifact response:",
@@ -173,7 +176,7 @@ export class GithubClient {
       core.isDebug() && fs.readdirSync(response.downloadPath)
     );
 
-    return `${response.downloadPath}/${response.artifactName}`;
+    return `${response.downloadPath}`;
   }
 
   /**
@@ -192,7 +195,6 @@ export class GithubClient {
     retention?: number;
   }): Promise<void> {
     const rootDirectory = path.dirname(file);
-    const client = createArtifactClient();
 
     debugLog(
       "uploadArtifact:",
@@ -203,15 +205,13 @@ export class GithubClient {
       core.isDebug() && fs.readdirSync(rootDirectory)
     );
 
-    const options: UploadOptions = {
-      continueOnError: false,
-    };
+    const options: UploadArtifactOptions = {};
     if (retention) {
       options.retentionDays = retention;
     }
 
     const info = await suppressOutput(async () =>
-      client.uploadArtifact(name, [file], rootDirectory, options)
+      artifactClient.uploadArtifact(name, [file], rootDirectory, options)
     );
 
     debugLog("uploadArtifact response:", info);
@@ -246,7 +246,7 @@ export class GithubClient {
 
   /**
    * Lists the workflow run artifacts for a completed workflow
-   * @param runId the workflow run number
+   * @param branch the branch name
    */
   async findLatestWorkflowRunForBranch({
     branch,

src/github/SyftGithubAction.ts

@@ -484,7 +484,7 @@ export async function attachReleaseAssets(): Promise<void> {
     const sbomArtifactPattern = sbomArtifactInput || `^${getArtifactName()}$`;
     const matcher = new RegExp(sbomArtifactPattern);
 
-    const artifacts = await client.listWorkflowArtifacts();
+    const artifacts = await client.listCurrentWorkflowArtifacts();
     let matched = artifacts.filter((a) => {
       const matches = matcher.test(a.name);
       if (matches) {

tests/GithubClient.test.ts

@@ -138,7 +138,7 @@ describe("Github Client", () => {
       "token"
     );
 
-    let artifacts = await client.listWorkflowArtifacts();
+    let artifacts = await client.listCurrentWorkflowArtifacts();
 
     expect(artifacts.length).toBe(0);
 

tests/SyftGithubAction.test.ts

@@ -197,7 +197,7 @@ describe("Action", () => {
       artifacts: [{
         runId: 6,
         name: "sbom.spdx.json",
-        file: "the_sbom",
+        files: ["the_sbom"],
       }],
     });
 

tests/integration/formatExports.test.ts

@@ -31,7 +31,7 @@ const testSource = async (source: string, format = "spdx"): Promise<string> => {
     .spyOn(client, "getClient")
     .mockImplementation(() => {
       return {
-        listWorkflowArtifacts() {
+        listCurrentWorkflowArtifacts() {
           return Promise.resolve(artifacts);
         },
         uploadWorkflowArtifact({ file }) {

tests/mocks.ts

@@ -1,9 +1,18 @@
+import {
+  DownloadArtifactOptions,
+  DownloadArtifactResponse,
+  FindOptions,
+  ListArtifactsResponse,
+  UploadArtifactOptions,
+  UploadArtifactResponse
+} from "@actions/artifact";
+
 /**
  * Get all the mocks and mock data
  */
 export function getMocks() {
   class Data {
-    artifacts: Partial<(Artifact & { runId: number, id: number, file: string })>[] = [];
+    artifacts: Partial<(Artifact & { runId: number, id: number, files: string[] })>[] = [];
 
     assets: Partial<ReleaseAsset>[] = [];
 
@@ -109,39 +118,52 @@ export function getMocks() {
         };
       },
 
-      "@actions/artifact/lib/internal/download-http-client": () => {
+      "@actions/artifact": () => {
         return {
-          DownloadHttpClient: class {
-            async listArtifacts() {
+          /*
+          export interface ArtifactClient {
+            uploadArtifact(name: string, files: string[], rootDirectory: string, options?: UploadArtifactOptions): Promise<UploadArtifactResponse>;
+            listArtifacts(options?: ListArtifactsOptions & FindOptions): Promise<ListArtifactsResponse>;
+            getArtifact(artifactName: string, options?: FindOptions): Promise<GetArtifactResponse>;
+            downloadArtifact(artifactId: number, options?: DownloadArtifactOptions & FindOptions): Promise<DownloadArtifactResponse>;
+            deleteArtifact(artifactName: string, options?: FindOptions): Promise<DeleteArtifactResponse>;
+          }
+          */
+          uploadArtifact(name: string, files: string[], rootDirectory: string, options?: UploadArtifactOptions): UploadArtifactResponse {
+            const id = data.artifacts.length;
+            data.artifacts.push({
+              id,
+              name: path.basename(name),
+              files,
+              rootDirectory,
+              options,
+            } as never);
+            return {
+              id,
+            };
+          },
+          downloadArtifact(artifactId: number, options?: DownloadArtifactOptions & FindOptions): DownloadArtifactResponse {
+            const tempPath = options?.path || "/tmp";
+            const artifact = data.artifacts.find(a => a.id == artifactId);
+            if (artifact) {
+              const name = "my-artifact-name";
+              fs.writeFileSync(`${tempPath}/${name}`, "file");
               return {
-                value: data.artifacts.filter(a => !a.runId),
+                downloadPath: `${tempPath}/${name}`,
               };
             }
+            throw new Error(`no artifact for id: ${artifactId}`);
           },
-        };
-      },
-
-      "@actions/artifact": () => {
-        return {
-          create() {
+          listArtifacts() {
             return {
-              uploadArtifact(name: string, file: string, rootDirectory: string, options?: any) {
-                data.artifacts.push({
-                  name: path.basename(name),
-                  file,
-                  rootDirectory,
-                  options,
-                } as never);
-              },
-              downloadArtifact(name: string, tempPath: string) {
-                fs.writeFileSync(`${tempPath}/${name}`, "file");
-                return {
-                  downloadPath: tempPath,
-                  artifactName: name,
-                };
-              },
+              artifacts: data.artifacts.filter(a => !a.runId),
             };
           },
+          getArtifact(artifactName: string, options?: FindOptions) {
+            return {
+              artifact: data.artifacts.find(a => a.name == artifactName)
+            }
+          },
         };
       },