hotcodepush 0.0.0 → 0.1.0

package/dist/utils/frameworks/sdk-package.js

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { INIT_MANUAL_STEP } from '../../config/consts.js';
+import { resolveInstallCommandLine, resolvePackageManager, runCommandLineVisibly, } from '../package-manager.js';
+export function checkSdkPackage({ directoryPath, packageJson }, packageName) {
+    if (!isSdkPackageDeclared(packageJson, packageName)) {
+        return {
+            check: 'package',
+            code: 'package_missing',
+            manualStep: INIT_MANUAL_STEP,
+            message: `The package ${packageName} is not in package.json.`,
+            status: 'failed',
+        };
+    }
+    const installedVersion = readInstalledPackageVersion(directoryPath, packageName);
+    if (installedVersion === undefined) {
+        return {
+            check: 'package',
+            code: 'package_not_installed',
+            manualStep: 'Install the dependencies.',
+            message: `The package ${packageName} is declared but not in node_modules.`,
+            status: 'failed',
+        };
+    }
+    return {
+        check: 'package',
+        message: `The package ${packageName} ${installedVersion} is installed.`,
+        status: 'ok',
+    };
+}
+export function installSdkPackage(projectDirectoryPath, packageName, packageSpec) {
+    runCommandLineVisibly(resolveInstallCommandLine(resolvePackageManager(projectDirectoryPath), packageSpec), projectDirectoryPath);
+    return `Installed ${packageName} from ${packageSpec}.`;
+}
+export function isSdkPackageDeclared(packageJson, packageName) {
+    return (packageJson?.dependencies?.[packageName] !== undefined ||
+        packageJson?.devDependencies?.[packageName] !== undefined);
+}
+export function readInstalledPackageVersion(projectDirectoryPath, packageName) {
+    const packageJsonPath = join(projectDirectoryPath, 'node_modules', packageName, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        return undefined;
+    }
+    return readPackageJsonVersion(packageJsonPath);
+}
+function readPackageJsonVersion(packageJsonPath) {
+    return JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+        .version;
+}
+// Resolved from the SDK package, since an isolated install such as pnpm's keeps it out of the project's `node_modules`.
+export function readSdkDependencyVersion(projectDirectoryPath, sdkPackageName, packageName) {
+    try {
+        const projectRequire = createRequire(join(projectDirectoryPath, 'package.json'));
+        const sdkPackageJsonPath = projectRequire.resolve(`${sdkPackageName}/package.json`);
+        return readPackageJsonVersion(projectRequire.resolve(`${packageName}/package.json`, {
+            paths: [dirname(sdkPackageJsonPath)],
+        }));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/utils/git-provenance.js

@@ -0,0 +1,71 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const EMPTY_PROVENANCE = {
+    gitMessage: null,
+    gitRef: null,
+    gitRemote: null,
+    gitSha: null,
+    isGitDirty: null,
+};
+// `--no-git` skips the detection for a pipeline without a checkout, while the typed flags still apply.
+export async function resolveGitProvenance(directoryPath, options) {
+    const detected = options.noGit
+        ? EMPTY_PROVENANCE
+        : await detectGitProvenance(directoryPath);
+    return {
+        gitMessage: options.gitMessage ?? detected.gitMessage,
+        gitRef: options.gitRef ?? detected.gitRef,
+        gitRemote: detected.gitRemote,
+        gitSha: options.gitSha ?? detected.gitSha,
+        isGitDirty: detected.isGitDirty,
+    };
+}
+// Drops the credentials, so `github.com/acme/shop` comes from an HTTPS or an SSH URL alike.
+export function resolveRemoteSlug(remoteUrl) {
+    const sshMatch = /^[^@]+@([^:]+):(.+)$/.exec(remoteUrl);
+    if (sshMatch?.[1] !== undefined && sshMatch[2] !== undefined) {
+        return `${sshMatch[1]}/${stripGitSuffix(sshMatch[2])}`;
+    }
+    try {
+        const url = new URL(remoteUrl);
+        return `${url.host}/${stripGitSuffix(url.pathname)}`;
+    }
+    catch {
+        return stripGitSuffix(remoteUrl);
+    }
+}
+async function detectGitProvenance(directoryPath) {
+    const [sha, ref, message, status, remoteUrl] = await Promise.all([
+        readGit(directoryPath, ['rev-parse', 'HEAD']),
+        readGit(directoryPath, ['rev-parse', '--abbrev-ref', 'HEAD']),
+        readGit(directoryPath, ['log', '-1', '--format=%s']),
+        readGit(directoryPath, ['status', '--porcelain']),
+        readGit(directoryPath, ['remote', 'get-url', 'origin']),
+    ]);
+    if (sha === null) {
+        return EMPTY_PROVENANCE;
+    }
+    return {
+        gitMessage: message,
+        gitRef: ref,
+        gitRemote: remoteUrl === null ? null : resolveRemoteSlug(remoteUrl),
+        gitSha: sha,
+        isGitDirty: status === null ? null : status.length > 0,
+    };
+}
+// Null when git is missing, the directory is no repository or the command fails.
+async function readGit(directoryPath, args) {
+    try {
+        const { stdout } = await execFileAsync('git', args, {
+            cwd: directoryPath,
+        });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+function stripGitSuffix(path) {
+    return path.replace(/^\/+/, '').replace(/\.git$/, '');
+}

package/dist/utils/global-options.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { defineOptions } from 'zodline';
+// zodline answers `--help` and `--version` before any command runs.
+// Both options are here only so the help lists them.
+const globalOptionsShape = {
+    app: z
+        .string()
+        .optional()
+        .describe('The app, by id or name, when no hotcodepush.json is found or another app is meant.'),
+    config: z
+        .string()
+        .optional()
+        .describe('The hotcodepush.json to use, when it is not the nearest one up from the working directory.'),
+    help: z.boolean().optional().describe('Print this help.'),
+    json: z
+        .boolean()
+        .optional()
+        .describe('Print machine output as JSON on stdout and ask nothing.'),
+    organization: z
+        .string()
+        .optional()
+        .describe('The organization, by id or name, when you belong to several.'),
+    verbose: z.boolean().optional().describe('Print the detail behind an error.'),
+    version: z.boolean().optional().describe("Print the CLI's version."),
+    yes: z
+        .boolean()
+        .optional()
+        .describe('Take every default, ask nothing, confirm nothing.'),
+};
+export function defineCommandOptions(shape) {
+    // The first spread puts the command options first in the help.
+    // The last spread overrides a global option of the same name.
+    return defineOptions(z.object({ ...shape, ...globalOptionsShape, ...shape }), { h: 'help', v: 'version', y: 'yes' });
+}

package/dist/utils/hosts.js

@@ -0,0 +1,53 @@
+import { DEFAULT_API_URL } from '../config/consts.js';
+const LOCAL_CONSOLE_BASE_URL = 'http://localhost:4300';
+const PRODUCTION_CONSOLE_BASE_URL = 'https://console.hotcodepush.com';
+const PRODUCTION_FILES_BASE_URL = 'https://files.hotcodepush.com';
+const PRODUCTION_UPDATES_BASE_URL = 'https://updates.hotcodepush.com';
+const STAGING_API_URL = 'https://api.staging.hotcodepush.com';
+const STAGING_CONSOLE_BASE_URL = 'https://console.staging.hotcodepush.com';
+const STAGING_FILES_BASE_URL = 'https://files.staging.hotcodepush.com';
+const STAGING_UPDATES_BASE_URL = 'https://updates.staging.hotcodepush.com';
+// Any API other than production and staging is the local stack, which serves the hosts itself.
+export function resolveDeviceHosts(apiUrl) {
+    const derived = resolveDerivedDeviceHosts(apiUrl);
+    return {
+        filesBaseUrl: process.env.HOTCODEPUSH_FILES_BASE_URL || derived.filesBaseUrl,
+        updatesBaseUrl: process.env.HOTCODEPUSH_UPDATES_BASE_URL || derived.updatesBaseUrl,
+    };
+}
+// The local console runs on the dev port of the monorepo.
+export function resolveConsoleBaseUrl(apiUrl) {
+    if (process.env.HOTCODEPUSH_CONSOLE_BASE_URL) {
+        return process.env.HOTCODEPUSH_CONSOLE_BASE_URL;
+    }
+    const trimmedApiUrl = apiUrl.replace(/\/+$/, '');
+    if (trimmedApiUrl === DEFAULT_API_URL) {
+        return PRODUCTION_CONSOLE_BASE_URL;
+    }
+    return trimmedApiUrl === STAGING_API_URL
+        ? STAGING_CONSOLE_BASE_URL
+        : LOCAL_CONSOLE_BASE_URL;
+}
+// The production host applies where the resource file names none.
+export function resolveFilesBaseUrl(apiUrl) {
+    return resolveDeviceHosts(apiUrl).filesBaseUrl ?? PRODUCTION_FILES_BASE_URL;
+}
+export function resolveUpdatesBaseUrl(apiUrl) {
+    return (resolveDeviceHosts(apiUrl).updatesBaseUrl ?? PRODUCTION_UPDATES_BASE_URL);
+}
+function resolveDerivedDeviceHosts(apiUrl) {
+    const trimmedApiUrl = apiUrl.replace(/\/+$/, '');
+    if (trimmedApiUrl === DEFAULT_API_URL) {
+        return { filesBaseUrl: undefined, updatesBaseUrl: undefined };
+    }
+    if (trimmedApiUrl === STAGING_API_URL) {
+        return {
+            filesBaseUrl: STAGING_FILES_BASE_URL,
+            updatesBaseUrl: STAGING_UPDATES_BASE_URL,
+        };
+    }
+    return {
+        filesBaseUrl: `${trimmedApiUrl}/files`,
+        updatesBaseUrl: `${trimmedApiUrl}/updates`,
+    };
+}

package/dist/utils/init-steps.js

@@ -0,0 +1,51 @@
+import { resolveCliError, resolveSentence } from './error-mapping.js';
+// Any error stops only its own step, so the run reports instead of throwing and independent steps still run.
+// An API message without a fix carries the fix itself, so it doubles as the manual step.
+export class InitRun {
+    steps = [];
+    unmetSteps = new Set();
+    get stoppedCode() {
+        return this.steps.find(({ status }) => status === 'stopped')?.code;
+    }
+    get stoppedStep() {
+        return this.steps.find(({ status }) => status === 'stopped')?.step;
+    }
+    async run(step, perform, { dependsOn = [] } = {}) {
+        const unmetStep = dependsOn.find(name => this.unmetSteps.has(name));
+        if (unmetStep !== undefined) {
+            this.steps.push({
+                message: `Waits on the ${unmetStep} step.`,
+                status: 'skipped',
+                step,
+            });
+            this.unmetSteps.add(step);
+            return undefined;
+        }
+        try {
+            const { message, status, value } = await perform();
+            this.steps.push({ message, status, step });
+            return value;
+        }
+        catch (error) {
+            const { code, fix, message } = resolveCliError(error);
+            const messageSentence = resolveSentence(message);
+            this.steps.push({
+                code,
+                manualStep: fix ?? messageSentence,
+                message: messageSentence,
+                status: 'stopped',
+                step,
+            });
+            this.unmetSteps.add(step);
+            return undefined;
+        }
+    }
+}
+export function resolveStepRows(steps) {
+    return steps.map(({ manualStep, message, status, step }) => ({
+        manualStep: manualStep === message ? undefined : manualStep,
+        message,
+        name: step,
+        status,
+    }));
+}

package/dist/utils/json-file.js

@@ -0,0 +1,28 @@
+import { readFileSync } from 'node:fs';
+import { InvalidJsonError } from './errors.js';
+// V8 quotes the text around an unexpected token, which in config.json can be the auth token.
+// Matches that message so only the unexpected token is kept.
+const QUOTED_TEXT_PATTERN = /^(Unexpected token '.+?'), .*$/s;
+export function readJsonFile(filePath) {
+    return parseJsonFileText(filePath, readFileSync(filePath, 'utf8'));
+}
+export function parseJsonFileText(filePath, text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError)) {
+            throw error;
+        }
+        throw new InvalidJsonError(filePath, resolveJsonSyntaxProblem(error));
+    }
+}
+// Keeps the indentation and final newline of the file, so the diff is only the edited line.
+export function stringifyLikeSource(value, sourceText) {
+    const indent = /^(\s+)"/m.exec(sourceText)?.[1] ?? '  ';
+    const newline = sourceText.endsWith('\n') ? '\n' : '';
+    return `${JSON.stringify(value, null, indent)}${newline}`;
+}
+function resolveJsonSyntaxProblem({ message }) {
+    return message.replace(QUOTED_TEXT_PATTERN, '$1');
+}

package/dist/utils/member-resolution.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { isInteractive } from './environment.js';
+import { MissingParameterError } from './errors.js';
+import { fetchAllPages } from './pagination.js';
+import { fetchResourceId, promptResourceId } from './resource-resolution.js';
+export const memberOptionShape = {
+    member: z.string().optional().describe('The member, by id or email.'),
+};
+export async function fetchMember(hotCodePush, organizationId, options) {
+    return hotCodePush.organizations.members.get({
+        memberId: await fetchMemberId(hotCodePush, organizationId, options),
+        organizationId,
+        relations: ['user', 'user.accounts'],
+    });
+}
+// The email is unique in the organization, so it names a member the way a name does an app.
+export function resolveMemberEmail({ user }) {
+    return user?.email ?? '';
+}
+// `users.get` embeds the member rows of the caller.
+export function resolveMemberRole(members, organizationId) {
+    return (members.find(member => member.organizationId === organizationId)?.role ??
+        null);
+}
+// A UUID is the id. Anything else is an email, matched among the members whose email contains it.
+async function fetchMemberId(hotCodePush, organizationId, options) {
+    const { member } = options;
+    if (member !== undefined) {
+        return fetchResourceId('member', member, async () => resolveNamedMembers(await fetchMembers(hotCodePush, organizationId, member)));
+    }
+    if (!isInteractive(options)) {
+        throw new MissingParameterError('--member');
+    }
+    return promptResourceId('member', resolveNamedMembers(await fetchMembers(hotCodePush, organizationId)), options);
+}
+function fetchMembers(hotCodePush, organizationId, query) {
+    return fetchAllPages(page => hotCodePush.organizations.members.list({
+        organizationId,
+        query,
+        relations: ['user'],
+        ...page,
+    }));
+}
+function resolveNamedMembers(members) {
+    return members.map(member => ({
+        id: member.id,
+        name: resolveMemberEmail(member),
+    }));
+}

package/dist/utils/native-project-edit.js

@@ -0,0 +1,41 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { NativeProjectError } from './errors.js';
+const GRADLE_EDIT_DESCRIPTION = 'the Gradle task that runs the build step';
+const GRADLE_FILE_MARKER = 'hotcodepush.gradle';
+const GRADLE_FILE_NAMES = ['build.gradle', 'build.gradle.kts'];
+// The line resolves the SDK package through Node, so it finds the package wherever `node_modules` lies.
+export function resolveGradleEdit(androidProjectPath, packageName) {
+    if (!existsSync(androidProjectPath)) {
+        return undefined;
+    }
+    const filePath = GRADLE_FILE_NAMES.map(fileName => join(androidProjectPath, 'app', fileName)).find(candidatePath => existsSync(candidatePath));
+    if (filePath === undefined) {
+        return resolveRefusedEdit(GRADLE_EDIT_DESCRIPTION, join(androidProjectPath, 'app', 'build.gradle'), new NativeProjectError(`The Android project ${androidProjectPath} has no build.gradle or build.gradle.kts in its app folder.`, `Apply node_modules/${packageName}/android/${GRADLE_FILE_MARKER} from the app module's Gradle file.`));
+    }
+    const resolvePackageScript = `require.resolve('${packageName}/package.json')`;
+    return {
+        description: GRADLE_EDIT_DESCRIPTION,
+        filePath,
+        isApplied: () => readFileSync(filePath, 'utf8').includes(GRADLE_FILE_MARKER),
+        apply: () => {
+            const source = readFileSync(filePath, 'utf8');
+            const applyLine = filePath.endsWith('.kts')
+                ? `apply(from = File(providers.exec { workingDir(rootDir); commandLine("node", "--print", "${resolvePackageScript}") }.standardOutput.asText.get().trim()).resolveSibling("android/${GRADLE_FILE_MARKER}"))`
+                : `apply from: new File(["node", "--print", "${resolvePackageScript}"].execute(null, rootDir).text.trim(), "../android/${GRADLE_FILE_MARKER}")`;
+            writeFileSync(filePath, `${source}${source.endsWith('\n') ? '' : '\n'}\n${applyLine}\n`);
+        },
+    };
+}
+// A file wired by hand holds the marker, so `doctor` passes it and `init` leaves it alone.
+export function resolveRefusedEdit(description, filePath, error, marker) {
+    return {
+        description,
+        filePath,
+        isApplied: () => marker !== undefined && readFileSync(filePath, 'utf8').includes(marker),
+        isRefused: true,
+        apply: () => {
+            throw error;
+        },
+    };
+}

package/dist/utils/nullable-field.js

@@ -0,0 +1,10 @@
+import { InvalidParameterError } from './errors.js';
+export function resolveNullableField(value, isCleared, flagName, clearFlagName = `clear-${flagName}`) {
+    if (!isCleared) {
+        return value;
+    }
+    if (value !== undefined) {
+        throw new InvalidParameterError(`The flags --${flagName} and --${clearFlagName} were passed together.`, 'Pass only one of them.');
+    }
+    return null;
+}

package/dist/utils/outcome.js

@@ -0,0 +1,24 @@
+const STATUS_MARKS = {
+    done: '✓',
+    failed: '✗',
+    ok: '✓',
+    skipped: '–',
+    stopped: '✗',
+};
+export function printOutcomeRows(rows) {
+    const labeledRows = rows.map(row => ({
+        ...row,
+        label: resolveOutcomeLabel(row.name),
+    }));
+    const labelWidth = Math.max(...labeledRows.map(({ label }) => label.length));
+    for (const { label, manualStep, message, status } of labeledRows) {
+        console.log(`${STATUS_MARKS[status]} ${label.padEnd(labelWidth)}  ${message}`);
+        if (manualStep !== undefined) {
+            console.log(`${' '.repeat(labelWidth + 4)}${manualStep}`);
+        }
+    }
+}
+function resolveOutcomeLabel(name) {
+    const words = name.replaceAll('_', ' ');
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}

package/dist/utils/output.js

@@ -0,0 +1,37 @@
+export function printDetails(details) {
+    const labelWidth = Math.max(...details.map(([label]) => label.length));
+    for (const [label, value] of details) {
+        console.log(`${label.padEnd(labelWidth)}  ${value}`);
+    }
+}
+export function printJson(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+// The API warns when a computed preview is likely not what was meant.
+export function printWarnings(warnings) {
+    for (const { message } of warnings) {
+        process.stderr.write(`Warning: ${message}\n`);
+    }
+}
+export function printTable({ emptyText, headers, nextOffset, rows, }) {
+    if (rows.length === 0) {
+        console.log(emptyText);
+        return;
+    }
+    const columnWidths = headers.map((header, columnIndex) => Math.max(header.length, ...rows.map(row => row[columnIndex]?.length ?? 0)));
+    for (const cells of [headers, ...rows]) {
+        console.log(cells
+            .map((cell, columnIndex) => cell.padEnd(columnWidths[columnIndex] ?? 0))
+            .join('  ')
+            .trimEnd());
+    }
+    if (nextOffset !== null) {
+        console.log(`Next page: --offset ${nextOffset}`);
+    }
+}
+export function resolveDate(timestamp) {
+    return timestamp.slice(0, 10);
+}
+export function resolveQuantityText(count, noun, pluralNoun = `${noun}s`) {
+    return `${count} ${count === 1 ? noun : pluralNoun}`;
+}

package/dist/utils/pack.js

@@ -0,0 +1,20 @@
+import { createReadStream, createWriteStream } from 'node:fs';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { buildPack } from '@hotcodepush/protocol';
+export async function writePack(files, outputFilePath) {
+    await pipeline(Readable.fromWeb(buildPack(readPackEntries(files))), createWriteStream(outputFilePath));
+}
+async function* readPackEntries(files) {
+    for (const { compressedFilePath, sha256, sizeBytes } of files) {
+        yield {
+            body: readBody(compressedFilePath),
+            sha256,
+            sizeBytes,
+            type: 'file',
+        };
+    }
+}
+function readBody(filePath) {
+    return Readable.toWeb(createReadStream(filePath));
+}

package/dist/utils/package-json.js

@@ -0,0 +1,5 @@
+import { join } from 'node:path';
+import { readJsonFile } from './json-file.js';
+export function readPackageJson(projectDirectoryPath) {
+    return readJsonFile(join(projectDirectoryPath, 'package.json'));
+}

package/dist/utils/package-manager.js

@@ -0,0 +1,50 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { CommandFailedError } from './errors.js';
+const LOCKFILES = [
+    ['bun.lock', 'bun'],
+    ['bun.lockb', 'bun'],
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'],
+];
+export function resolvePackageManager(projectDirectoryPath) {
+    const detected = LOCKFILES.find(([fileName]) => existsSync(join(projectDirectoryPath, fileName)));
+    return detected === undefined ? 'npm' : detected[1];
+}
+export function resolveInstallCommandLine(packageManager, packageSpec) {
+    switch (packageManager) {
+        case 'bun':
+            return { args: ['add', '--exact', packageSpec], command: 'bun' };
+        case 'npm':
+            return {
+                args: ['install', '--save-exact', packageSpec],
+                command: 'npm',
+            };
+        case 'pnpm':
+            return { args: ['add', '--save-exact', packageSpec], command: 'pnpm' };
+        case 'yarn':
+            return { args: ['add', '--exact', packageSpec], command: 'yarn' };
+    }
+}
+export function resolveRunScriptCommandLine(packageManager, scriptName) {
+    return packageManager === 'yarn'
+        ? { args: [scriptName], command: 'yarn' }
+        : { args: ['run', scriptName], command: packageManager };
+}
+export function resolveCommandLineText({ args, command }) {
+    return [command, ...args].join(' ');
+}
+// Output goes to stderr, so `--json` keeps stdout for data.
+export function runCommandLineVisibly(commandLine, projectDirectoryPath) {
+    const commandLineText = resolveCommandLineText(commandLine);
+    process.stderr.write(`$ ${commandLineText}\n`);
+    const result = spawnSync(commandLine.command, commandLine.args, {
+        cwd: projectDirectoryPath,
+        shell: process.platform === 'win32',
+        stdio: ['ignore', process.stderr, process.stderr],
+    });
+    if (result.status !== 0) {
+        throw new CommandFailedError(commandLineText, result.status);
+    }
+}

package/dist/utils/pagination.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 100;
+export const paginationShape = {
+    limit: z.coerce
+        .number()
+        .int()
+        .optional()
+        .describe(`How many to list, at most ${MAX_LIMIT}; ${DEFAULT_LIMIT} by default.`),
+    offset: z.coerce
+        .number()
+        .int()
+        .optional()
+        .describe('How many to skip: the offset the previous page ended with.'),
+};
+export async function fetchAllPages(fetchPage, limit = MAX_LIMIT) {
+    const fetchedItems = [];
+    for (let offset = 0;; offset += limit) {
+        const fetchedPage = await fetchPage({ limit, offset });
+        fetchedItems.push(...fetchedPage);
+        if (fetchedPage.length < limit) {
+            return fetchedItems;
+        }
+    }
+}
+// The API answers a plain array without a total, so a full page implies another.
+export function resolveNextOffset(itemCount, { limit = DEFAULT_LIMIT, offset = 0 }) {
+    return itemCount < limit ? null : offset + limit;
+}

package/dist/utils/progress.js

@@ -0,0 +1,23 @@
+export function createReporter({ json }) {
+    const isReporting = Boolean(process.stderr.isTTY) && !json;
+    return {
+        report: line => {
+            if (isReporting) {
+                process.stderr.write(`${line}\n`);
+            }
+        },
+    };
+}
+// Decimal units, as the limits use.
+export function resolveByteText(bytes) {
+    if (bytes < 1000) {
+        return `${bytes} B`;
+    }
+    if (bytes < 1_000_000) {
+        return `${(bytes / 1000).toFixed(1)} kB`;
+    }
+    if (bytes < 1_000_000_000) {
+        return `${(bytes / 1_000_000).toFixed(1)} MB`;
+    }
+    return `${(bytes / 1_000_000_000).toFixed(2)} GB`;
+}