@nocobase/plugin-async-task-manager 1.5.0-beta.20

package/dist/server/base-task-manager.js

@@ -0,0 +1,135 @@
+/**
+ * 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 base_task_manager_exports = {};
+__export(base_task_manager_exports, {
+  BaseTaskManager: () => BaseTaskManager
+});
+module.exports = __toCommonJS(base_task_manager_exports);
+var import_events = require("events");
+class BaseTaskManager extends import_events.EventEmitter {
+  taskTypes = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  // Clean up completed tasks after 30 minutes by default
+  cleanupDelay = 30 * 60 * 1e3;
+  logger;
+  app;
+  setLogger(logger) {
+    this.logger = logger;
+  }
+  setApp(app) {
+    this.app = app;
+  }
+  scheduleCleanup(taskId) {
+    setTimeout(() => {
+      this.tasks.delete(taskId);
+      this.logger.debug(`Task ${taskId} cleaned up after ${this.cleanupDelay}ms`);
+    }, this.cleanupDelay);
+  }
+  constructor() {
+    super();
+  }
+  async cancelTask(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      this.logger.warn(`Attempted to cancel non-existent task ${taskId}`);
+      return false;
+    }
+    this.logger.info(`Cancelling task ${taskId}, type: ${task.constructor.name}, tags: ${JSON.stringify(task.tags)}`);
+    return task.cancel();
+  }
+  createTask(options) {
+    const taskType = this.taskTypes.get(options.type);
+    if (!taskType) {
+      this.logger.error(`Task type not found: ${options.type}, params: ${JSON.stringify(options.params)}`);
+      throw new Error(`Task type ${options.type} not found`);
+    }
+    this.logger.info(
+      `Creating task of type: ${options.type}, params: ${JSON.stringify(options.params)}, tags: ${JSON.stringify(
+        options.tags
+      )}`
+    );
+    const task = new taskType(options.params, options.tags);
+    task.title = options.title;
+    task.setLogger(this.logger);
+    task.setApp(this.app);
+    task.setContext(options.context);
+    this.tasks.set(task.taskId, task);
+    this.logger.info(
+      `Created new task ${task.taskId} of type ${options.type}, params: ${JSON.stringify(
+        options.params
+      )}, tags: ${JSON.stringify(options.tags)}, title: ${task.title}`
+    );
+    this.emit("taskCreated", { task });
+    task.on("progress", (progress) => {
+      this.logger.debug(`Task ${task.taskId} progress: ${progress}`);
+      this.emit("taskProgress", { task, progress });
+    });
+    task.on("statusChange", (status) => {
+      if (["success", "failed"].includes(status.type)) {
+        this.scheduleCleanup(task.taskId);
+      } else if (status.type === "cancelled") {
+        this.tasks.delete(task.taskId);
+      }
+      this.emit("taskStatusChange", { task, status });
+    });
+    return task;
+  }
+  getTask(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      this.logger.debug(`Task not found: ${taskId}`);
+      return void 0;
+    }
+    this.logger.debug(`Retrieved task ${taskId}, type: ${task.constructor.name}, status: ${task.status.type}`);
+    return task;
+  }
+  async getTaskStatus(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      this.logger.warn(`Attempted to get status of non-existent task ${taskId}`);
+      throw new Error(`Task ${taskId} not found`);
+    }
+    this.logger.debug(`Getting status for task ${taskId}, current status: ${task.status.type}`);
+    return task.status;
+  }
+  registerTaskType(taskType) {
+    this.logger.info(`Registering task type: ${taskType.type}`);
+    this.taskTypes.set(taskType.type, taskType);
+  }
+  async getTasksByTag(tagKey, tagValue) {
+    this.logger.debug(`Getting tasks by tag - key: ${tagKey}, value: ${tagValue}`);
+    const tasks = Array.from(this.tasks.values()).filter((task) => {
+      return task.tags[tagKey] == tagValue;
+    });
+    this.logger.debug(`Found ${tasks.length} tasks with tag ${tagKey}=${tagValue}`);
+    return tasks;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseTaskManager
+});

package/dist/server/command-task-type.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Worker } from 'worker_threads';
+import { TaskType } from './task-type';
+export declare class CommandTaskType extends TaskType {
+    static type: string;
+    workerThread: Worker;
+    execute(): Promise<unknown>;
+}

package/dist/server/command-task-type.js

@@ -0,0 +1,121 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var command_task_type_exports = {};
+__export(command_task_type_exports, {
+  CommandTaskType: () => CommandTaskType
+});
+module.exports = __toCommonJS(command_task_type_exports);
+var import_async_task_manager = require("./interfaces/async-task-manager");
+var import_node_process = __toESM(require("node:process"));
+var import_worker_threads = require("worker_threads");
+var import_path = __toESM(require("path"));
+var import_task_type = require("./task-type");
+class CommandTaskType extends import_task_type.TaskType {
+  static type = "command";
+  workerThread;
+  async execute() {
+    var _a;
+    const { argv } = this.options;
+    const isDev = (((_a = import_node_process.default.argv[1]) == null ? void 0 : _a.endsWith(".ts")) || import_node_process.default.argv[1].includes("tinypool")) ?? false;
+    const appRoot = import_node_process.default.env.APP_PACKAGE_ROOT || "packages/core/app";
+    const workerPath = import_path.default.resolve(import_node_process.default.cwd(), appRoot, isDev ? "src/index.ts" : "lib/index.js");
+    const workerPromise = new Promise((resolve, reject) => {
+      var _a2, _b;
+      try {
+        (_a2 = this.logger) == null ? void 0 : _a2.info(
+          `Creating worker for task ${this.taskId} - path: ${workerPath}, argv: ${JSON.stringify(
+            argv
+          )}, isDev: ${isDev}`
+        );
+        const worker = new import_worker_threads.Worker(workerPath, {
+          execArgv: isDev ? ["--require", "tsx/cjs"] : [],
+          workerData: {
+            argv
+          }
+        });
+        this.workerThread = worker;
+        (_b = this.logger) == null ? void 0 : _b.debug(`Worker created successfully for task ${this.taskId}`);
+        let isCancelling = false;
+        this.abortController.signal.addEventListener("abort", () => {
+          var _a3;
+          isCancelling = true;
+          (_a3 = this.logger) == null ? void 0 : _a3.info(`Terminating worker for task ${this.taskId} due to cancellation`);
+          worker.terminate();
+        });
+        worker.on("message", (message) => {
+          var _a3, _b2;
+          (_a3 = this.logger) == null ? void 0 : _a3.debug(`Worker message received for task ${this.taskId} - type: ${message.type}`);
+          if (message.type === "progress") {
+            this.reportProgress(message.payload);
+          }
+          if (message.type === "success") {
+            (_b2 = this.logger) == null ? void 0 : _b2.info(
+              `Worker completed successfully for task ${this.taskId} with payload: ${JSON.stringify(message.payload)}`
+            );
+            resolve(message.payload);
+          }
+        });
+        worker.on("error", (error) => {
+          var _a3;
+          (_a3 = this.logger) == null ? void 0 : _a3.error(`Worker error for task ${this.taskId}`, error);
+          reject(error);
+        });
+        worker.on("exit", (code) => {
+          var _a3;
+          (_a3 = this.logger) == null ? void 0 : _a3.info(`Worker exited for task ${this.taskId} with code ${code}`);
+          if (isCancelling) {
+            reject(new import_async_task_manager.CancelError());
+          } else if (code !== 0) {
+            reject(new Error(`Worker stopped with exit code ${code}`));
+          } else {
+            resolve(code);
+          }
+        });
+        worker.on("messageerror", (error) => {
+          reject(error);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+    return workerPromise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandTaskType
+});

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interfaces/async-task-manager';
+export * from './static-import';
+export { default } from './plugin';

package/dist/server/index.js

@@ -0,0 +1,50 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("./interfaces/async-task-manager"), module.exports);
+__reExport(server_exports, require("./static-import"), module.exports);
+var import_plugin = __toESM(require("./plugin"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./interfaces/async-task-manager"),
+  ...require("./static-import")
+});

package/dist/server/interfaces/async-task-manager.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+import { Logger } from '@nocobase/logger';
+import { ITask, TaskConstructor } from './task';
+import { Application } from '@nocobase/server';
+import { EventEmitter } from 'events';
+export type TaskOptions = any;
+export interface CreateTaskOptions {
+    type: string;
+    params: TaskOptions;
+    tags?: Record<string, string>;
+    title?: {
+        actionType: string;
+        collection: string;
+        dataSource: string;
+    };
+    context?: any;
+}
+export type TaskId = string;
+export type TaskStatus = PendingStatus | SuccessStatus<any> | RunningStatus | FailedStatus | CancelledStatus;
+export type ProgressIndicator = 'spinner' | 'progress' | 'success' | 'error';
+export interface PendingStatus {
+    type: 'pending';
+    indicator?: 'spinner';
+}
+export interface SuccessStatus<T = any> {
+    type: 'success';
+    indicator?: 'success';
+    resultType?: 'file' | 'data';
+    payload?: T;
+}
+export interface RunningStatus {
+    type: 'running';
+    indicator: 'progress';
+}
+export interface FailedStatus {
+    type: 'failed';
+    indicator?: 'error';
+    errors: Array<{
+        message: string;
+        code?: number;
+    }>;
+}
+export interface CancelledStatus {
+    type: 'cancelled';
+}
+export interface AsyncTasksManager extends EventEmitter {
+    setLogger(logger: Logger): void;
+    setApp(app: Application): void;
+    registerTaskType(taskType: TaskConstructor): void;
+    createTask<T>(options: CreateTaskOptions): ITask;
+    getTasksByTag(tagKey: string, tagValue: string): Promise<ITask[]>;
+    cancelTask(taskId: TaskId): Promise<boolean>;
+    getTaskStatus(taskId: TaskId): Promise<TaskStatus>;
+    getTask(taskId: TaskId): ITask | undefined;
+}
+export declare class CancelError extends Error {
+    constructor(message?: string);
+}

package/dist/server/interfaces/async-task-manager.js

@@ -0,0 +1,41 @@
+/**
+ * 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 async_task_manager_exports = {};
+__export(async_task_manager_exports, {
+  CancelError: () => CancelError
+});
+module.exports = __toCommonJS(async_task_manager_exports);
+class CancelError extends Error {
+  constructor(message = "Task cancelled") {
+    super(message);
+    this.name = "CancelError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CancelError
+});

package/dist/server/interfaces/task.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { Logger } from '@nocobase/logger';
+import { TaskStatus } from './async-task-manager';
+import { EventEmitter } from 'events';
+import { Application } from '@nocobase/server';
+export interface ITask extends EventEmitter {
+    taskId: string;
+    status: TaskStatus;
+    progress: {
+        total: number;
+        current: number;
+    };
+    startedAt: Date;
+    fulfilledAt: Date;
+    tags: Record<string, string>;
+    createdAt: Date;
+    title?: any;
+    isCancelled: boolean;
+    context?: any;
+    setLogger(logger: Logger): void;
+    setApp(app: Application): void;
+    setContext(context: any): void;
+    cancel(): Promise<boolean>;
+    execute(): Promise<any>;
+    reportProgress(progress: {
+        total: number;
+        current: number;
+    }): void;
+    run(): Promise<void>;
+    toJSON(options?: {
+        raw?: boolean;
+    }): any;
+}
+export interface TaskConstructor {
+    type: string;
+    new (options: any, tags?: Record<string, string>): ITask;
+}

package/dist/server/interfaces/task.js

@@ -0,0 +1,24 @@
+/**
+ * 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 __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 task_exports = {};
+module.exports = __toCommonJS(task_exports);

package/dist/server/plugin.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from '@nocobase/server';
+export declare class PluginAsyncExportServer extends Plugin {
+    afterAdd(): Promise<void>;
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+}
+export default PluginAsyncExportServer;

package/dist/server/plugin.js

@@ -0,0 +1,163 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  PluginAsyncExportServer: () => PluginAsyncExportServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@nocobase/server");
+var import_base_task_manager = require("./base-task-manager");
+var import_command_task_type = require("./command-task-type");
+var import_async_tasks = __toESM(require("./resourcers/async-tasks"));
+class PluginAsyncExportServer extends import_server.Plugin {
+  async afterAdd() {
+  }
+  async beforeLoad() {
+    this.app.container.register("AsyncTaskManager", () => {
+      const manager = new import_base_task_manager.BaseTaskManager();
+      manager.setLogger(this.app.logger);
+      manager.setApp(this.app);
+      return manager;
+    });
+    this.app.container.get("AsyncTaskManager").registerTaskType(import_command_task_type.CommandTaskType);
+    this.app.acl.allow("asyncTasks", ["get", "fetchFile"], "loggedIn");
+  }
+  async load() {
+    this.app.resourceManager.define(import_async_tasks.default);
+    const asyncTaskManager = this.app.container.get("AsyncTaskManager");
+    this.app.on(`ws:message:request:async-tasks:list`, async (message) => {
+      const { tags } = message;
+      this.app.logger.info(`Received request for async tasks with tags: ${JSON.stringify(tags)}`);
+      const userTag = tags == null ? void 0 : tags.find((tag) => tag.startsWith("userId#"));
+      const userId = userTag ? userTag.split("#")[1] : null;
+      if (userId) {
+        this.app.logger.info(`Fetching tasks for userId: ${userId}`);
+        const tasks = await asyncTaskManager.getTasksByTag("userId", userId);
+        this.app.logger.info(`Found ${tasks.length} tasks for userId: ${userId}`);
+        this.app.emit("ws:sendToTag", {
+          tagKey: "userId",
+          tagValue: userId,
+          message: {
+            type: "async-tasks",
+            payload: tasks.map((task) => task.toJSON())
+          }
+        });
+      } else {
+        this.app.logger.warn(`No userId found in message tags: ${JSON.stringify(tags)}`);
+      }
+    });
+    asyncTaskManager.on("taskCreated", ({ task }) => {
+      const userId = task.tags["userId"];
+      if (userId) {
+        this.app.emit("ws:sendToTag", {
+          tagKey: "userId",
+          tagValue: userId,
+          message: {
+            type: "async-tasks:created",
+            payload: task.toJSON()
+          }
+        });
+      }
+    });
+    asyncTaskManager.on("taskProgress", ({ task, progress }) => {
+      const userId = task.tags["userId"];
+      if (userId) {
+        this.app.emit("ws:sendToTag", {
+          tagKey: "userId",
+          tagValue: userId,
+          message: {
+            type: "async-tasks:progress",
+            payload: {
+              taskId: task.taskId,
+              progress
+            }
+          }
+        });
+      }
+    });
+    asyncTaskManager.on("taskStatusChange", ({ task, status }) => {
+      const userId = task.tags["userId"];
+      if (userId) {
+        this.app.emit("ws:sendToTag", {
+          tagKey: "userId",
+          tagValue: userId,
+          message: {
+            type: "async-tasks:status",
+            payload: {
+              taskId: task.taskId,
+              status: task.toJSON().status
+            }
+          }
+        });
+      }
+    });
+    asyncTaskManager.on("taskStatusChange", ({ status }) => {
+      if (status.type === "success") {
+        this.app.emit("workflow:dispatch");
+      }
+    });
+    this.app.on("ws:message:request:async-tasks:cancel", async (message) => {
+      const { payload, tags } = message;
+      const { taskId } = payload;
+      const userTag = tags == null ? void 0 : tags.find((tag) => tag.startsWith("userId#"));
+      const userId = userTag ? userTag.split("#")[1] : null;
+      if (userId) {
+        const task = asyncTaskManager.getTask(taskId);
+        if (task.tags["userId"] != userId) {
+          return;
+        }
+        const cancelled = await asyncTaskManager.cancelTask(taskId);
+        if (cancelled) {
+          this.app.emit("ws:sendToTag", {
+            tagKey: "userId",
+            tagValue: userId,
+            message: {
+              type: "async-tasks:cancelled",
+              payload: { taskId }
+            }
+          });
+        }
+      }
+    });
+  }
+}
+var plugin_default = PluginAsyncExportServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginAsyncExportServer
+});

package/dist/server/resourcers/async-tasks.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    name: string;
+    actions: {
+        get(ctx: any, next: any): Promise<void>;
+        fetchFile(ctx: any, next: any): Promise<void>;
+    };
+};
+export default _default;