@backstage/plugin-scaffolder-backend 1.22.8-next.2 → 1.22.8

package/dist/cjs/{router-Czj3wQrV.cjs.js → router-Bj9ovbjU.cjs.js}

@@ -164,6 +164,7 @@ function createCatalogRegisterAction(options) {
       }
     },
     async handler(ctx) {
+      var _a, _b;
       const { input } = ctx;
       let catalogInfoUrl;
       if ("catalogInfoUrl" in input) {
@@ -182,10 +183,10 @@ function createCatalogRegisterAction(options) {
         });
       }
       ctx.logger.info(`Registering ${catalogInfoUrl} in the catalog`);
-      const { token } = await auth?.getPluginRequestToken({
+      const { token } = (_b = await (auth == null ? void 0 : auth.getPluginRequestToken({
         onBehalfOf: await ctx.getInitiatorCredentials(),
         targetPluginId: "catalog"
-      }) ?? { token: ctx.secrets?.backstageToken };
+      }))) != null ? _b : { token: (_a = ctx.secrets) == null ? void 0 : _a.backstageToken };
       try {
         await catalogClient.addLocation(
           {
@@ -281,10 +282,11 @@ function createCatalogWriteAction() {
     examples: examples$8,
     supportsDryRun: true,
     async handler(ctx) {
+      var _a;
       ctx.logger.info(`Writing catalog-info.yaml`);
       const { filePath, entity } = ctx.input;
-      const entityRef = ctx.templateInfo?.entityRef;
-      const path = filePath ?? "catalog-info.yaml";
+      const entityRef = (_a = ctx.templateInfo) == null ? void 0 : _a.entityRef;
+      const path = filePath != null ? filePath : "catalog-info.yaml";
       await fs__default.default.writeFile(
         backendPluginApi.resolveSafeChildPath(ctx.workspacePath, path),
         yaml__namespace.stringify({
@@ -371,6 +373,7 @@ function createFetchCatalogEntityAction(options) {
       })
     },
     async handler(ctx) {
+      var _a, _b;
       const { entityRef, entityRefs, optional, defaultKind, defaultNamespace } = ctx.input;
       if (!entityRef && !entityRefs) {
         if (optional) {
@@ -378,10 +381,10 @@ function createFetchCatalogEntityAction(options) {
         }
         throw new Error("Missing entity reference or references");
       }
-      const { token } = await auth?.getPluginRequestToken({
+      const { token } = (_b = await (auth == null ? void 0 : auth.getPluginRequestToken({
         onBehalfOf: await ctx.getInitiatorCredentials(),
         targetPluginId: "catalog"
-      }) ?? { token: ctx.secrets?.backstageToken };
+      }))) != null ? _b : { token: (_a = ctx.secrets) == null ? void 0 : _a.backstageToken };
       if (entityRef) {
         const entity = await catalogClient.getEntityByRef(
           catalogModel.stringifyEntityRef(
@@ -394,7 +397,7 @@ function createFetchCatalogEntityAction(options) {
         if (!entity && !optional) {
           throw new Error(`Entity ${entityRef} not found`);
         }
-        ctx.output("entity", entity ?? null);
+        ctx.output("entity", entity != null ? entity : null);
       }
       if (entityRefs) {
         const entities = await catalogClient.getEntitiesByRefs(
@@ -413,7 +416,7 @@ function createFetchCatalogEntityAction(options) {
           if (!e && !optional) {
             throw new Error(`Entity ${entityRefs[i]} not found`);
           }
-          return e ?? null;
+          return e != null ? e : null;
         });
         ctx.output("entities", finalEntities);
       }
@@ -480,11 +483,12 @@ function createDebugLogAction() {
     },
     supportsDryRun: true,
     async handler(ctx) {
+      var _a, _b;
       ctx.logger.info(JSON.stringify(ctx.input, null, 2));
-      if (ctx.input?.message) {
+      if ((_a = ctx.input) == null ? void 0 : _a.message) {
         ctx.logger.info(ctx.input.message);
       }
-      if (ctx.input?.listWorkspace) {
+      if ((_b = ctx.input) == null ? void 0 : _b.listWorkspace) {
         const files = await recursiveReadDir(ctx.workspacePath);
         ctx.logger.info(
           `Workspace:
@@ -590,18 +594,20 @@ function createWaitAction(options) {
     },
     async handler(ctx) {
       const delayTime = luxon.Duration.fromObject(ctx.input);
-      const maxWait = toDuration(options?.maxWaitTime);
+      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());
-        ctx.signal?.addEventListener("abort", abort);
+        (_a = ctx.signal) == null ? void 0 : _a.addEventListener("abort", abort);
         function abort() {
-          ctx.signal?.removeEventListener("abort", abort);
+          var _a2;
+          (_a2 = ctx.signal) == null ? void 0 : _a2.removeEventListener("abort", abort);
           clearTimeout(timeoutHandle);
           controller.abort();
           resolve("finished");
@@ -677,13 +683,14 @@ function createFetchPlainAction(options) {
     },
     supportsDryRun: true,
     async handler(ctx) {
+      var _a, _b;
       ctx.logger.info("Fetching plain content from remote URL");
-      const targetPath = ctx.input.targetPath ?? "./";
+      const targetPath = (_a = ctx.input.targetPath) != null ? _a : "./";
       const outputPath = backendPluginApi.resolveSafeChildPath(ctx.workspacePath, targetPath);
       await pluginScaffolderNode.fetchContents({
         reader,
         integrations,
-        baseUrl: ctx.templateInfo?.baseUrl,
+        baseUrl: (_b = ctx.templateInfo) == null ? void 0 : _b.baseUrl,
         fetchUrl: ctx.input.url,
         outputPath,
         token: ctx.input.token
@@ -742,6 +749,7 @@ function createFetchPlainFileAction(options) {
     },
     supportsDryRun: true,
     async handler(ctx) {
+      var _a;
       ctx.logger.info("Fetching plain content from remote URL");
       const outputPath = backendPluginApi.resolveSafeChildPath(
         ctx.workspacePath,
@@ -750,7 +758,7 @@ function createFetchPlainFileAction(options) {
       await pluginScaffolderNode.fetchFile({
         reader,
         integrations,
-        baseUrl: ctx.templateInfo?.baseUrl,
+        baseUrl: (_a = ctx.templateInfo) == null ? void 0 : _a.baseUrl,
         fetchUrl: ctx.input.url,
         outputPath,
         token: ctx.input.token
@@ -760,7 +768,8 @@ function createFetchPlainFileAction(options) {
 }
 
 function isNoNodeSnapshotOptionProvided() {
-  return process.env.NODE_OPTIONS?.includes("--no-node-snapshot") || process.argv.includes("--no-node-snapshot");
+  var _a;
+  return ((_a = process.env.NODE_OPTIONS) == null ? void 0 : _a.includes("--no-node-snapshot")) || process.argv.includes("--no-node-snapshot");
 }
 function getMajorNodeVersion() {
   const version = process.versions.node;
@@ -1035,10 +1044,11 @@ function createFetchTemplateAction(options) {
     },
     supportsDryRun: true,
     async handler(ctx) {
+      var _a, _b;
       ctx.logger.info("Fetching template content from remote URL");
       const workDir = await ctx.createTemporaryDirectory();
       const templateDir = backendPluginApi.resolveSafeChildPath(workDir, "template");
-      const targetPath = ctx.input.targetPath ?? "./";
+      const targetPath = (_a = ctx.input.targetPath) != null ? _a : "./";
       const outputDir = backendPluginApi.resolveSafeChildPath(ctx.workspacePath, targetPath);
       if (ctx.input.copyWithoutRender && ctx.input.copyWithoutTemplating) {
         throw new errors.InputError(
@@ -1077,7 +1087,7 @@ function createFetchTemplateAction(options) {
       await pluginScaffolderNode.fetchContents({
         reader,
         integrations,
-        baseUrl: ctx.templateInfo?.baseUrl,
+        baseUrl: (_b = ctx.templateInfo) == null ? void 0 : _b.baseUrl,
         fetchUrl: ctx.input.url,
         outputPath: templateDir,
         token: ctx.input.token
@@ -1224,7 +1234,8 @@ const createFilesystemDeleteAction = () => {
     },
     supportsDryRun: true,
     async handler(ctx) {
-      if (!Array.isArray(ctx.input?.files)) {
+      var _a;
+      if (!Array.isArray((_a = ctx.input) == null ? void 0 : _a.files)) {
         throw new errors.InputError("files must be an Array");
       }
       for (const file of ctx.input.files) {
@@ -1301,7 +1312,8 @@ const createFilesystemRenameAction = () => {
     },
     supportsDryRun: true,
     async handler(ctx) {
-      if (!Array.isArray(ctx.input?.files)) {
+      var _a, _b;
+      if (!Array.isArray((_a = ctx.input) == null ? void 0 : _a.files)) {
         throw new errors.InputError("files must be an Array");
       }
       for (const file of ctx.input.files) {
@@ -1315,7 +1327,7 @@ const createFilesystemRenameAction = () => {
         const destFilepath = backendPluginApi.resolveSafeChildPath(ctx.workspacePath, file.to);
         try {
           await fs__default.default.move(sourceFilepath, destFilepath, {
-            overwrite: file.overwrite ?? false
+            overwrite: (_b = file.overwrite) != null ? _b : false
           });
           ctx.logger.info(
             `File ${sourceFilepath} renamed to ${destFilepath} successfully`
@@ -1455,8 +1467,16 @@ const createBuiltinActions = (options) => {
   return actions;
 };
 
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, key + "" , value);
+  return value;
+};
 class TemplateActionRegistry {
-  actions = /* @__PURE__ */ new Map();
+  constructor() {
+    __publicField$4(this, "actions", /* @__PURE__ */ new Map());
+  }
   register(action) {
     if (this.actions.has(action.id)) {
       throw new errors.ConflictError(
@@ -1526,6 +1546,12 @@ const restoreWorkspace = async (path, buffer) => {
   }
 };
 
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, key + "" , value);
+  return value;
+};
 const migrationsDir = backendPluginApi.resolvePackagePath(
   "@backstage/plugin-scaffolder-backend",
   "migrations"
@@ -1546,7 +1572,10 @@ const parseSqlDateToIsoString = (input) => {
   return input;
 };
 class DatabaseTaskStore {
-  db;
+  constructor(client) {
+    __publicField$3(this, "db");
+    this.db = client;
+  }
   static async create(options) {
     const { database } = options;
     const client = await this.getClient(database);
@@ -1554,8 +1583,9 @@ class DatabaseTaskStore {
     return new DatabaseTaskStore(client);
   }
   isRecoverableTask(spec) {
+    var _a, _b;
     return ["startOver"].includes(
-      spec.EXPERIMENTAL_recovery?.EXPERIMENTAL_strategy ?? "none"
+      (_b = (_a = spec.EXPERIMENTAL_recovery) == null ? void 0 : _a.EXPERIMENTAL_strategy) != null ? _b : "none"
     );
   }
   parseSpec({ spec, id }) {
@@ -1581,21 +1611,19 @@ class DatabaseTaskStore {
     return database;
   }
   static async runMigrations(database, client) {
+    var _a;
     if (!isPluginDatabaseManager(database)) {
       await client.migrate.latest({
         directory: migrationsDir
       });
       return;
     }
-    if (!database.migrations?.skip) {
+    if (!((_a = database.migrations) == null ? void 0 : _a.skip)) {
       await client.migrate.latest({
         directory: migrationsDir
       });
     }
   }
-  constructor(client) {
-    this.db = client;
-  }
   async list(options) {
     const queryBuilder = this.db("tasks");
     if (options.createdBy) {
@@ -1604,17 +1632,21 @@ class DatabaseTaskStore {
       });
     }
     const results = await queryBuilder.orderBy("created_at", "desc").select();
-    const tasks = results.map((result) => ({
-      id: result.id,
-      spec: JSON.parse(result.spec),
-      status: result.status,
-      createdBy: result.created_by ?? void 0,
-      lastHeartbeatAt: parseSqlDateToIsoString(result.last_heartbeat_at),
-      createdAt: parseSqlDateToIsoString(result.created_at)
-    }));
+    const tasks = results.map((result) => {
+      var _a;
+      return {
+        id: result.id,
+        spec: JSON.parse(result.spec),
+        status: result.status,
+        createdBy: (_a = result.created_by) != null ? _a : void 0,
+        lastHeartbeatAt: parseSqlDateToIsoString(result.last_heartbeat_at),
+        createdAt: parseSqlDateToIsoString(result.created_at)
+      };
+    });
     return { tasks };
   }
   async getTask(taskId) {
+    var _a;
     const [result] = await this.db("tasks").where({ id: taskId }).select();
     if (!result) {
       throw new errors.NotFoundError(`No task with id '${taskId}' found`);
@@ -1629,7 +1661,7 @@ class DatabaseTaskStore {
         status: result.status,
         lastHeartbeatAt: parseSqlDateToIsoString(result.last_heartbeat_at),
         createdAt: parseSqlDateToIsoString(result.created_at),
-        createdBy: result.created_by ?? void 0,
+        createdBy: (_a = result.created_by) != null ? _a : void 0,
         secrets,
         state
       };
@@ -1638,18 +1670,20 @@ class DatabaseTaskStore {
     }
   }
   async createTask(options) {
+    var _a;
     const taskId = uuid.v4();
     await this.db("tasks").insert({
       id: taskId,
       spec: JSON.stringify(options.spec),
       secrets: options.secrets ? JSON.stringify(options.secrets) : void 0,
-      created_by: options.createdBy ?? null,
+      created_by: (_a = options.createdBy) != null ? _a : null,
       status: "open"
     });
     return { taskId };
   }
   async claimTask() {
     return this.db.transaction(async (tx) => {
+      var _a;
       const [task] = await tx("tasks").where({
         status: "open"
       }).limit(1).select();
@@ -1682,7 +1716,7 @@ class DatabaseTaskStore {
         status: "processing",
         lastHeartbeatAt: task.last_heartbeat_at,
         createdAt: task.created_at,
-        createdBy: task.created_by ?? void 0,
+        createdBy: (_a = task.created_by) != null ? _a : void 0,
         secrets,
         state: getState()
       };
@@ -1811,7 +1845,7 @@ class DatabaseTaskStore {
     const { taskId } = options;
     const message = `This task was marked as stale as it exceeded its timeout`;
     const statusStepEvents = (await this.listEvents({ taskId })).events.filter(
-      ({ body }) => body?.stepId
+      ({ body }) => body == null ? void 0 : body.stepId
     );
     const completedSteps = statusStepEvents.filter(
       ({ body: { status } }) => status === "failed" || status === "completed"
@@ -1864,6 +1898,7 @@ class DatabaseTaskStore {
     const taskIdsToRecover = [];
     const timeoutS = luxon.Duration.fromObject(options.timeout).as("seconds");
     await this.db.transaction(async (tx) => {
+      var _a, _b;
       const heartbeatInterval = intervalFromNowTill(timeoutS, this.db);
       const result = await tx("tasks").where("status", "processing").andWhere("last_heartbeat_at", "<=", heartbeatInterval).update(
         {
@@ -1879,7 +1914,7 @@ class DatabaseTaskStore {
           task_id: id,
           event_type: "recovered",
           body: JSON.stringify({
-            recoverStrategy: taskSpec.EXPERIMENTAL_recovery?.EXPERIMENTAL_strategy ?? "none"
+            recoverStrategy: (_b = (_a = taskSpec.EXPERIMENTAL_recovery) == null ? void 0 : _a.EXPERIMENTAL_strategy) != null ? _b : "none"
           })
         });
       }
@@ -1892,19 +1927,20 @@ function isTruthy(value) {
   return lodash.isArray(value) ? value.length > 0 : !!value;
 }
 function generateExampleOutput(schema) {
+  var _a, _b;
   const { examples } = schema;
   if (examples && Array.isArray(examples)) {
     return examples[0];
   }
   if (schema.type === "object") {
     return Object.fromEntries(
-      Object.entries(schema.properties ?? {}).map(([key, value]) => [
+      Object.entries((_a = schema.properties) != null ? _a : {}).map(([key, value]) => [
         key,
         generateExampleOutput(value)
       ])
     );
   } else if (schema.type === "array") {
-    const [firstSchema] = [schema.items]?.flat();
+    const [firstSchema] = (_b = [schema.items]) == null ? void 0 : _b.flat();
     if (firstSchema) {
       return [generateExampleOutput(firstSchema)];
     }
@@ -1919,12 +1955,18 @@ function generateExampleOutput(schema) {
   return "<unknown>";
 }
 const readDuration$1 = (config$1, key, defaultValue) => {
-  if (config$1?.has(key)) {
+  if (config$1 == null ? void 0 : config$1.has(key)) {
     return config.readDurationFromConfig(config$1, { key });
   }
   return defaultValue;
 };
 
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class TaskManager {
   // Runs heartbeat internally
   constructor(task, storage, signal, logger, auth, config) {
@@ -1934,9 +1976,9 @@ class TaskManager {
     this.logger = logger;
     this.auth = auth;
     this.config = config;
+    __publicField$2(this, "isDone", false);
+    __publicField$2(this, "heartbeatTimeoutId");
   }
-  isDone = false;
-  heartbeatTimeoutId;
   static create(task, storage, abortSignal, logger, auth, config) {
     const agent = new TaskManager(
       task,
@@ -1965,8 +2007,9 @@ class TaskManager {
     return this.task.taskId;
   }
   async rehydrateWorkspace(options) {
+    var _a, _b;
     if (this.isWorkspaceSerializationEnabled()) {
-      this.storage.rehydrateWorkspace?.(options);
+      (_b = (_a = this.storage).rehydrateWorkspace) == null ? void 0 : _b.call(_a, options);
     }
   }
   get done() {
@@ -1979,31 +2022,35 @@ class TaskManager {
     });
   }
   async getTaskState() {
-    return this.storage.getTaskState?.({ taskId: this.task.taskId });
+    var _a, _b;
+    return (_b = (_a = this.storage).getTaskState) == null ? void 0 : _b.call(_a, { taskId: this.task.taskId });
   }
   async updateCheckpoint(options) {
+    var _a, _b;
     const { key, ...value } = options;
     if (this.task.state) {
       this.task.state.checkpoints[key] = value;
     } else {
       this.task.state = { checkpoints: { [key]: value } };
     }
-    await this.storage.saveTaskState?.({
+    await ((_b = (_a = this.storage).saveTaskState) == null ? void 0 : _b.call(_a, {
       taskId: this.task.taskId,
       state: this.task.state
-    });
+    }));
   }
   async serializeWorkspace(options) {
+    var _a, _b;
     if (this.isWorkspaceSerializationEnabled()) {
-      await this.storage.serializeWorkspace?.({
+      await ((_b = (_a = this.storage).serializeWorkspace) == null ? void 0 : _b.call(_a, {
         path: options.path,
         taskId: this.task.taskId
-      });
+      }));
     }
   }
   async cleanWorkspace() {
+    var _a, _b;
     if (this.isWorkspaceSerializationEnabled()) {
-      await this.storage.cleanWorkspace?.({ taskId: this.task.taskId });
+      await ((_b = (_a = this.storage).cleanWorkspace) == null ? void 0 : _b.call(_a, { taskId: this.task.taskId }));
     }
   }
   async complete(result, metadata) {
@@ -2035,9 +2082,10 @@ class TaskManager {
     }, 1e3);
   }
   isWorkspaceSerializationEnabled() {
-    return this.config?.getOptionalBoolean(
+    var _a, _b;
+    return (_b = (_a = this.config) == null ? void 0 : _a.getOptionalBoolean(
       "scaffolder.EXPERIMENTAL_workspaceSerialization"
-    ) ?? false;
+    )) != null ? _b : false;
   }
   async getInitiatorCredentials() {
     const secrets = this.task.secrets;
@@ -2066,6 +2114,7 @@ class StorageTaskBroker {
     this.logger = logger;
     this.config = config;
     this.auth = auth;
+    __publicField$2(this, "deferredDispatch", defer());
   }
   async list(options) {
     if (!this.storage.list) {
@@ -2073,9 +2122,8 @@ class StorageTaskBroker {
         "TaskStore does not implement the list method. Please implement the list method to be able to list tasks"
       );
     }
-    return await this.storage.list({ createdBy: options?.createdBy });
+    return await this.storage.list({ createdBy: options == null ? void 0 : options.createdBy });
   }
-  deferredDispatch = defer();
   async registerCancellable(taskId, abortController) {
     let shouldUnsubscribe = false;
     const subscription = this.event$({ taskId, after: void 0 }).subscribe({
@@ -2099,9 +2147,10 @@ class StorageTaskBroker {
     });
   }
   async recoverTasks() {
-    const enabled = (this.config && this.config.getOptionalBoolean(
+    var _a, _b, _c, _d;
+    const enabled = (_a = this.config && this.config.getOptionalBoolean(
       "scaffolder.EXPERIMENTAL_recoverTasks"
-    )) ?? false;
+    )) != null ? _a : false;
     if (enabled) {
       const defaultTimeout = { seconds: 30 };
       const timeout = readDuration$1(
@@ -2109,9 +2158,9 @@ class StorageTaskBroker {
         "scaffolder.EXPERIMENTAL_recoverTasksTimeout",
         defaultTimeout
       );
-      const { ids: recoveredTaskIds } = await this.storage.recoverTasks?.({
+      const { ids: recoveredTaskIds } = (_d = await ((_c = (_b = this.storage).recoverTasks) == null ? void 0 : _c.call(_b, {
         timeout
-      }) ?? { ids: [] };
+      }))) != null ? _d : { ids: [] };
       if (recoveredTaskIds.length > 0) {
         this.signalDispatch();
       }
@@ -2213,16 +2262,17 @@ class StorageTaskBroker {
     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?.stepId).reduce((prev, curr) => prev.id > curr.id ? prev : curr).body.stepId : 0;
-    await this.storage.cancelTask?.({
+    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"
       }
-    });
+    }));
   }
 }
 
@@ -2252,7 +2302,8 @@ const hasTag = createTemplatePermissionRule({
     tag: zod.z.string().describe("Name of the tag to match on")
   }),
   apply: (resource, { tag }) => {
-    return resource["backstage:permissions"]?.tags?.includes(tag) ?? false;
+    var _a, _b, _c;
+    return (_c = (_b = (_a = resource["backstage:permissions"]) == null ? void 0 : _a.tags) == null ? void 0 : _b.includes(tag)) != null ? _c : false;
   },
   toQuery: () => ({})
 });
@@ -2323,56 +2374,85 @@ const scaffolderActionRules = {
   hasStringProperty
 };
 
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  member.set(obj, value);
+  return value;
+};
+var _winston, _addRedactions;
 const escapeRegExp = (text) => {
   return text.replace(/[.*+?^${}(\)|[\]\\]/g, "\\$&");
 };
 class BackstageLoggerTransport extends Transport__default.default {
-  constructor(backstageLogger, opts) {
+  constructor(backstageLogger, taskContext, stepId, opts) {
     super(opts);
     this.backstageLogger = backstageLogger;
+    this.taskContext = taskContext;
+    this.stepId = stepId;
   }
   log(info, callback) {
     if (typeof info !== "object" || info === null) {
       callback();
       return;
     }
-    const { level, message, ...meta } = info;
+    const message = info[tripleBeam.MESSAGE];
+    const level = info[tripleBeam.LEVEL];
+    const splat = info[tripleBeam.SPLAT];
     switch (level) {
       case "error":
-        this.backstageLogger.error(String(message), meta);
+        this.backstageLogger.error(String(message), ...splat);
         break;
       case "warn":
-        this.backstageLogger.warn(String(message), meta);
+        this.backstageLogger.warn(String(message), ...splat);
         break;
       case "info":
-        this.backstageLogger.info(String(message), meta);
+        this.backstageLogger.info(String(message), ...splat);
         break;
       case "debug":
-        this.backstageLogger.debug(String(message), meta);
+        this.backstageLogger.debug(String(message), ...splat);
         break;
       default:
-        this.backstageLogger.info(String(message), meta);
+        this.backstageLogger.info(String(message), ...splat);
     }
+    this.taskContext.emitLog(message, { stepId: this.stepId });
     callback();
   }
 }
-class WinstonLogger {
-  #winston;
-  #addRedactions;
+const _WinstonLogger = class _WinstonLogger {
+  constructor(winston, addRedactions) {
+    __privateAdd(this, _winston, void 0);
+    __privateAdd(this, _addRedactions, void 0);
+    __privateSet(this, _winston, winston);
+    __privateSet(this, _addRedactions, addRedactions);
+  }
   /**
    * Creates a {@link WinstonLogger} instance.
    */
   static create(options) {
-    const redacter = WinstonLogger.redacter();
+    var _a;
+    const redacter = _WinstonLogger.redacter();
     let logger = winston.createLogger({
       level: options.level,
-      format: winston.format.combine(redacter.format, options.format),
-      transports: options.transports ?? new winston.transports.Console()
+      format: winston.format.combine(options.format, redacter.format),
+      transports: (_a = options.transports) != null ? _a : new winston.transports.Console()
     });
     if (options.meta) {
       logger = logger.child(options.meta);
     }
-    return new WinstonLogger(logger, redacter.add);
+    return new _WinstonLogger(logger, redacter.add);
   }
   /**
    * Creates a winston log formatter for redacting secrets.
@@ -2382,10 +2462,11 @@ class WinstonLogger {
     let redactionPattern = void 0;
     return {
       format: winston.format((obj) => {
+        var _a, _b;
         if (!redactionPattern || !obj) {
           return obj;
         }
-        obj[tripleBeam.MESSAGE] = obj[tripleBeam.MESSAGE]?.replace?.(redactionPattern, "***");
+        obj[tripleBeam.MESSAGE] = (_b = (_a = obj[tripleBeam.MESSAGE]) == null ? void 0 : _a.replace) == null ? void 0 : _b.call(_a, redactionPattern, "[REDACTED]");
         return obj;
       })(),
       add(newRedactions) {
@@ -2423,7 +2504,10 @@ class WinstonLogger {
         }
       }),
       winston.format.printf((info) => {
-        const { timestamp, level, message, plugin, service, ...fields } = info;
+        const { timestamp, plugin, service } = info;
+        const message = info[tripleBeam.MESSAGE];
+        const level = info[tripleBeam.LEVEL];
+        const fields = info[tripleBeam.SPLAT];
         const prefix = plugin || service;
         const timestampColor = colorizer.colorize("timestamp", timestamp);
         const prefixColor = colorizer.colorize("prefix", prefix);
@@ -2434,30 +2518,36 @@ class WinstonLogger {
       })
     );
   }
-  constructor(winston, addRedactions) {
-    this.#winston = winston;
-    this.#addRedactions = addRedactions;
-  }
   error(message, meta) {
-    this.#winston.error(message, meta);
+    __privateGet(this, _winston).error(message, meta);
   }
   warn(message, meta) {
-    this.#winston.warn(message, meta);
+    __privateGet(this, _winston).warn(message, meta);
   }
   info(message, meta) {
-    this.#winston.info(message, meta);
+    __privateGet(this, _winston).info(message, meta);
   }
   debug(message, meta) {
-    this.#winston.debug(message, meta);
+    __privateGet(this, _winston).debug(message, meta);
   }
   child(meta) {
-    return new WinstonLogger(this.#winston.child(meta));
+    return new _WinstonLogger(__privateGet(this, _winston).child(meta));
   }
   addRedactions(redactions) {
-    this.#addRedactions?.(redactions);
+    var _a;
+    (_a = __privateGet(this, _addRedactions)) == null ? void 0 : _a.call(this, redactions);
   }
-}
+};
+_winston = new WeakMap();
+_addRedactions = new WeakMap();
+let WinstonLogger = _WinstonLogger;
 
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 const isValidTaskSpec = (taskSpec) => {
   return taskSpec.apiVersion === "scaffolder.backstage.io/v1beta3";
 };
@@ -2466,29 +2556,20 @@ const createStepLogger = ({
   step,
   rootLogger
 }) => {
-  const stepLogStream = new stream.PassThrough();
-  stepLogStream.on("data", async (data) => {
-    const message = data.toString().trim();
-    if (message?.length > 1) {
-      await task.emitLog(message, { stepId: step.id });
-    }
-  });
+  var _a;
   const taskLogger = WinstonLogger.create({
     level: process.env.LOG_LEVEL || "info",
     format: winston__namespace.format.combine(
       winston__namespace.format.colorize(),
       winston__namespace.format.simple()
     ),
-    transports: [
-      new winston__namespace.transports.Stream({ stream: stepLogStream }),
-      new BackstageLoggerTransport(rootLogger)
-    ]
+    transports: [new BackstageLoggerTransport(rootLogger, task, step.id)]
   });
-  taskLogger.addRedactions(Object.values(task.secrets ?? {}));
+  taskLogger.addRedactions(Object.values((_a = task.secrets) != null ? _a : {}));
   const streamLogger = new stream.PassThrough();
   streamLogger.on("data", async (data) => {
     const message = data.toString().trim();
-    if (message?.length > 1) {
+    if ((message == null ? void 0 : message.length) > 1) {
       taskLogger.info(message);
     }
   });
@@ -2500,13 +2581,14 @@ const isActionAuthorized = pluginPermissionNode.createConditionAuthorizer(
 class NunjucksWorkflowRunner {
   constructor(options) {
     this.options = options;
+    __publicField$1(this, "defaultTemplateFilters");
+    __publicField$1(this, "tracker", scaffoldingTracker());
     this.defaultTemplateFilters = createDefaultFilters({
       integrations: this.options.integrations
     });
   }
-  defaultTemplateFilters;
-  tracker = scaffoldingTracker();
   isSingleTemplateString(input) {
+    var _a, _b;
     const { parser, nodes } = nunjucks__default.default;
     const parsed = parser.parse(
       input,
@@ -2519,7 +2601,7 @@ class NunjucksWorkflowRunner {
         }
       }
     );
-    return parsed.children.length === 1 && !(parsed.children[0]?.children?.[0] instanceof nodes.TemplateData);
+    return parsed.children.length === 1 && !(((_b = (_a = parsed.children[0]) == null ? void 0 : _a.children) == null ? void 0 : _b[0]) instanceof nodes.TemplateData);
   }
   render(input, context, renderTemplate) {
     return JSON.parse(JSON.stringify(input), (_key, value) => {
@@ -2555,6 +2637,7 @@ class NunjucksWorkflowRunner {
     });
   }
   async executeStep(task, step, context, renderTemplate, taskTrack, workspacePath, decision) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const stepTrack = await this.tracker.stepStart(task, step);
     if (task.cancelSignal.aborted) {
       throw new Error(`Step ${step.name} has been cancelled.`);
@@ -2575,16 +2658,19 @@ class NunjucksWorkflowRunner {
       });
       if (task.isDryRun) {
         const redactedSecrets = Object.fromEntries(
-          Object.entries(task.secrets ?? {}).map((secret) => [secret[0], "***"])
+          Object.entries((_a = task.secrets) != null ? _a : {}).map((secret) => [
+            secret[0],
+            "[REDACTED]"
+          ])
         );
-        const debugInput = (step.input && this.render(
+        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,
@@ -2594,7 +2680,7 @@ class NunjucksWorkflowRunner {
         );
         if (!action.supportsDryRun) {
           await taskTrack.skipDryRun(step, action);
-          const outputSchema = action.schema?.output;
+          const outputSchema = (_c = action.schema) == null ? void 0 : _c.output;
           if (outputSchema) {
             context.steps[step.id] = {
               output: generateExampleOutput(outputSchema)
@@ -2609,18 +2695,21 @@ class NunjucksWorkflowRunner {
         ([key, value]) => ({
           each: { key, value }
         })
-      ) : [{}]).map((i) => ({
-        ...i,
-        // Secrets are only passed when templating the input to actions for security reasons
-        input: step.input ? this.render(
-          step.input,
-          { ...context, secrets: task.secrets ?? {}, ...i },
-          renderTemplate
-        ) : {}
-      }));
+      ) : [{}]).map((i) => {
+        var _a2;
+        return {
+          ...i,
+          // Secrets are only passed when templating the input to actions for security reasons
+          input: step.input ? this.render(
+            step.input,
+            { ...context, secrets: (_a2 = task.secrets) != null ? _a2 : {}, ...i },
+            renderTemplate
+          ) : {}
+        };
+      });
       for (const iteration of iterations) {
         const actionId = `${action.id}${iteration.each ? `[${iteration.each.key}]` : ""}`;
-        if (action.schema?.input) {
+        if ((_d = action.schema) == null ? void 0 : _d.input) {
           const validateResult = jsonschema.validate(
             iteration.input,
             action.schema.input
@@ -2647,7 +2736,7 @@ class NunjucksWorkflowRunner {
       }
       const tmpDirs = new Array();
       const stepOutput = {};
-      const prevTaskState = await task.getTaskState?.();
+      const prevTaskState = await ((_e = task.getTaskState) == null ? void 0 : _e.call(task));
       for (const iteration of iterations) {
         if (iteration.each) {
           taskLogger.info(
@@ -2660,24 +2749,25 @@ class NunjucksWorkflowRunner {
         }
         await action.handler({
           input: iteration.input,
-          secrets: task.secrets ?? {},
+          secrets: (_f = task.secrets) != null ? _f : {},
           // TODO(blam): move to LoggerService and away from Winston
           logger: backendCommon.loggerToWinstonLogger(taskLogger),
           logStream: streamLogger,
           workspacePath,
           async checkpoint(keySuffix, fn) {
+            var _a2, _b2, _c2, _d2, _e2;
             const key = `v1.task.checkpoint.${keySuffix}`;
             try {
               let prevValue;
               if (prevTaskState) {
-                const prevState = prevTaskState.state?.checkpoints?.[key];
+                const prevState = (_b2 = (_a2 = prevTaskState.state) == null ? void 0 : _a2.checkpoints) == null ? void 0 : _b2[key];
                 if (prevState && prevState.status === "success") {
                   prevValue = prevState.value;
                 }
               }
               const value = prevValue ? prevValue : await fn();
               if (!prevValue) {
-                task.updateCheckpoint?.({
+                (_c2 = task.updateCheckpoint) == null ? void 0 : _c2.call(task, {
                   key,
                   status: "success",
                   value
@@ -2685,14 +2775,14 @@ class NunjucksWorkflowRunner {
               }
               return value;
             } catch (err) {
-              task.updateCheckpoint?.({
+              (_d2 = task.updateCheckpoint) == null ? void 0 : _d2.call(task, {
                 key,
                 status: "failed",
                 reason: errors.stringifyError(err)
               });
               throw err;
             } finally {
-              await task.serializeWorkspace?.({ path: workspacePath });
+              await ((_e2 = task.serializeWorkspace) == null ? void 0 : _e2.call(task, { path: workspacePath }));
             }
           },
           createTemporaryDirectory: async () => {
@@ -2724,17 +2814,18 @@ class NunjucksWorkflowRunner {
       if (task.cancelSignal.aborted) {
         throw new Error(`Step ${step.name} has been cancelled.`);
       }
-      await task.cleanWorkspace?.();
+      await ((_g = task.cleanWorkspace) == null ? void 0 : _g.call(task));
       await stepTrack.markSuccessful();
     } catch (err) {
       await taskTrack.markFailed(step, err);
       await stepTrack.markFailed();
       throw err;
     } finally {
-      await task.serializeWorkspace?.({ path: workspacePath });
+      await ((_h = task.serializeWorkspace) == null ? void 0 : _h.call(task, { path: workspacePath }));
     }
   }
   async execute(task) {
+    var _a;
     if (!isValidTaskSpec(task.spec)) {
       throw new errors.InputError(
         "Wrong template version executed with the workflow engine"
@@ -2751,7 +2842,7 @@ class NunjucksWorkflowRunner {
       templateGlobals: additionalTemplateGlobals
     });
     try {
-      await task.rehydrateWorkspace?.({ taskId, targetPath: workspacePath });
+      await ((_a = task.rehydrateWorkspace) == null ? void 0 : _a.call(task, { taskId, targetPath: workspacePath }));
       const taskTrack = await this.tracker.taskStart(task);
       await fs__default.default.ensureDir(workspacePath);
       const context = {
@@ -2806,9 +2897,10 @@ function scaffoldingTracker() {
     labelNames: ["template", "step", "result"]
   });
   async function taskStart(task) {
+    var _a, _b;
     await task.emitLog(`Starting up task with ${task.spec.steps.length} steps`);
-    const template = task.spec.templateInfo?.entityRef || "";
-    const user = task.spec.user?.ref || "";
+    const template = ((_a = task.spec.templateInfo) == null ? void 0 : _a.entityRef) || "";
+    const user = ((_b = task.spec.user) == null ? void 0 : _b.ref) || "";
     const taskTimer = taskDuration.startTimer({
       template
     });
@@ -2858,11 +2950,12 @@ function scaffoldingTracker() {
     };
   }
   async function stepStart(task, step) {
+    var _a;
     await task.emitLog(`Beginning step ${step.name}`, {
       stepId: step.id,
       status: "processing"
     });
-    const template = task.spec.templateInfo?.entityRef || "";
+    const template = ((_a = task.spec.templateInfo) == null ? void 0 : _a.entityRef) || "";
     const stepTimer = stepDuration.startTimer({
       template,
       step: step.name
@@ -2915,18 +3008,24 @@ function scaffoldingTracker() {
   };
 }
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class TaskWorker {
   constructor(options) {
     this.options = options;
+    __publicField(this, "taskQueue");
+    __publicField(this, "logger");
+    __publicField(this, "stopWorkers");
     this.stopWorkers = false;
     this.logger = options.logger;
     this.taskQueue = new PQueue__default.default({
       concurrency: options.concurrentTasksLimit
     });
   }
-  taskQueue;
-  logger;
-  stopWorkers;
   static async create(options) {
     const {
       taskBroker,
@@ -2957,10 +3056,11 @@ class TaskWorker {
     });
   }
   async recoverTasks() {
+    var _a, _b, _c;
     try {
-      await this.options.taskBroker.recoverTasks?.();
+      await ((_b = (_a = this.options.taskBroker).recoverTasks) == null ? void 0 : _b.call(_a));
     } catch (err) {
-      this.logger?.error(errors.stringifyError(err));
+      (_c = this.logger) == null ? void 0 : _c.error(errors.stringifyError(err));
     }
   }
   start() {
@@ -3082,7 +3182,7 @@ function createDryRunner(options) {
         getWorkspaceName: async () => `dry-run-${dryRunId}`,
         cancelSignal: abortSignal,
         async emitLog(message, logMetadata) {
-          if (logMetadata?.stepId === dryRunId) {
+          if ((logMetadata == null ? void 0 : logMetadata.stepId) === dryRunId) {
             return;
           }
           log.push({
@@ -3129,9 +3229,10 @@ async function getWorkingDirectory(config, logger) {
   return workingDirectory;
 }
 function getEntityBaseUrl(entity) {
-  let location = entity.metadata.annotations?.[catalogModel.ANNOTATION_SOURCE_LOCATION];
+  var _a, _b;
+  let location = (_a = entity.metadata.annotations) == null ? void 0 : _a[catalogModel.ANNOTATION_SOURCE_LOCATION];
   if (!location) {
-    location = entity.metadata.annotations?.[catalogModel.ANNOTATION_LOCATION];
+    location = (_b = entity.metadata.annotations) == null ? void 0 : _b[catalogModel.ANNOTATION_LOCATION];
   }
   if (!location) {
     return void 0;
@@ -3158,24 +3259,6 @@ async function findTemplate(options) {
   return template;
 }
 
-async function checkPermission(options) {
-  const { permissions, permissionService, credentials } = options;
-  if (permissionService) {
-    const permissionRequest = permissions.map((permission) => ({
-      permission
-    }));
-    const authorizationResponses = await permissionService.authorize(
-      permissionRequest,
-      { credentials }
-    );
-    for (const response of authorizationResponses) {
-      if (response.result === pluginPermissionCommon.AuthorizeResult.DENY) {
-        throw new errors.NotAllowedError();
-      }
-    }
-  }
-}
-
 function isTemplatePermissionRuleInput(permissionRule) {
   return permissionRule.resourceType === alpha.RESOURCE_TYPE_SCAFFOLDER_TEMPLATE;
 }
@@ -3188,13 +3271,14 @@ function isSupportedTemplate(entity) {
 function buildDefaultIdentityClient(options) {
   return {
     getIdentity: async ({ request }) => {
+      var _a;
       const header = request.headers.authorization;
       const { logger } = options;
       if (!header) {
         return void 0;
       }
       try {
-        const token = header.match(/^Bearer\s(\S+\.\S+\.\S+)$/i)?.[1];
+        const token = (_a = header.match(/^Bearer\s(\S+\.\S+\.\S+)$/i)) == null ? void 0 : _a[1];
         if (!token) {
           throw new TypeError("Expected Bearer with JWT");
         }
@@ -3235,6 +3319,7 @@ const readDuration = (config$1, key, defaultValue) => {
   return defaultValue;
 };
 async function createRouter(options) {
+  var _a;
   const router = Router__default.default();
   router.use(express__default.default.json({ limit: "10MB" }));
   const {
@@ -3258,7 +3343,7 @@ async function createRouter(options) {
     identity,
     discovery
   });
-  const concurrentTasksLimit = options.concurrentTasksLimit ?? options.config.getOptionalNumber("scaffolder.concurrentTasksLimit");
+  const concurrentTasksLimit = (_a = options.concurrentTasksLimit) != null ? _a : options.config.getOptionalNumber("scaffolder.concurrentTasksLimit");
   const logger = parentLogger.child({ plugin: "scaffolder" });
   const workingDirectory = await getWorkingDirectory(config, logger);
   const integrations = integration.ScmIntegrations.fromConfig(config);
@@ -3367,13 +3452,13 @@ async function createRouter(options) {
         permissions: alpha.scaffolderActionPermissions,
         rules: actionRules
       }
-    ],
-    permissions: alpha.scaffolderTaskPermissions
+    ]
   });
   router.use(permissionIntegrationRouter);
   router.get(
     "/v2/templates/:namespace/:kind/:name/parameter-schema",
     async (req, res) => {
+      var _a2, _b;
       const credentials = await httpAuth.credentials(req);
       const { token } = await auth.getPluginRequestToken({
         onBehalfOf: credentials,
@@ -3384,18 +3469,21 @@ async function createRouter(options) {
         token,
         credentials
       );
-      const parameters = [template.spec.parameters ?? []].flat();
+      const parameters = [(_a2 = template.spec.parameters) != null ? _a2 : []].flat();
       const presentation = template.spec.presentation;
       res.json({
-        title: template.metadata.title ?? template.metadata.name,
+        title: (_b = template.metadata.title) != null ? _b : template.metadata.name,
         ...presentation ? { presentation } : {},
         description: template.metadata.description,
         "ui:options": template.metadata["ui:options"],
-        steps: parameters.map((schema) => ({
-          title: schema.title ?? "Please enter the following information",
-          description: schema.description,
-          schema
-        }))
+        steps: parameters.map((schema) => {
+          var _a3;
+          return {
+            title: (_a3 = schema.title) != null ? _a3 : "Please enter the following information",
+            description: schema.description,
+            schema
+          };
+        })
       });
     }
   ).get("/v2/actions", async (_req, res) => {
@@ -3409,16 +3497,12 @@ async function createRouter(options) {
     });
     res.json(actionsList);
   }).post("/v2/tasks", async (req, res) => {
+    var _a2, _b;
     const templateRef = req.body.templateRef;
     const { kind, namespace, name } = catalogModel.parseEntityRef(templateRef, {
       defaultKind: "template"
     });
     const credentials = await httpAuth.credentials(req);
-    await checkPermission({
-      credentials,
-      permissions: [alpha.taskCreatePermission],
-      permissionService: permissions
-    });
     const { token } = await auth.getPluginRequestToken({
       onBehalfOf: credentials,
       targetPluginId: "catalog"
@@ -3436,7 +3520,7 @@ async function createRouter(options) {
       token,
       credentials
     );
-    for (const parameters of [template.spec.parameters ?? []].flat()) {
+    for (const parameters of [(_a2 = template.spec.parameters) != null ? _a2 : []].flat()) {
       const result2 = jsonschema.validate(values, parameters);
       if (!result2.valid) {
         res.status(400).json({ errors: result2.errors });
@@ -3446,13 +3530,16 @@ async function createRouter(options) {
     const baseUrl = getEntityBaseUrl(template);
     const taskSpec = {
       apiVersion: template.apiVersion,
-      steps: template.spec.steps.map((step, index) => ({
-        ...step,
-        id: step.id ?? `step-${index + 1}`,
-        name: step.name ?? step.action
-      })),
+      steps: template.spec.steps.map((step, index) => {
+        var _a3, _b2;
+        return {
+          ...step,
+          id: (_a3 = step.id) != null ? _a3 : `step-${index + 1}`,
+          name: (_b2 = step.name) != null ? _b2 : step.action
+        };
+      }),
       EXPERIMENTAL_recovery: template.spec.EXPERIMENTAL_recovery,
-      output: template.spec.output ?? {},
+      output: (_b = template.spec.output) != null ? _b : {},
       parameters: values,
       user: {
         entity: userEntity,
@@ -3478,12 +3565,6 @@ async function createRouter(options) {
     });
     res.status(201).json({ id: result.taskId });
   }).get("/v2/tasks", async (req, res) => {
-    const credentials = await httpAuth.credentials(req);
-    await checkPermission({
-      credentials,
-      permissions: [alpha.taskReadPermission],
-      permissionService: permissions
-    });
     const [userEntityRef] = [req.query.createdBy].flat();
     if (typeof userEntityRef !== "string" && typeof userEntityRef !== "undefined") {
       throw new errors.InputError("createdBy query parameter must be a string");
@@ -3498,12 +3579,6 @@ async function createRouter(options) {
     });
     res.status(200).json(tasks);
   }).get("/v2/tasks/:taskId", async (req, res) => {
-    const credentials = await httpAuth.credentials(req);
-    await checkPermission({
-      credentials,
-      permissions: [alpha.taskReadPermission],
-      permissionService: permissions
-    });
     const { taskId } = req.params;
     const task = await taskBroker.get(taskId);
     if (!task) {
@@ -3512,22 +3587,11 @@ async function createRouter(options) {
     delete task.secrets;
     res.status(200).json(task);
   }).post("/v2/tasks/:taskId/cancel", async (req, res) => {
-    const credentials = await httpAuth.credentials(req);
-    await checkPermission({
-      credentials,
-      permissions: [alpha.taskCancelPermission, alpha.taskReadPermission],
-      permissionService: permissions
-    });
+    var _a2;
     const { taskId } = req.params;
-    await taskBroker.cancel?.(taskId);
+    await ((_a2 = taskBroker.cancel) == null ? void 0 : _a2.call(taskBroker, taskId));
     res.status(200).json({ status: "cancelled" });
   }).get("/v2/tasks/:taskId/eventstream", async (req, res) => {
-    const credentials = await httpAuth.credentials(req);
-    await checkPermission({
-      credentials,
-      permissions: [alpha.taskReadPermission],
-      permissionService: permissions
-    });
     const { taskId } = req.params;
     const after = req.query.after !== void 0 ? Number(req.query.after) : void 0;
     logger.debug(`Event stream observing taskId '${taskId}' opened`);
@@ -3544,6 +3608,7 @@ async function createRouter(options) {
         res.end();
       },
       next: ({ events }) => {
+        var _a2;
         let shouldUnsubscribe = false;
         for (const event of events) {
           res.write(
@@ -3556,7 +3621,7 @@ data: ${JSON.stringify(event)}
             shouldUnsubscribe = true;
           }
         }
-        res.flush?.();
+        (_a2 = res.flush) == null ? void 0 : _a2.call(res);
         if (shouldUnsubscribe) {
           subscription.unsubscribe();
           res.end();
@@ -3568,12 +3633,6 @@ data: ${JSON.stringify(event)}
       logger.debug(`Event stream observing taskId '${taskId}' closed`);
     });
   }).get("/v2/tasks/:taskId/events", async (req, res) => {
-    const credentials = await httpAuth.credentials(req);
-    await checkPermission({
-      credentials,
-      permissions: [alpha.taskReadPermission],
-      permissionService: permissions
-    });
     const { taskId } = req.params;
     const after = Number(req.query.after) || void 0;
     const timeout = setTimeout(() => {
@@ -3596,12 +3655,7 @@ data: ${JSON.stringify(event)}
       clearTimeout(timeout);
     });
   }).post("/v2/dry-run", async (req, res) => {
-    const credentials = await httpAuth.credentials(req);
-    await checkPermission({
-      credentials,
-      permissions: [alpha.taskCreatePermission],
-      permissionService: permissions
-    });
+    var _a2, _b, _c;
     const bodySchema = zod.z.object({
       template: zod.z.unknown(),
       values: zod.z.record(zod.z.unknown()),
@@ -3617,30 +3671,34 @@ data: ${JSON.stringify(event)}
     if (!await pluginScaffolderCommon.templateEntityV1beta3Validator.check(template)) {
       throw new errors.InputError("Input template is not a template");
     }
+    const credentials = await httpAuth.credentials(req);
     const { token } = await auth.getPluginRequestToken({
       onBehalfOf: credentials,
       targetPluginId: "catalog"
     });
-    for (const parameters of [template.spec.parameters ?? []].flat()) {
+    for (const parameters of [(_a2 = template.spec.parameters) != null ? _a2 : []].flat()) {
       const result2 = jsonschema.validate(body.values, parameters);
       if (!result2.valid) {
         res.status(400).json({ errors: result2.errors });
         return;
       }
     }
-    const steps = template.spec.steps.map((step, index) => ({
-      ...step,
-      id: step.id ?? `step-${index + 1}`,
-      name: step.name ?? step.action
-    }));
+    const steps = template.spec.steps.map((step, index) => {
+      var _a3, _b2;
+      return {
+        ...step,
+        id: (_a3 = step.id) != null ? _a3 : `step-${index + 1}`,
+        name: (_b2 = step.name) != null ? _b2 : step.action
+      };
+    });
     const result = await dryRunner({
       spec: {
         apiVersion: template.apiVersion,
         steps,
-        output: template.spec.output ?? {},
+        output: (_b = template.spec.output) != null ? _b : {},
         parameters: body.values
       },
-      directoryContents: (body.directoryContents ?? []).map((file) => ({
+      directoryContents: ((_c = body.directoryContents) != null ? _c : []).map((file) => ({
         path: file.path,
         content: Buffer.from(file.base64Content, "base64")
       })),
@@ -3717,4 +3775,4 @@ exports.createRouter = createRouter;
 exports.createWaitAction = createWaitAction;
 exports.scaffolderActionRules = scaffolderActionRules;
 exports.scaffolderTemplateRules = scaffolderTemplateRules;
-//# sourceMappingURL=router-Czj3wQrV.cjs.js.map
+//# sourceMappingURL=router-Bj9ovbjU.cjs.js.map