@datatruck/cli 0.36.7 → 0.37.0

package/lib/commands/RunCommand.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunCommand = void 0;
+const ConfigAction_1 = require("../actions/ConfigAction");
+const job_1 = require("../utils/datatruck/job");
+const error_1 = require("../utils/error");
+const CommandAbstract_1 = require("./CommandAbstract");
+class RunCommand extends CommandAbstract_1.CommandAbstract {
+    optionsConfig() {
+        return this.castOptionsConfig({
+            jobName: {
+                description: "Job name",
+                required: true,
+            },
+        });
+    }
+    async exec() {
+        const config = await ConfigAction_1.ConfigAction.fromGlobalOptionsWithPath(this.globalOptions);
+        const verbose = !!this.globalOptions.verbose;
+        const log = config.data.server?.log ?? true;
+        const jobs = config.data.jobs || {};
+        const jobName = this.options.jobName;
+        const job = jobs[jobName];
+        if (!job)
+            throw new error_1.AppError(`Job not found: ${jobName}`);
+        await (0, job_1.runJob)(job, jobName, {
+            log,
+            verbose: verbose,
+            configPath: config.path,
+            logPath: config.data.server?.cron?.logPath,
+        });
+        return { exitCode: 0 };
+    }
+}
+exports.RunCommand = RunCommand;

package/lib/commands/StartServerCommand.js

@@ -13,13 +13,14 @@ class StartServerCommand extends CommandAbstract_1.CommandAbstract {
     }
     async exec() {
         const config = await ConfigAction_1.ConfigAction.fromGlobalOptions(this.globalOptions);
+        const configPath = this.configPath;
         const verbose = !!this.globalOptions.verbose;
         const log = config.server?.log ?? true;
         const repositoryOptions = config.server?.repository || {};
         if (repositoryOptions.enabled ?? true) {
             const server = (0, repository_server_1.createDatatruckRepositoryServer)(repositoryOptions, {
+                configPath,
                 log,
-                configPath: this.configPath,
             });
             const port = repositoryOptions.listen?.port ?? 8888;
             const address = repositoryOptions.listen?.address ?? "127.0.0.1";
@@ -31,24 +32,23 @@ class StartServerCommand extends CommandAbstract_1.CommandAbstract {
             server.listen(port, address);
         }
         const cronOptions = config.server?.cron || {};
-        const cronJobs = cronOptions.actions || [];
+        const logPath = config.server?.cron?.logPath;
         if (cronOptions.enabled ?? true) {
-            if (typeof this.configPath !== "string")
+            if (typeof configPath !== "string")
                 throw new error_1.AppError(`Config path is required by cron server`);
-            const server = (0, cron_server_1.createCronServer)(cronOptions, {
+            const server = await (0, cron_server_1.createCronServer)({
+                configPath,
                 verbose,
                 log,
-                configPath: this.configPath,
+                logPath,
             });
             server.start();
-            (0, cli_1.logJson)("cron-server", `server started`, {
-                jobs: cronJobs.length,
-            });
+            (0, cli_1.logJson)("cron-server", `server started`);
         }
-        process.on("SIGINT", () => process.exit(1));
-        process.on("SIGTERM", () => process.exit(1));
-        await new Promise(() => setInterval(() => { }, 60000));
-        return { exitCode: 0 };
+        const exitCode = await new Promise((resolve) => {
+            process.on("SIGINT", () => resolve(1)).on("SIGTERM", () => resolve(1));
+        });
+        return { exitCode };
     }
 }
 exports.StartServerCommand = StartServerCommand;

package/lib/utils/cli.d.ts

@@ -5,7 +5,7 @@ export declare const showCursorCommand = "\u001B[?25h";
 export declare function renderProgressBar(progress: number, size?: number, subprogress?: number): string;
 export declare function logExec(command: string, argv?: string[], env?: NodeJS.ProcessEnv, logToStderr?: boolean): void;
 export declare function renderResult(error: Error | null | string | boolean | undefined, color?: boolean): string;
-export declare function renderError(error: Error | null | string | undefined, verbose?: number): string;
+export declare function renderError(error: Error | null | string | undefined, index?: number): string;
 export declare function renderListTaskItem<T extends Record<string, any>>(item: Listr3TaskResultEnd<T>, color: boolean | undefined, config: {
     [K in Listr3TaskResultEnd<T>["key"]]: (data: Extract<Listr3TaskResultEnd<T>, {
         key: K;
@@ -16,7 +16,7 @@ export type OptionsConfig<T1, T2 extends {
     [K in keyof T1]: unknown;
 }> = {
     [K in keyof Required<T1>]: {
-        option: string;
+        option?: string;
         description: string;
         required?: boolean;
         defaults?: Exclude<T1[K], undefined>;

package/lib/utils/cli.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logJson = exports.colorizeObject = exports.colorizeValue = exports.waitForStdDrain = exports.confirm = exports.stringifyOptions = exports.parseOptions = exports.renderObject = exports.renderListTaskItem = exports.renderError = exports.renderResult = exports.logExec = exports.renderProgressBar = exports.showCursorCommand = void 0;
-const error_1 = require("./error");
 const chalk_1 = __importDefault(require("chalk"));
 const chalk_2 = require("chalk");
 const readline_1 = require("readline");
@@ -59,20 +58,15 @@ function renderResult(error, color = true) {
             : "✓";
 }
 exports.renderResult = renderResult;
-function renderError(error, verbose) {
-    if (!error) {
+function renderError(error, index) {
+    if (!error)
         return "";
-    }
-    else if (error instanceof error_1.AppError) {
-        return chalk_1.default.red(verbose ? error.stack ?? error.message : error.message);
-    }
-    else if (error instanceof Error) {
-        return chalk_1.default.red(error.stack ?? error.message);
-    }
-    else {
-        const message = error.split(/\r?\n/).shift() ?? "";
-        return chalk_1.default.red(message.trim());
-    }
+    const message = error instanceof Error
+        ? error.message
+        : (error.split(/\r?\n/).shift() ?? "").trim();
+    return chalk_1.default.red(typeof index === "number" && index !== -1
+        ? `${index + 1}. ${message}`
+        : message);
 }
 exports.renderError = renderError;
 function renderListTaskItem(item, color, config) {
@@ -101,10 +95,14 @@ exports.renderObject = renderObject;
 function parseOptions(object, options) {
     const result = {};
     for (const key in options) {
-        const isNegative = options[key].option.startsWith("--no");
-        const defaultsValue = isNegative ? true : options[key].defaults;
+        const opt = options[key].option;
+        let defaultsValue;
+        let parser = options[key].parser;
+        if (typeof opt === "string") {
+            const isNegative = opt.startsWith("--no");
+            defaultsValue = isNegative ? true : options[key].defaults;
+        }
         const value = object?.[key] ?? defaultsValue;
-        const parser = options[key].parser;
         if (typeof value !== "undefined") {
             result[key] = parser ? parser(value) : value;
         }
@@ -114,22 +112,30 @@ function parseOptions(object, options) {
 exports.parseOptions = parseOptions;
 function stringifyOptions(options, object) {
     const result = [];
+    const prepend = [];
     for (const key in options) {
         const fullOpt = options[key].option;
-        const [opt] = fullOpt.split(",");
-        const isNegative = fullOpt.startsWith("--no");
-        const isBool = !fullOpt.includes("<") && !fullOpt.includes("[");
-        const defaultsValue = isNegative ? true : options[key].defaults;
-        const value = object?.[key] ?? defaultsValue;
-        if (isBool) {
-            if (object[key])
-                result.push(opt);
+        if (typeof fullOpt === "string") {
+            const [opt] = fullOpt.split(",");
+            const isNegative = fullOpt.startsWith("--no");
+            const isBool = !fullOpt.includes("<") && !fullOpt.includes("[");
+            const defaultsValue = isNegative ? true : options[key].defaults;
+            const value = object?.[key] ?? defaultsValue;
+            if (isBool) {
+                if (object[key])
+                    result.push(opt);
+            }
+            else if (value !== undefined) {
+                result.push(opt, `${value}`);
+            }
         }
-        else if (value !== undefined) {
-            result.push(opt, `${value}`);
+        else {
+            const value = object?.[key];
+            if (value !== undefined)
+                prepend.push(value);
         }
     }
-    return result;
+    return [...prepend, ...result];
 }
 exports.stringifyOptions = stringifyOptions;
 function confirm(message) {

package/lib/utils/datatruck/command.d.ts

@@ -6,6 +6,7 @@ import { CopyCommand } from "../../commands/CopyCommand";
 import { InitCommand } from "../../commands/InitCommand";
 import { PruneCommand } from "../../commands/PruneCommand";
 import { RestoreCommand } from "../../commands/RestoreCommand";
+import { RunCommand } from "../../commands/RunCommand";
 import { SnapshotsCommand } from "../../commands/SnapshotsCommand";
 import { StartServerCommand } from "../../commands/StartServerCommand";
 import { StdStreams } from "../stream";
@@ -16,6 +17,7 @@ export declare const datatruckCommandMap: {
     prune: typeof PruneCommand;
     backup: typeof BackupCommand;
     restore: typeof RestoreCommand;
+    run: typeof RunCommand;
     copy: typeof CopyCommand;
     cleanCache: typeof CleanCacheCommand;
     startServer: typeof StartServerCommand;
@@ -23,7 +25,7 @@ export declare const datatruckCommandMap: {
 export type DatatruckCommandMap = typeof datatruckCommandMap;
 export type InferDatatruckCommandOptions<T extends keyof DatatruckCommandMap> = InstanceType<DatatruckCommandMap[T]>["inputOptions"];
 export type InferDatatruckCommandResult<T extends keyof DatatruckCommandMap, R = Awaited<ReturnType<InstanceType<DatatruckCommandMap[T]>["exec"]>>> = "result" extends keyof R ? R["result"] : undefined;
-export declare function createCommand<T extends keyof DatatruckCommandMap>(name: T, globalOptions: GlobalOptions<true>, options: InferDatatruckCommandOptions<T>, streams?: Partial<StdStreams>, configPath?: string): BackupCommand | CopyCommand | PruneCommand | CleanCacheCommand | ConfigCommand | InitCommand | RestoreCommand | SnapshotsCommand | StartServerCommand;
+export declare function createCommand<T extends keyof DatatruckCommandMap>(name: T, globalOptions: GlobalOptions<true>, options: InferDatatruckCommandOptions<T>, streams?: Partial<StdStreams>, configPath?: string): BackupCommand | CopyCommand | PruneCommand | CleanCacheCommand | ConfigCommand | InitCommand | RestoreCommand | RunCommand | SnapshotsCommand | StartServerCommand;
 export declare function createCommands(globalOptions: GlobalOptions<true>): {
     [K in keyof DatatruckCommandMap as `${K}`]: (options: InferDatatruckCommandOptions<K>) => Promise<InferDatatruckCommandResult<K>>;
 };

package/lib/utils/datatruck/command.js

@@ -8,6 +8,7 @@ const CopyCommand_1 = require("../../commands/CopyCommand");
 const InitCommand_1 = require("../../commands/InitCommand");
 const PruneCommand_1 = require("../../commands/PruneCommand");
 const RestoreCommand_1 = require("../../commands/RestoreCommand");
+const RunCommand_1 = require("../../commands/RunCommand");
 const SnapshotsCommand_1 = require("../../commands/SnapshotsCommand");
 const StartServerCommand_1 = require("../../commands/StartServerCommand");
 const error_1 = require("../error");
@@ -19,6 +20,7 @@ exports.datatruckCommandMap = {
     prune: PruneCommand_1.PruneCommand,
     backup: BackupCommand_1.BackupCommand,
     restore: RestoreCommand_1.RestoreCommand,
+    run: RunCommand_1.RunCommand,
     copy: CopyCommand_1.CopyCommand,
     cleanCache: CleanCacheCommand_1.CleanCacheCommand,
     startServer: StartServerCommand_1.StartServerCommand,

package/lib/utils/datatruck/config-type.d.ts

@@ -5,6 +5,7 @@ import type { SpawnStep } from "../spawnSteps";
 import type { PackageRepositoryConfig, RepositoryConfigEnabledAction, RepositoryConfig } from "./config-repository-type";
 import type { TaskConfig } from "./config-task-type";
 import type { DatatruckCronServerOptions } from "./cron-server";
+import type { Job } from "./job";
 import type { DatatruckRepositoryServerOptions } from "./repository-server";
 export { RepositoryConfig, RepositoryConfigEnabledAction, TaskConfig };
 export type Config = {
@@ -15,6 +16,9 @@ export type Config = {
     repositories: RepositoryConfig[];
     packages: PackageConfig[];
     server?: DatatruckServerOptions;
+    jobs?: {
+        [name: string]: Job;
+    };
     reports?: DatatruckReportConfig[];
     prunePolicy?: DatatruckPolicyConfig;
 };

package/lib/utils/datatruck/cron-server.d.ts

@@ -1,44 +1,13 @@
-import { BackupCommandOptions } from "../../commands/BackupCommand";
-import { CopyCommandOptions } from "../../commands/CopyCommand";
-import { PruneCommandOptions } from "../../commands/PruneCommand";
-export type CronScheduleObject = {
-    minute?: number | {
-        each: number;
-    };
-    hour?: number | {
-        each: number;
-    };
-    day?: number | {
-        each: number;
-    };
-    month?: number | {
-        each: number;
-    };
-    weekDay?: number | {
-        each: number;
-    };
-};
-export type CronAction = {
-    schedule: string | CronScheduleObject;
-} & ({
-    name: "backup";
-    options: BackupCommandOptions;
-} | {
-    name: "copy";
-    options: CopyCommandOptions;
-} | {
-    name: "prune";
-    options: Omit<PruneCommandOptions, "confirm">;
-});
+import { JobConfig } from "./job";
+export declare const defaultsLogPath: string;
 export type DatatruckCronServerOptions = {
     enabled?: boolean;
-    actions?: CronAction[];
+    /**
+     * @default '/var/logs/datatruck'
+     */
+    logPath?: string | boolean;
 };
-export declare function createCronServer(options: DatatruckCronServerOptions, config: {
-    log: boolean;
-    verbose: boolean;
-    configPath: string;
-}): {
+export declare function createCronServer(options: JobConfig): Promise<{
     start: () => void;
     stop: () => void;
-};
+}>;

package/lib/utils/datatruck/cron-server.js

@@ -1,89 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCronServer = void 0;
+exports.createCronServer = exports.defaultsLogPath = void 0;
 const ConfigAction_1 = require("../../actions/ConfigAction");
-const async_process_1 = require("../async-process");
 const cli_1 = require("../cli");
 const cron_1 = require("../cron");
 const string_1 = require("../string");
 const watcher_1 = require("../watcher");
-const command_1 = require("./command");
+const job_1 = require("./job");
 const croner_1 = require("croner");
-function createJobs(actions, worker) {
-    const jobs = [];
-    for (const action of actions) {
-        const index = actions.indexOf(action);
-        jobs.push((0, croner_1.Cron)(typeof action.schedule === "string"
-            ? action.schedule
-            : (0, cron_1.formatCronScheduleObject)(action.schedule), {
-            paused: true,
-            context: index,
-            catch: true,
-            protect: true,
-        }, () => worker(action, index)));
+const os_1 = require("os");
+const path_1 = require("path");
+exports.defaultsLogPath = (0, os_1.platform)() === "win32"
+    ? (0, path_1.join)(process.env.APPDATA ?? `${process.env.HOMEDRIVE ?? "C:"}\\ProgramData`, "datatruck\\logs")
+    : "/var/logs/datatruck";
+function createCrons(jobs, options) {
+    const crons = [];
+    for (const name in jobs) {
+        const job = jobs[name];
+        if (job.schedule)
+            crons.push((0, croner_1.Cron)(typeof job.schedule === "string"
+                ? job.schedule
+                : (0, cron_1.formatCronScheduleObject)(job.schedule), {
+                paused: true,
+                context: name,
+                catch: true,
+                protect: true,
+            }, () => (0, job_1.runJob)(job, name, options)));
     }
-    return jobs;
+    return crons;
 }
-function createCronServer(options, config) {
-    const worker = async (action, index) => {
-        let pid = 0;
-        try {
-            const Command = command_1.datatruckCommandMap[action.name];
-            const command = new Command({ config: { packages: [], repositories: [] } }, {});
-            const cliOptions = (0, cli_1.stringifyOptions)(command.optionsConfig(), action.name === "prune"
-                ? ({ ...action.options, confirm: true })
-                : action.options);
-            const [node, bin] = process.argv;
-            const p = new async_process_1.AsyncProcess(node, [
-                process.env.pm_exec_path ?? bin,
-                "-c",
-                config.configPath,
-                action.name,
-                ...cliOptions,
-            ], { $log: config.verbose, $exitCode: false });
-            pid = p.child.pid || 0;
-            if (config.log)
-                (0, cli_1.logJson)("cron-server", `${action.name} started`, { pid });
-            const exitCode = await p.waitForClose();
-            if (config.log)
-                (0, cli_1.logJson)("cron-server", `${action.name} finished`, { pid, exitCode });
-        }
-        catch (error) {
-            if (config.log)
-                (0, cli_1.logJson)("cron-server", `${action.name} failed`, { pid });
-            console.error(error);
-        }
-    };
-    let jobs = createJobs(options.actions || [], worker);
+async function createCronServer(options) {
+    const config = await ConfigAction_1.ConfigAction.fromGlobalOptions({
+        config: options.configPath,
+    });
+    let crons = createCrons(config.jobs || {}, options);
     const watcher = (0, watcher_1.createWatcher)({
-        onRead: () => ConfigAction_1.ConfigAction.findAndParseFile(config.configPath),
+        onRead: () => ConfigAction_1.ConfigAction.findAndParseFile(options.configPath),
         onCheck: (prev, current) => (0, string_1.compareJsons)(prev, current),
         onError: (error) => {
-            if (config.log) {
+            if (options.log) {
                 (0, cli_1.logJson)("cron-server", "job update error");
                 console.error(error);
             }
         },
         onChange: (data) => {
-            if (config.log)
+            if (options.log)
                 (0, cli_1.logJson)("cron-server", "jobs updated");
             handler.stop();
-            const cron = data?.server?.cron;
-            const enabled = cron?.enabled ?? true;
-            jobs = enabled ? createJobs(cron?.actions || [], worker) : [];
+            const enabled = data?.server?.cron?.enabled ?? true;
+            crons = enabled ? createCrons(data?.jobs || {}, options) : [];
             handler.start();
         },
     });
     const handler = {
         start: () => {
-            for (const job of jobs)
-                job.resume();
+            for (const cron of crons)
+                cron.resume();
             watcher.start();
         },
         stop: () => {
             watcher.stop();
-            for (const job of jobs)
-                job.stop();
+            for (const cron of crons)
+                cron.stop();
         },
     };
     return handler;

package/lib/utils/datatruck/job.d.ts

@@ -0,0 +1,41 @@
+import { BackupCommandOptions } from "../../commands/BackupCommand";
+import { CopyCommandOptions } from "../../commands/CopyCommand";
+import { PruneCommandOptions } from "../../commands/PruneCommand";
+export type JobScheduleObject = {
+    minute?: number | {
+        each: number;
+    };
+    hour?: number | {
+        each: number;
+    };
+    day?: number | {
+        each: number;
+    };
+    month?: number | {
+        each: number;
+    };
+    weekDay?: number | {
+        each: number;
+    };
+};
+export type JobAction = {
+    action: "backup";
+    options: BackupCommandOptions;
+} | {
+    action: "copy";
+    options: CopyCommandOptions;
+} | {
+    action: "prune";
+    options: Omit<PruneCommandOptions, "confirm">;
+};
+export type JobSchedule = string | JobScheduleObject;
+export type Job = JobAction & {
+    schedule?: JobSchedule;
+};
+export type JobConfig = {
+    log: boolean;
+    logPath: string | boolean | undefined;
+    verbose: boolean;
+    configPath: string;
+};
+export declare function runJob(job: Job, name: string, config: JobConfig): Promise<void>;

package/lib/utils/datatruck/job.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runJob = void 0;
+const async_process_1 = require("../async-process");
+const cli_1 = require("../cli");
+const fs_1 = require("../fs");
+const command_1 = require("./command");
+const cron_server_1 = require("./cron-server");
+const fs_2 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+async function runJob(job, name, config) {
+    let pid = 0;
+    try {
+        const Command = command_1.datatruckCommandMap[job.action];
+        const command = new Command({ config: { packages: [], repositories: [] } }, {});
+        const cliOptions = (0, cli_1.stringifyOptions)(command.optionsConfig(), job.action === "prune"
+            ? ({ ...job.options, confirm: true })
+            : job.options);
+        const [node, bin] = process.argv;
+        const baseLogPath = typeof config.logPath === "string"
+            ? config.logPath
+            : config.logPath === true || config.logPath === undefined
+                ? cron_server_1.defaultsLogPath
+                : config.logPath;
+        let stream;
+        let logPath;
+        const dt = new Date().toISOString().replaceAll(":", "-");
+        if (baseLogPath) {
+            const tmpLogPath = (0, path_1.join)(baseLogPath, dt) + ".log";
+            await (0, promises_1.mkdir)(baseLogPath, { recursive: true });
+            stream = (0, fs_2.createWriteStream)(tmpLogPath);
+        }
+        const p = new async_process_1.AsyncProcess(node, [
+            process.env.pm_exec_path ?? bin,
+            "--tty",
+            "false",
+            "--progress",
+            "interval:3000",
+            "-c",
+            config.configPath,
+            job.action,
+            ...cliOptions,
+        ], {
+            $log: config.verbose,
+            $exitCode: false,
+            env: {
+                ...process.env,
+                COLUMNS: "160",
+                NO_COLOR: "1",
+                JOB_NAME: name,
+            },
+        });
+        pid = p.child.pid || 0;
+        if (config.log)
+            (0, cli_1.logJson)("job", `'${name}' started`, { pid });
+        const [exitCode] = await Promise.all([
+            p.waitForClose(),
+            stream && p.stderr.pipe(stream),
+            stream && p.stdout.pipe(stream),
+        ]);
+        if (stream)
+            await (0, fs_1.safeRename)(stream.path.toString(), (logPath = (0, path_1.join)(stream.path.toString(), `${dt}-${pid}.log`)));
+        if (config.log)
+            (0, cli_1.logJson)("job", `'${name}' finished`, {
+                pid,
+                exitCode,
+                ...(logPath && { log: logPath }),
+            });
+    }
+    catch (error) {
+        if (config.log)
+            (0, cli_1.logJson)("job", `'${name}' failed`, { pid });
+        console.error(error);
+    }
+}
+exports.runJob = runJob;

package/lib/utils/datatruck/report-list.js

@@ -42,7 +42,7 @@ function createReportListTasks(list, options) {
                 else if ((0, reportSteps_1.isReportStep)(report.run)) {
                     await (0, reportSteps_1.runReportSteps)(report.run, {
                         data: {
-                            title: `[${options.hostname}] DTT ${options.action}`,
+                            title: `[${options.hostname}] DTT ${process.env.JOB_NAME ?? options.action}`,
                             message,
                             success,
                         },

package/lib/utils/datatruck/repository-server.d.ts

@@ -15,6 +15,10 @@ export type DatatruckRepositoryServerOptions = {
         remoteAddressHeader: string;
     };
     keepAliveTimeout?: number;
+    /**
+     * @default true
+     */
+    contentLength?: boolean;
     allowlist?: {
         /**
          * @default true

package/lib/utils/datatruck/repository-server.js

@@ -67,6 +67,7 @@ function createDatatruckRepositoryServer(inOptions, config = {}) {
         let responseError;
         req.on("error", (error) => (requestError = error));
         res.on("error", (error) => (responseError = error));
+        res.setHeader("X-Accel-Buffering", "no");
         try {
             const { repository, action, params } = parseUrl(url);
             if (!repository || !action)
@@ -93,7 +94,9 @@ function createDatatruckRepositoryServer(inOptions, config = {}) {
             else if (action === "download") {
                 const [target] = params;
                 const path = fs.resolvePath(target);
-                await (0, http_1.sendFile)(req, res, path);
+                await (0, http_1.sendFile)(req, res, path, {
+                    contentLength: options.contentLength ?? true,
+                });
             }
             else if (action === "writeFile") {
                 const data = await (0, http_1.readRequestData)(req);

package/lib/utils/http.d.ts

@@ -10,6 +10,7 @@ export declare function fetchJson<T = any>(url: string, options?: RequestInit):
 export declare function post(url: string, data: string, options?: Omit<RequestInit, "method" | "body">): Promise<Response>;
 export declare function parseContentLength(value: string | undefined): number;
 export declare function sendFile(req: IncomingMessage, res: ServerResponse, path: string, options?: {
+    contentLength?: boolean;
     end?: boolean;
     checksum?: boolean;
 }): Promise<void>;

package/lib/utils/http.js

@@ -62,7 +62,7 @@ async function sendFile(req, res, path, options = {}) {
     try {
         file = (0, fs_1.createReadStream)(path);
         const fileStat = await (0, promises_1.stat)(path);
-        res.setHeader("Content-Length", fileStat.size);
+        res.setHeader(options.contentLength ?? true ? "Content-Length" : "x-content-length", fileStat.size);
         if (options.checksum)
             res.setHeader("x-checksum", await (0, crypto_1.calcFileHash)(path, "sha1"));
         file.pipe(res);
@@ -111,7 +111,9 @@ async function downloadFile(url, output, options = {}) {
             ...fetchOptions,
             signal: AbortSignal.timeout(timeout ?? 3600 * 1000), // 60m
         });
-        length.total = parseContentLength(res.headers.get("content-length") ?? undefined);
+        length.total = parseContentLength(res.headers.get("content-length") ??
+            res.headers.get("x-content-length") ??
+            undefined);
         checksum = res.headers.get("x-checksum") ?? undefined;
         const body = stream_1.Readable.fromWeb(res.body);
         const progress = onProgress &&

package/lib/utils/list.d.ts

@@ -63,6 +63,11 @@ export declare class Listr3<T extends Listr3Context> extends Listr<void, "defaul
     getSummaryResult(): List3SummaryResult;
     getResult(): (List3SummaryResult | Listr3TaskResult<T>)[];
     protected release(): void;
+    execAndParse(verbose: boolean | undefined): Promise<{
+        result: (List3SummaryResult | Listr3TaskResult<T>)[];
+        exitCode: number;
+        errors: Error[];
+    }>;
     exec(): Promise<(Listr3TaskResult<T> | List3SummaryResult)[]>;
 }
 export {};