@backstage/plugin-scaffolder-backend 0.16.1 → 0.17.0

package/dist/index.cjs.js

@@ -24,6 +24,7 @@ var node = require('@gitbeaker/node');
 var webhooks = require('@octokit/webhooks');
 var uuid = require('uuid');
 var luxon = require('luxon');
+var ObservableImpl = require('zen-observable');
 var Handlebars = require('handlebars');
 var winston = require('winston');
 var jsonschema = require('jsonschema');
@@ -59,6 +60,7 @@ var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var globby__default = /*#__PURE__*/_interopDefaultLegacy(globby);
 var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
+var ObservableImpl__default = /*#__PURE__*/_interopDefaultLegacy(ObservableImpl);
 var Handlebars__namespace = /*#__PURE__*/_interopNamespace(Handlebars);
 var winston__namespace = /*#__PURE__*/_interopNamespace(winston);
 var nunjucks__default = /*#__PURE__*/_interopDefaultLegacy(nunjucks);
@@ -250,9 +252,6 @@ async function fetchContents({
   fetchUrl = ".",
   outputPath
 }) {
-  if (typeof fetchUrl !== "string") {
-    throw new errors.InputError(`Invalid url parameter, expected string, got ${typeof fetchUrl}`);
-  }
   let fetchUrlIsAbsolute = false;
   try {
     new URL(fetchUrl);
@@ -309,14 +308,14 @@ function createFetchPlainAction(options) {
       }
     },
     async handler(ctx) {
-      var _a;
+      var _a, _b;
       ctx.logger.info("Fetching plain content from remote URL");
       const targetPath = (_a = ctx.input.targetPath) != null ? _a : "./";
       const outputPath = backendCommon.resolveSafeChildPath(ctx.workspacePath, targetPath);
       await fetchContents({
         reader,
         integrations,
-        baseUrl: ctx.baseUrl,
+        baseUrl: (_b = ctx.templateInfo) == null ? void 0 : _b.baseUrl,
         fetchUrl: ctx.input.url,
         outputPath
       });
@@ -475,7 +474,7 @@ function createFetchTemplateAction(options) {
       }
     },
     async handler(ctx) {
-      var _a;
+      var _a, _b;
       ctx.logger.info("Fetching template content from remote URL");
       const workDir = await ctx.createTemporaryDirectory();
       const templateDir = backendCommon.resolveSafeChildPath(workDir, "template");
@@ -497,7 +496,7 @@ function createFetchTemplateAction(options) {
       await fetchContents({
         reader,
         integrations,
-        baseUrl: ctx.baseUrl,
+        baseUrl: (_b = ctx.templateInfo) == null ? void 0 : _b.baseUrl,
         fetchUrl: ctx.input.url,
         outputPath: templateDir
       });
@@ -666,14 +665,15 @@ const createFilesystemRenameAction = () => {
   });
 };
 
-const runCommand = async ({
-  command,
-  args,
-  logStream = new stream.PassThrough(),
-  options
-}) => {
+const executeShellCommand = async (options) => {
+  const {
+    command,
+    args,
+    options: spawnOptions,
+    logStream = new stream.PassThrough()
+  } = options;
   await new Promise((resolve, reject) => {
-    const process = child_process.spawn(command, args, options);
+    const process = child_process.spawn(command, args, spawnOptions);
     process.stdout.on("data", (stream) => {
       logStream.write(stream);
     });
@@ -691,6 +691,7 @@ const runCommand = async ({
     });
   });
 };
+const runCommand = executeShellCommand;
 async function initRepoAndPush({
   dir,
   remoteUrl,
@@ -1191,47 +1192,40 @@ function createPublishFileAction() {
   });
 }
 
-class OctokitProvider {
-  constructor(integrations, githubCredentialsProvider) {
-    this.integrations = integrations;
-    this.githubCredentialsProvider = githubCredentialsProvider || integration.DefaultGithubCredentialsProvider.fromIntegrations(this.integrations);
+async function getOctokitOptions(options) {
+  var _a;
+  const { integrations, credentialsProvider, repoUrl, token } = options;
+  const { owner, repo, host } = parseRepoUrl(repoUrl, integrations);
+  if (!owner) {
+    throw new errors.InputError(`No owner provided for repo ${repoUrl}`);
   }
-  async getOctokit(repoUrl, options) {
-    var _a;
-    const { owner, repo, host } = parseRepoUrl(repoUrl, this.integrations);
-    if (!owner) {
-      throw new errors.InputError(`No owner provided for repo ${repoUrl}`);
-    }
-    const integrationConfig = (_a = this.integrations.github.byHost(host)) == null ? void 0 : _a.config;
-    if (!integrationConfig) {
-      throw new errors.InputError(`No integration for host ${host}`);
-    }
-    if (options == null ? void 0 : options.token) {
-      const client2 = new octokit.Octokit({
-        auth: options.token,
-        baseUrl: integrationConfig.apiBaseUrl,
-        previews: ["nebula-preview"]
-      });
-      return { client: client2, token: options.token, owner, repo };
-    }
-    const { token } = await this.githubCredentialsProvider.getCredentials({
-      url: `https://${host}/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`
-    });
-    if (!token) {
-      throw new errors.InputError(`No token available for host: ${host}, with owner ${owner}, and repo ${repo}`);
-    }
-    const client = new octokit.Octokit({
+  const integrationConfig = (_a = integrations.github.byHost(host)) == null ? void 0 : _a.config;
+  if (!integrationConfig) {
+    throw new errors.InputError(`No integration for host ${host}`);
+  }
+  if (token) {
+    return {
       auth: token,
       baseUrl: integrationConfig.apiBaseUrl,
       previews: ["nebula-preview"]
-    });
-    return { client, token, owner, repo };
+    };
   }
+  const githubCredentialsProvider = credentialsProvider != null ? credentialsProvider : integration.DefaultGithubCredentialsProvider.fromIntegrations(integrations);
+  const { token: credentialProviderToken } = await githubCredentialsProvider.getCredentials({
+    url: `https://${host}/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`
+  });
+  if (!credentialProviderToken) {
+    throw new errors.InputError(`No token available for host: ${host}, with owner ${owner}, and repo ${repo}`);
+  }
+  return {
+    auth: credentialProviderToken,
+    baseUrl: integrationConfig.apiBaseUrl,
+    previews: ["nebula-preview"]
+  };
 }
 
 function createPublishGithubAction(options) {
   const { integrations, config, githubCredentialsProvider } = options;
-  const octokitProvider = new OctokitProvider(integrations, githubCredentialsProvider || integration.DefaultGithubCredentialsProvider.fromIntegrations(integrations));
   return createTemplateAction({
     id: "publish:github",
     description: "Initializes a git repository of contents in workspace and publishes it to GitHub.",
@@ -1334,7 +1328,17 @@ function createPublishGithubAction(options) {
         topics,
         token: providedToken
       } = ctx.input;
-      const { client, token, owner, repo } = await octokitProvider.getOctokit(repoUrl, { token: providedToken });
+      const { owner, repo } = parseRepoUrl(repoUrl, integrations);
+      if (!owner) {
+        throw new errors.InputError("Invalid repository owner provided in repoUrl");
+      }
+      const octokitOptions = await getOctokitOptions({
+        integrations,
+        credentialsProvider: githubCredentialsProvider,
+        token: providedToken,
+        repoUrl
+      });
+      const client = new octokit.Octokit(octokitOptions);
       const user = await client.rest.users.getByUsername({
         username: owner
       });
@@ -1410,7 +1414,7 @@ function createPublishGithubAction(options) {
         defaultBranch,
         auth: {
           username: "x-access-token",
-          password: token
+          password: octokitOptions.auth
         },
         logger: ctx.logger,
         commitMessage: config.getOptionalString("scaffolder.defaultCommitMessage"),
@@ -1445,29 +1449,15 @@ const defaultClientFactory = async ({
   host = "github.com",
   token: providedToken
 }) => {
-  var _a;
-  const integrationConfig = (_a = integrations.github.byHost(host)) == null ? void 0 : _a.config;
-  const OctokitPR = octokit.Octokit.plugin(octokitPluginCreatePullRequest.createPullRequest);
-  if (!integrationConfig) {
-    throw new errors.InputError(`No integration for host ${host}`);
-  }
-  if (providedToken) {
-    return new OctokitPR({
-      auth: providedToken,
-      baseUrl: integrationConfig.apiBaseUrl
-    });
-  }
-  const credentialsProvider = githubCredentialsProvider || integration.SingleInstanceGithubCredentialsProvider.create(integrationConfig);
-  const { token } = await credentialsProvider.getCredentials({
-    url: `https://${host}/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`
-  });
-  if (!token) {
-    throw new errors.InputError(`No token available for host: ${host}, with owner ${owner}, and repo ${repo}`);
-  }
-  return new OctokitPR({
-    auth: token,
-    baseUrl: integrationConfig.apiBaseUrl
+  const [encodedHost, encodedOwner, encodedRepo] = [host, owner, repo].map(encodeURIComponent);
+  const octokitOptions = await getOctokitOptions({
+    integrations,
+    credentialsProvider: githubCredentialsProvider,
+    repoUrl: `https://${encodedHost}/${encodedOwner}/${encodedRepo}`,
+    token: providedToken
   });
+  const OctokitPR = octokit.Octokit.plugin(octokitPluginCreatePullRequest.createPullRequest);
+  return new OctokitPR(octokitOptions);
 };
 const createPublishGithubPullRequestAction = ({
   integrations,
@@ -1830,7 +1820,6 @@ const createPublishGitlabMergeRequestAction = (options) => {
 
 function createGithubActionsDispatchAction(options) {
   const { integrations, githubCredentialsProvider } = options;
-  const octokitProvider = new OctokitProvider(integrations, githubCredentialsProvider || integration.DefaultGithubCredentialsProvider.fromIntegrations(integrations));
   return createTemplateAction({
     id: "github:actions:dispatch",
     description: "Dispatches a GitHub Action workflow for a given branch or tag",
@@ -1876,7 +1865,16 @@ function createGithubActionsDispatchAction(options) {
         token: providedToken
       } = ctx.input;
       ctx.logger.info(`Dispatching workflow ${workflowId} for repo ${repoUrl} on ${branchOrTagName}`);
-      const { client, owner, repo } = await octokitProvider.getOctokit(repoUrl, { token: providedToken });
+      const { owner, repo } = parseRepoUrl(repoUrl, integrations);
+      if (!owner) {
+        throw new errors.InputError("Invalid repository owner provided in repoUrl");
+      }
+      const client = new octokit.Octokit(await getOctokitOptions({
+        integrations,
+        repoUrl,
+        credentialsProvider: githubCredentialsProvider,
+        token: providedToken
+      }));
       await client.rest.actions.createWorkflowDispatch({
         owner,
         repo,
@@ -1891,7 +1889,6 @@ function createGithubActionsDispatchAction(options) {
 
 function createGithubWebhookAction(options) {
   const { integrations, defaultWebhookSecret, githubCredentialsProvider } = options;
-  const octokitProvider = new OctokitProvider(integrations, githubCredentialsProvider != null ? githubCredentialsProvider : integration.DefaultGithubCredentialsProvider.fromIntegrations(integrations));
   const eventNames = webhooks.emitterEventNames.filter((event) => !event.includes("."));
   return createTemplateAction({
     id: "github:webhook",
@@ -1971,7 +1968,16 @@ function createGithubWebhookAction(options) {
         token: providedToken
       } = ctx.input;
       ctx.logger.info(`Creating webhook ${webhookUrl} for repo ${repoUrl}`);
-      const { client, owner, repo } = await octokitProvider.getOctokit(repoUrl, { token: providedToken });
+      const { owner, repo } = parseRepoUrl(repoUrl, integrations);
+      if (!owner) {
+        throw new errors.InputError("Invalid repository owner provided in repoUrl");
+      }
+      const client = new octokit.Octokit(await getOctokitOptions({
+        integrations,
+        credentialsProvider: githubCredentialsProvider,
+        repoUrl,
+        token: providedToken
+      }));
       try {
         const insecure_ssl = insecureSsl ? "1" : "0";
         await client.rest.repos.createWebhook({
@@ -1995,6 +2001,44 @@ function createGithubWebhookAction(options) {
   });
 }
 
+class OctokitProvider {
+  constructor(integrations, githubCredentialsProvider) {
+    this.integrations = integrations;
+    this.githubCredentialsProvider = githubCredentialsProvider || integration.DefaultGithubCredentialsProvider.fromIntegrations(this.integrations);
+  }
+  async getOctokit(repoUrl, options) {
+    var _a;
+    const { owner, repo, host } = parseRepoUrl(repoUrl, this.integrations);
+    if (!owner) {
+      throw new errors.InputError(`No owner provided for repo ${repoUrl}`);
+    }
+    const integrationConfig = (_a = this.integrations.github.byHost(host)) == null ? void 0 : _a.config;
+    if (!integrationConfig) {
+      throw new errors.InputError(`No integration for host ${host}`);
+    }
+    if (options == null ? void 0 : options.token) {
+      const client2 = new octokit.Octokit({
+        auth: options.token,
+        baseUrl: integrationConfig.apiBaseUrl,
+        previews: ["nebula-preview"]
+      });
+      return { client: client2, token: options.token, owner, repo };
+    }
+    const { token } = await this.githubCredentialsProvider.getCredentials({
+      url: `https://${host}/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`
+    });
+    if (!token) {
+      throw new errors.InputError(`No token available for host: ${host}, with owner ${owner}, and repo ${repo}`);
+    }
+    const client = new octokit.Octokit({
+      auth: token,
+      baseUrl: integrationConfig.apiBaseUrl,
+      previews: ["nebula-preview"]
+    });
+    return { client, token, owner, repo };
+  }
+}
+
 const createBuiltinActions = (options) => {
   const {
     reader,
@@ -2054,6 +2098,9 @@ const createBuiltinActions = (options) => {
     })
   ];
   if (containerRunner) {
+    backendCommon.getRootLogger().warn(`[DEPRECATED] The fetch:cookiecutter action will be removed part of the default scaffolder actions in later versions. 
+You can install the package seperately and remove the containerRunner from the createBuiltInActions to remove this warning,
+or you can migrate to using fetch:template https://backstage.io/docs/features/software-templates/builtin-actions#migrating-from-fetchcookiecutter-to-fetchtemplate`);
     actions.push(pluginScaffolderBackendModuleCookiecutter.createFetchCookiecutterAction({
       reader,
       integrations,
@@ -2116,12 +2163,12 @@ class DatabaseTaskStore {
       throw new Error(`Failed to parse spec of task '${taskId}', ${error}`);
     }
   }
-  async createTask(spec, secrets) {
+  async createTask(options) {
     const taskId = uuid.v4();
     await this.db("tasks").insert({
       id: taskId,
-      spec: JSON.stringify(spec),
-      secrets: secrets ? JSON.stringify(secrets) : void 0,
+      spec: JSON.stringify(options.spec),
+      secrets: options.secrets ? JSON.stringify(options.secrets) : void 0,
       status: "open"
     });
     return { taskId };
@@ -2213,12 +2260,13 @@ class DatabaseTaskStore {
       });
     });
   }
-  async emitLogEvent({ taskId, body }) {
-    const serliazedBody = JSON.stringify(body);
+  async emitLogEvent(options) {
+    const { taskId, body } = options;
+    const serializedBody = JSON.stringify(body);
     await this.db("task_events").insert({
       task_id: taskId,
       event_type: "log",
-      body: serliazedBody
+      body: serializedBody
     });
   }
   async listEvents({
@@ -2251,38 +2299,38 @@ class DatabaseTaskStore {
 }
 
 class TaskManager {
-  constructor(state, storage, logger) {
-    this.state = state;
+  constructor(task, storage, logger) {
+    this.task = task;
     this.storage = storage;
     this.logger = logger;
     this.isDone = false;
   }
-  static create(state, storage, logger) {
-    const agent = new TaskManager(state, storage, logger);
+  static create(task, storage, logger) {
+    const agent = new TaskManager(task, storage, logger);
     agent.startTimeout();
     return agent;
   }
   get spec() {
-    return this.state.spec;
+    return this.task.spec;
   }
   get secrets() {
-    return this.state.secrets;
+    return this.task.secrets;
   }
   async getWorkspaceName() {
-    return this.state.taskId;
+    return this.task.taskId;
   }
   get done() {
     return this.isDone;
   }
-  async emitLog(message, metadata) {
+  async emitLog(message, logMetadata) {
     await this.storage.emitLogEvent({
-      taskId: this.state.taskId,
-      body: { message, ...metadata }
+      taskId: this.task.taskId,
+      body: { message, ...logMetadata }
     });
   }
   async complete(result, metadata) {
     await this.storage.completeTask({
-      taskId: this.state.taskId,
+      taskId: this.task.taskId,
       status: result === "failed" ? "failed" : "completed",
       eventBody: {
         message: `Run completed with status: ${result}`,
@@ -2297,11 +2345,11 @@ class TaskManager {
   startTimeout() {
     this.heartbeatTimeoutId = setTimeout(async () => {
       try {
-        await this.storage.heartbeatTask(this.state.taskId);
+        await this.storage.heartbeatTask(this.task.taskId);
         this.startTimeout();
       } catch (error) {
         this.isDone = true;
-        this.logger.error(`Heartbeat for task ${this.state.taskId} failed`, error);
+        this.logger.error(`Heartbeat for task ${this.task.taskId} failed`, error);
       }
     }, 1e3);
   }
@@ -2333,8 +2381,8 @@ class StorageTaskBroker {
       await this.waitForDispatch();
     }
   }
-  async dispatch(spec, secrets) {
-    const taskRow = await this.storage.createTask(spec, secrets);
+  async dispatch(options) {
+    const taskRow = await this.storage.createTask(options);
     this.signalDispatch();
     return {
       taskId: taskRow.taskId
@@ -2343,33 +2391,29 @@ class StorageTaskBroker {
   async get(taskId) {
     return this.storage.getTask(taskId);
   }
-  observe(options, callback) {
-    const { taskId } = options;
-    let cancelled = false;
-    const unsubscribe = () => {
-      cancelled = true;
-    };
-    (async () => {
+  event$(options) {
+    return new ObservableImpl__default["default"]((observer) => {
+      const { taskId } = options;
       let after = options.after;
-      while (!cancelled) {
-        const result = await this.storage.listEvents({ taskId, after });
-        const { events } = result;
-        if (events.length) {
-          after = events[events.length - 1].id;
-          try {
-            callback(void 0, result);
-          } catch (error) {
-            errors.assertError(error);
-            callback(error, { events: [] });
+      let cancelled = false;
+      (async () => {
+        while (!cancelled) {
+          const result = await this.storage.listEvents({ taskId, after });
+          const { events } = result;
+          if (events.length) {
+            after = events[events.length - 1].id;
+            observer.next(result);
           }
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
         }
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-      }
-    })();
-    return { unsubscribe };
+      })();
+      return () => {
+        cancelled = true;
+      };
+    });
   }
-  async vacuumTasks(timeoutS) {
-    const { tasks } = await this.storage.listStaleTasks(timeoutS);
+  async vacuumTasks(options) {
+    const { tasks } = await this.storage.listStaleTasks(options);
     await Promise.all(tasks.map(async (task) => {
       try {
         await this.storage.completeTask({
@@ -2509,9 +2553,6 @@ class HandlebarsWorkflowRunner {
           this.options.logger.debug(`Running ${action.id} with input`, {
             input: JSON.stringify(input, null, 2)
           });
-          if (!task.spec.metadata) {
-            console.warn("DEPRECATION NOTICE: metadata is undefined. metadata will be required in the future.");
-          }
           await action.handler({
             baseUrl: task.spec.baseUrl,
             logger: taskLogger,
@@ -2527,7 +2568,8 @@ class HandlebarsWorkflowRunner {
             output(name, value) {
               stepOutputs[name] = value;
             },
-            metadata: task.spec.metadata
+            metadata: task.spec.metadata,
+            templateInfo: task.spec.templateInfo
           });
           for (const tmpDir of tmpDirs) {
             await fs__default["default"].remove(tmpDir);
@@ -2702,7 +2744,8 @@ class NunjucksWorkflowRunner {
             output(name, value) {
               stepOutput[name] = value;
             },
-            metadata: task.spec.metadata
+            metadata: task.spec.metadata,
+            templateInfo: task.spec.templateInfo
           });
           for (const tmpDir of tmpDirs) {
             await fs__default["default"].remove(tmpDir);
@@ -2814,33 +2857,19 @@ function getEntityBaseUrl(entity) {
   }
   return void 0;
 }
-async function findTemplate({
-  entityRef,
-  token,
-  catalogApi
-}) {
-  const parsedEntityRef = catalogModel.parseEntityRef(entityRef, {
-    defaultKind: "template",
-    defaultNamespace: "default"
-  });
-  const { items } = await catalogApi.getEntities({
-    filter: {
-      kind: "template",
-      "metadata.name": parsedEntityRef.name,
-      "metadata.namespace": parsedEntityRef.namespace
-    }
-  }, {
-    token
-  });
-  const templates = items.filter((entity) => entity.kind === "Template");
-  if (templates.length !== 1) {
-    if (templates.length > 1) {
-      throw new errors.ConflictError("Templates lookup resulted in multiple matches");
-    } else {
-      throw new errors.NotFoundError("Template not found");
-    }
+async function findTemplate(options) {
+  const { entityRef, token, catalogApi } = options;
+  if (entityRef.namespace.toLocaleLowerCase("en-US") !== catalogModel.DEFAULT_NAMESPACE) {
+    throw new errors.InputError(`Invalid namespace, only '${catalogModel.DEFAULT_NAMESPACE}' namespace is supported`);
+  }
+  if (entityRef.kind.toLocaleLowerCase("en-US") !== "template") {
+    throw new errors.InputError(`Invalid kind, only 'Template' kind is supported`);
+  }
+  const template = await catalogApi.getEntityByName(entityRef, { token });
+  if (!template) {
+    throw new errors.NotFoundError(`Template ${entityRef} not found`);
   }
-  return templates[0];
+  return template;
 }
 
 function isSupportedTemplate(entity) {
@@ -2898,12 +2927,6 @@ async function createRouter(options) {
   router.get("/v2/templates/:namespace/:kind/:name/parameter-schema", async (req, res) => {
     var _a, _b;
     const { namespace, kind, name } = req.params;
-    if (namespace !== "default") {
-      throw new errors.InputError(`Invalid namespace, only 'default' namespace is supported`);
-    }
-    if (kind.toLowerCase() !== "template") {
-      throw new errors.InputError(`Invalid kind, only 'Template' kind is supported`);
-    }
     const template = await findTemplate({
       catalogApi: catalogClient,
       entityRef: { kind, namespace, name },
@@ -2934,15 +2957,16 @@ async function createRouter(options) {
     });
     res.json(actionsList);
   }).post("/v2/tasks", async (req, res) => {
-    var _a, _b, _c, _d, _e;
-    const templateName = req.body.templateName;
+    var _a, _b, _c, _d;
+    const templateRef = req.body.templateRef;
+    const { kind, namespace, name } = catalogModel.parseEntityRef(templateRef, {
+      defaultKind: "template"
+    });
     const values = req.body.values;
     const token = getBearerToken(req.headers.authorization);
     const template = await findTemplate({
       catalogApi: catalogClient,
-      entityRef: {
-        name: templateName
-      },
+      entityRef: { kind, namespace, name },
       token: getBearerToken(req.headers.authorization)
     });
     let taskSpec;
@@ -2958,10 +2982,8 @@ async function createRouter(options) {
         }
       }
       const baseUrl = getEntityBaseUrl(template);
-      taskSpec = template.apiVersion === "backstage.io/v1beta2" ? {
-        apiVersion: template.apiVersion,
+      const baseTaskSpec = {
         baseUrl,
-        values,
         steps: template.spec.steps.map((step, index) => {
           var _a2, _b2;
           return {
@@ -2971,29 +2993,34 @@ async function createRouter(options) {
           };
         }),
         output: (_b = template.spec.output) != null ? _b : {},
-        metadata: { name: (_c = template.metadata) == null ? void 0 : _c.name }
+        metadata: { name: (_c = template.metadata) == null ? void 0 : _c.name },
+        templateInfo: {
+          entityRef: catalogModel.stringifyEntityRef({
+            kind,
+            namespace,
+            name: (_d = template.metadata) == null ? void 0 : _d.name
+          }),
+          baseUrl
+        }
+      };
+      taskSpec = template.apiVersion === "backstage.io/v1beta2" ? {
+        ...baseTaskSpec,
+        apiVersion: template.apiVersion,
+        values
       } : {
+        ...baseTaskSpec,
         apiVersion: template.apiVersion,
-        baseUrl,
-        parameters: values,
-        steps: template.spec.steps.map((step, index) => {
-          var _a2, _b2;
-          return {
-            ...step,
-            id: (_a2 = step.id) != null ? _a2 : `step-${index + 1}`,
-            name: (_b2 = step.name) != null ? _b2 : step.action
-          };
-        }),
-        output: (_d = template.spec.output) != null ? _d : {},
-        metadata: { name: (_e = template.metadata) == null ? void 0 : _e.name }
+        parameters: values
       };
     } else {
       throw new errors.InputError(`Unsupported apiVersion field in schema entity, ${template.apiVersion}`);
     }
-    const result = await taskBroker.dispatch(taskSpec, {
-      ...req.body.secrets,
-      backstageToken: token,
-      token
+    const result = await taskBroker.dispatch({
+      spec: taskSpec,
+      secrets: {
+        ...req.body.secrets,
+        backstageToken: token
+      }
     });
     res.status(201).json({ id: result.taskId });
   }).get("/v2/tasks/:taskId", async (req, res) => {
@@ -3013,48 +3040,49 @@ async function createRouter(options) {
       "Cache-Control": "no-cache",
       "Content-Type": "text/event-stream"
     });
-    const { unsubscribe } = taskBroker.observe({ taskId, after }, (error, { events }) => {
-      var _a;
-      if (error) {
+    const subscription = taskBroker.event$({ taskId, after }).subscribe({
+      error: (error) => {
         logger.error(`Received error from event stream when observing taskId '${taskId}', ${error}`);
-      }
-      let shouldUnsubscribe = false;
-      for (const event of events) {
-        res.write(`event: ${event.type}
+      },
+      next: ({ events }) => {
+        var _a;
+        let shouldUnsubscribe = false;
+        for (const event of events) {
+          res.write(`event: ${event.type}
 data: ${JSON.stringify(event)}
 
 `);
-        if (event.type === "completion") {
-          shouldUnsubscribe = true;
+          if (event.type === "completion") {
+            shouldUnsubscribe = true;
+          }
         }
+        (_a = res.flush) == null ? void 0 : _a.call(res);
+        if (shouldUnsubscribe)
+          subscription.unsubscribe();
       }
-      (_a = res.flush) == null ? void 0 : _a.call(res);
-      if (shouldUnsubscribe)
-        unsubscribe();
     });
     req.on("close", () => {
-      unsubscribe();
+      subscription.unsubscribe();
       logger.debug(`Event stream observing taskId '${taskId}' closed`);
     });
   }).get("/v2/tasks/:taskId/events", async (req, res) => {
     const { taskId } = req.params;
     const after = Number(req.query.after) || void 0;
-    let unsubscribe = () => {
-    };
     const timeout = setTimeout(() => {
-      unsubscribe();
       res.json([]);
     }, 3e4);
-    ({ unsubscribe } = taskBroker.observe({ taskId, after }, (error, { events }) => {
-      clearTimeout(timeout);
-      unsubscribe();
-      if (error) {
-        logger.error(`Received error from log when observing taskId '${taskId}', ${error}`);
+    const subscription = taskBroker.event$({ taskId, after }).subscribe({
+      error: (error) => {
+        logger.error(`Received error from event stream when observing taskId '${taskId}', ${error}`);
+      },
+      next: ({ events }) => {
+        clearTimeout(timeout);
+        subscription.unsubscribe();
+        res.json(events);
       }
-      res.json(events);
-    }));
+    });
     req.on("close", () => {
-      unsubscribe();
+      subscription.unsubscribe();
       clearTimeout(timeout);
     });
   });
@@ -3072,6 +3100,9 @@ class ScaffolderEntitiesProcessor {
   constructor() {
     this.validators = [pluginScaffolderCommon.templateEntityV1beta3Validator];
   }
+  getProcessorName() {
+    return "ScaffolderEntitiesProcessor";
+  }
   async validateEntityKind(entity) {
     for (const validator of this.validators) {
       if (await validator.check(entity)) {
@@ -3143,6 +3174,7 @@ exports.createPublishGitlabAction = createPublishGitlabAction;
 exports.createPublishGitlabMergeRequestAction = createPublishGitlabMergeRequestAction;
 exports.createRouter = createRouter;
 exports.createTemplateAction = createTemplateAction;
+exports.executeShellCommand = executeShellCommand;
 exports.fetchContents = fetchContents;
 exports.runCommand = runCommand;
 //# sourceMappingURL=index.cjs.js.map