hotcodepush 0.0.1 → 0.2.0

package/dist/utils/cli.js

@@ -0,0 +1,80 @@
+import { stripVTControlCharacters } from 'node:util';
+import { defineConfig, processConfig } from 'zodline';
+import { ensureAuthentication } from './authentication.js';
+import { loadCommands, resolveInvocation } from './command-registry.js';
+import { isColorEnabled } from './environment.js';
+import { printError, resolveCliError } from './error-mapping.js';
+import { ExitCode, ReportedFailureError } from './errors.js';
+import { printTelemetryNotice, reportFinishedCommand } from './telemetry.js';
+import { printUpdateNotice, refreshLatestKnownVersion, } from './update-notice.js';
+export async function runCli(commandRegistry, argv, meta) {
+    if (isShellStartup(argv)) {
+        const { cliError } = await runCommandLine(commandRegistry, argv, meta);
+        printCommandLineError(cliError, argv);
+        return cliError?.exitCode ?? ExitCode.Success;
+    }
+    const startedAt = performance.now();
+    printTelemetryNotice();
+    // The check runs beside the command, so the notice after it never waits long on the registry.
+    const latestKnownVersionRefresh = refreshLatestKnownVersion();
+    const { cliError, commandName } = await runCommandLine(commandRegistry, argv, meta);
+    printCommandLineError(cliError, argv);
+    if (commandName !== undefined) {
+        await reportFinishedCommand({
+            cliError,
+            commandName,
+            durationMs: performance.now() - startedAt,
+        });
+    }
+    await latestKnownVersionRefresh;
+    printUpdateNotice();
+    return cliError?.exitCode ?? ExitCode.Success;
+}
+// A shell profile runs `completion` at startup, so it must not wait on the network or print a notice.
+function isShellStartup(argv) {
+    return argv[0] === 'completion';
+}
+function printCommandLineError(cliError, argv) {
+    if (cliError !== undefined && !(cliError instanceof ReportedFailureError)) {
+        printError(cliError, {
+            isJson: argv.includes('--json'),
+            isVerbose: argv.includes('--verbose'),
+        });
+    }
+}
+async function runCommandLine(commandRegistry, argv, meta) {
+    let commandName;
+    try {
+        const invocation = resolveInvocation(Object.keys(commandRegistry), argv);
+        // A line without a command shows the help or the version, and zodline ends the process there.
+        commandName =
+            invocation.commandNames.length === 1
+                ? invocation.commandNames[0]
+                : undefined;
+        const commands = await loadCommands(commandRegistry, invocation.commandNames);
+        const config = defineConfig({ commands, meta });
+        const { args, command, options } = isColorEnabled(process.stdout)
+            ? processConfig(config, invocation.argv)
+            : processConfigWithoutColor(config, invocation.argv);
+        if (commandName !== undefined &&
+            commands[commandName]?.authentication === 'required') {
+            await ensureAuthentication(options);
+        }
+        await command.action(options, args);
+        return { cliError: undefined, commandName };
+    }
+    catch (error) {
+        return { cliError: resolveCliError(error), commandName };
+    }
+}
+// zodline always colours its help, so the colour codes are stripped while it runs.
+function processConfigWithoutColor(config, argv) {
+    const log = console.log;
+    console.log = (...values) => log(...values.map(value => typeof value === 'string' ? stripVTControlCharacters(value) : value));
+    try {
+        return processConfig(config, argv);
+    }
+    finally {
+        console.log = log;
+    }
+}

package/dist/utils/command-registry.js

@@ -0,0 +1,79 @@
+import { UnknownCommandError } from './errors.js';
+const MAX_SUGGESTION_DISTANCE = 2;
+const SHORT_FLAG_EXPANSIONS = {
+    '-h': '--help',
+    '-v': '--version',
+};
+export async function loadCommands(commandRegistry, commandNames) {
+    const invokedEntries = Object.entries(commandRegistry).filter(([name]) => commandNames.includes(name));
+    const loadedEntries = await Promise.all(invokedEntries.map(async ([name, importCommand]) => [
+        name,
+        (await importCommand()).default,
+    ]));
+    return Object.fromEntries(loadedEntries);
+}
+export function resolveClosestCommandName(commandNames, words) {
+    let closestCommandName;
+    let closestDistance = MAX_SUGGESTION_DISTANCE + 1;
+    for (const commandName of commandNames) {
+        const typedCommand = words
+            .slice(0, commandName.split(' ').length)
+            .join(' ');
+        const distance = resolveEditDistance(typedCommand, commandName);
+        if (distance < closestDistance) {
+            closestCommandName = commandName;
+            closestDistance = distance;
+        }
+    }
+    return closestCommandName;
+}
+export function resolveCommandName(commandNames, words) {
+    for (let wordCount = words.length; wordCount > 0; wordCount--) {
+        const candidate = words.slice(0, wordCount).join(' ');
+        if (commandNames.includes(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+// A line without a command, or with a noun alone, shows the help instead of failing.
+export function resolveInvocation(commandNames, argv) {
+    const expandedArgv = argv.map(arg => SHORT_FLAG_EXPANSIONS[arg] ?? arg);
+    if (expandedArgv.includes('--version')) {
+        return { argv: ['--version'], commandNames: [] };
+    }
+    const words = resolveCommandWords(expandedArgv);
+    if (words.length === 0) {
+        return { argv: withHelpFlag(expandedArgv), commandNames };
+    }
+    const commandName = resolveCommandName(commandNames, words);
+    if (commandName) {
+        return { argv: expandedArgv, commandNames: [commandName] };
+    }
+    const nounCommandNames = commandNames.filter(name => name.startsWith(`${words[0]} `));
+    if (words.length === 1 && nounCommandNames.length > 0) {
+        return { argv: withHelpFlag(expandedArgv), commandNames: nounCommandNames };
+    }
+    throw new UnknownCommandError(words.join(' '), resolveClosestCommandName(commandNames, words));
+}
+function resolveCommandWords(argv) {
+    const firstFlagIndex = argv.findIndex(arg => arg.startsWith('-'));
+    return firstFlagIndex === -1 ? argv : argv.slice(0, firstFlagIndex);
+}
+// Levenshtein distance.
+function resolveEditDistance(source, target) {
+    let previousRow = Array.from({ length: target.length + 1 }, (_, index) => index);
+    for (let sourceIndex = 1; sourceIndex <= source.length; sourceIndex++) {
+        const currentRow = [sourceIndex];
+        for (let targetIndex = 1; targetIndex <= target.length; targetIndex++) {
+            const substitutionCost = source[sourceIndex - 1] === target[targetIndex - 1] ? 0 : 1;
+            currentRow.push(Math.min((previousRow[targetIndex] ?? 0) + 1, (currentRow[targetIndex - 1] ?? 0) + 1, (previousRow[targetIndex - 1] ?? 0) + substitutionCost));
+        }
+        previousRow = currentRow;
+    }
+    return previousRow[target.length] ?? 0;
+}
+// zodline reads a repeated flag as an array, so `--help` is added only when it is absent.
+function withHelpFlag(argv) {
+    return argv.includes('--help') ? argv : [...argv, '--help'];
+}

package/dist/utils/command.js

@@ -0,0 +1,4 @@
+import { defineCommand as defineZodlineCommand } from 'zodline';
+export function defineCommand({ authentication = 'required', ...command }) {
+    return { ...defineZodlineCommand(command), authentication };
+}

package/dist/utils/completion/bash.js

@@ -0,0 +1,48 @@
+import { buildPosixCaseArms } from './posix-case-arms.js';
+import { quotePosixWord } from './posix-quote.js';
+export function buildBashScript(commands) {
+    return [
+        '_hotcodepush() {',
+        '  local cur=${COMP_WORDS[COMP_CWORD]} prev=${COMP_WORDS[COMP_CWORD-1]}',
+        '  if (( COMP_CWORD == 1 )); then',
+        `    ${buildReply(commands.map(({ name }) => name))}`,
+        '    return',
+        '  fi',
+        '  if (( COMP_CWORD == 2 )) && [[ $cur != -* ]]; then',
+        '    case ${COMP_WORDS[1]} in',
+        ...commands
+            .filter(({ verbs }) => verbs.length > 0)
+            .map(({ name, verbs }) => `      ${quotePosixWord(name)}) ${buildReply(verbs.map(verb => verb.name))}; return ;;`),
+        '    esac',
+        '  fi',
+        '  case "${COMP_WORDS[1]} ${COMP_WORDS[2]}" in',
+        ...buildPosixCaseArms(commands, buildOptionsArm),
+        '  esac',
+        '}',
+        '',
+        'complete -o default -F _hotcodepush hotcodepush',
+    ].join('\n');
+}
+// A command that takes arguments offers its flags only for a word starting with `-`.
+// Its arguments fall back to the file names.
+function buildOptionsArm(pattern, { hasArguments, options }) {
+    const enumOptions = options.filter(({ choices }) => choices.length > 0);
+    const freeValueFlags = options
+        .filter(({ choices, hasValue }) => hasValue && choices.length === 0)
+        .map(({ name }) => quotePosixWord(`--${name}`));
+    const flagReply = buildReply(options.map(({ name }) => `--${name}`));
+    return [
+        `    ${pattern})`,
+        '      case $prev in',
+        ...enumOptions.map(({ choices, name }) => `        ${quotePosixWord(`--${name}`)}) ${buildReply(choices)} ;;`),
+        ...(freeValueFlags.length > 0
+            ? [`        ${freeValueFlags.join('|')}) ;;`]
+            : []),
+        `        *) ${hasArguments ? `[[ $cur == -* ]] && ${flagReply}` : flagReply} ;;`,
+        '      esac',
+        '      ;;',
+    ];
+}
+function buildReply(words) {
+    return `COMPREPLY=($(compgen -W ${quotePosixWord(words.join(' '))} -- "$cur"))`;
+}

package/dist/utils/completion/command-tree.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { resolveFlagName } from '../flag-name.js';
+// A noun that runs nothing itself is described by its verbs.
+export function resolveCommandTree(commands) {
+    const commandEntries = Object.entries(commands);
+    const topLevelNames = new Set(commandEntries.map(([commandName]) => commandName.split(' ')[0] ?? ''));
+    return [...topLevelNames].map(topLevelName => {
+        const verbs = commandEntries
+            .filter(([commandName]) => commandName.startsWith(`${topLevelName} `))
+            .map(([commandName, command]) => resolveCompletionCommand(commandName.slice(topLevelName.length + 1), command));
+        const topLevelCommand = commands[topLevelName];
+        return topLevelCommand === undefined
+            ? {
+                description: verbs.map(({ name }) => name).join(', '),
+                hasArguments: false,
+                name: topLevelName,
+                options: [],
+                verbs,
+            }
+            : { ...resolveCompletionCommand(topLevelName, topLevelCommand), verbs };
+    });
+}
+// A union counts too, since `--protected` also takes `true` or `false` as text.
+function isBooleanFlag(schema) {
+    if (schema instanceof z.ZodOptional || schema instanceof z.ZodDefault) {
+        return isBooleanFlag(schema.unwrap());
+    }
+    if (schema instanceof z.ZodUnion) {
+        return schema.options.some(isBooleanFlag);
+    }
+    return schema instanceof z.ZodBoolean;
+}
+// zodline fills an array from a repeated flag. A comma list is text piped into an array and given once.
+function isRepeatableFlag(schema) {
+    if (schema instanceof z.ZodOptional || schema instanceof z.ZodDefault) {
+        return isRepeatableFlag(schema.unwrap());
+    }
+    return schema instanceof z.ZodArray;
+}
+// The pipe of a comma list splits the text before it checks each choice.
+function resolveChoices(schema) {
+    if (schema instanceof z.ZodOptional || schema instanceof z.ZodDefault) {
+        return resolveChoices(schema.unwrap());
+    }
+    if (schema instanceof z.ZodPipe) {
+        return resolveChoices(schema.out);
+    }
+    if (schema instanceof z.ZodArray) {
+        return resolveChoices(schema.element);
+    }
+    return schema instanceof z.ZodEnum ? schema.options.map(String) : [];
+}
+function resolveCompletionCommand(name, command) {
+    const shape = command.options?.schema.shape ?? {};
+    return {
+        description: command.description ?? '',
+        hasArguments: command.args !== undefined,
+        name,
+        options: Object.entries(shape).map(([key, schema]) => resolveCompletionOption(key, schema)),
+        verbs: [],
+    };
+}
+function resolveCompletionOption(key, schema) {
+    const hasValue = !isBooleanFlag(schema);
+    return {
+        choices: hasValue ? resolveChoices(schema) : [],
+        description: schema.description ?? '',
+        hasValue,
+        isRepeatable: isRepeatableFlag(schema),
+        name: resolveFlagName(key),
+    };
+}

package/dist/utils/completion/fish.js

@@ -0,0 +1,44 @@
+export function buildFishScript(commands) {
+    return [
+        'function __hotcodepush_needs_command',
+        '    test (count (commandline -opc)) -eq 1',
+        'end',
+        '',
+        'function __hotcodepush_needs_verb --argument-names noun',
+        '    set -l tokens (commandline -opc)',
+        '    test (count $tokens) -eq 2; and test "$tokens[2]" = "$noun"',
+        'end',
+        '',
+        'function __hotcodepush_using --argument-names first_word second_word',
+        '    set -l tokens (commandline -opc)',
+        '    test "$tokens[2]" = "$first_word"; and test -z "$second_word" -o "$tokens[3]" = "$second_word"',
+        'end',
+        '',
+        ...commands.map(({ description, name }) => `complete -c hotcodepush -f -n __hotcodepush_needs_command -a ${quoteFishWord(name)} -d ${quoteFishWord(description)}`),
+        ...commands.flatMap(noun => noun.verbs.map(({ description, name }) => `complete -c hotcodepush -f -n ${quoteFishWord(`__hotcodepush_needs_verb ${noun.name}`)} -a ${quoteFishWord(name)} -d ${quoteFishWord(description)}`)),
+        ...commands.flatMap(command => [
+            ...buildOptionLines(resolveStandaloneCondition(command), command.options),
+            ...command.verbs.flatMap(verb => buildOptionLines(`__hotcodepush_using ${command.name} ${verb.name}`, verb.options)),
+        ]),
+    ].join('\n');
+}
+function buildOptionLines(condition, options) {
+    return options.map(option => `complete -c hotcodepush -n ${quoteFishWord(condition)} -l ${option.name}${buildValueArguments(option)} -d ${quoteFishWord(option.description)}`);
+}
+function buildValueArguments({ choices, hasValue }) {
+    if (choices.length > 0) {
+        return ` -x -a ${quoteFishWord(choices.join(' '))}`;
+    }
+    return hasValue ? ' -r' : '';
+}
+// In fish, a backslash and a single quote are the only escapes inside single quotes.
+function quoteFishWord(text) {
+    return `'${text.replace(/[\\']/g, '\\$&')}'`;
+}
+// Excludes the verbs, so `fingerprint` does not also match `fingerprint diff`.
+function resolveStandaloneCondition({ name, verbs, }) {
+    return [
+        `__hotcodepush_using ${name}`,
+        ...verbs.map(verb => `not __hotcodepush_using ${name} ${verb.name}`),
+    ].join('; and ');
+}

package/dist/utils/completion/posix-case-arms.js

@@ -0,0 +1,9 @@
+import { quotePosixWord } from './posix-quote.js';
+// The verb arms come first, so `fingerprint diff` matches before `fingerprint`.
+export function buildPosixCaseArms(commands, buildCaseArm) {
+    const verbArms = commands.flatMap(noun => noun.verbs.map(verb => buildCaseArm(quotePosixWord(`${noun.name} ${verb.name}`), verb, 2)));
+    const standaloneArms = commands
+        .filter(({ options }) => options.length > 0)
+        .map(command => buildCaseArm(`${quotePosixWord(`${command.name} `)}*`, command, 1));
+    return [...verbArms, ...standaloneArms].flat();
+}

package/dist/utils/completion/posix-quote.js

@@ -0,0 +1,4 @@
+// Each single quote closes the quote, is escaped and reopens it.
+export function quotePosixWord(text) {
+    return `'${text.replaceAll("'", `'\\''`)}'`;
+}

package/dist/utils/completion/script-files.js

@@ -0,0 +1,26 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { COMPLETION_DIRECTORY_PATH } from '../../config/consts.js';
+import { loadCommands } from '../command-registry.js';
+import { buildBashScript } from './bash.js';
+import { resolveCommandTree } from './command-tree.js';
+import { buildFishScript } from './fish.js';
+import { buildZshScript } from './zsh.js';
+export const COMPLETION_SHELLS = ['bash', 'fish', 'zsh'];
+const SCRIPT_BUILDERS = {
+    bash: buildBashScript,
+    fish: buildFishScript,
+    zsh: buildZshScript,
+};
+export async function readCompletionScript(shell) {
+    return readFile(resolveCompletionScriptPath(shell), 'utf8');
+}
+// The build runs this once, so a shell start loads no command.
+export async function writeCompletionScripts(commandRegistry) {
+    const commands = resolveCommandTree(await loadCommands(commandRegistry, Object.keys(commandRegistry)));
+    await mkdir(COMPLETION_DIRECTORY_PATH, { recursive: true });
+    await Promise.all(COMPLETION_SHELLS.map(shell => writeFile(resolveCompletionScriptPath(shell), SCRIPT_BUILDERS[shell](commands))));
+}
+function resolveCompletionScriptPath(shell) {
+    return join(COMPLETION_DIRECTORY_PATH, `hotcodepush.${shell}`);
+}

package/dist/utils/completion/zsh.js

@@ -0,0 +1,72 @@
+import { buildPosixCaseArms } from './posix-case-arms.js';
+import { quotePosixWord } from './posix-quote.js';
+export function buildZshScript(commands) {
+    return [
+        '#compdef hotcodepush',
+        '',
+        '_hotcodepush() {',
+        '  local -a completions',
+        '  if (( CURRENT == 2 )); then',
+        ...buildDescribeLines('    ', 'hotcodepush command', commands),
+        '  fi',
+        '  if (( CURRENT == 3 )) && [[ ${words[CURRENT]} != -* ]]; then',
+        '    case ${words[2]} in',
+        ...commands
+            .filter(({ verbs }) => verbs.length > 0)
+            .flatMap(({ name, verbs }) => [
+            `      ${quotePosixWord(name)})`,
+            ...buildDescribeLines('        ', `${name} command`, verbs),
+            '        ;;',
+        ]),
+        '    esac',
+        '  fi',
+        '  case "${words[2]} ${words[3]}" in',
+        ...buildPosixCaseArms(commands, (pattern, command, commandWordCount) => buildArgumentsArm(pattern, commandWordCount, command)),
+        '  esac',
+        '}',
+        '',
+        '# drops the command words, so _arguments reads the flags as the words of the command they belong to',
+        '_hotcodepush_arguments() {',
+        '  local command_word_count=$1',
+        '  shift',
+        '  shift $command_word_count words',
+        '  (( CURRENT -= command_word_count ))',
+        '  _arguments "$@"',
+        '}',
+        '',
+        'compdef _hotcodepush hotcodepush',
+        '',
+        '# under fpath this file is the body of _hotcodepush: its first run defines the function, then completes with it',
+        'if [ "$funcstack[1]" = "_hotcodepush" ]; then',
+        '  _hotcodepush "$@"',
+        'fi',
+    ].join('\n');
+}
+function buildArgumentsArm(pattern, commandWordCount, { hasArguments, options }) {
+    const specs = [
+        ...options.map(buildOptionSpec),
+        ...(hasArguments ? ['*:argument:_files'] : []),
+    ];
+    return [
+        `    ${pattern})`,
+        `      _hotcodepush_arguments ${commandWordCount} \\`,
+        ...specs.map(spec => `        ${quotePosixWord(spec)} \\`),
+        '      ;;',
+    ];
+}
+function buildDescribeLines(indentation, tag, commands) {
+    return [
+        `${indentation}completions=(`,
+        ...commands.map(({ description, name }) => `${indentation}  ${quotePosixWord(`${name}:${description}`)}`),
+        `${indentation})`,
+        `${indentation}_describe -t commands ${quotePosixWord(tag)} completions`,
+        `${indentation}return`,
+    ];
+}
+function buildOptionSpec({ choices, description, hasValue, isRepeatable, name, }) {
+    const flag = `${isRepeatable ? '*' : ''}--${name}[${description.replace(/[[\]\\]/g, '\\$&')}]`;
+    if (!hasValue) {
+        return flag;
+    }
+    return `${flag}:${name}:${choices.length > 0 ? `(${choices.join(' ')})` : '_files'}`;
+}

package/dist/utils/compressed-files.js

@@ -0,0 +1,31 @@
+import { createReadStream, createWriteStream } from 'node:fs';
+import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { createGzip } from 'node:zlib';
+export async function compressFiles(files, temporaryDirectoryPath) {
+    const compressedFiles = new Map();
+    for (const file of files) {
+        if (compressedFiles.has(file.sha256)) {
+            continue;
+        }
+        const compressedFilePath = join(temporaryDirectoryPath, `${file.sha256}.gz`);
+        await pipeline(createReadStream(file.filePath), createGzip(), createWriteStream(compressedFilePath));
+        compressedFiles.set(file.sha256, {
+            compressedFilePath,
+            sha256: file.sha256,
+            sizeBytes: (await stat(compressedFilePath)).size,
+        });
+    }
+    return compressedFiles;
+}
+export async function withTemporaryDirectory(task) {
+    const temporaryDirectoryPath = await mkdtemp(join(tmpdir(), 'hotcodepush-'));
+    try {
+        return await task(temporaryDirectoryPath);
+    }
+    finally {
+        await rm(temporaryDirectoryPath, { force: true, recursive: true });
+    }
+}

package/dist/utils/credential.js

@@ -0,0 +1,15 @@
+import { HotCodePushError } from '@hotcodepush/node';
+import { createApiClient } from './api-client.js';
+const UNAUTHENTICATED_STATUS = 401;
+export async function fetchCurrentUser() {
+    return createApiClient().users.get({ userId: 'me' });
+}
+export function isUnauthenticatedError(error) {
+    return (error instanceof HotCodePushError && error.status === UNAUTHENTICATED_STATUS);
+}
+export function resolveCredentialText(user, isEnvironmentToken) {
+    const who = `${user.name} (${user.email})`;
+    return isEnvironmentToken
+        ? `Authenticated with HOTCODEPUSH_TOKEN as ${who}.`
+        : `Logged in as ${who}.`;
+}

package/dist/utils/device-resolution.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { readProjectConfig } from './project-config.js';
+import { promptText } from './prompts.js';
+import { fetchAppId } from './resource-resolution.js';
+export const deviceOptionShape = {
+    device: z
+        .string()
+        .optional()
+        .describe('The device, by the id it generated, as the debug screen and device list show it.'),
+};
+// A device has no name to pick from, so a missing one is asked for as text.
+export async function resolveDeviceReference(hotCodePush, options) {
+    const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+    const deviceId = options.device ??
+        (await promptText('--device', 'Which device id?', options));
+    return { appId, deviceId };
+}

package/dist/utils/diagnostics.js

@@ -0,0 +1,20 @@
+import { styleText } from 'node:util';
+import { log } from '@clack/prompts';
+import { isColorEnabled } from './environment.js';
+// A diagnostic addresses the person, so it goes to stderr in the gutter the prompts use; stdout stays the command's result.
+const STDERR = { output: process.stderr };
+export function printError({ docsUrl, sentences }) {
+    const styledDocsUrl = isColorEnabled(process.stderr)
+        ? styleText('dim', docsUrl, { validateStream: false })
+        : docsUrl;
+    log.error([...sentences, styledDocsUrl].join('\n'), STDERR);
+}
+export function printNotice(text) {
+    log.info(text, STDERR);
+}
+export function printSuccess(text) {
+    log.success(text, STDERR);
+}
+export function printWarning(text) {
+    log.warn(text, STDERR);
+}

package/dist/utils/duration.js

@@ -0,0 +1,16 @@
+export const DURATION_PATTERN = /^\d+[dh]$/;
+const MILLISECONDS_PER_DURATION_UNIT = {
+    d: 24 * 60 * 60 * 1000,
+    h: 60 * 60 * 1000,
+};
+// The caller has checked the duration against `DURATION_PATTERN`.
+export function resolveDurationMilliseconds(duration) {
+    const unit = duration.slice(-1);
+    return Number(duration.slice(0, -1)) * MILLISECONDS_PER_DURATION_UNIT[unit];
+}
+// A duration such as 2h means that long ago. Anything else is passed on as a timestamp.
+export function resolveTimeBound(bound) {
+    return bound !== undefined && DURATION_PATTERN.test(bound)
+        ? new Date(Date.now() - resolveDurationMilliseconds(bound)).toISOString()
+        : bound;
+}

package/dist/utils/environment.js

@@ -0,0 +1,22 @@
+// Follows the colour rules of clig.dev.
+export function isColorEnabled(stream) {
+    return (Boolean(stream.isTTY) &&
+        !process.env.NO_COLOR &&
+        process.env.TERM !== 'dumb');
+}
+// GitHub Actions and the other CI runners set `CI`.
+export function isCi() {
+    return Boolean(process.env.CI);
+}
+// For a build that is never shipped.
+export function isOfflineBuild() {
+    return process.env.HOTCODEPUSH_OFFLINE === '1';
+}
+// A prompt in a pipeline would hang the job, even where a TTY exists.
+export function isInteractive({ json, yes }) {
+    return (Boolean(process.stdin.isTTY) &&
+        Boolean(process.stdout.isTTY) &&
+        !isCi() &&
+        !json &&
+        !yes);
+}

package/dist/utils/error-mapping.js

@@ -0,0 +1,75 @@
+import { inspect, stripVTControlCharacters } from 'node:util';
+import { HotCodePushError } from '@hotcodepush/node';
+import { ZodError } from 'zod';
+import { ZodlineError } from 'zodline';
+import { ERRORS_DOCS_URL } from '../config/consts.js';
+import { printError as printErrorDiagnostic } from './diagnostics.js';
+import { ApiError, CliError, InvalidParameterError, UnexpectedError, UnexpectedResponseError, } from './errors.js';
+import { resolveFlagName } from './flag-name.js';
+import { printJson } from './output.js';
+// Matches the end of a sentence. A message from zodline or an unexpected error may lack it.
+const SENTENCE_END_PATTERN = /[.!?]$/;
+const UNEXPECTED_RESPONSE_CODE = 'unexpected_response';
+export function buildErrorJson({ code, fix, message }) {
+    return { error: { code, message, fix } };
+}
+export function resolveSentence(message) {
+    return SENTENCE_END_PATTERN.test(message) ? message : `${message}.`;
+}
+export function resolveErrorDocsUrl({ code }) {
+    return `${ERRORS_DOCS_URL}#${code}`;
+}
+// An API error message says what to do itself, so it has no fix.
+export function resolveErrorSentences({ fix, message }) {
+    return fix === null ? [message] : [resolveSentence(message), fix];
+}
+export function printError(cliError, { isJson, isVerbose }) {
+    if (isVerbose) {
+        process.stderr.write(`${inspect(cliError)}\n`);
+    }
+    if (isJson) {
+        printJson(buildErrorJson(cliError));
+    }
+    else {
+        printErrorDiagnostic({
+            docsUrl: resolveErrorDocsUrl(cliError),
+            sentences: resolveErrorSentences(cliError),
+        });
+    }
+}
+// A response without a code, such as a proxy HTML page, is not an error from the API catalog.
+export function resolveApiError({ code, error, error_description, message, status, statusText, }) {
+    const receivedCode = code ?? error;
+    if (receivedCode === undefined) {
+        return new UnexpectedResponseError(status);
+    }
+    return new ApiError(receivedCode, message ?? error_description ?? statusText, status);
+}
+export function resolveCliError(error) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    if (error instanceof HotCodePushError) {
+        return error.code === UNEXPECTED_RESPONSE_CODE
+            ? new UnexpectedResponseError(error.status, error)
+            : new ApiError(error.code, error.message, error.status);
+    }
+    if (error instanceof ZodError) {
+        return new InvalidParameterError(resolveZodErrorMessage(error), undefined, error);
+    }
+    if (error instanceof ZodlineError) {
+        return new InvalidParameterError(resolveSentence(stripVTControlCharacters(error.message)), undefined, error);
+    }
+    return new UnexpectedError(error);
+}
+function resolveZodErrorMessage(error) {
+    const [issue] = error.issues;
+    if (!issue) {
+        return error.message;
+    }
+    const [key] = issue.path;
+    if (typeof key !== 'string') {
+        return issue.message;
+    }
+    return `The value of --${resolveFlagName(key)} is invalid. ${issue.message}.`;
+}