@datatruck/cli 0.26.2 → 0.28.0

package/Command/CommandAbstract.js

@@ -2,12 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandAbstract = void 0;
 const cli_1 = require("../utils/cli");
+const stream_1 = require("../utils/stream");
 class CommandAbstract {
     globalOptions;
     options;
-    constructor(globalOptions, options) {
+    streams;
+    constructor(globalOptions, options, streams = {}) {
         this.globalOptions = globalOptions;
         this.options = (0, cli_1.parseOptions)(options, this.onOptions());
+        this.streams = (0, stream_1.createStreams)(streams);
     }
     returnsOptions(options) {
         return options;

package/Command/ConfigCommand.d.ts

@@ -1,18 +1,15 @@
+import { ConfigAction } from "../Action/ConfigAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
-import { If } from "../utils/ts";
+import { If, Unwrap } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
-export type ConfigCommandOptionsType<TResolved = false> = {
+export type ConfigCommandOptions<TResolved = false> = {
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
     repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
 };
-export type ConfigCommandLogType = {
-    packageName: string;
-    repositoryNames: string[];
-    taskName: string | undefined;
-}[];
-export declare class ConfigCommand extends CommandAbstract<ConfigCommandOptionsType<false>, ConfigCommandOptionsType<true>> {
-    onOptions(): import("../utils/cli").OptionsType<ConfigCommandOptionsType<false>, ConfigCommandOptionsType<true>>;
+export type ConfigCommandResult = Unwrap<ConfigAction["exec"]>;
+export declare class ConfigCommand extends CommandAbstract<ConfigCommandOptions<false>, ConfigCommandOptions<true>> {
+    onOptions(): import("../utils/cli").OptionsType<ConfigCommandOptions<false>, ConfigCommandOptions<true>>;
     onExec(): Promise<number>;
 }

package/Command/ConfigCommand.js

@@ -32,8 +32,8 @@ class ConfigCommand extends CommandAbstract_1.CommandAbstract {
         });
     }
     async onExec() {
-        const config = await ConfigAction_1.ConfigAction.fromGlobalOptions(this.globalOptions);
-        const packages = (0, config_1.filterPackages)(config, {
+        const result = await ConfigAction_1.ConfigAction.fromGlobalOptionsWithPath(this.globalOptions);
+        const packages = (0, config_1.filterPackages)(result.data, {
             packageNames: this.options.package,
             packageTaskNames: this.options.packageTask,
             repositoryNames: this.options.repository,
@@ -45,22 +45,27 @@ class ConfigCommand extends CommandAbstract_1.CommandAbstract {
             taskName: pkg.task?.name,
         }));
         const dataFormat = new DataFormat_1.DataFormat({
-            items: summaryConfig,
+            streams: this.streams,
+            json: result,
             table: {
-                labels: ["Package", "Repository", "Task"],
-                handler: (item) => [
+                headers: [
+                    { value: "Package" },
+                    { value: "Repository" },
+                    { value: "Task" },
+                ],
+                rows: () => summaryConfig.map((item) => [
                     item.packageName,
                     item.repositoryNames.join(", "),
                     item.taskName ?? "",
-                ],
+                ]),
             },
         });
         if (this.globalOptions.outputFormat)
-            console.info(dataFormat.format(this.globalOptions.outputFormat, {
+            dataFormat.log(this.globalOptions.outputFormat, {
                 tpl: {
                     pkgNames: () => summaryConfig.map((i) => i.packageName).join(),
                 },
-            }));
+            });
         return 0;
     }
 }

package/Command/CopyCommand.d.ts

@@ -0,0 +1,15 @@
+import { CopyAction } from "../Action/CopyAction";
+import { If, Unwrap } from "../utils/ts";
+import { CommandAbstract } from "./CommandAbstract";
+export type CopyCommandOptionsType<TResolved = false> = {
+    id: If<TResolved, string[]>;
+    package?: If<TResolved, string[]>;
+    packageTask?: If<TResolved, string[]>;
+    repository: string;
+    repository2?: If<TResolved, string[]>;
+};
+export type CopyCommandResult = Unwrap<CopyAction["exec"]>;
+export declare class CopyCommand extends CommandAbstract<CopyCommandOptionsType<false>, CopyCommandOptionsType<true>> {
+    onOptions(): import("../utils/cli").OptionsType<CopyCommandOptionsType<false>, CopyCommandOptionsType<true>>;
+    onExec(): Promise<0 | 1>;
+}

package/Command/CopyCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyCommand = void 0;
+const ConfigAction_1 = require("../Action/ConfigAction");
+const CopyAction_1 = require("../Action/CopyAction");
+const string_1 = require("../utils/string");
+const CommandAbstract_1 = require("./CommandAbstract");
+class CopyCommand extends CommandAbstract_1.CommandAbstract {
+    onOptions() {
+        return this.returnsOptions({
+            id: {
+                option: "-i,--id <ids>",
+                description: "Filter by identifiers",
+                required: true,
+                parser: string_1.parseStringList,
+            },
+            package: {
+                option: "-p,--package <names>",
+                description: "Filter by package names",
+                parser: string_1.parseStringList,
+            },
+            packageTask: {
+                option: "-pt,--package-task <values>",
+                description: "Filter by task names",
+                parser: string_1.parseStringList,
+            },
+            repository: {
+                option: "-r,--repository <name>",
+                description: "Filter by repository name",
+                required: true,
+            },
+            repository2: {
+                option: "-r2,--repository2 <names>",
+                description: "Filter by repository names",
+                parser: string_1.parseStringList,
+            },
+        });
+    }
+    async onExec() {
+        const verbose = this.globalOptions.verbose ?? 0;
+        const config = await ConfigAction_1.ConfigAction.fromGlobalOptions(this.globalOptions);
+        const copy = new CopyAction_1.CopyAction(config, {
+            ids: this.options.id,
+            packageNames: this.options.package,
+            packageTaskNames: this.options.packageTask,
+            repositoryName: this.options.repository,
+            repositoryNames2: this.options.repository2,
+            verbose: verbose > 0,
+            tty: this.globalOptions.tty,
+            progress: this.globalOptions.progress,
+            progressInterval: this.globalOptions.progressInterval,
+        });
+        const result = await copy.exec();
+        if (this.globalOptions.outputFormat)
+            copy
+                .dataFormat(result, { streams: this.streams, verbose })
+                .log(this.globalOptions.outputFormat);
+        return result.some((item) => item.error) ? 1 : 0;
+    }
+}
+exports.CopyCommand = CopyCommand;

package/Command/InitCommand.d.ts

@@ -2,12 +2,12 @@ import { InitAction } from "../Action/InitAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
-export type InitCommandOptionsType<TResolved = false> = {
+export type InitCommandOptions<TResolved = false> = {
     repository?: If<TResolved, string[]>;
     repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
 };
-export type InitCommandLogType = Unwrap<InitAction["exec"]>;
-export declare class InitCommand extends CommandAbstract<InitCommandOptionsType<false>, InitCommandOptionsType<true>> {
-    onOptions(): import("../utils/cli").OptionsType<InitCommandOptionsType<false>, InitCommandOptionsType<true>>;
+export type InitCommandResult = Unwrap<InitAction["exec"]>;
+export declare class InitCommand extends CommandAbstract<InitCommandOptions<false>, InitCommandOptions<true>> {
+    onOptions(): import("../utils/cli").OptionsType<InitCommandOptions<false>, InitCommandOptions<true>>;
     onExec(): Promise<number>;
 }

package/Command/InitCommand.js

@@ -5,7 +5,6 @@ const ConfigAction_1 = require("../Action/ConfigAction");
 const InitAction_1 = require("../Action/InitAction");
 const DataFormat_1 = require("../utils/DataFormat");
 const cli_1 = require("../utils/cli");
-const object_1 = require("../utils/object");
 const string_1 = require("../utils/string");
 const CommandAbstract_1 = require("./CommandAbstract");
 class InitCommand extends CommandAbstract_1.CommandAbstract {
@@ -33,30 +32,27 @@ class InitCommand extends CommandAbstract_1.CommandAbstract {
         });
         const response = await init.exec();
         const dataFormat = new DataFormat_1.DataFormat({
-            items: response,
-            json: (item) => ({
-                ...item,
-                error: item.error ? (0, object_1.getErrorProperties)(item.error) : null,
-            }),
+            streams: this.streams,
+            json: response,
             table: {
-                labels: [
-                    "   ",
-                    "Repository name",
-                    "Repository type",
-                    "Repository source",
-                    "",
+                headers: [
+                    { value: "", width: 3 },
+                    { value: "Repository name" },
+                    { value: "Repository type" },
+                    { value: "Repository source" },
+                    { value: "Error", width: 50 },
                 ],
-                handler: (item) => [
+                rows: () => response.map((item) => [
                     (0, cli_1.resultColumn)(item.error),
                     item.repositoryName,
                     item.repositoryType,
                     item.repositorySource,
                     (0, cli_1.errorColumn)(item.error, verbose),
-                ],
+                ]),
             },
         });
         if (this.globalOptions.outputFormat)
-            console.info(dataFormat.format(this.globalOptions.outputFormat));
+            dataFormat.log(this.globalOptions.outputFormat);
         return 0;
     }
 }

package/Command/PruneCommand.d.ts

@@ -2,7 +2,7 @@ import { SnapshotGroupByType } from "../Action/SnapshotsAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
-export type PruneCommandOptionsType<TResolved = false> = {
+export type PruneCommandOptions<TResolved = false> = {
     id?: If<TResolved, string[]>;
     longId?: boolean;
     package?: If<TResolved, string[]>;
@@ -21,7 +21,7 @@ export type PruneCommandOptionsType<TResolved = false> = {
     showAll?: boolean;
     confirm?: boolean;
 };
-export declare class PruneCommand extends CommandAbstract<PruneCommandOptionsType<false>, PruneCommandOptionsType<true>> {
-    onOptions(): import("../utils/cli").OptionsType<PruneCommandOptionsType<false>, PruneCommandOptionsType<true>>;
+export declare class PruneCommand extends CommandAbstract<PruneCommandOptions<false>, PruneCommandOptions<true>> {
+    onOptions(): import("../utils/cli").OptionsType<PruneCommandOptions<false>, PruneCommandOptions<true>>;
     onExec(): Promise<number>;
 }

package/Command/PruneCommand.js

@@ -27,7 +27,7 @@ class PruneCommand extends CommandAbstract_1.CommandAbstract {
             },
             id: {
                 description: "Filter by snapshot id",
-                option: "-i,--id",
+                option: "-i,--id <snapshotId>",
                 parser: string_1.parseStringList,
             },
             keepMinutely: {
@@ -123,28 +123,29 @@ class PruneCommand extends CommandAbstract_1.CommandAbstract {
         });
         const pruneResult = await prune.exec();
         const dataFormat = new DataFormat_1.DataFormat({
-            items: pruneResult.snapshots,
+            streams: this.streams,
+            json: pruneResult,
             table: {
-                labels: [
-                    "Id.",
-                    "Date",
-                    "Package",
-                    "Repository",
-                    "Repository type",
-                    "Exclusion reasons",
+                headers: [
+                    { value: "Id.", width: (this.options.longId ? 32 : 8) + 2 },
+                    { value: "Date", width: 23 + 2 },
+                    { value: "Package" },
+                    { value: "Repository" },
+                    { value: "Repository type" },
+                    { value: "Exclusion reasons" },
                 ],
-                handler: (item) => [
+                rows: () => pruneResult.snapshots.map((item) => [
                     this.options.longId ? item.id : item.id.slice(0, 8),
                     item.date.replace("T", " ").replace("Z", ""),
                     item.packageName,
                     item.repositoryName,
                     item.repositoryType,
                     item.exclusionReasons?.join(", ") ?? "",
-                ],
+                ]),
             },
         });
         if (this.globalOptions.outputFormat)
-            console.info(dataFormat.format(this.globalOptions.outputFormat));
+            dataFormat.log(this.globalOptions.outputFormat);
         if (!this.options.confirm && !this.options.dryRun) {
             const answer = await (0, cli_1.confirm)(`Delete ${pruneResult.prune}/${pruneResult.total} snapshots?`);
             if (answer)

package/Command/RestoreCommand.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestoreCommand = void 0;
 const ConfigAction_1 = require("../Action/ConfigAction");
 const RestoreAction_1 = require("../Action/RestoreAction");
-const ConsoleSessionDriver_1 = require("../SessionDriver/ConsoleSessionDriver");
-const SqliteSessionDriver_1 = require("../SessionDriver/SqliteSessionDriver");
-const RestoreSessionManager_1 = require("../SessionManager/RestoreSessionManager");
 const string_1 = require("../utils/string");
 const CommandAbstract_1 = require("./CommandAbstract");
 class RestoreCommand extends CommandAbstract_1.CommandAbstract {
@@ -64,22 +61,17 @@ class RestoreCommand extends CommandAbstract_1.CommandAbstract {
             tags: this.options.tag,
             verbose: verbose > 0,
             restorePath: this.options.restorePath,
-        });
-        const sessionManager = new RestoreSessionManager_1.RestoreSessionManager({
-            driver: new SqliteSessionDriver_1.SqliteSessionDriver({
-                verbose: verbose > 1,
-            }),
-            altDrivers: [
-                new ConsoleSessionDriver_1.ConsoleSessionDriver({
-                    verbose: verbose > 0,
-                    progress: this.globalOptions.progress,
-                }),
-            ],
-            verbose: verbose > 1,
+            tty: this.globalOptions.tty,
+            progress: this.globalOptions.progress,
             progressInterval: this.globalOptions.progressInterval,
+            streams: this.streams,
         });
-        const result = await restore.exec(sessionManager);
-        return result.errors.length ? 1 : 0;
+        const result = await restore.exec();
+        if (this.globalOptions.outputFormat)
+            restore
+                .dataFormat(result, { streams: this.streams, verbose })
+                .log(this.globalOptions.outputFormat);
+        return result.some((item) => item.error) ? 1 : 0;
     }
 }
 exports.RestoreCommand = RestoreCommand;

package/Command/SnapshotsCommand.d.ts

@@ -2,7 +2,7 @@ import { SnapshotsAction } from "../Action/SnapshotsAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../utils/ts";
 import { CommandAbstract } from "./CommandAbstract";
-export type SnapshotsCommandOptionsType<TResolved = false> = {
+export type SnapshotsCommandOptions<TResolved = false> = {
     id?: If<TResolved, string[]>;
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
@@ -20,8 +20,8 @@ export type SnapshotsCommandOptionsType<TResolved = false> = {
     groupBy?: If<TResolved, SnapshotsAction["options"]["groupBy"]>;
     tag?: If<TResolved, string[]>;
 };
-export type SnapshotsCommandLogType = Unwrap<SnapshotsAction["exec"]>;
-export declare class SnapshotsCommand extends CommandAbstract<SnapshotsCommandOptionsType<false>, SnapshotsCommandOptionsType<true>> {
-    onOptions(): import("../utils/cli").OptionsType<SnapshotsCommandOptionsType<false>, SnapshotsCommandOptionsType<true>>;
+export type SnapshotsCommandResult = Unwrap<SnapshotsAction["exec"]>;
+export declare class SnapshotsCommand extends CommandAbstract<SnapshotsCommandOptions<false>, SnapshotsCommandOptions<true>> {
+    onOptions(): import("../utils/cli").OptionsType<SnapshotsCommandOptions<false>, SnapshotsCommandOptions<true>>;
     onExec(): Promise<number>;
 }

package/Command/SnapshotsCommand.js

@@ -9,7 +9,7 @@ const SnapshotsAction_1 = require("../Action/SnapshotsAction");
 const DataFormat_1 = require("../utils/DataFormat");
 const string_1 = require("../utils/string");
 const CommandAbstract_1 = require("./CommandAbstract");
-const pretty_bytes_1 = __importDefault(require("pretty-bytes"));
+const bytes_1 = __importDefault(require("bytes"));
 class SnapshotsCommand extends CommandAbstract_1.CommandAbstract {
     onOptions() {
         const groupByValues = [
@@ -122,36 +122,37 @@ class SnapshotsCommand extends CommandAbstract_1.CommandAbstract {
         });
         const items = await snapshots.exec();
         const dataFormat = new DataFormat_1.DataFormat({
-            items,
+            streams: this.streams,
+            json: items,
             table: {
-                labels: [
-                    "Id.",
-                    "Date",
-                    "Package",
-                    "Task",
-                    "Size",
-                    "Repository",
-                    "Repository type",
+                headers: [
+                    { value: "Id.", width: (this.options.longId ? 32 : 8) + 2 },
+                    { value: "Date", width: 23 + 2 },
+                    { value: "Package" },
+                    { value: "Task" },
+                    { value: "Size" },
+                    { value: "Repository" },
+                    { value: "Repository type" },
                 ],
-                handler: (item) => [
+                rows: () => items.map((item) => [
                     this.options.longId ? item.id : item.id.slice(0, 8),
                     item.date.replace("T", " ").replace("Z", ""),
                     item.packageName,
                     item.packageTaskName || "",
-                    (0, pretty_bytes_1.default)(item.size),
+                    (0, bytes_1.default)(item.size),
                     item.repositoryName,
                     item.repositoryType,
-                ],
+                ]),
             },
         });
         if (this.globalOptions.outputFormat)
-            console.info(dataFormat.format(this.globalOptions.outputFormat, {
+            dataFormat.log(this.globalOptions.outputFormat, {
                 tpl: {
                     sids: () => items.map((i) => i.id).join(),
                     ssids: () => items.map((i) => i.shortId).join(),
                     pkgNames: () => items.map((i) => i.packageName).join(),
                 },
-            }));
+            });
         return 0;
     }
 }

package/Command/StartServerCommand.d.ts

@@ -0,0 +1,6 @@
+import { CommandAbstract } from "./CommandAbstract";
+export type StartServerCommandOptions<TResolved = false> = {};
+export declare class StartServerCommand extends CommandAbstract<StartServerCommandOptions<false>, StartServerCommandOptions<true>> {
+    onOptions(): import("../utils/cli").OptionsType<StartServerCommandOptions<false>, StartServerCommandOptions<true>>;
+    onExec(): Promise<number>;
+}

package/Command/StartServerCommand.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartServerCommand = void 0;
+const ConfigAction_1 = require("../Action/ConfigAction");
+const server_1 = require("../utils/datatruck/server");
+const CommandAbstract_1 = require("./CommandAbstract");
+class StartServerCommand extends CommandAbstract_1.CommandAbstract {
+    onOptions() {
+        return this.returnsOptions({});
+    }
+    async onExec() {
+        const config = await ConfigAction_1.ConfigAction.fromGlobalOptions(this.globalOptions);
+        const server = (0, server_1.createDatatruckServer)(config.server || {});
+        const port = config.server?.listen?.port ?? 8888;
+        const address = config.server?.listen?.address ?? "127.0.0.1";
+        console.info(`Listening on http://${address}:${port}`);
+        await new Promise((resolve, reject) => {
+            server.listen(port, address);
+            server.on("error", reject);
+        });
+        return 0;
+    }
+}
+exports.StartServerCommand = StartServerCommand;

package/Config/Config.d.ts

@@ -1,9 +1,20 @@
+import { FormatType } from "../utils/DataFormat";
+import { DatatruckServerOptions } from "../utils/datatruck/server";
+import { Step } from "../utils/steps";
 import { PackageConfigType } from "./PackageConfig";
 import { RepositoryConfigType } from "./RepositoryConfig";
 import type { JSONSchema7 } from "json-schema";
 export type ConfigType = {
     tempDir?: string;
+    minFreeDiskSpace?: string | number;
     repositories: RepositoryConfigType[];
     packages: PackageConfigType[];
+    server?: DatatruckServerOptions;
+    reports?: ReportConfig[];
+};
+export type ReportConfig = {
+    when?: "success" | "error";
+    format?: Exclude<FormatType, "custom" | "tpl">;
+    run: Step;
 };
 export declare const configDefinition: JSONSchema7;

package/Config/Config.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configDefinition = void 0;
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
+const ScriptTask_1 = require("../Task/ScriptTask");
+const DataFormat_1 = require("../utils/DataFormat");
 exports.configDefinition = {
     type: "object",
     required: ["repositories", "packages"],
@@ -9,6 +11,21 @@ exports.configDefinition = {
     properties: {
         $schema: { type: "string" },
         tempDir: { type: "string" },
+        minFreeDiskSpace: { anyOf: [{ type: "integer" }, { type: "string" }] },
+        reports: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    when: { enum: ["success", "error"] },
+                    format: {
+                        enum: DataFormat_1.dataFormats.filter((f) => !["custom", "tpl"].includes(f)),
+                    },
+                    run: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.scriptTask, ScriptTask_1.ScriptTaskDefinitionEnum.step),
+                },
+            },
+        },
         repositories: {
             type: "array",
             items: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.repository),
@@ -17,5 +34,31 @@ exports.configDefinition = {
             type: "array",
             items: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.package),
         },
+        server: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                path: { type: "string" },
+                users: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            name: { type: "string" },
+                            password: { type: "string" },
+                        },
+                    },
+                },
+                listen: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        port: { type: "integer" },
+                        address: { type: "string" },
+                    },
+                },
+            },
+        },
     },
 };

package/Config/PrunePolicyConfig.d.ts

@@ -1,4 +1,4 @@
-import { PruneActionsOptionsType } from "../Action/PruneAction";
+import { PruneActionsOptions } from "../Action/PruneAction";
 import { JSONSchema7 } from "json-schema";
 export declare const prunePolicyConfigDefinition: JSONSchema7;
-export type PrunePolicyConfigType = Pick<PruneActionsOptionsType, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;
+export type PrunePolicyConfigType = Pick<PruneActionsOptions, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;

package/Factory/CommandFactory.d.ts

@@ -1,49 +1,45 @@
-import { CleanCacheActionOptionsType } from "../Action/CleanCacheAction";
-import { BackupCommandOptionsType } from "../Command/BackupCommand";
-import { BackupSessionsCommandOptionsType } from "../Command/BackupSessionsCommand";
-import { CleanCacheCommand } from "../Command/CleanCacheCommand";
-import { GlobalOptionsType } from "../Command/CommandAbstract";
-import { ConfigCommandLogType, ConfigCommandOptionsType } from "../Command/ConfigCommand";
-import { InitCommandLogType, InitCommandOptionsType } from "../Command/InitCommand";
-import { PruneCommandOptionsType } from "../Command/PruneCommand";
+import { CleanCacheActionOptions } from "../Action/CleanCacheAction";
+import { BackupCommandOptions, BackupCommandResult } from "../Command/BackupCommand";
+import { GlobalOptions } from "../Command/CommandAbstract";
+import { ConfigCommandResult, ConfigCommandOptions } from "../Command/ConfigCommand";
+import { CopyCommandOptionsType } from "../Command/CopyCommand";
+import { InitCommandResult, InitCommandOptions } from "../Command/InitCommand";
+import { PruneCommandOptions } from "../Command/PruneCommand";
 import { RestoreCommandOptionsType } from "../Command/RestoreCommand";
-import { RestoreSessionsCommandOptionsType } from "../Command/RestoreSessionsCommand";
-import { SnapshotsCommandLogType, SnapshotsCommandOptionsType } from "../Command/SnapshotsCommand";
+import { SnapshotsCommandResult, SnapshotsCommandOptions } from "../Command/SnapshotsCommand";
+import { StartServerCommand, StartServerCommandOptions } from "../Command/StartServerCommand";
+import { Streams } from "../utils/stream";
 export declare enum CommandEnum {
     config = "config",
     init = "init",
     snapshots = "snapshots",
     prune = "prune",
     backup = "backup",
-    backupSessions = "backup-sessions",
     restore = "restore",
-    restoreSessions = "restore-sessions",
-    cleanCache = "clean-cache"
+    copy = "copy",
+    cleanCache = "clean-cache",
+    startServer = "start-server"
 }
 export type OptionsMapType = {
-    [CommandEnum.config]: ConfigCommandOptionsType;
-    [CommandEnum.init]: InitCommandOptionsType;
-    [CommandEnum.snapshots]: SnapshotsCommandOptionsType;
-    [CommandEnum.prune]: PruneCommandOptionsType;
-    [CommandEnum.backup]: BackupCommandOptionsType;
-    [CommandEnum.backupSessions]: BackupSessionsCommandOptionsType;
+    [CommandEnum.config]: ConfigCommandOptions;
+    [CommandEnum.init]: InitCommandOptions;
+    [CommandEnum.snapshots]: SnapshotsCommandOptions;
+    [CommandEnum.prune]: PruneCommandOptions;
+    [CommandEnum.backup]: BackupCommandOptions;
     [CommandEnum.restore]: RestoreCommandOptionsType;
-    [CommandEnum.restoreSessions]: RestoreSessionsCommandOptionsType;
-    [CommandEnum.cleanCache]: CleanCacheActionOptionsType;
+    [CommandEnum.copy]: CopyCommandOptionsType;
+    [CommandEnum.cleanCache]: CleanCacheActionOptions;
+    [CommandEnum.startServer]: StartServerCommandOptions;
 };
 export type LogMapType = {
-    [CommandEnum.config]: ConfigCommandLogType;
-    [CommandEnum.init]: InitCommandLogType;
-    [CommandEnum.snapshots]: SnapshotsCommandLogType;
+    [CommandEnum.config]: ConfigCommandResult;
+    [CommandEnum.init]: InitCommandResult;
+    [CommandEnum.snapshots]: SnapshotsCommandResult;
+    [CommandEnum.backup]: BackupCommandResult;
 };
-export declare function CommandFactory<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptionsType<false>, options: OptionsMapType[TCommand]): CleanCacheCommand;
-export declare function exec<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptionsType<false>, options: OptionsMapType[TCommand]): Promise<number>;
-export declare function createActionInterface(globalOptions: GlobalOptionsType<false>): {
+export declare function CommandFactory<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMapType[TCommand], streams?: Partial<Streams>): StartServerCommand;
+export declare function exec<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMapType[TCommand], streams?: Partial<Streams>): Promise<number>;
+export declare function createActionInterface(globalOptions: GlobalOptions<true>): {
     [K in keyof OptionsMapType as `${K}`]: (options: OptionsMapType[K]) => Promise<K extends keyof LogMapType ? LogMapType[K] : never>;
 };
-export declare function runAndParse<TCommand extends keyof LogMapType>(type: TCommand, run: () => Promise<any>): Promise<{
-    exitCode: any;
-    log: LogMapType[TCommand];
-}>;
-export declare function makeParseLog<TCommand extends keyof LogMapType>(type: TCommand): () => LogMapType[TCommand];
-export declare function CommandConstructorFactory(type: CommandEnum): typeof CleanCacheCommand;
+export declare function CommandConstructorFactory(type: CommandEnum): typeof StartServerCommand;