@tachybase/module-backup 1.0.6 → 1.0.25

package/dist/server/collections/autoBackup.d.ts

@@ -0,0 +1,2 @@
+import { CollectionOptions } from '@tachybase/database';
+export default function (): CollectionOptions;

package/dist/server/collections/autoBackup.js

@@ -0,0 +1,64 @@
+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 autoBackup_exports = {};
+__export(autoBackup_exports, {
+  default: () => autoBackup_default
+});
+module.exports = __toCommonJS(autoBackup_exports);
+var import_constants = require("../../constants");
+function autoBackup_default() {
+  return {
+    dumpRules: "required",
+    name: import_constants.COLLECTION_AUTOBACKUP,
+    shared: true,
+    createdAt: true,
+    updatedAt: true,
+    createdBy: true,
+    updatedBy: true,
+    fields: [
+      {
+        type: "string",
+        name: "title",
+        required: true
+      },
+      {
+        type: "boolean",
+        name: "enabled",
+        defaultValue: false
+      },
+      {
+        type: "string",
+        name: "repeat"
+      },
+      {
+        type: "array",
+        name: "dumpRules"
+      },
+      {
+        type: "integer",
+        name: "maxNumber"
+      },
+      {
+        type: "encryption",
+        name: "password",
+        interface: "encryption",
+        iv: "welljzlyq2p2439v"
+      }
+    ]
+  };
+}

package/dist/server/commands/backup-command.d.ts

@@ -0,0 +1,2 @@
+import { Application } from '@tachybase/server';
+export default function addBackupCommand(app: Application): void;

package/dist/server/commands/backup-command.js

@@ -0,0 +1,78 @@
+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 backup_command_exports = {};
+__export(backup_command_exports, {
+  default: () => addBackupCommand
+});
+module.exports = __toCommonJS(backup_command_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_server = require("@tachybase/server");
+var import_dumper = require("../dumper");
+function addBackupCommand(app) {
+  app.command("backup").ipc().option("-a, --app <appName>", "sub app name if you want to backup").option(
+    "-g, --groups <groups>",
+    "groups to backup",
+    (value, previous) => {
+      return previous.concat([value]);
+    },
+    []
+  ).action(async (options) => {
+    let backupApp = app;
+    if (options.app) {
+      if (!await app.db.getCollection("applications").repository.findOne({
+        filter: { name: options.app }
+      })) {
+        await app.db.getCollection("applications").repository.create({
+          values: {
+            name: options.app
+          }
+        });
+      }
+      const subApp = await import_server.AppSupervisor.getInstance().getApp(options.app);
+      if (!subApp) {
+        app.logger.error(`app ${options.app} not found`);
+        await app.stop();
+        return;
+      }
+      backupApp = subApp;
+    }
+    const groups = new Set(options.groups);
+    groups.add("required");
+    const dumper = new import_dumper.Dumper(app);
+    const appName = backupApp.name;
+    const backupFileName = import_dumper.Dumper.generateFileName();
+    const tmpFile = await dumper.writeLockFile(backupFileName, appName);
+    await dumper.runDumpTask({
+      groups,
+      appName,
+      fileName: backupFileName
+    });
+    await import_promises.default.unlink(tmpFile);
+    backupApp.logger.info(`${appName} backup into ${backupFileName}!`);
+  });
+}

package/dist/server/dumper.d.ts

@@ -16,6 +16,11 @@ type BackUpStatusDoing = {
     inProgress: true;
     status: 'in_progress';
 };
+type BackUpStatusError = {
+    name: string;
+    createdAt: Date;
+    status: 'error';
+};
 export declare class Dumper extends AppMigrator {
     static dumpTasks: Map<string, Promise<any>>;
     direction: "dump";
@@ -26,7 +31,7 @@ export declare class Dumper extends AppMigrator {
         };
     };
     static getTaskPromise(taskId: string): Promise<any> | undefined;
-    static getFileStatus(filePath: string): Promise<BackUpStatusOk | BackUpStatusDoing>;
+    static getFileStatus(filePath: string): Promise<BackUpStatusOk | BackUpStatusDoing | BackUpStatusError>;
     static generateFileName(): string;
     writeSQLContent(key: string, data: {
         sql: string | string[];
@@ -49,9 +54,10 @@ export declare class Dumper extends AppMigrator {
     }): Promise<string[]>;
     backUpFilePath(fileName: string, appName?: string): string;
     lockFilePath(fileName: string, appName?: string): string;
-    writeLockFile(fileName: string, appName?: string): Promise<void>;
-    cleanLockFile(fileName: string, appName?: string): Promise<void>;
-    runDumpTask(options: Omit<DumpOptions, 'fileName'>): Promise<string>;
+    writeLockFile(fileName: string, appName?: string): Promise<string>;
+    cleanLockFile(fileName: string, appName: string): Promise<void>;
+    getLockFile(appName: string): Promise<string>;
+    runDumpTask(options: DumpOptions): Promise<void>;
     dumpableCollectionsGroupByGroup(): Promise<{
         [x: string]: Pick<any, string>[];
     }>;

package/dist/server/dumper.js

@@ -36,7 +36,6 @@ var import_path = __toESM(require("path"));
 var process = __toESM(require("process"));
 var import_stream = __toESM(require("stream"));
 var import_util = __toESM(require("util"));
-var import_worker_threads = require("worker_threads");
 var import_database = require("@tachybase/database");
 var import_archiver = __toESM(require("archiver"));
 var import_dayjs = __toESM(require("dayjs"));
@@ -60,11 +59,19 @@ const _Dumper = class _Dumper extends import_app_migrator.AppMigrator {
     const fileName = import_path.default.basename(filePath);
     return import_fs.default.promises.stat(lockFile).then((lockFileStat) => {
       if (lockFileStat.isFile()) {
-        return {
-          name: fileName,
-          inProgress: true,
-          status: "in_progress"
-        };
+        if (lockFileStat.ctime.getTime() < Date.now() - 2 * 60 * 60 * 1e3) {
+          return {
+            name: fileName,
+            createdAt: lockFileStat.ctime,
+            status: "error"
+          };
+        } else {
+          return {
+            name: fileName,
+            inProgress: true,
+            status: "in_progress"
+          };
+        }
       } else {
         throw new Error("Lock file is not a file");
       }
@@ -182,40 +189,24 @@ const _Dumper = class _Dumper extends import_app_migrator.AppMigrator {
     await (0, import_mkdirp.default)(dirname);
     const filePath = this.lockFilePath(fileName, appName);
     await import_promises.default.writeFile(filePath, "lock", "utf8");
+    return filePath;
   }
   async cleanLockFile(fileName, appName) {
     const filePath = this.lockFilePath(fileName, appName);
     await import_promises.default.unlink(filePath);
   }
-  async runDumpTask(options) {
+  async getLockFile(appName) {
     const backupFileName = _Dumper.generateFileName();
-    await this.writeLockFile(backupFileName, options.appName);
-    if (import_worker_threads.isMainThread) {
-      const promise = this.dump({
-        groups: options.groups,
-        fileName: backupFileName,
-        appName: options.appName
-      }).finally(() => {
-        this.cleanLockFile(backupFileName, options.appName);
-        _Dumper.dumpTasks.delete(backupFileName);
-        this.app.noticeManager.notify("backup", { msg: "Done" });
-      });
-      _Dumper.dumpTasks.set(backupFileName, promise);
-    } else {
-      try {
-        await this.dump({
-          groups: options.groups,
-          fileName: backupFileName,
-          appName: options.appName
-        });
-      } catch (err) {
-        throw err;
-      } finally {
-        this.cleanLockFile(backupFileName, options.appName);
-      }
-    }
+    await this.writeLockFile(backupFileName, appName);
     return backupFileName;
   }
+  async runDumpTask(options) {
+    await this.dump({
+      groups: options.groups,
+      fileName: options.fileName,
+      appName: options.appName
+    });
+  }
   async dumpableCollectionsGroupByGroup() {
     return (0, import_lodash.default)(await this.dumpableCollections()).map((c) => import_lodash.default.pick(c, ["name", "group", "origin", "title", "isView", "inherits"])).groupBy("group").mapValues((items) => import_lodash.default.sortBy(items, (item) => item.name)).value();
   }

package/dist/server/model/AutoBackupModel.d.ts

@@ -0,0 +1,15 @@
+import { Model } from '@tachybase/database';
+export declare class AutoBackupModel extends Model {
+    id: number;
+    title: string;
+    startsOn: Date;
+    endsOn?: Date;
+    repeat: string;
+    enabled: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    allExecuted: number;
+    password: string;
+    dumpRules: string;
+    maxNumber: number;
+}

package/dist/server/model/AutoBackupModel.js

@@ -0,0 +1,29 @@
+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 AutoBackupModel_exports = {};
+__export(AutoBackupModel_exports, {
+  AutoBackupModel: () => AutoBackupModel
+});
+module.exports = __toCommonJS(AutoBackupModel_exports);
+var import_database = require("@tachybase/database");
+class AutoBackupModel extends import_database.Model {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AutoBackupModel
+});

package/dist/server/resourcers/backup-files.js

@@ -115,31 +115,45 @@ var backup_files_default = {
     async create(ctx, next) {
       var _a, _b;
       const data = ctx.request.body;
-      let taskId;
       const app = ctx.app;
       if (data.method === "worker" && !((_a = app.worker) == null ? void 0 : _a.available)) {
         ctx.throw(500, ctx.t("No worker thread", { ns: "worker-thread" }));
         return next();
       }
       let useWorker = data.method === "worker" || data.method === "priority" && ((_b = app.worker) == null ? void 0 : _b.available);
+      const dumper = new import_dumper.Dumper(ctx.app);
+      const taskId = await dumper.getLockFile(ctx.app.name);
       if (useWorker) {
-        try {
-          taskId = await app.worker.callPluginMethod({
-            plugin: import_server2.default,
-            method: "workerCreateBackUp",
-            params: {
-              dataTypes: data.dataTypes
-            },
-            // 目前限制方法并发为1
-            concurrency: 1
-          });
-          app.noticeManager.notify("backup", { level: "info", msg: ctx.t("Done") });
-        } catch (error) {
-          ctx.throw(500, ctx.t(error.message, { ns: "worker-thread" }));
-        }
+        app.worker.callPluginMethod({
+          plugin: import_server2.default,
+          method: "workerCreateBackUp",
+          params: {
+            dataTypes: data.dataTypes,
+            appName: ctx.app.name,
+            filename: taskId
+          },
+          // 目前限制方法并发为1
+          concurrency: 1
+        }).then((res) => {
+          app.noticeManager.notify("backup", { level: "info", msg: ctx.t("Done", { ns: "backup" }) });
+        }).catch((error) => {
+          app.noticeManager.notify("backup", { level: "error", msg: error.message });
+        }).finally(() => {
+          dumper.cleanLockFile(taskId, ctx.app.name);
+        });
       } else {
         const plugin = app.pm.get(import_server2.default);
-        taskId = await plugin.workerCreateBackUp(data);
+        plugin.workerCreateBackUp({
+          dataTypes: data.dataTypes,
+          appName: ctx.app.name,
+          filename: taskId
+        }).then((res) => {
+          app.noticeManager.notify("backup", { level: "info", msg: ctx.t("Done", { ns: "backup" }) });
+        }).catch((error) => {
+          app.noticeManager.notify("backup", { level: "error", msg: error.message });
+        }).finally(() => {
+          dumper.cleanLockFile(taskId, ctx.app.name);
+        });
       }
       ctx.body = {
         key: taskId

package/dist/server/server.d.ts

@@ -1,8 +1,19 @@
 import { Plugin } from '@tachybase/server';
+import { AutoBackupModel } from './model/AutoBackupModel';
 export default class PluginBackupRestoreServer extends Plugin {
+    private static readonly inspectFields;
     beforeLoad(): void;
+    private timers;
     load(): Promise<void>;
+    inspect(cronJobs: AutoBackupModel[]): void;
+    getNextTime(cronJob: AutoBackupModel, currentDate: Date, nextSecond?: boolean): number;
+    schedule(cronJob: AutoBackupModel, nextTime: number, toggle?: boolean): void;
+    trigger(cronJobId: number, time: number): Promise<void>;
+    on(cronJob: AutoBackupModel): void;
+    off(cronJob: AutoBackupModel): void;
     workerCreateBackUp(data: {
         dataTypes: string[];
-    }): Promise<string>;
+        appName: string;
+        filename: string;
+    }): Promise<void>;
 }

package/dist/server/server.js

@@ -31,23 +31,202 @@ __export(server_exports, {
 });
 module.exports = __toCommonJS(server_exports);
 var import_server = require("@tachybase/server");
+var import_cron_parser = __toESM(require("cron-parser"));
+var import_constants = require("../constants");
 var import_dumper = require("./dumper");
 var import_backup_files = __toESM(require("./resourcers/backup-files"));
-class PluginBackupRestoreServer extends import_server.Plugin {
+var import_files = require("./utils/files");
+function parseDateWithoutMs(date) {
+  return Math.floor(date.getTime() / 1e3) * 1e3;
+}
+const MAX_SAFE_INTERVAL = 2147483647;
+const _PluginBackupRestoreServer = class _PluginBackupRestoreServer extends import_server.Plugin {
+  constructor() {
+    super(...arguments);
+    this.timers = /* @__PURE__ */ new Map();
+  }
   beforeLoad() {
     this.app.acl.registerSnippet({
-      name: `pm.${this.name}`,
+      name: `pm.${this.name}.files`,
       actions: ["backupFiles:*"]
     });
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.auto`,
+      actions: ["autoBackup:*"]
+    });
   }
   async load() {
     this.app.resourcer.define(import_backup_files.default);
+    this.app.on("afterStart", async (app) => {
+      const cronJobs = await app.db.getRepository(import_constants.COLLECTION_AUTOBACKUP).find({
+        filter: { enabled: true }
+      });
+      this.inspect(cronJobs);
+    });
+    this.app.on("beforeStop", () => {
+      for (const timer of this.timers.values()) {
+        clearInterval(timer);
+      }
+    });
+    this.db.on(`${import_constants.COLLECTION_AUTOBACKUP}.beforeSave`, async (cronjob, options) => {
+      let changed = false;
+      for (const field of options.fields) {
+        if (_PluginBackupRestoreServer.inspectFields.includes(field)) {
+          changed = true;
+          break;
+        }
+      }
+      if (!changed) {
+        return;
+      }
+      this.off(cronjob);
+    });
+    this.db.on(`${import_constants.COLLECTION_AUTOBACKUP}.afterSave`, async (cronjob, options) => {
+      let changed = false;
+      for (const field of options.fields) {
+        if (_PluginBackupRestoreServer.inspectFields.includes(field)) {
+          changed = true;
+          break;
+        }
+      }
+      if (!changed) {
+        return;
+      }
+      if (cronjob.get("enabled")) {
+        this.on(cronjob);
+      }
+    });
+    this.db.on(`${import_constants.COLLECTION_AUTOBACKUP}.afterDestroy`, async (cronjob) => {
+      this.off(cronjob);
+    });
+  }
+  inspect(cronJobs) {
+    const now = /* @__PURE__ */ new Date();
+    cronJobs.forEach((cronJob) => {
+      const nextTime = this.getNextTime(cronJob, now);
+      if (nextTime) {
+        this.app.logger.info(
+          `cronJobs [${cronJob.id}] caching scheduled will run at: ${new Date(nextTime).toISOString()}`
+        );
+      } else {
+        this.app.logger.info(`cronJobs [${cronJob.id}] will not be scheduled`);
+      }
+      this.schedule(cronJob, nextTime, nextTime >= now.getTime());
+    });
+  }
+  getNextTime(cronJob, currentDate, nextSecond = false) {
+    currentDate.setMilliseconds(nextSecond ? 1e3 : 0);
+    const timestamp = currentDate.getTime();
+    const startTime = parseDateWithoutMs(cronJob.startsOn || /* @__PURE__ */ new Date());
+    if (startTime > timestamp) {
+      return startTime;
+    }
+    if (cronJob.repeat) {
+      const endTime = cronJob.endsOn ? parseDateWithoutMs(cronJob.endsOn) : null;
+      if (endTime && endTime < timestamp) {
+        return null;
+      }
+      if (cronJob.repeat && isNaN(+cronJob.repeat)) {
+        const interval = import_cron_parser.default.parseExpression(cronJob.repeat, { currentDate });
+        const next = interval.next();
+        return next.getTime();
+      } else if (!isNaN(+cronJob.repeat)) {
+        const repeat = +cronJob.repeat;
+        const next = timestamp + repeat - (timestamp - startTime) % repeat;
+        return next;
+      } else {
+        return null;
+      }
+    } else {
+      if (startTime < timestamp) {
+        return null;
+      }
+      return timestamp;
+    }
+  }
+  schedule(cronJob, nextTime, toggle = true) {
+    if (toggle) {
+      const key = `${cronJob.id}@${nextTime}`;
+      if (!this.timers.has(key)) {
+        const interval = Math.max(nextTime - Date.now(), 0);
+        if (interval > MAX_SAFE_INTERVAL) {
+          this.timers.set(
+            key,
+            setTimeout(() => {
+              this.timers.delete(key);
+              this.schedule(cronJob, nextTime);
+            }, MAX_SAFE_INTERVAL)
+          );
+        } else {
+          this.timers.set(key, setTimeout(this.trigger.bind(this, cronJob.id, nextTime), interval));
+        }
+      }
+    } else {
+      for (const [key, timer] of this.timers.entries()) {
+        if (key.startsWith(`${cronJob.id}@`)) {
+          clearTimeout(timer);
+          this.timers.delete(key);
+        }
+      }
+    }
+  }
+  async trigger(cronJobId, time) {
+    try {
+      const cronJob = await this.db.getRepository(import_constants.COLLECTION_AUTOBACKUP).findOne({ filterByTk: cronJobId });
+      if (!cronJob) {
+        this.app.logger.warn(`Scheduled cron job ${cronJobId} no longer exists`);
+        const eventKey2 = `${cronJobId}@${time}`;
+        this.timers.delete(eventKey2);
+        return;
+      }
+      const eventKey = `${cronJob.id}@${time}`;
+      this.timers.delete(eventKey);
+      try {
+        const dumper = new import_dumper.Dumper(this.app);
+        const filename = await dumper.getLockFile(this.app.name);
+        this.app.worker.callPluginMethod({
+          plugin: _PluginBackupRestoreServer,
+          method: "workerCreateBackUp",
+          params: {
+            dataTypes: cronJob.dumpRules,
+            appName: this.app.name,
+            filename
+          },
+          // 目前限制方法并发为1
+          concurrency: 1
+        }).finally(() => {
+          dumper.cleanLockFile(filename, this.app.name);
+          const dirPath = dumper.backUpStorageDir(this.app.name);
+          (0, import_files.cleanOldFiles)(dumper.backUpStorageDir(this.app.name), cronJob.maxNumber).then(() => {
+            this.app.logger.info(`clean backup ${dirPath} to count: {cronJob.maxNumber}`);
+          }).catch((err) => {
+            this.app.logger.error("clean backup error", err);
+          });
+        });
+      } catch (e) {
+        this.app.logger.error(e);
+      }
+      const nextTime = this.getNextTime(cronJob, /* @__PURE__ */ new Date(), true);
+      if (nextTime) {
+        this.schedule(cronJob, nextTime);
+      }
+    } catch (e) {
+      this.app.logger.error(`cronJobs [${cronJobId}] failed: ${e.message}`);
+    }
+  }
+  on(cronJob) {
+    this.inspect([cronJob]);
+  }
+  off(cronJob) {
+    this.schedule(cronJob, null, false);
   }
   async workerCreateBackUp(data) {
-    const dumper = new import_dumper.Dumper(this.app);
-    return dumper.runDumpTask({
+    await new import_dumper.Dumper(this.app).runDumpTask({
       groups: new Set(data.dataTypes),
-      appName: this.app.name
+      appName: data.appName,
+      fileName: data.filename
     });
   }
-}
+};
+_PluginBackupRestoreServer.inspectFields = ["repeat", "enabled"];
+let PluginBackupRestoreServer = _PluginBackupRestoreServer;

package/dist/server/utils/files.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 清理指定目录中旧的 .tbdump 文件，仅保留最新的 maxNumber 个文件
+ * @param dirPath 目标目录路径
+ * @param maxNumber 要保留的最新文件数量
+ */
+export declare function cleanOldFiles(dirPath: string, maxNumber: number): Promise<void>;

package/dist/server/utils/files.js

@@ -0,0 +1,59 @@
+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 files_exports = {};
+__export(files_exports, {
+  cleanOldFiles: () => cleanOldFiles
+});
+module.exports = __toCommonJS(files_exports);
+var import_promises = require("node:fs/promises");
+var import_path = __toESM(require("path"));
+async function cleanOldFiles(dirPath, maxNumber) {
+  const names = await (0, import_promises.readdir)(dirPath);
+  const files = await Promise.all(
+    names.map(async (name) => {
+      const filePath = import_path.default.join(dirPath, name);
+      try {
+        const info = await (0, import_promises.stat)(filePath);
+        if (info.isFile() && import_path.default.extname(name) === ".tbdump") {
+          return { name, mtime: info.mtime };
+        }
+      } catch (err) {
+        return null;
+      }
+      return null;
+    })
+  );
+  const validFiles = files.filter(Boolean);
+  validFiles.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  const toDelete = validFiles.slice(maxNumber).map((f) => f.name);
+  await Promise.all(toDelete.map((name) => (0, import_promises.unlink)(import_path.default.join(dirPath, name))));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanOldFiles
+});