@nocobase/plugin-workflow-javascript 3.0.0-alpha.1 → 3.0.0-alpha.12

package/dist/server/TaskConsumer.js

@@ -0,0 +1,317 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TaskConsumer_exports = {};
+__export(TaskConsumer_exports, {
+  TaskConsumer: () => TaskConsumer
+});
+module.exports = __toCommonJS(TaskConsumer_exports);
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+var import_constants = require("../common/constants");
+var import_ScriptWorkerRunner = require("./ScriptWorkerRunner");
+function isTaskMessage(message) {
+  return typeof message === "object" && message !== null && "jobId" in message;
+}
+function isScriptArguments(value) {
+  return value === null || Array.isArray(value) || typeof value === "object" && value !== null;
+}
+function getJavaScriptArguments(job) {
+  if (!job.meta || !("args" in job.meta) || !isScriptArguments(job.meta.args)) {
+    return {};
+  }
+  return job.meta.args;
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createJobAbortController(workflowPlugin, runningJobs, job, execution) {
+  const controller = new AbortController();
+  let timeoutGuard = null;
+  const abort = (reason) => {
+    if (!controller.signal.aborted) {
+      if ((0, import_plugin_workflow.isWorkflowTimeoutError)(reason)) {
+        controller.abort(reason);
+      } else if (reason === import_plugin_workflow.EXECUTION_REASON.TIMEOUT) {
+        controller.abort(new import_plugin_workflow.WorkflowTimeoutError());
+      } else {
+        controller.abort(reason instanceof Error ? reason : new Error("Workflow execution has been aborted"));
+      }
+    }
+  };
+  const remaining = execution.expiresAt ? execution.expiresAt.getTime() - Date.now() : null;
+  if (remaining != null) {
+    if (remaining <= 0) {
+      abort();
+    } else {
+      timeoutGuard = setTimeout(abort, remaining);
+    }
+  }
+  const unregister = workflowPlugin.registerRunningExecution(execution.id, abort);
+  const unregisterJob = runningJobs.register({
+    jobId: job.id,
+    executionId: execution.id,
+    abort
+  });
+  return {
+    abort,
+    signal: controller.signal,
+    dispose: () => {
+      if (timeoutGuard) {
+        clearTimeout(timeoutGuard);
+        timeoutGuard = null;
+      }
+      unregister();
+      unregisterJob();
+    }
+  };
+}
+class TaskConsumer {
+  constructor(workflowPlugin, runningJobs) {
+    this.workflowPlugin = workflowPlugin;
+    this.runningJobs = runningJobs;
+  }
+  ready = false;
+  closing = false;
+  processing = /* @__PURE__ */ new Set();
+  setReady(ready) {
+    this.ready = ready;
+  }
+  idle() {
+    return this.ready && !this.closing && this.workflowPlugin.serving();
+  }
+  async beforeStop() {
+    this.closing = true;
+    await Promise.allSettled(Array.from(this.processing));
+  }
+  process = async (message) => {
+    if (!isTaskMessage(message)) {
+      this.workflowPlugin.getLogger("javascript").warn("invalid JavaScript queue job message ignored", { message });
+      return;
+    }
+    const processing = this.processWithPermit(message.jobId);
+    this.processing.add(processing);
+    try {
+      await processing;
+    } finally {
+      this.processing.delete(processing);
+    }
+  };
+  async processWithPermit(jobId) {
+    if (this.closing) {
+      return;
+    }
+    const existingJob = await this.workflowPlugin.db.getRepository("jobs").findOne({
+      filterByTk: jobId
+    });
+    if (!existingJob) {
+      return;
+    }
+    if (existingJob.status !== import_plugin_workflow.JOB_STATUS.PENDING) {
+      return;
+    }
+    const node = await existingJob.getNode();
+    if ((node == null ? void 0 : node.type) !== import_constants.SCRIPT_INSTRUCTION_TYPE) {
+      return;
+    }
+    const claimedJob = await this.claimJob(existingJob);
+    if (!claimedJob) {
+      return;
+    }
+    const job = claimedJob;
+    const config = node.config;
+    const payload = {
+      content: (config == null ? void 0 : config.content) ?? "",
+      args: getJavaScriptArguments(job),
+      timeout: config == null ? void 0 : config.timeout,
+      continue: config == null ? void 0 : config.continue
+    };
+    const execution = await job.getExecution({ attributes: ["id", "workflowId", "status"] });
+    if (!execution || execution.status !== import_plugin_workflow.EXECUTION_STATUS.STARTED) {
+      await this.finishClaimedJob(job, {
+        status: import_plugin_workflow.JOB_STATUS.ABORTED,
+        result: `Execution (${job.executionId}) is not running`
+      });
+      return;
+    }
+    const logger = this.workflowPlugin.getLogger((execution == null ? void 0 : execution.workflowId) ?? "javascript");
+    const queueWaitMs = job.startedAt && job.createdAt ? job.startedAt.getTime() - job.createdAt.getTime() : 0;
+    logger.info(`JavaScript job (${job.id}) claimed for node (${job.nodeId})`, {
+      executionId: job.executionId,
+      jobId: job.id,
+      nodeId: job.nodeId,
+      queueWaitMs
+    });
+    if (!await this.workflowPlugin.timeoutManager.shouldContinue(execution)) {
+      await this.finishClaimedJob(job, {
+        status: import_plugin_workflow.JOB_STATUS.ABORTED,
+        result: "Execution timeout reached before JavaScript Worker started"
+      });
+      return;
+    }
+    const abortHandle = createJobAbortController(this.workflowPlugin, this.runningJobs, job, execution);
+    const stopHeartbeat = this.startClaimHeartbeat(job, abortHandle.abort);
+    let values;
+    try {
+      const result = await import_ScriptWorkerRunner.ScriptWorkerRunner.run(payload.content, payload.args, {
+        timeout: payload.timeout,
+        logger,
+        signal: abortHandle.signal
+      });
+      if (result.status === import_plugin_workflow.JOB_STATUS.RESOLVED) {
+        logger.info(`script (#${job.nodeId}) get result success`);
+        values = { status: import_plugin_workflow.JOB_STATUS.RESOLVED, result: result.result };
+        logger.info(`run script execution success, node id: ${job.nodeId},the result is ${result.result}`);
+      } else if (payload.continue) {
+        logger.warn(`script (#${job.nodeId}) get result failed, the reason is ${result.result}`);
+        values = { status: import_plugin_workflow.JOB_STATUS.RESOLVED, result: result.result };
+      } else {
+        logger.info(`script (#${job.nodeId}) get result failed, the reason is ${result.result}`);
+        values = { status: import_plugin_workflow.JOB_STATUS.ERROR, result: result.result };
+      }
+    } catch (error) {
+      const message = getErrorMessage(error);
+      logger.error(`script (#${job.nodeId}) get result failed, the reason is ${message}`);
+      values = {
+        status: abortHandle.signal.aborted || (0, import_plugin_workflow.isWorkflowTimeoutError)(error) ? import_plugin_workflow.JOB_STATUS.ABORTED : import_plugin_workflow.JOB_STATUS.ERROR,
+        result: message
+      };
+    } finally {
+      abortHandle.dispose();
+      await stopHeartbeat();
+    }
+    try {
+      await this.settleClaimedJob(job, execution, values, logger);
+    } catch (error) {
+      logger.error(`JavaScript job (${job.id}) failed to resume workflow execution (${job.executionId})`, { error });
+      throw error;
+    }
+  }
+  async claimJob(job) {
+    if (job.startedAt != null) {
+      return null;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const JobModel = this.workflowPlugin.db.getModel("jobs");
+    const [affected] = await JobModel.update(
+      {
+        startedAt: now
+      },
+      {
+        where: {
+          id: job.id,
+          status: import_plugin_workflow.JOB_STATUS.PENDING,
+          startedAt: null
+        }
+      }
+    );
+    if (!affected) {
+      return null;
+    }
+    const claimedJob = await job.reload();
+    return claimedJob;
+  }
+  async finishClaimedJob(job, values) {
+    const updated = await this.updatePendingJob(job, values);
+    if (updated) {
+      await this.workflowPlugin.resume(job);
+    }
+  }
+  async settleClaimedJob(job, execution, values, logger) {
+    if (!await this.workflowPlugin.timeoutManager.shouldContinue(execution)) {
+      logger.warn(`script (#${job.nodeId}) result discarded because execution (${execution.id}) is ended`);
+      return;
+    }
+    await execution.reload();
+    await job.reload();
+    if (execution.status !== import_plugin_workflow.EXECUTION_STATUS.STARTED || job.status !== import_plugin_workflow.JOB_STATUS.PENDING) {
+      logger.warn(`script (#${job.nodeId}) result discarded because execution (${execution.id}) is ended`);
+      return;
+    }
+    const updated = await this.updatePendingJob(job, values);
+    if (updated) {
+      await this.workflowPlugin.resume(job);
+    }
+  }
+  async updatePendingJob(job, values) {
+    const JobModel = this.workflowPlugin.db.getModel("jobs");
+    const [affected] = await JobModel.update(
+      {
+        status: values.status,
+        result: values.result
+      },
+      {
+        where: {
+          id: job.id,
+          status: import_plugin_workflow.JOB_STATUS.PENDING,
+          startedAt: job.startedAt
+        }
+      }
+    );
+    if (!affected) {
+      return false;
+    }
+    await job.reload();
+    return true;
+  }
+  startClaimHeartbeat(job, abort) {
+    let heartbeat = null;
+    const beat = () => {
+      if (heartbeat) {
+        return;
+      }
+      const JobModel = this.workflowPlugin.db.getModel("jobs");
+      heartbeat = JobModel.update(
+        { updatedAt: /* @__PURE__ */ new Date() },
+        {
+          where: {
+            id: job.id,
+            status: import_plugin_workflow.JOB_STATUS.PENDING,
+            startedAt: job.startedAt
+          }
+        }
+      ).then(([affected]) => {
+        if (!affected) {
+          abort();
+        }
+      }).catch((error) => {
+        this.workflowPlugin.getLogger("javascript").error(`JavaScript job (${job.id}) claim heartbeat failed`, {
+          error
+        });
+      }).finally(() => {
+        heartbeat = null;
+      });
+    };
+    const timer = setInterval(beat, 3e4);
+    return async () => {
+      clearInterval(timer);
+      await heartbeat;
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TaskConsumer
+});

package/dist/server/TaskRecovery.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type WorkflowPlugin from '@nocobase/plugin-workflow';
+export declare class TaskRecovery {
+    private readonly workflowPlugin;
+    private readonly taskQueueChannel;
+    private timer;
+    private ready;
+    private recovering;
+    constructor(workflowPlugin: WorkflowPlugin, taskQueueChannel: string);
+    start(): void;
+    stop(): Promise<void>;
+    recover(): void;
+    private recoverTasks;
+    private republishQueuedJobs;
+}

package/dist/server/TaskRecovery.js

@@ -0,0 +1,155 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TaskRecovery_exports = {};
+__export(TaskRecovery_exports, {
+  TaskRecovery: () => TaskRecovery
+});
+module.exports = __toCommonJS(TaskRecovery_exports);
+var import_sequelize = require("sequelize");
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+var import_constants = require("../common/constants");
+const RECOVERY_BATCH_SIZE = 100;
+const RECOVERY_MAX_SCAN_SIZE = 1e3;
+const RECOVERY_INTERVAL = 6e4;
+const RECOVERY_GRACE_PERIOD = RECOVERY_INTERVAL;
+class TaskRecovery {
+  constructor(workflowPlugin, taskQueueChannel) {
+    this.workflowPlugin = workflowPlugin;
+    this.taskQueueChannel = taskQueueChannel;
+  }
+  timer = null;
+  ready = false;
+  recovering = null;
+  start() {
+    this.ready = true;
+    this.recover();
+    this.timer = setInterval(() => {
+      this.recover();
+    }, RECOVERY_INTERVAL);
+  }
+  async stop() {
+    var _a;
+    this.ready = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await ((_a = this.recovering) == null ? void 0 : _a.catch(() => void 0));
+  }
+  recover() {
+    if (!this.ready || this.recovering) {
+      return;
+    }
+    const recovering = this.recoverTasks().catch(() => void 0).finally(() => {
+      if (this.recovering === recovering) {
+        this.recovering = null;
+      }
+    });
+    this.recovering = recovering;
+  }
+  async recoverTasks() {
+    const logger = this.workflowPlugin.getLogger("javascript");
+    if (!this.workflowPlugin.serving()) {
+      logger.warn("workflow:process is not serving on this instance, JavaScript job recovery will be ignored");
+      return;
+    }
+    try {
+      await this.republishQueuedJobs();
+    } catch (error) {
+      logger.error("JavaScript job recovery failed", { error });
+    }
+  }
+  async republishQueuedJobs() {
+    let cursor = null;
+    let scanned = 0;
+    const now = /* @__PURE__ */ new Date();
+    const recoverableBefore = new Date(now.getTime() - RECOVERY_GRACE_PERIOD);
+    const staleBefore = new Date(now.getTime() - 12e4);
+    const logger = this.workflowPlugin.getLogger("javascript");
+    const JobModel = this.workflowPlugin.db.getModel("jobs");
+    while (scanned < RECOVERY_MAX_SCAN_SIZE) {
+      const jobs = await JobModel.findAll({
+        where: {
+          ...cursor == null ? {} : { id: { [import_sequelize.Op.gt]: cursor } },
+          status: import_plugin_workflow.JOB_STATUS.PENDING,
+          createdAt: {
+            [import_sequelize.Op.lt]: recoverableBefore
+          }
+        },
+        attributes: ["id", "startedAt", "updatedAt"],
+        include: [
+          {
+            association: "node",
+            attributes: [],
+            where: {
+              type: import_constants.SCRIPT_INSTRUCTION_TYPE
+            },
+            required: true
+          },
+          {
+            association: "execution",
+            attributes: [],
+            where: {
+              status: import_plugin_workflow.EXECUTION_STATUS.STARTED,
+              [import_sequelize.Op.or]: [
+                { expiresAt: null },
+                {
+                  expiresAt: {
+                    [import_sequelize.Op.gt]: now
+                  }
+                }
+              ]
+            },
+            required: true
+          }
+        ],
+        order: [["id", "ASC"]],
+        limit: Math.min(RECOVERY_BATCH_SIZE, RECOVERY_MAX_SCAN_SIZE - scanned)
+      });
+      if (!jobs.length) {
+        break;
+      }
+      for (const job of jobs) {
+        if (job.startedAt) {
+          if (job.updatedAt && job.updatedAt <= staleBefore) {
+            logger.warn(`JavaScript job (${job.id}) claim heartbeat timed out, manual recovery is required`);
+          }
+          continue;
+        }
+        await this.workflowPlugin.app.eventQueue.publish(this.taskQueueChannel, {
+          jobId: job.id
+        });
+      }
+      scanned += jobs.length;
+      cursor = jobs[jobs.length - 1].id;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TaskRecovery
+});

package/dist/server/Vm.js

@@ -105,7 +105,14 @@ async function main() {
   const result = script.runInNewContext(context, { timeout: options.timeout });
   return result;
 }
-main().then((result) => {
+function flushOutput() {
+  const flush = (stream) => new Promise((resolve, reject) => {
+    stream.write("", (error) => error ? reject(error) : resolve());
+  });
+  return Promise.all([flush(process.stdout), flush(process.stderr)]);
+}
+main().then(async (result) => {
+  await flushOutput();
   parentPort.postMessage({ type: "result", result });
 }).catch((error) => {
   throw error;

package/dist/server/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export declare const PENDING_JAVASCRIPT_TASK_CHANNEL = "@nocobase/plugin-workflow-javascript.pendingJavaScriptTask";

package/dist/server/constants.js

@@ -0,0 +1,36 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  PENDING_JAVASCRIPT_TASK_CHANNEL: () => PENDING_JAVASCRIPT_TASK_CHANNEL
+});
+module.exports = __toCommonJS(constants_exports);
+const PENDING_JAVASCRIPT_TASK_CHANNEL = "@nocobase/plugin-workflow-javascript.pendingJavaScriptTask";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PENDING_JAVASCRIPT_TASK_CHANNEL
+});

package/dist/server/plugin.d.ts

@@ -1,8 +1,22 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
 import { Plugin } from '@nocobase/server';
 export declare class PluginWorkflowScriptServer extends Plugin {
+    private readonly runningJobs;
+    private workflowPlugin;
+    private taskConsumer;
+    private taskRecovery;
+    private readonly handleJobsAfterBulkUpdate;
     afterAdd(): Promise<void>;
     beforeLoad(): Promise<void>;
     load(): Promise<void>;
+    handleSyncMessage(message: unknown): Promise<void>;
     install(): Promise<void>;
     afterEnable(): Promise<void>;
     afterDisable(): Promise<void>;

package/dist/server/plugin.js

@@ -42,15 +42,105 @@ __export(plugin_exports, {
 module.exports = __toCommonJS(plugin_exports);
 var import_server = require("@nocobase/server");
 var import_plugin_workflow = __toESM(require("@nocobase/plugin-workflow"));
+var import_constants = require("../common/constants");
 var import_ScriptInstruction = __toESM(require("./ScriptInstruction"));
+var import_constants2 = require("./constants");
+var import_RunningJobs = require("./RunningJobs");
+var import_TaskConsumer = require("./TaskConsumer");
+var import_TaskRecovery = require("./TaskRecovery");
 class PluginWorkflowScriptServer extends import_server.Plugin {
+  runningJobs = new import_RunningJobs.RunningJobs();
+  workflowPlugin;
+  taskConsumer;
+  taskRecovery;
+  handleJobsAfterBulkUpdate = async (options) => {
+    var _a;
+    if (((_a = options.attributes) == null ? void 0 : _a.status) !== import_plugin_workflow.JOB_STATUS.ABORTED) {
+      return;
+    }
+    const JobModel = this.db.getModel("jobs");
+    const jobs = await JobModel.findAll({
+      attributes: ["id", "executionId"],
+      where: options.where,
+      include: [
+        {
+          association: "node",
+          attributes: [],
+          where: {
+            type: import_constants.SCRIPT_INSTRUCTION_TYPE
+          },
+          required: true
+        },
+        {
+          association: "execution",
+          attributes: ["reason"],
+          required: false
+        }
+      ],
+      transaction: options.transaction
+    });
+    const abortJobs = async () => {
+      var _a2;
+      for (const job of jobs) {
+        try {
+          await this.runningJobs.abortAcrossInstances(this.workflowPlugin, {
+            type: import_RunningJobs.ABORT_JAVASCRIPT_JOB_SYNC_MESSAGE_TYPE,
+            jobId: job.id,
+            executionId: job.executionId,
+            reason: ((_a2 = job.execution) == null ? void 0 : _a2.reason) ?? void 0
+          });
+        } catch (error) {
+          this.workflowPlugin.getLogger("javascript").error(`aborting JavaScript job (${job.id}) failed`, { error });
+        }
+      }
+    };
+    if (options.transaction) {
+      options.transaction.afterCommit(abortJobs);
+      return;
+    }
+    await abortJobs();
+  };
   async afterAdd() {
   }
   async beforeLoad() {
   }
   async load() {
-    const workflowPlugin = this.app.pm.get(import_plugin_workflow.default);
-    workflowPlugin.registerInstruction("script", import_ScriptInstruction.default);
+    this.workflowPlugin = this.app.pm.get(import_plugin_workflow.default);
+    this.taskConsumer = new import_TaskConsumer.TaskConsumer(this.workflowPlugin, this.runningJobs);
+    this.taskRecovery = new import_TaskRecovery.TaskRecovery(this.workflowPlugin, import_constants2.PENDING_JAVASCRIPT_TASK_CHANNEL);
+    this.workflowPlugin.registerInstruction(
+      import_constants.SCRIPT_INSTRUCTION_TYPE,
+      new import_ScriptInstruction.default(this.workflowPlugin, this.runningJobs)
+    );
+    this.db.on("jobs.afterBulkUpdate", this.handleJobsAfterBulkUpdate);
+    const workerConcurrency = Number.parseInt(process.env.WORKFLOW_SCRIPT_WORKER_CONCURRENCY, 10);
+    this.app.eventQueue.subscribe(import_constants2.PENDING_JAVASCRIPT_TASK_CHANNEL, {
+      concurrency: Number.isInteger(workerConcurrency) && workerConcurrency >= 0 ? workerConcurrency : 0,
+      idle: () => this.taskConsumer.idle(),
+      process: this.taskConsumer.process
+    });
+    this.app.on("afterStart", () => {
+      this.taskConsumer.setReady(true);
+      this.taskRecovery.start();
+    });
+    this.app.on("beforeStop", async () => {
+      this.taskConsumer.setReady(false);
+      await this.taskConsumer.beforeStop();
+      await this.taskRecovery.stop();
+      this.db.off("jobs.afterBulkUpdate", this.handleJobsAfterBulkUpdate);
+    });
+  }
+  async handleSyncMessage(message) {
+    if (typeof message !== "object" || message === null) {
+      return;
+    }
+    const { type, jobId, reason } = message;
+    if (type !== import_RunningJobs.ABORT_JAVASCRIPT_JOB_SYNC_MESSAGE_TYPE) {
+      return;
+    }
+    if (typeof jobId === "string" || typeof jobId === "number") {
+      this.runningJobs.abortJob(jobId, typeof reason === "string" ? reason : void 0);
+    }
   }
   async install() {
   }