@datatruck/cli 0.28.0 → 0.29.0

package/Action/BackupAction.d.ts

@@ -1,5 +1,6 @@
 import type { ConfigType } from "../Config/Config";
 import { PackageConfigType } from "../Config/PackageConfig";
+import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { PreSnapshot } from "../Repository/RepositoryAbstract";
 import { DataFormat } from "../utils/DataFormat";
 import { Listr3TaskResultEnd } from "../utils/list";
@@ -8,7 +9,7 @@ import { Streams } from "../utils/stream";
 import { IfRequireKeys } from "../utils/ts";
 export type BackupActionOptions = {
     repositoryNames?: string[];
-    repositoryTypes?: string[];
+    repositoryTypes?: RepositoryConfigType["type"][];
     packageNames?: string[];
     packageTaskNames?: string[];
     tags?: string[];
@@ -19,11 +20,16 @@ export type BackupActionOptions = {
     progress?: "auto" | "interval" | boolean;
     progressInterval?: number;
     streams?: Streams;
+    prune?: boolean;
 };
 type Context = {
     snapshot: {
         id: string;
     };
+    prune: {
+        total: number;
+        pruned: number;
+    };
     task: {
         taskName: string;
         packageName: string;

package/Action/BackupAction.js

@@ -18,6 +18,7 @@ const temp_1 = require("../utils/temp");
 const assert_1 = require("assert");
 const chalk_1 = __importDefault(require("chalk"));
 const crypto_1 = require("crypto");
+const dayjs_1 = __importDefault(require("dayjs"));
 class BackupAction {
     config;
     options;
@@ -33,9 +34,12 @@ class BackupAction {
         });
     }
     prepareSnapshot() {
+        const date = this.options.date ?? new Date().toISOString();
+        if (!(0, dayjs_1.default)(date, "YYYY-MM-DDTHH:mm:ss.SSS[Z]", true).isValid())
+            throw new Error(`Invalid snapshot date: ${date}`);
         return {
             id: (0, crypto_1.randomUUID)().replaceAll("-", ""),
-            date: this.options.date ?? new Date().toISOString(),
+            date,
         };
     }
     getPackages(snapshot) {
@@ -102,21 +106,28 @@ class BackupAction {
             let title = item.key.slice(0, 1).toUpperCase() + item.key.slice(1);
             return item.key === "backup" && color ? chalk_1.default.cyan(title) : title;
         };
-        const renderData = (item, color) => {
+        const renderData = (item, color, result = []) => {
             const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
-            return item.key === "snapshot"
-                ? item.data.id
-                : item.key === "task"
-                    ? `${item.data.packageName} ${g(item.data.taskName)}`
-                    : item.key === "backup"
-                        ? `${item.data.packageName} ${g(item.data.repositoryName)}`
-                        : item.key === "copy"
-                            ? `${item.data.packageName} ${g(item.data.mirrorRepositoryName)}`
-                            : item.key === "summary"
-                                ? `Errors: ${item.data.errors}`
-                                : item.key === "report"
-                                    ? item.data.type
-                                    : "";
+            return item.key === "prune"
+                ? `${item.data.pruned}/${item.data.total}`
+                : item.key === "snapshot"
+                    ? item.data.id
+                    : item.key === "task"
+                        ? `${item.data.packageName} ${g(item.data.taskName)}`
+                        : item.key === "backup"
+                            ? `${item.data.packageName} ${g(item.data.repositoryName)}`
+                            : item.key === "copy"
+                                ? `${item.data.packageName} ${g(item.data.mirrorRepositoryName)}`
+                                : item.key === "summary"
+                                    ? (0, cli_1.renderObject)({
+                                        errors: item.data.errors,
+                                        backups: result.filter((r) => !r.error && r.key === "backup")
+                                            .length,
+                                        copies: result.filter((r) => !r.error && r.key === "copy").length,
+                                    })
+                                    : item.key === "report"
+                                        ? item.data.type
+                                        : "";
         };
         return new DataFormat_1.DataFormat({
             streams: options.streams,
@@ -124,9 +135,9 @@ class BackupAction {
             list: () => result
                 .filter((item) => item.key !== "cleanup")
                 .map((item) => {
-                const icon = (0, cli_1.resultColumn)(item.error, false);
+                const icon = (0, cli_1.renderResult)(item.error, false);
                 const title = renderTitle(item);
-                const data = renderData(item, false);
+                const data = renderData(item, false, result);
                 return `${icon} ${title}: ${data}`;
             }),
             table: {
@@ -140,11 +151,11 @@ class BackupAction {
                 rows: () => result
                     .filter((item) => item.key !== "cleanup")
                     .map((item) => [
-                    (0, cli_1.resultColumn)(item.error),
+                    (0, cli_1.renderResult)(item.error),
                     renderTitle(item, true),
                     renderData(item, true),
                     (0, date_1.duration)(item.elapsed),
-                    (0, cli_1.errorColumn)(item.error, options.verbose),
+                    (0, cli_1.renderError)(item.error, options.verbose),
                 ]),
             },
         });
@@ -162,164 +173,169 @@ class BackupAction {
             progressManager: pm,
         });
         return l
-            .add(l.$tasks({
-            key: "snapshot",
-            data: { id: "" },
-            exitOnError: false,
-            title: {
-                initial: "Prepare snapshots",
-                started: "Preparing snapshots",
-                failed: "Snapshots prepare failed",
-            },
-            run: async (task, data) => {
-                const { minFreeDiskSpace } = this.config;
-                if (minFreeDiskSpace)
-                    await (0, temp_1.ensureFreeDiskTempSpace)(minFreeDiskSpace);
-                const snapshot = this.prepareSnapshot();
-                const packages = this.getPackages(snapshot);
-                const snapshotId = (data.id = snapshot.id.slice(0, 8));
-                task.title = `Snapshots prepared: ${snapshotId} (${packages.length} packages)`;
-                return packages.flatMap((pkg) => {
-                    let taskResult = {};
-                    const gc = new temp_1.GargabeCollector();
-                    const repositories = this.getRepositoryNames(pkg.repositoryNames ?? []);
-                    const mirrorRepositories = repositories
-                        .filter((r) => r.mirrors.length)
-                        .flatMap(({ name, mirrors }) => mirrors.map((mirror) => ({ name, mirror })));
-                    return l.$tasks(!!pkg.task &&
-                        l.$task({
-                            key: "task",
-                            keyIndex: pkg.name,
-                            data: { taskName: pkg.task.name, packageName: pkg.name },
-                            title: {
-                                initial: `Execute task: ${pkg.task?.name}`,
-                                started: `Executing task: ${pkg.task?.name}`,
-                                failed: `Task execute failed: ${pkg.task?.name}`,
-                                completed: `Task executed: ${pkg.task?.name}`,
-                            },
-                            exitOnError: false,
-                            runWrapper: gc.cleanupIfFail.bind(gc),
-                            run: async (task) => {
-                                taskResult = await (0, TaskFactory_1.createTask)(pkg.task).backup({
-                                    options,
-                                    package: pkg,
-                                    snapshot,
-                                    onProgress: (p) => pm.update(p, (t) => (task.output = t)),
-                                });
-                            },
-                        }), ...repositories.map(({ name: repositoryName }) => l.$task({
-                        key: "backup",
-                        keyIndex: [pkg.name, repositoryName],
-                        data: {
-                            packageName: pkg.name,
-                            repositoryName: repositoryName,
-                        },
-                        title: {
-                            initial: `Create backup: ${repositoryName}`,
-                            started: `Creating backup: ${repositoryName}`,
-                            completed: `Backup created: ${repositoryName}`,
-                            failed: `Backup create failed: ${repositoryName}`,
-                        },
-                        exitOnError: false,
-                        runWrapper: gc.cleanupOnFinish.bind(gc),
-                        run: async (task) => {
-                            const taskSummary = pkg.task
-                                ? l.result("task", pkg.name)
-                                : undefined;
-                            if (taskSummary?.error)
-                                throw new Error(`Task failed`);
-                            await this.backup({
-                                pkg,
-                                repositoryName,
-                                snapshot,
-                                snapshotPath: taskResult?.snapshotPath,
-                                onProgress: (p) => this.pm.update(p, (t) => (task.output = t)),
-                            });
-                        },
-                    })), l.$task({
-                        key: "cleanup",
-                        keyIndex: pkg.name,
-                        data: {},
-                        title: {
-                            initial: "Clean task files",
-                            started: "Cleaning task files",
-                            completed: "Task files cleaned",
-                            failed: "Task files clean failed",
-                        },
-                        exitOnError: false,
-                        enabled: gc.pending,
-                        run: () => gc.cleanup(),
-                    }), ...mirrorRepositories.map(({ name, mirror }) => l.$task({
-                        key: "copy",
-                        keyIndex: [pkg.name, mirror],
-                        data: {
-                            packageName: pkg.name,
-                            repositoryName: name,
-                            mirrorRepositoryName: mirror,
-                        },
-                        title: {
-                            initial: `Copy snapshot: ${mirror}`,
-                            started: `Copying snapshot: ${mirror}`,
-                            completed: `Snapshot copied: ${mirror}`,
-                            failed: `Snapshot copy failed: ${mirror}`,
-                        },
-                        exitOnError: false,
-                        runWrapper: gc.cleanup.bind(gc),
-                        run: async (task) => {
-                            const backupSummary = l.result("backup", [
-                                pkg.name,
-                                name,
-                            ]);
-                            if (backupSummary.error)
-                                throw new Error(`Backup failed`);
-                            await this.copy({
-                                repositoryName: name,
-                                mirrorRepositoryName: mirror,
-                                pkg,
-                                snapshot,
-                                onProgress: (p) => pm.update(p, (t) => (task.output = t)),
-                            });
-                        },
-                    })), ...(this.config.reports || []).map((report, index) => {
-                        const reportIndex = index + 1;
-                        return l.$task({
-                            title: {
-                                initial: `Send report ${reportIndex}`,
-                                started: `Sending report ${reportIndex}`,
-                                completed: `Report sent: ${reportIndex}`,
-                                failed: `Report send failed: ${reportIndex}`,
-                            },
-                            key: "report",
-                            keyIndex: index,
-                            data: { type: report.run.type },
-                            exitOnError: false,
-                            run: async (task) => {
-                                const result = l
-                                    .getResult()
-                                    .filter((r) => r.key !== "report");
-                                const success = result.every((r) => !r.error);
-                                const enabled = !report.when ||
-                                    (report.when === "success" && success) ||
-                                    (report.when === "error" && !success);
-                                if (!enabled)
-                                    return task.skip(`Report send skipped: ${reportIndex}`);
-                                const text = this.dataFormat(result).format(report.format ?? "list");
-                                await (0, steps_1.runSteps)(report.run, {
-                                    verbose: this.options.verbose,
-                                    process: { vars: { DTT_REPORT: text } },
-                                    telegram: { vars: { TEXT: text } },
-                                    node: {
-                                        vars: {
-                                            dtt: { report: text, result },
-                                        },
+            .add([
+            l.$task({
+                key: "snapshot",
+                data: { id: "" },
+                exitOnError: false,
+                title: {
+                    initial: "Prepare snapshots",
+                    started: "Preparing snapshots",
+                    failed: "Snapshots prepare failed",
+                },
+                run: async (task, data) => {
+                    const { minFreeDiskSpace } = this.config;
+                    if (minFreeDiskSpace)
+                        await (0, temp_1.ensureFreeDiskTempSpace)(minFreeDiskSpace);
+                    const snapshot = this.prepareSnapshot();
+                    const packages = this.getPackages(snapshot);
+                    const snapshotId = (data.id = snapshot.id.slice(0, 8));
+                    task.title = `Snapshots prepared: ${snapshotId} (${packages.length} packages)`;
+                    return [
+                        ...packages.flatMap((pkg) => {
+                            let taskResult = {};
+                            const gc = new temp_1.GargabeCollector();
+                            const repositories = this.getRepositoryNames(pkg.repositoryNames ?? []);
+                            const mirrorRepositories = repositories
+                                .filter((r) => r.mirrors.length)
+                                .flatMap(({ name, mirrors }) => mirrors.map((mirror) => ({ name, mirror })));
+                            return l.$tasks(!!pkg.task &&
+                                l.$task({
+                                    key: "task",
+                                    keyIndex: pkg.name,
+                                    data: { taskName: pkg.task.name, packageName: pkg.name },
+                                    title: {
+                                        initial: `Execute task: ${pkg.task?.name}`,
+                                        started: `Executing task: ${pkg.task?.name}`,
+                                        failed: `Task execute failed: ${pkg.task?.name}`,
+                                        completed: `Task executed: ${pkg.task?.name}`,
                                     },
-                                });
-                            },
-                        });
-                    }));
-                });
-            },
-        }))
+                                    exitOnError: false,
+                                    runWrapper: gc.cleanupIfFail.bind(gc),
+                                    run: async (task) => {
+                                        taskResult = await (0, TaskFactory_1.createTask)(pkg.task).backup({
+                                            options,
+                                            package: pkg,
+                                            snapshot,
+                                            onProgress: (p) => pm.update(p, (t) => (task.output = t)),
+                                        });
+                                    },
+                                }), ...repositories.map(({ name: repositoryName }) => l.$task({
+                                key: "backup",
+                                keyIndex: [pkg.name, repositoryName],
+                                data: {
+                                    packageName: pkg.name,
+                                    repositoryName: repositoryName,
+                                },
+                                title: {
+                                    initial: `Create backup: ${repositoryName}`,
+                                    started: `Creating backup: ${repositoryName}`,
+                                    completed: `Backup created: ${repositoryName}`,
+                                    failed: `Backup create failed: ${repositoryName}`,
+                                },
+                                exitOnError: false,
+                                runWrapper: gc.cleanupOnFinish.bind(gc),
+                                run: async (task) => {
+                                    const taskSummary = pkg.task
+                                        ? l.result("task", pkg.name)
+                                        : undefined;
+                                    if (taskSummary?.error)
+                                        throw new Error(`Task failed`);
+                                    await this.backup({
+                                        pkg,
+                                        repositoryName,
+                                        snapshot,
+                                        snapshotPath: taskResult?.snapshotPath,
+                                        onProgress: (p) => this.pm.update(p, (t) => (task.output = t)),
+                                    });
+                                },
+                            })), l.$task({
+                                key: "cleanup",
+                                keyIndex: pkg.name,
+                                data: {},
+                                title: {
+                                    initial: "Clean task files",
+                                    started: "Cleaning task files",
+                                    completed: "Task files cleaned",
+                                    failed: "Task files clean failed",
+                                },
+                                exitOnError: false,
+                                enabled: gc.pending,
+                                run: () => gc.cleanup(),
+                            }), ...mirrorRepositories.map(({ name, mirror }) => l.$task({
+                                key: "copy",
+                                keyIndex: [pkg.name, mirror],
+                                data: {
+                                    packageName: pkg.name,
+                                    repositoryName: name,
+                                    mirrorRepositoryName: mirror,
+                                },
+                                title: {
+                                    initial: `Copy snapshot: ${mirror}`,
+                                    started: `Copying snapshot: ${mirror}`,
+                                    completed: `Snapshot copied: ${mirror}`,
+                                    failed: `Snapshot copy failed: ${mirror}`,
+                                },
+                                exitOnError: false,
+                                runWrapper: gc.cleanup.bind(gc),
+                                run: async (task) => {
+                                    const backupSummary = l.result("backup", [
+                                        pkg.name,
+                                        name,
+                                    ]);
+                                    if (backupSummary.error)
+                                        throw new Error(`Backup failed`);
+                                    await this.copy({
+                                        repositoryName: name,
+                                        mirrorRepositoryName: mirror,
+                                        pkg,
+                                        snapshot,
+                                        onProgress: (p) => pm.update(p, (t) => (task.output = t)),
+                                    });
+                                },
+                            })));
+                        }),
+                        ...(this.config.reports || []).map((report, index) => {
+                            const reportIndex = index + 1;
+                            return l.$task({
+                                title: {
+                                    initial: `Send report ${reportIndex}`,
+                                    started: `Sending report ${reportIndex}`,
+                                    completed: `Report sent: ${reportIndex}`,
+                                    failed: `Report send failed: ${reportIndex}`,
+                                },
+                                key: "report",
+                                keyIndex: index,
+                                data: { type: report.run.type },
+                                exitOnError: false,
+                                run: async (task) => {
+                                    const result = l
+                                        .getResult()
+                                        .filter((r) => r.key !== "report");
+                                    const success = result.every((r) => !r.error);
+                                    const enabled = !report.when ||
+                                        (report.when === "success" && success) ||
+                                        (report.when === "error" && !success);
+                                    if (!enabled)
+                                        return task.skip(`Report send skipped: ${reportIndex}`);
+                                    const text = this.dataFormat(result).format(report.format ?? "list");
+                                    await (0, steps_1.runSteps)(report.run, {
+                                        verbose: this.options.verbose,
+                                        process: { vars: { DTT_REPORT: text } },
+                                        telegram: { vars: { TEXT: text } },
+                                        node: {
+                                            vars: {
+                                                dtt: { report: text, result },
+                                            },
+                                        },
+                                    });
+                                },
+                            });
+                        }),
+                    ];
+                },
+            }),
+        ])
             .exec();
     }
 }

package/Action/CopyAction.d.ts

@@ -5,7 +5,8 @@ import { Listr3TaskResultEnd } from "../utils/list";
 import { Streams } from "../utils/stream";
 import { IfRequireKeys } from "../utils/ts";
 export type CopyActionOptionsType = {
-    ids: string[];
+    ids?: string[];
+    last?: number;
     repositoryName: string;
     packageNames?: string[];
     packageTaskNames?: string[];
@@ -27,6 +28,7 @@ export type Context = {
         packageName: string;
         repositoryName: string;
         mirrorRepositoryName: string;
+        skipped: boolean;
     };
 };
 export declare class CopyAction<TRequired extends boolean = true> {

package/Action/CopyAction.js

@@ -8,6 +8,7 @@ const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
 const DataFormat_1 = require("../utils/DataFormat");
 const cli_1 = require("../utils/cli");
 const config_1 = require("../utils/datatruck/config");
+const snapshot_1 = require("../utils/datatruck/snapshot");
 const date_1 = require("../utils/date");
 const list_1 = require("../utils/list");
 const progress_1 = require("../utils/progress");
@@ -25,13 +26,22 @@ class CopyAction {
             let title = item.key.slice(0, 1).toUpperCase() + item.key.slice(1);
             return item.key === "copy" && color ? chalk_1.default.cyan(title) : title;
         };
-        const renderData = (item, color) => {
+        const renderData = (item, color, items = []) => {
             const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
             return item.key === "snapshots"
                 ? item.data.snapshots.length
                 : item.key === "copy"
-                    ? `${item.data.packageName} ${g(item.data.mirrorRepositoryName)}`
-                    : "";
+                    ? `${item.data.packageName} ${g([
+                        item.data.snapshotId.slice(0, 8),
+                        item.data.mirrorRepositoryName,
+                    ].join(" "))}`
+                    : item.key === "summary"
+                        ? (0, cli_1.renderObject)({
+                            errors: item.data.errors,
+                            copied: items.filter((i) => i.key === "copy" && !i.error && !i.data.skipped).length,
+                            skipped: items.filter((i) => i.key === "copy" && !i.error && i.data.skipped).length,
+                        })
+                        : "";
         };
         return new DataFormat_1.DataFormat({
             streams: options.streams,
@@ -45,11 +55,11 @@ class CopyAction {
                     { value: "Error", width: 50 },
                 ],
                 rows: () => result.map((item) => [
-                    (0, cli_1.resultColumn)(item.error),
+                    (0, cli_1.renderResult)(item.error),
                     renderTitle(item, true),
-                    renderData(item, true),
+                    renderData(item, true, result),
                     (0, date_1.duration)(item.elapsed),
-                    (0, cli_1.errorColumn)(item.error, options.verbose),
+                    (0, cli_1.renderError)(item.error, options.verbose),
                 ]),
             },
         });
@@ -78,13 +88,17 @@ class CopyAction {
                     await (0, temp_1.ensureFreeDiskTempSpace)(this.config.minFreeDiskSpace);
                 const sourceRepoConfig = (0, config_1.findRepositoryOrFail)(this.config, this.options.repositoryName);
                 const repo = (0, RepositoryFactory_1.createRepo)(sourceRepoConfig);
-                const snapshots = await repo.fetchSnapshots({
+                let snapshots = await repo.fetchSnapshots({
                     options: {
                         ids: this.options.ids,
                         packageNames: this.options.packageNames,
                         packageTaskNames: this.options.packageTaskNames,
                     },
                 });
+                if (this.options.last)
+                    snapshots = (0, snapshot_1.groupAndFilter)(snapshots, ["packageName"], {
+                        last: this.options.last,
+                    }).map(({ item }) => item);
                 data.snapshots = snapshots;
                 task.title = `Snapshots fetched: ${snapshots.length}`;
                 if (!snapshots.length)
@@ -97,45 +111,52 @@ class CopyAction {
                         .map((r) => r.name);
                 if (!repositoryNames2.length)
                     throw new Error("No mirror snapshots found");
-                return snapshots.flatMap((snapshot) => repositoryNames2.map((repo2) => l.$task({
-                    key: "copy",
-                    keyIndex: [snapshot.packageName, repo2],
-                    data: {
-                        snapshotId: snapshot.id,
-                        packageName: snapshot.packageName,
-                        repositoryName: sourceRepoConfig.name,
-                        mirrorRepositoryName: repo2,
-                    },
-                    title: {
-                        initial: `Copy snapshot: ${repo2}`,
-                        started: `Copying snapshot: ${repo2}`,
-                        completed: `Snapshot copied: ${repo2}`,
-                        failed: `Snapshot copy failed: ${repo2}`,
-                    },
-                    exitOnError: false,
-                    run: async (task) => {
-                        const mirrorConfig = (0, config_1.findRepositoryOrFail)(this.config, repo2);
-                        const mirrorRepo = (0, RepositoryFactory_1.createRepo)(mirrorConfig);
-                        (0, config_1.ensureSameRepositoryType)(sourceRepoConfig, mirrorConfig);
-                        const currentCopies = await mirrorRepo.fetchSnapshots({
-                            options: {
-                                ids: [snapshot.id],
-                                packageNames: [snapshot.packageName],
-                            },
-                        });
-                        if (currentCopies.length)
-                            return task.skip(`Already exists at ${mirrorConfig.name}`);
-                        if (this.config.minFreeDiskSpace)
-                            await mirrorRepo.ensureFreeDiskSpace(mirrorConfig.config, this.config.minFreeDiskSpace);
-                        await repo.copy({
-                            mirrorRepositoryConfig: mirrorConfig.config,
-                            options: { verbose: this.options.verbose },
-                            package: { name: snapshot.packageName },
-                            snapshot,
-                            onProgress: (p) => pm.update(p, (d) => (task.output = d)),
-                        });
-                    },
-                })));
+                return snapshots.flatMap((snapshot) => repositoryNames2.map((repo2) => {
+                    const id = snapshot.id.slice(0, 8);
+                    const pkgName = snapshot.packageName;
+                    return l.$task({
+                        key: "copy",
+                        keyIndex: [snapshot.packageName, repo2, snapshot.id],
+                        data: {
+                            snapshotId: snapshot.id,
+                            packageName: snapshot.packageName,
+                            repositoryName: sourceRepoConfig.name,
+                            mirrorRepositoryName: repo2,
+                            skipped: false,
+                        },
+                        title: {
+                            initial: `Copy snapshot: ${pkgName} (${id}) » ${repo2}`,
+                            started: `Copying snapshot: ${pkgName} (${id}) » ${repo2}`,
+                            completed: `Snapshot copied: ${pkgName} (${id}) » ${repo2}`,
+                            failed: `Snapshot copy failed: ${pkgName} (${id}) » ${repo2}`,
+                        },
+                        exitOnError: false,
+                        run: async (task, data) => {
+                            const mirrorConfig = (0, config_1.findRepositoryOrFail)(this.config, repo2);
+                            const mirrorRepo = (0, RepositoryFactory_1.createRepo)(mirrorConfig);
+                            (0, config_1.ensureSameRepositoryType)(sourceRepoConfig, mirrorConfig);
+                            const currentCopies = await mirrorRepo.fetchSnapshots({
+                                options: {
+                                    ids: [snapshot.id],
+                                    packageNames: [snapshot.packageName],
+                                },
+                            });
+                            if (currentCopies.length) {
+                                data.skipped = true;
+                                return task.skip(`Already exists at ${mirrorConfig.name}: ${pkgName} (${id})`);
+                            }
+                            if (this.config.minFreeDiskSpace)
+                                await mirrorRepo.ensureFreeDiskSpace(mirrorConfig.config, this.config.minFreeDiskSpace);
+                            await repo.copy({
+                                mirrorRepositoryConfig: mirrorConfig.config,
+                                options: { verbose: this.options.verbose },
+                                package: { name: snapshot.packageName },
+                                snapshot,
+                                onProgress: (p) => pm.update(p, (d) => (task.output = d)),
+                            });
+                        },
+                    });
+                }));
             },
         }))
             .exec();

package/Action/PruneAction.d.ts

@@ -1,20 +1,14 @@
 import type { ConfigType } from "../Config/Config";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { KeepObject } from "../utils/date";
 import { IfRequireKeys } from "../utils/ts";
 import { ExtendedSnapshot, SnapshotsActionOptions } from "./SnapshotsAction";
-export type PruneActionsOptions = {
+export type PruneActionsOptions = KeepObject & {
     ids?: string[];
     packageNames?: string[];
     repositoryNames?: string[];
     repositoryTypes?: RepositoryConfigType["type"][];
     tags?: string[];
-    keepLast?: number;
-    keepMinutely?: number;
-    keepHourly?: number;
-    keepDaily?: number;
-    keepWeekly?: number;
-    keepMonthly?: number;
-    keepYearly?: number;
     verbose?: boolean;
     groupBy?: SnapshotsActionOptions["groupBy"];
     dryRun?: boolean;