@kitsi/action 0.2.0 → 0.3.0

package/dist/index.js

@@ -126757,6 +126757,16 @@ var writeFiles = async (basePath, files) => {
     await writeFile(destination, contents);
   }));
 };
+var copyFiles = async (sourceBase, destinationBase) => {
+  const files = await walk(sourceBase);
+  const fileMap = {};
+  await Promise.all(files.map(async (file) => {
+    const relativePath = relative(sourceBase, file);
+    fileMap[relativePath] = await readFile3(file);
+  }));
+  await mkdir2(destinationBase, { recursive: true });
+  await writeFiles(destinationBase, fileMap);
+};
 
 // ../core/src/engine/cache/serialize.ts
 var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -127960,8 +127970,7 @@ class AnnotateHandler {
 
 // ../core/src/engine/handlers/artifact-download-handler.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir4, readFile as readFile6 } from "node:fs/promises";
-import { join as join5, relative as relative3 } from "node:path";
+import { join as join5 } from "node:path";
 class ArtifactDownloadHandler {
   kind = "artifact-download";
   async execute(op, context, _state) {
@@ -127971,15 +127980,8 @@ class ArtifactDownloadHandler {
       if (!existsSync2(sourceBase)) {
         throw OpErrors.artifact(`Artifact "${op.name}" not found at ${sourceBase}`).build();
       }
-      const files = await walk(sourceBase);
-      const fileMap = {};
-      await Promise.all(files.map(async (file) => {
-        const relativePath = relative3(sourceBase, file);
-        fileMap[relativePath] = await readFile6(file);
-      }));
       const destinationBase = join5(context.workspace, op.destination);
-      await mkdir4(destinationBase, { recursive: true });
-      await writeFiles(destinationBase, fileMap);
+      await copyFiles(sourceBase, destinationBase);
       context.reporter?.emit("artifact_download_end", {
         artifact: op.name,
         status: "success"
@@ -128030,7 +128032,7 @@ class BindServiceHandler {
 
 // ../core/src/engine/handlers/cache-mount-handler.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { mkdir as mkdir5 } from "node:fs/promises";
+import { mkdir as mkdir4 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 
 class CacheMountHandler {
@@ -128042,7 +128044,7 @@ class CacheMountHandler {
       cache: op.cache.name,
       path: mountPath
     });
-    await mkdir5(mountPath, { recursive: true });
+    await mkdir4(mountPath, { recursive: true });
   }
 }
 
@@ -128078,7 +128080,7 @@ class EnvHandler {
 }
 
 // ../core/src/engine/handlers/http-handler.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { isAbsolute, resolve } from "node:path";
 class HttpHandler {
   kind = "http";
@@ -128096,7 +128098,7 @@ class HttpHandler {
     let body;
     if (op.bodyPath) {
       const resolved = isAbsolute(op.bodyPath) ? op.bodyPath : resolve(context.workspace, op.bodyPath);
-      body = await readFile7(resolved);
+      body = await readFile6(resolved);
     } else if (op.body) {
       body = this.renderTemplate(op.body, context);
     }
@@ -128824,41 +128826,11 @@ class PlanRunner {
       state.artifactUploads.push({ op, step: step2.name });
       return;
     }
-    const opStart = Date.now();
-    this.reporter?.emit("op_start", { task: task2.config.name, step: step2.name, op: op.kind });
-    try {
-      const context = {
-        workspace: this.workspace,
-        env: env2,
-        logger: this.logger,
-        resolver: this.resolver,
-        reporter: this.reporter,
-        signal: this.signal,
-        task: task2.config.name,
-        step: step2.name
-      };
+    return this.runOpWithLifecycle(task2.config.name, step2.name, op.kind, env2, async (context) => {
       const executeBaseOp = (opToRun) => this.opHandlers.execute(opToRun, context, state);
       const cacheResult = await this.cache.tryExecuteOp(op, task2, context, state, executeBaseOp, this.executeOp.bind(this));
-      const result = cacheResult?.handled ? cacheResult.value : await executeBaseOp(op);
-      this.reporter?.emit("op_end", {
-        task: task2.config.name,
-        step: step2.name,
-        op: op.kind,
-        status: "success",
-        duration: (Date.now() - opStart) / 1000
-      });
-      return result;
-    } catch (error2) {
-      this.reporter?.emit("op_end", {
-        task: task2.config.name,
-        step: step2.name,
-        op: op.kind,
-        status: "failed",
-        duration: (Date.now() - opStart) / 1000,
-        error: error2 instanceof Error ? error2.message : String(error2)
-      });
-      throw error2;
-    }
+      return cacheResult?.handled ? cacheResult.value : await executeBaseOp(op);
+    });
   }
   async flushArtifactUploads(task2, env2, state, status) {
     if (state.artifactUploads.length === 0)
@@ -128883,36 +128855,38 @@ class PlanRunner {
     return when === "always" || status === "success";
   }
   async executeArtifactUpload(task2, env2, state, entry) {
+    await this.runOpWithLifecycle(task2.config.name, entry.step, entry.op.kind, env2, (context) => this.opHandlers.execute(entry.op, context, state));
+  }
+  createExecutionContext(taskName, stepName, env2) {
+    return {
+      workspace: this.workspace,
+      env: env2,
+      logger: this.logger,
+      resolver: this.resolver,
+      reporter: this.reporter,
+      signal: this.signal,
+      task: taskName,
+      step: stepName
+    };
+  }
+  async runOpWithLifecycle(taskName, stepName, opKind, env2, execute) {
     const opStart = Date.now();
-    this.reporter?.emit("op_start", {
-      task: task2.config.name,
-      step: entry.step,
-      op: entry.op.kind
-    });
+    this.reporter?.emit("op_start", { task: taskName, step: stepName, op: opKind });
     try {
-      const context = {
-        workspace: this.workspace,
-        env: env2,
-        logger: this.logger,
-        resolver: this.resolver,
-        reporter: this.reporter,
-        signal: this.signal,
-        task: task2.config.name,
-        step: entry.step
-      };
-      await this.opHandlers.execute(entry.op, context, state);
+      const result = await execute(this.createExecutionContext(taskName, stepName, env2));
       this.reporter?.emit("op_end", {
-        task: task2.config.name,
-        step: entry.step,
-        op: entry.op.kind,
+        task: taskName,
+        step: stepName,
+        op: opKind,
         status: "success",
         duration: (Date.now() - opStart) / 1000
       });
+      return result;
     } catch (error2) {
       this.reporter?.emit("op_end", {
-        task: task2.config.name,
-        step: entry.step,
-        op: entry.op.kind,
+        task: taskName,
+        step: stepName,
+        op: opKind,
         status: "failed",
         duration: (Date.now() - opStart) / 1000,
         error: error2 instanceof Error ? error2.message : String(error2)

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "@kitsi/action",
- "version": "0.2.0",
+ "version": "0.3.0",
  "description": "GitHub Action for running Kitsi pipelines",
  "type": "module",
  "main": "./dist/index.js",