@backstage/plugin-scaffolder-backend 1.12.0-next.2 → 1.12.1-next.0

package/dist/alpha.cjs.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var backendPluginApi = require('@backstage/backend-plugin-api');
 var alpha = require('@backstage/plugin-catalog-node/alpha');
 var catalogModel = require('@backstage/catalog-model');
-var pluginCatalogBackend = require('@backstage/plugin-catalog-backend');
+var pluginCatalogNode = require('@backstage/plugin-catalog-node');
 var pluginScaffolderCommon = require('@backstage/plugin-scaffolder-common');
 var backendCommon = require('@backstage/backend-common');
 var integration = require('@backstage/integration');
@@ -15,6 +15,7 @@ var yaml = require('yaml');
 var fs = require('fs-extra');
 var zod = require('zod');
 var path = require('path');
+var luxon = require('luxon');
 var globby = require('globby');
 var isbinaryfile = require('isbinaryfile');
 var vm2 = require('vm2');
@@ -30,7 +31,6 @@ var fs$1 = require('fs');
 var limiterFactory = require('p-limit');
 var node = require('@gitbeaker/node');
 var uuid = require('uuid');
-var luxon = require('luxon');
 var ObservableImpl = require('zen-observable');
 var PQueue = require('p-queue');
 var winston = require('winston');
@@ -105,7 +105,7 @@ class ScaffolderEntitiesProcessor {
           defaultNamespace: selfRef.namespace
         });
         emit(
-          pluginCatalogBackend.processingResult.relation({
+          pluginCatalogNode.processingResult.relation({
             source: selfRef,
             type: catalogModel.RELATION_OWNED_BY,
             target: {
@@ -116,7 +116,7 @@ class ScaffolderEntitiesProcessor {
           })
         );
         emit(
-          pluginCatalogBackend.processingResult.relation({
+          pluginCatalogNode.processingResult.relation({
             source: {
               kind: targetRef.kind,
               namespace: targetRef.namespace,
@@ -147,14 +147,14 @@ const catalogModuleTemplateKind = backendPluginApi.createBackendModule({
   }
 });
 
-const id$3 = "catalog:register";
-const examples$3 = [
+const id$4 = "catalog:register";
+const examples$4 = [
   {
     description: "Register with the catalog",
     example: yaml__default["default"].stringify({
       steps: [
         {
-          action: id$3,
+          action: id$4,
           id: "register-with-catalog",
           name: "Register with the catalog",
           input: {
@@ -168,9 +168,9 @@ const examples$3 = [
 function createCatalogRegisterAction(options) {
   const { catalogClient, integrations } = options;
   return pluginScaffolderNode.createTemplateAction({
-    id: id$3,
+    id: id$4,
     description: "Registers entities from a catalog descriptor file in the workspace into the software catalog.",
-    examples: examples$3,
+    examples: examples$4,
     schema: {
       input: {
         oneOf: [
@@ -288,14 +288,14 @@ function createCatalogRegisterAction(options) {
   });
 }
 
-const id$2 = "catalog:write";
-const examples$2 = [
+const id$3 = "catalog:write";
+const examples$3 = [
   {
     description: "Write a catalog yaml file",
     example: yaml__namespace.stringify({
       steps: [
         {
-          action: id$2,
+          action: id$3,
           id: "create-catalog-info-file",
           name: "Create catalog file",
           input: {
@@ -320,7 +320,7 @@ const examples$2 = [
 ];
 function createCatalogWriteAction() {
   return pluginScaffolderNode.createTemplateAction({
-    id: id$2,
+    id: id$3,
     description: "Writes the catalog-info.yaml for your template",
     schema: {
       input: zod.z.object({
@@ -331,7 +331,7 @@ function createCatalogWriteAction() {
         )
       })
     },
-    examples: examples$2,
+    examples: examples$3,
     supportsDryRun: true,
     async handler(ctx) {
       ctx.logStream.write(`Writing catalog-info.yaml`);
@@ -345,14 +345,14 @@ function createCatalogWriteAction() {
   });
 }
 
-const id$1 = "catalog:fetch";
-const examples$1 = [
+const id$2 = "catalog:fetch";
+const examples$2 = [
   {
     description: "Fetch entity by reference",
     example: yaml__default["default"].stringify({
       steps: [
         {
-          action: id$1,
+          action: id$2,
           id: "fetch",
           name: "Fetch catalog entity",
           input: {
@@ -361,17 +361,31 @@ const examples$1 = [
         }
       ]
     })
+  },
+  {
+    description: "Fetch multiple entities by referencse",
+    example: yaml__default["default"].stringify({
+      steps: [
+        {
+          action: id$2,
+          id: "fetchMultiple",
+          name: "Fetch catalog entities",
+          input: {
+            entityRefs: ["component:default/name"]
+          }
+        }
+      ]
+    })
   }
 ];
 function createFetchCatalogEntityAction(options) {
   const { catalogClient } = options;
   return pluginScaffolderNode.createTemplateAction({
-    id: id$1,
-    description: "Returns entity from the catalog by entity reference",
-    examples: examples$1,
+    id: id$2,
+    description: "Returns entity or entities from the catalog by entity reference(s)",
+    examples: examples$2,
     schema: {
       input: {
-        required: ["entityRef"],
         type: "object",
         properties: {
           entityRef: {
@@ -379,9 +393,14 @@ function createFetchCatalogEntityAction(options) {
             title: "Entity reference",
             description: "Entity reference of the entity to get"
           },
+          entityRefs: {
+            type: "array",
+            title: "Entity references",
+            description: "Entity references of the entities to get"
+          },
           optional: {
             title: "Optional",
-            description: "Permit the entity to optionally exist. Default: false",
+            description: "Allow the entity or entities to optionally exist. Default: false",
             type: "boolean"
           }
         }
@@ -392,40 +411,62 @@ function createFetchCatalogEntityAction(options) {
           entity: {
             title: "Entity found by the entity reference",
             type: "object",
-            description: "Object containing same values used in the Entity schema."
+            description: "Object containing same values used in the Entity schema. Only when used with `entityRef` parameter."
+          },
+          entities: {
+            title: "Entities found by the entity references",
+            type: "array",
+            items: { type: "object" },
+            description: "Array containing objects with same values used in the Entity schema. Only when used with `entityRefs` parameter."
           }
         }
       }
     },
     async handler(ctx) {
-      var _a;
-      const { entityRef, optional } = ctx.input;
-      let entity;
-      try {
-        entity = await catalogClient.getEntityByRef(entityRef, {
+      var _a, _b;
+      const { entityRef, entityRefs, optional } = ctx.input;
+      if (!entityRef && !entityRefs) {
+        if (optional) {
+          return;
+        }
+        throw new Error("Missing entity reference or references");
+      }
+      if (entityRef) {
+        const entity = await catalogClient.getEntityByRef(entityRef, {
           token: (_a = ctx.secrets) == null ? void 0 : _a.backstageToken
         });
-      } catch (e) {
-        if (!optional) {
-          throw e;
+        if (!entity && !optional) {
+          throw new Error(`Entity ${entityRef} not found`);
         }
+        ctx.output("entity", entity != null ? entity : null);
       }
-      if (!entity && !optional) {
-        throw new Error(`Entity ${entityRef} not found`);
+      if (entityRefs) {
+        const entities = await catalogClient.getEntitiesByRefs(
+          { entityRefs },
+          {
+            token: (_b = ctx.secrets) == null ? void 0 : _b.backstageToken
+          }
+        );
+        const finalEntities = entities.items.map((e, i) => {
+          if (!e && !optional) {
+            throw new Error(`Entity ${entityRefs[i]} not found`);
+          }
+          return e != null ? e : null;
+        });
+        ctx.output("entities", finalEntities);
       }
-      ctx.output("entity", entity != null ? entity : null);
     }
   });
 }
 
-const id = "debug:log";
-const examples = [
+const id$1 = "debug:log";
+const examples$1 = [
   {
     description: "Write a debug message",
     example: yaml__default["default"].stringify({
       steps: [
         {
-          action: id,
+          action: id$1,
           id: "write-debug-line",
           name: 'Write "Hello Backstage!" log line',
           input: {
@@ -440,7 +481,7 @@ const examples = [
     example: yaml__default["default"].stringify({
       steps: [
         {
-          action: id,
+          action: id$1,
           id: "write-workspace-directory",
           name: "List the workspace directory",
           input: {
@@ -453,9 +494,9 @@ const examples = [
 ];
 function createDebugLogAction() {
   return pluginScaffolderNode.createTemplateAction({
-    id,
+    id: id$1,
     description: "Writes a message into the log or lists all files in the workspace.",
-    examples,
+    examples: examples$1,
     schema: {
       input: {
         type: "object",
@@ -502,6 +543,98 @@ async function recursiveReadDir(dir) {
   return files.reduce((a, f) => a.concat(f), []);
 }
 
+const id = "debug:wait";
+const MAX_WAIT_TIME_IN_ISO = "T00:00:30";
+const examples = [
+  {
+    description: "Waiting for 5 seconds",
+    example: yaml__default["default"].stringify({
+      steps: [
+        {
+          action: id,
+          id: "wait-5sec",
+          name: "Waiting for 5 seconds",
+          input: {
+            seconds: 5
+          }
+        }
+      ]
+    })
+  },
+  {
+    description: "Waiting for 5 minutes",
+    example: yaml__default["default"].stringify({
+      steps: [
+        {
+          action: id,
+          id: "wait-5min",
+          name: "Waiting for 5 minutes",
+          input: {
+            minutes: 5
+          }
+        }
+      ]
+    })
+  }
+];
+function createWaitAction(options) {
+  const toDuration = (maxWaitTime) => {
+    if (maxWaitTime) {
+      if (maxWaitTime instanceof luxon.Duration) {
+        return maxWaitTime;
+      }
+      return luxon.Duration.fromObject(maxWaitTime);
+    }
+    return luxon.Duration.fromISOTime(MAX_WAIT_TIME_IN_ISO);
+  };
+  return pluginScaffolderNode.createTemplateAction({
+    id,
+    description: "Waits for a certain period of time.",
+    examples,
+    schema: {
+      input: {
+        type: "object",
+        properties: {
+          minutes: {
+            title: "Waiting period in minutes.",
+            type: "number"
+          },
+          seconds: {
+            title: "Waiting period in seconds.",
+            type: "number"
+          },
+          milliseconds: {
+            title: "Waiting period in milliseconds.",
+            type: "number"
+          }
+        }
+      }
+    },
+    async handler(ctx) {
+      const delayTime = luxon.Duration.fromObject(ctx.input);
+      const maxWait = toDuration(options == null ? void 0 : options.maxWaitTime);
+      if (delayTime.minus(maxWait).toMillis() > 0) {
+        throw new Error(
+          `Waiting duration is longer than the maximum threshold of ${maxWait.toHuman()}`
+        );
+      }
+      await new Promise((resolve) => {
+        var _a;
+        const controller = new AbortController();
+        const timeoutHandle = setTimeout(abort, delayTime.toMillis());
+        (_a = ctx.signal) == null ? void 0 : _a.addEventListener("abort", abort);
+        function abort() {
+          var _a2;
+          (_a2 = ctx.signal) == null ? void 0 : _a2.removeEventListener("abort", abort);
+          clearTimeout(timeoutHandle);
+          controller.abort();
+          resolve("finished");
+        }
+      });
+    }
+  });
+}
+
 async function fetchContents(options) {
   const { reader, integrations, baseUrl, fetchUrl = ".", outputPath } = options;
   let fetchUrlIsAbsolute = false;
@@ -3970,7 +4103,7 @@ const createPublishGitlabMergeRequestAction = (options) => {
             title: "Gitlab Project path",
             type: "string"
           },
-          mergeRequestURL: {
+          mergeRequestUrl: {
             title: "MergeRequest(MR) URL",
             type: "string",
             description: "Link to the merge request in GitLab"
@@ -4142,6 +4275,7 @@ const createBuiltinActions = (options) => {
       config
     }),
     createDebugLogAction(),
+    createWaitAction(),
     createCatalogRegisterAction({ catalogClient, integrations }),
     createFetchCatalogEntityAction({ catalogClient }),
     createCatalogWriteAction(),
@@ -4308,7 +4442,7 @@ class DatabaseTaskStore {
       const updateCount = await tx("tasks").where({ id: task.id, status: "open" }).update({
         status: "processing",
         last_heartbeat_at: this.db.fn.now(),
-        // remove the secrets when moving moving to processing state.
+        // remove the secrets when moving to processing state.
         secrets: null
       });
       if (updateCount < 1) {
@@ -4356,7 +4490,7 @@ class DatabaseTaskStore {
   async completeTask(options) {
     const { taskId, status, eventBody } = options;
     let oldStatus;
-    if (status === "failed" || status === "completed") {
+    if (["failed", "completed", "cancelled"].includes(status)) {
       oldStatus = "processing";
     } else {
       throw new Error(
@@ -4367,6 +4501,30 @@ class DatabaseTaskStore {
       const [task] = await tx("tasks").where({
         id: taskId
       }).limit(1).select();
+      const updateTask = async (criteria) => {
+        const updateCount = await tx("tasks").where(criteria).update({
+          status
+        });
+        if (updateCount !== 1) {
+          throw new errors.ConflictError(
+            `Failed to update status to '${status}' for taskId ${taskId}`
+          );
+        }
+        await tx("task_events").insert({
+          task_id: taskId,
+          event_type: "completion",
+          body: JSON.stringify(eventBody)
+        });
+      };
+      if (status === "cancelled") {
+        await updateTask({
+          id: taskId
+        });
+        return;
+      }
+      if (task.status === "cancelled") {
+        return;
+      }
       if (!task) {
         throw new Error(`No task with taskId ${taskId} found`);
       }
@@ -4375,21 +4533,9 @@ class DatabaseTaskStore {
           `Refusing to update status of run '${taskId}' to status '${status}' as it is currently '${task.status}', expected '${oldStatus}'`
         );
       }
-      const updateCount = await tx("tasks").where({
+      await updateTask({
         id: taskId,
         status: oldStatus
-      }).update({
-        status
-      });
-      if (updateCount !== 1) {
-        throw new errors.ConflictError(
-          `Failed to update status to '${status}' for taskId ${taskId}`
-        );
-      }
-      await tx("task_events").insert({
-        task_id: taskId,
-        event_type: "completion",
-        body: JSON.stringify(eventBody)
       });
     });
   }
@@ -4457,24 +4603,37 @@ class DatabaseTaskStore {
       }
     });
   }
+  async cancelTask(options) {
+    const { taskId, body } = options;
+    const serializedBody = JSON.stringify(body);
+    await this.db("task_events").insert({
+      task_id: taskId,
+      event_type: "cancelled",
+      body: serializedBody
+    });
+  }
 }
 
 class TaskManager {
   // Runs heartbeat internally
-  constructor(task, storage, logger) {
+  constructor(task, storage, signal, logger) {
     this.task = task;
     this.storage = storage;
+    this.signal = signal;
     this.logger = logger;
     this.isDone = false;
   }
-  static create(task, storage, logger) {
-    const agent = new TaskManager(task, storage, logger);
+  static create(task, storage, abortSignal, logger) {
+    const agent = new TaskManager(task, storage, abortSignal, logger);
     agent.startTimeout();
     return agent;
   }
   get spec() {
     return this.task.spec;
   }
+  get cancelSignal() {
+    return this.signal;
+  }
   get secrets() {
     return this.task.secrets;
   }
@@ -4544,6 +4703,28 @@ class StorageTaskBroker {
     }
     return await this.storage.list({ createdBy: options == null ? void 0 : options.createdBy });
   }
+  async registerCancellable(taskId, abortController) {
+    let shouldUnsubscribe = false;
+    const subscription = this.event$({ taskId, after: void 0 }).subscribe({
+      error: (_) => {
+        subscription.unsubscribe();
+      },
+      next: ({ events }) => {
+        for (const event of events) {
+          if (event.type === "cancelled") {
+            abortController.abort();
+            shouldUnsubscribe = true;
+          }
+          if (event.type === "completion") {
+            shouldUnsubscribe = true;
+          }
+        }
+        if (shouldUnsubscribe) {
+          subscription.unsubscribe();
+        }
+      }
+    });
+  }
   /**
    * {@inheritdoc TaskBroker.claim}
    */
@@ -4551,6 +4732,8 @@ class StorageTaskBroker {
     for (; ; ) {
       const pendingTask = await this.storage.claimTask();
       if (pendingTask) {
+        const abortController = new AbortController();
+        await this.registerCancellable(pendingTask.id, abortController);
         return TaskManager.create(
           {
             taskId: pendingTask.id,
@@ -4559,6 +4742,7 @@ class StorageTaskBroker {
             createdBy: pendingTask.createdBy
           },
           this.storage,
+          abortController.signal,
           this.logger
         );
       }
@@ -4633,6 +4817,19 @@ class StorageTaskBroker {
     this.deferredDispatch.resolve();
     this.deferredDispatch = defer();
   }
+  async cancel(taskId) {
+    var _a, _b;
+    const { events } = await this.storage.listEvents({ taskId });
+    const currentStepId = events.length > 0 ? events.filter(({ body }) => body == null ? void 0 : body.stepId).reduce((prev, curr) => prev.id > curr.id ? prev : curr).body.stepId : 0;
+    await ((_b = (_a = this.storage).cancelTask) == null ? void 0 : _b.call(_a, {
+      taskId,
+      body: {
+        message: `Step ${currentStepId} has been cancelled.`,
+        stepId: currentStepId,
+        status: "cancelled"
+      }
+    }));
+  }
 }
 
 function isTruthy(value) {
@@ -4764,8 +4961,107 @@ class NunjucksWorkflowRunner {
       return value;
     });
   }
-  async execute(task) {
+  async executeStep(task, step, context, renderTemplate, taskTrack, workspacePath) {
     var _a, _b, _c, _d, _e, _f, _g;
+    const stepTrack = await this.tracker.stepStart(task, step);
+    if (task.cancelSignal.aborted) {
+      throw new Error(`Step ${step.name} has been cancelled.`);
+    }
+    try {
+      if (step.if) {
+        const ifResult = await this.render(step.if, context, renderTemplate);
+        if (!isTruthy(ifResult)) {
+          await stepTrack.skipFalsy();
+          return;
+        }
+      }
+      const action = this.options.actionRegistry.get(step.action);
+      const { taskLogger, streamLogger } = createStepLogger({ task, step });
+      if (task.isDryRun) {
+        const redactedSecrets = Object.fromEntries(
+          Object.entries((_a = task.secrets) != null ? _a : {}).map((secret) => [
+            secret[0],
+            "[REDACTED]"
+          ])
+        );
+        const debugInput = (_b = step.input && this.render(
+          step.input,
+          {
+            ...context,
+            secrets: redactedSecrets
+          },
+          renderTemplate
+        )) != null ? _b : {};
+        taskLogger.info(
+          `Running ${action.id} in dry-run mode with inputs (secrets redacted): ${JSON.stringify(
+            debugInput,
+            void 0,
+            2
+          )}`
+        );
+        if (!action.supportsDryRun) {
+          await taskTrack.skipDryRun(step, action);
+          const outputSchema = (_c = action.schema) == null ? void 0 : _c.output;
+          if (outputSchema) {
+            context.steps[step.id] = {
+              output: generateExampleOutput(outputSchema)
+            };
+          } else {
+            context.steps[step.id] = { output: {} };
+          }
+          return;
+        }
+      }
+      const input = (_e = step.input && this.render(
+        step.input,
+        { ...context, secrets: (_d = task.secrets) != null ? _d : {} },
+        renderTemplate
+      )) != null ? _e : {};
+      if ((_f = action.schema) == null ? void 0 : _f.input) {
+        const validateResult = jsonschema.validate(input, action.schema.input);
+        if (!validateResult.valid) {
+          const errors$1 = validateResult.errors.join(", ");
+          throw new errors.InputError(
+            `Invalid input passed to action ${action.id}, ${errors$1}`
+          );
+        }
+      }
+      const tmpDirs = new Array();
+      const stepOutput = {};
+      await action.handler({
+        input,
+        secrets: (_g = task.secrets) != null ? _g : {},
+        logger: taskLogger,
+        logStream: streamLogger,
+        workspacePath,
+        createTemporaryDirectory: async () => {
+          const tmpDir = await fs__default["default"].mkdtemp(`${workspacePath}_step-${step.id}-`);
+          tmpDirs.push(tmpDir);
+          return tmpDir;
+        },
+        output(name, value) {
+          stepOutput[name] = value;
+        },
+        templateInfo: task.spec.templateInfo,
+        user: task.spec.user,
+        isDryRun: task.isDryRun,
+        signal: task.cancelSignal
+      });
+      for (const tmpDir of tmpDirs) {
+        await fs__default["default"].remove(tmpDir);
+      }
+      context.steps[step.id] = { output: stepOutput };
+      if (task.cancelSignal.aborted) {
+        throw new Error(`Step ${step.name} has been cancelled.`);
+      }
+      await stepTrack.markSuccessful();
+    } catch (err) {
+      await taskTrack.markFailed(step, err);
+      await stepTrack.markFailed();
+      throw err;
+    }
+  }
+  async execute(task) {
     if (!isValidTaskSpec(task.spec)) {
       throw new errors.InputError(
         "Wrong template version executed with the workflow engine"
@@ -4775,7 +5071,11 @@ class NunjucksWorkflowRunner {
       this.options.workingDirectory,
       await task.getWorkspaceName()
     );
-    const { integrations } = this.options;
+    const {
+      additionalTemplateFilters,
+      additionalTemplateGlobals,
+      integrations
+    } = this.options;
     const renderTemplate = await SecureTemplater.loadRenderer({
       // TODO(blam): let's work out how we can deprecate this.
       // We shouldn't really need to be exposing these now we can deal with
@@ -4784,8 +5084,8 @@ class NunjucksWorkflowRunner {
       parseRepoUrl(url) {
         return parseRepoUrl(url, integrations);
       },
-      additionalTemplateFilters: this.options.additionalTemplateFilters,
-      additionalTemplateGlobals: this.options.additionalTemplateGlobals
+      additionalTemplateFilters,
+      additionalTemplateGlobals
     });
     try {
       const taskTrack = await this.tracker.taskStart(task);
@@ -4796,105 +5096,14 @@ class NunjucksWorkflowRunner {
         user: task.spec.user
       };
       for (const step of task.spec.steps) {
-        const stepTrack = await this.tracker.stepStart(task, step);
-        try {
-          if (step.if) {
-            const ifResult = await this.render(
-              step.if,
-              context,
-              renderTemplate
-            );
-            if (!isTruthy(ifResult)) {
-              await stepTrack.skipFalsy();
-              continue;
-            }
-          }
-          const action = this.options.actionRegistry.get(step.action);
-          const { taskLogger, streamLogger } = createStepLogger({ task, step });
-          if (task.isDryRun) {
-            const redactedSecrets = Object.fromEntries(
-              Object.entries((_a = task.secrets) != null ? _a : {}).map((secret) => [
-                secret[0],
-                "[REDACTED]"
-              ])
-            );
-            const debugInput = (_b = step.input && this.render(
-              step.input,
-              {
-                ...context,
-                secrets: redactedSecrets
-              },
-              renderTemplate
-            )) != null ? _b : {};
-            taskLogger.info(
-              `Running ${action.id} in dry-run mode with inputs (secrets redacted): ${JSON.stringify(
-                debugInput,
-                void 0,
-                2
-              )}`
-            );
-            if (!action.supportsDryRun) {
-              await taskTrack.skipDryRun(step, action);
-              const outputSchema = (_c = action.schema) == null ? void 0 : _c.output;
-              if (outputSchema) {
-                context.steps[step.id] = {
-                  output: generateExampleOutput(outputSchema)
-                };
-              } else {
-                context.steps[step.id] = { output: {} };
-              }
-              continue;
-            }
-          }
-          const input = (_e = step.input && this.render(
-            step.input,
-            { ...context, secrets: (_d = task.secrets) != null ? _d : {} },
-            renderTemplate
-          )) != null ? _e : {};
-          if ((_f = action.schema) == null ? void 0 : _f.input) {
-            const validateResult = jsonschema.validate(
-              input,
-              action.schema.input
-            );
-            if (!validateResult.valid) {
-              const errors$1 = validateResult.errors.join(", ");
-              throw new errors.InputError(
-                `Invalid input passed to action ${action.id}, ${errors$1}`
-              );
-            }
-          }
-          const tmpDirs = new Array();
-          const stepOutput = {};
-          await action.handler({
-            input,
-            secrets: (_g = task.secrets) != null ? _g : {},
-            logger: taskLogger,
-            logStream: streamLogger,
-            workspacePath,
-            createTemporaryDirectory: async () => {
-              const tmpDir = await fs__default["default"].mkdtemp(
-                `${workspacePath}_step-${step.id}-`
-              );
-              tmpDirs.push(tmpDir);
-              return tmpDir;
-            },
-            output(name, value) {
-              stepOutput[name] = value;
-            },
-            templateInfo: task.spec.templateInfo,
-            user: task.spec.user,
-            isDryRun: task.isDryRun
-          });
-          for (const tmpDir of tmpDirs) {
-            await fs__default["default"].remove(tmpDir);
-          }
-          context.steps[step.id] = { output: stepOutput };
-          await stepTrack.markSuccessful();
-        } catch (err) {
-          await taskTrack.markFailed(step, err);
-          await stepTrack.markFailed();
-          throw err;
-        }
+        await this.executeStep(
+          task,
+          step,
+          context,
+          renderTemplate,
+          taskTrack,
+          workspacePath
+        );
       }
       const output = this.render(task.spec.output, context, renderTemplate);
       await taskTrack.markSuccessful();
@@ -4961,8 +5170,21 @@ function scaffoldingTracker() {
       });
       taskTimer({ result: "failed" });
     }
+    async function markCancelled(step) {
+      await task.emitLog(`Step ${step.id} has been cancelled.`, {
+        stepId: step.id,
+        status: "cancelled"
+      });
+      taskCount.inc({
+        template,
+        user,
+        result: "cancelled"
+      });
+      taskTimer({ result: "cancelled" });
+    }
     return {
       skipDryRun,
+      markCancelled,
       markSuccessful,
       markFailed
     };
@@ -4990,6 +5212,14 @@ function scaffoldingTracker() {
       });
       stepTimer({ result: "ok" });
     }
+    async function markCancelled() {
+      stepCount.inc({
+        template,
+        step: step.name,
+        result: "cancelled"
+      });
+      stepTimer({ result: "cancelled" });
+    }
     async function markFailed() {
       stepCount.inc({
         template,
@@ -5006,8 +5236,9 @@ function scaffoldingTracker() {
       stepTimer({ result: "skipped" });
     }
     return {
-      markSuccessful,
+      markCancelled,
       markFailed,
+      markSuccessful,
       skipFalsy
     };
   }
@@ -5131,6 +5362,7 @@ function createDryRunner(options) {
     );
     try {
       await deserializeDirectoryContents(contentsPath, input.directoryContents);
+      const abortSignal = new AbortController().signal;
       const result = await workflowRunner.execute({
         spec: {
           ...input.spec,
@@ -5154,6 +5386,7 @@ function createDryRunner(options) {
         done: false,
         isDryRun: true,
         getWorkspaceName: async () => `dry-run-${dryRunId}`,
+        cancelSignal: abortSignal,
         async emitLog(message, logMetadata) {
           if ((logMetadata == null ? void 0 : logMetadata.stepId) === dryRunId) {
             return;
@@ -5165,7 +5398,7 @@ function createDryRunner(options) {
             }
           });
         },
-        async complete() {
+        complete: async () => {
           throw new Error("Not implemented");
         }
       });
@@ -5496,6 +5729,11 @@ async function createRouter(options) {
     }
     delete task.secrets;
     res.status(200).json(task);
+  }).post("/v2/tasks/:taskId/cancel", async (req, res) => {
+    var _a;
+    const { taskId } = req.params;
+    await ((_a = taskBroker.cancel) == null ? void 0 : _a.call(taskBroker, taskId));
+    res.status(200).json({ status: "cancelled" });
   }).get("/v2/tasks/:taskId/eventstream", async (req, res) => {
     const { taskId } = req.params;
     const after = req.query.after !== void 0 ? Number(req.query.after) : void 0;