@pnpm/releasing.commands 1100.7.0 → 1100.7.1

package/lib/publish/recursivePublish.js

@@ -0,0 +1,132 @@
+import path from 'node:path';
+import { pickRegistryForPackage } from '@pnpm/config.pick-registry-for-package';
+import { createResolver } from '@pnpm/installing.client';
+import { logger } from '@pnpm/logger';
+import { sortFilteredProjects } from '@pnpm/workspace.projects-sorter';
+import pFilter from 'p-filter';
+import { pick } from 'ramda';
+import { writeJsonFile } from 'write-json-file';
+import { batchPublishPackages } from './batchPublish.js';
+import { publish } from './publish.js';
+export async function recursivePublish(opts) {
+    const pkgs = Object.values(opts.selectedProjectsGraph).map((wsPkg) => wsPkg.package);
+    const { resolve } = createResolver({
+        ...opts,
+        configByUri: opts.configByUri,
+        retry: {
+            factor: opts.fetchRetryFactor,
+            maxTimeout: opts.fetchRetryMaxtimeout,
+            minTimeout: opts.fetchRetryMintimeout,
+            retries: opts.fetchRetries,
+        },
+        timeout: opts.fetchTimeout,
+    });
+    const pkgsToPublish = await pFilter(pkgs, async (pkg) => {
+        if (!pkg.manifest.name || !pkg.manifest.version || pkg.manifest.private)
+            return false;
+        if (opts.force)
+            return true;
+        return !(await isAlreadyPublished({
+            dir: pkg.rootDir,
+            lockfileDir: opts.lockfileDir ?? pkg.rootDir,
+            registries: opts.registries,
+            resolve,
+        }, pkg.manifest.name, pkg.manifest.version));
+    });
+    const publishedPkgDirs = new Set(pkgsToPublish.map(({ rootDir }) => rootDir));
+    const publishedPackages = [];
+    if (publishedPkgDirs.size === 0) {
+        logger.info({
+            message: 'There are no new packages that should be published',
+            prefix: opts.dir,
+        });
+    }
+    else {
+        const appendedArgs = [];
+        if (opts.cliOptions['access']) {
+            appendedArgs.push(`--access=${opts.cliOptions['access']}`);
+        }
+        if (opts.dryRun) {
+            appendedArgs.push('--dry-run');
+        }
+        if (opts.force) {
+            appendedArgs.push('--force');
+        }
+        if (opts.cliOptions['otp']) {
+            appendedArgs.push(`--otp=${opts.cliOptions['otp']}`);
+        }
+        const chunks = sortFilteredProjects(opts);
+        const tag = opts.tag ?? 'latest';
+        if (opts.batch) {
+            const sortedPkgs = chunks
+                .flat()
+                .filter((pkgDir) => publishedPkgDirs.has(pkgDir))
+                .map((pkgDir) => opts.selectedProjectsGraph[pkgDir].package);
+            publishedPackages.push(...await batchPublishPackages(sortedPkgs, { ...opts, tag }));
+        }
+        else {
+            const commandArgs = opts.stage ? ['stage', 'publish'] : ['publish'];
+            for (const chunk of chunks) {
+                // We can't run publish concurrently due to the npm CLI asking for OTP.
+                // NOTE: If we solve the OTP issue, we still need to limit packages concurrency.
+                // Otherwise, publishing will consume too much resources.
+                // See related issue: https://github.com/pnpm/pnpm/issues/6968
+                for (const pkgDir of chunk) {
+                    if (!publishedPkgDirs.has(pkgDir))
+                        continue;
+                    const pkg = opts.selectedProjectsGraph[pkgDir].package;
+                    const registry = pkg.manifest.publishConfig?.registry ?? pickRegistryForPackage(opts.registries, pkg.manifest.name);
+                    // eslint-disable-next-line no-await-in-loop
+                    const publishResult = await publish({
+                        ...opts,
+                        dir: pkg.rootDir,
+                        argv: {
+                            original: [
+                                ...commandArgs,
+                                '--tag',
+                                tag,
+                                '--registry',
+                                registry,
+                                ...appendedArgs,
+                            ],
+                        },
+                        gitChecks: false,
+                        recursive: false,
+                    }, [pkg.rootDir]);
+                    if (publishResult?.publishSummary != null) {
+                        publishedPackages.push(publishResult.publishSummary);
+                    }
+                    else {
+                        // Fallback for paths that don't produce a full PublishSummary (e.g. dry run via the
+                        // legacy npm-CLI bridge, or future call sites that bypass publishPackedPkg).
+                        const publishedManifest = publishResult?.publishedManifest ?? publishResult?.manifest;
+                        if (publishedManifest != null) {
+                            publishedPackages.push(pick(['name', 'version'], publishedManifest));
+                        }
+                        else if (publishResult?.exitCode) {
+                            return { exitCode: publishResult.exitCode, publishedPackages };
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (opts.reportSummary) {
+        await writeJsonFile(path.join(opts.lockfileDir ?? opts.dir, 'pnpm-publish-summary.json'), { publishedPackages });
+    }
+    return { exitCode: 0, publishedPackages };
+}
+async function isAlreadyPublished(opts, pkgName, pkgVersion) {
+    try {
+        await opts.resolve({ alias: pkgName, bareSpecifier: pkgVersion }, {
+            lockfileDir: opts.lockfileDir,
+            preferredVersions: {},
+            projectDir: opts.dir,
+        });
+        return true;
+    }
+    catch (err) { // eslint-disable-line
+        return false;
+    }
+}
+//# sourceMappingURL=recursivePublish.js.map

package/lib/publish/registryConfigKeys.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Protocols currently supported.
+ */
+type SupportedRegistryScheme = 'http' | 'https';
+/**
+ * A registry URL that has been normalized to match its corresponding {@link RegistryConfigKey}.
+ */
+export type NormalizedRegistryUrl = `${SupportedRegistryScheme}://${string}/`;
+/**
+ * A config key of a registry url is a key on the `.npmrc` file. This key starts with
+ * a "//" prefix followed by a hostname and the rest of the URI and ends with a "/".
+ * They usually specify authentication information.
+ */
+export type RegistryConfigKey = `//${string}/`;
+export interface SupportedRegistryUrlInfo {
+    normalizedUrl: NormalizedRegistryUrl;
+    longestConfigKey: RegistryConfigKey;
+}
+/**
+ * If the {@link registryUrl} is an HTTP or an HTTPS registry url, return the longest
+ * {@link RegistryConfigKey} that corresponds to the registry url and a {@link NormalizedRegistryUrl}
+ * that matches it.
+ */
+export declare function parseSupportedRegistryUrl(registryUrl: string): SupportedRegistryUrlInfo | undefined;
+/**
+ * Generate all {@link RegistryConfigKey} of the same hostname from the longest to the shortest,
+ * including {@link longest} itself.
+ */
+export declare function allRegistryConfigKeys(longest: RegistryConfigKey): Generator<RegistryConfigKey, void, void>;
+export {};

package/lib/publish/registryConfigKeys.js

@@ -0,0 +1,50 @@
+import normalizeRegistryUrl from 'normalize-registry-url';
+/**
+ * If {@link text} starts with {@link oldPrefix}, replace it with {@link newPrefix}.
+ * Otherwise, return `undefined`.
+ */
+const replacePrefix = (text, oldPrefix, newPrefix) => text.startsWith(oldPrefix)
+    ? text.replace(oldPrefix, newPrefix)
+    : undefined;
+/**
+ * If {@link text} already ends with {@link suffix}, return it.
+ * Otherwise, append {@link suffix} to {@link text} and return it.
+ */
+const ensureSuffix = (text, suffix) => text.endsWith(suffix) ? text : `${text}${suffix}`;
+/**
+ * If the {@link registryUrl} is an HTTP or an HTTPS registry url, return the longest
+ * {@link RegistryConfigKey} that corresponds to the registry url and a {@link NormalizedRegistryUrl}
+ * that matches it.
+ */
+export function parseSupportedRegistryUrl(registryUrl) {
+    registryUrl = normalizeRegistryUrl(registryUrl);
+    const keyPrefix = replacePrefix(registryUrl, 'http://', '//') ?? replacePrefix(registryUrl, 'https://', '//');
+    if (!keyPrefix)
+        return undefined;
+    const normalizedUrl = ensureSuffix(registryUrl, '/');
+    const longestConfigKey = ensureSuffix(keyPrefix, '/');
+    return { normalizedUrl, longestConfigKey };
+}
+/**
+ * This value is used for termination check in {@link allRegistryConfigKeys} only.
+ * It is not actually a valid {@link RegistryConfigKey}.
+ */
+const EMPTY_REGISTRY_CONFIG_KEY = '///';
+/**
+ * Generate all {@link RegistryConfigKey} of the same hostname from the longest to the shortest,
+ * including {@link longest} itself.
+ */
+export function* allRegistryConfigKeys(longest) {
+    if (!longest.startsWith('//')) {
+        throw new RangeError(`The string ${JSON.stringify(longest)} is not a valid registry config key`);
+    }
+    if (longest === EMPTY_REGISTRY_CONFIG_KEY) {
+        throw new RangeError('Registry config key cannot be without hostname');
+    }
+    if (longest.length <= EMPTY_REGISTRY_CONFIG_KEY.length)
+        return;
+    yield longest;
+    const next = longest.replace(/[^/]*\/$/, '');
+    yield* allRegistryConfigKeys(next);
+}
+//# sourceMappingURL=registryConfigKeys.js.map

package/lib/publish/utils/shared-context.d.ts

@@ -0,0 +1,7 @@
+import type { AuthTokenContext } from '../oidc/authToken.js';
+import type { IdTokenContext } from '../oidc/idToken.js';
+import type { ProvenanceContext } from '../oidc/provenance.js';
+import type { OtpContext } from '../otp.js';
+type SharedContext = AuthTokenContext & IdTokenContext & ProvenanceContext & OtpContext;
+export declare const SHARED_CONTEXT: SharedContext;
+export {};

package/lib/publish/utils/shared-context.js

@@ -0,0 +1,20 @@
+import readline from 'node:readline';
+import { input } from '@inquirer/prompts';
+import { globalInfo, globalWarn } from '@pnpm/logger';
+import { fetch } from '@pnpm/network.fetch';
+import ciInfo from 'ci-info';
+import { publish as _publish } from 'libnpmpublish';
+const publish = _publish;
+export const SHARED_CONTEXT = {
+    Date,
+    createReadlineInterface: readline.createInterface.bind(null, { input: process.stdin }),
+    ciInfo,
+    enquirer: { input },
+    fetch,
+    globalInfo,
+    globalWarn,
+    process,
+    publish,
+    setTimeout,
+};
+//# sourceMappingURL=shared-context.js.map

package/lib/resolveUnpublishedDirs.d.ts

@@ -0,0 +1,10 @@
+import type { ReleasePlan } from '@pnpm/releasing.versioning';
+import { type PreviousChangelogOptions } from './publish/previousChangelog.js';
+export type CheckVersionPublished = (pkgName: string, version: string) => Promise<boolean>;
+export type UnpublishedProbeOptions = PreviousChangelogOptions & {
+    /** Overridable for tests; production probes the registry. */
+    checkVersionPublished?: CheckVersionPublished;
+    networkConcurrency?: number;
+};
+/** The releases in `plan` whose current version the registry does not have — {@link assembleReleasePlan}'s `unpublishedDirs`. */
+export declare function resolveUnpublishedDirs(plan: ReleasePlan, opts: UnpublishedProbeOptions): Promise<Set<string>>;

package/lib/resolveUnpublishedDirs.js

@@ -0,0 +1,14 @@
+import pLimit from 'p-limit';
+import { createVersionPublishedChecker } from './publish/previousChangelog.js';
+const DEFAULT_NETWORK_CONCURRENCY = 16;
+/** The releases in `plan` whose current version the registry does not have — {@link assembleReleasePlan}'s `unpublishedDirs`. */
+export async function resolveUnpublishedDirs(plan, opts) {
+    const checkVersionPublished = opts.checkVersionPublished ?? createVersionPublishedChecker(opts);
+    const limit = pLimit(opts.networkConcurrency ?? DEFAULT_NETWORK_CONCURRENCY);
+    const probed = await Promise.all(plan.releases.map((release) => limit(async () => ({
+        dir: release.dir,
+        published: await checkVersionPublished(release.name, release.currentVersion),
+    }))));
+    return new Set(probed.filter(({ published }) => !published).map(({ dir }) => dir));
+}
+//# sourceMappingURL=resolveUnpublishedDirs.js.map

package/lib/stage/approve.d.ts

@@ -0,0 +1,2 @@
+import type { StageOptions } from './types.js';
+export declare function stageApprove(opts: StageOptions, params: string[]): Promise<string>;

package/lib/stage/approve.js

@@ -0,0 +1,14 @@
+import { createStageContext } from './context.js';
+import { requireStageId } from './parsing.js';
+import { stageRequestWithOtp } from './request.js';
+export async function stageApprove(opts, params) {
+    const stageId = requireStageId(params, 'approve');
+    const context = createStageContext(opts);
+    await stageRequestWithOtp(context, {
+        url: new URL(`-/stage/${stageId}/approve`, context.registry).href,
+        init: { method: 'POST' },
+        action: `approve staged package ${stageId}`,
+    });
+    return `Staged package ${stageId} approved and published successfully.`;
+}
+//# sourceMappingURL=approve.js.map

package/lib/stage/context.d.ts

@@ -0,0 +1,14 @@
+import { createFetchFromRegistry } from '@pnpm/network.fetch';
+import type { StageOptions } from './types.js';
+/**
+ * Shared per-subcommand request context. Created once at the entry of each stage
+ * subcommand so that paginated calls (e.g. `stageList`) reuse a single
+ * `fetchFromRegistry` instance and a precomputed auth header.
+ */
+export interface StageContext {
+    opts: StageOptions;
+    registry: string;
+    authHeaderValue: string | undefined;
+    fetchFromRegistry: ReturnType<typeof createFetchFromRegistry>;
+}
+export declare function createStageContext(opts: StageOptions, packageName?: string): StageContext;

package/lib/stage/context.js

@@ -0,0 +1,25 @@
+import { pickRegistryForPackage } from '@pnpm/config.pick-registry-for-package';
+import { createGetAuthHeaderByURI } from '@pnpm/network.auth-header';
+import { createFetchFromRegistry } from '@pnpm/network.fetch';
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org/';
+export function createStageContext(opts, packageName) {
+    const registry = getStageRegistry(opts, packageName);
+    const getAuthHeaderByUri = createGetAuthHeaderByURI(opts.configByUri ?? {});
+    return {
+        opts,
+        registry,
+        authHeaderValue: packageName ? getAuthHeaderByUri(registry, { pkgName: packageName }) : getAuthHeaderByUri(registry),
+        fetchFromRegistry: createFetchFromRegistry(opts),
+    };
+}
+function getStageRegistry(opts, packageName) {
+    const registries = getRegistries(opts);
+    const registry = packageName
+        ? pickRegistryForPackage(registries, packageName)
+        : registries.default;
+    return registry.endsWith('/') ? registry : `${registry}/`;
+}
+function getRegistries(opts) {
+    return opts.registries ?? { default: opts.registry ?? DEFAULT_REGISTRY };
+}
+//# sourceMappingURL=context.js.map

package/lib/stage/download.d.ts

@@ -0,0 +1,2 @@
+import type { StageOptions } from './types.js';
+export declare function stageDownload(opts: StageOptions, params: string[]): Promise<string>;

package/lib/stage/download.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { PnpmError } from '@pnpm/error';
+import { createTarballFilename } from '../tarball/safeTarballFilename.js';
+import { summarizeTarball } from '../tarball/summarizeTarball.js';
+import { createStageContext } from './context.js';
+import { requireStageId } from './parsing.js';
+import { renderTarballSummary } from './rendering.js';
+import { stageRequest } from './request.js';
+export async function stageDownload(opts, params) {
+    const stageId = requireStageId(params, 'download');
+    const context = createStageContext(opts);
+    const response = await stageRequest(context, {
+        url: new URL(`-/stage/${stageId}/tarball`, context.registry).href,
+        init: { method: 'GET' },
+        action: `download staged package ${stageId}`,
+    });
+    const tarballData = Buffer.from(await response.arrayBuffer());
+    const summary = await summarizeTarball(tarballData);
+    const filename = createTarballFilename({ name: summary.name, version: summary.version, suffix: stageId });
+    const downloadedSummary = { ...summary, filename };
+    const downloadDir = path.resolve(opts.dir ?? process.cwd());
+    const outputPath = path.resolve(downloadDir, filename);
+    if (path.dirname(outputPath) !== downloadDir) {
+        throw new PnpmError('INVALID_TARBALL_FILENAME', `Invalid tarball filename "${filename}".`);
+    }
+    await fs.writeFile(outputPath, tarballData);
+    if (opts.json)
+        return JSON.stringify({ [summary.name]: downloadedSummary }, null, 2);
+    return `${renderTarballSummary(downloadedSummary)}\n${filename}`;
+}
+//# sourceMappingURL=download.js.map

package/lib/stage/errors.d.ts

@@ -0,0 +1,15 @@
+import { PnpmError } from '@pnpm/error';
+interface StageRegistryErrorProperties {
+    readonly action: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly text: string;
+}
+export declare class StageRegistryError extends PnpmError implements StageRegistryErrorProperties {
+    readonly action: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly text: string;
+    constructor(opts: StageRegistryErrorProperties);
+}
+export {};

package/lib/stage/errors.js

@@ -0,0 +1,17 @@
+import { PnpmError } from '@pnpm/error';
+export class StageRegistryError extends PnpmError {
+    action;
+    status;
+    statusText;
+    text;
+    constructor(opts) {
+        const statusDisplay = opts.statusText ? `${opts.status} ${opts.statusText}` : opts.status.toString();
+        const trimmedText = opts.text.trim();
+        super('STAGE_REGISTRY_ERROR', `Failed to ${opts.action} (status ${statusDisplay})${trimmedText ? `: ${trimmedText}` : ''}`);
+        this.action = opts.action;
+        this.status = opts.status;
+        this.statusText = opts.statusText;
+        this.text = opts.text;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/lib/stage/help.d.ts

@@ -0,0 +1 @@
+export declare function help(): string;

package/lib/stage/help.js

@@ -0,0 +1,84 @@
+import { FILTERING } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { renderHelp } from 'render-help';
+export function help() {
+    return renderHelp({
+        description: 'Stage packages for publishing, deferring proof-of-presence (2FA) to a later point in time.',
+        descriptionLists: [
+            {
+                title: 'Subcommands',
+                list: [
+                    {
+                        description: 'Stage a package for publishing.',
+                        name: 'publish',
+                    },
+                    {
+                        description: 'List all staged package versions.',
+                        name: 'list',
+                    },
+                    {
+                        description: 'View details of a specific staged package.',
+                        name: 'view',
+                    },
+                    {
+                        description: 'Approve a staged package, publishing it to the npm registry.',
+                        name: 'approve',
+                    },
+                    {
+                        description: 'Reject a staged package, removing it from the registry.',
+                        name: 'reject',
+                    },
+                    {
+                        description: 'Download the tarball of a staged package for inspection.',
+                        name: 'download',
+                    },
+                ],
+            },
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'The base URL of the npm registry.',
+                        name: '--registry <url>',
+                    },
+                    {
+                        description: 'Show information in JSON format for list, view, publish, and download.',
+                        name: '--json',
+                    },
+                    {
+                        description: 'Registers the staged package with the given tag. By default, the "latest" tag is used.',
+                        name: '--tag <tag>',
+                    },
+                    {
+                        description: 'Tells the registry whether the staged package should be public or restricted.',
+                        name: '--access <public|restricted>',
+                    },
+                    {
+                        description: 'Does everything stage publish would do except uploading to the registry.',
+                        name: '--dry-run',
+                    },
+                    {
+                        description: 'One-time password for approve and reject.',
+                        name: '--otp',
+                    },
+                    {
+                        description: 'Stage all publishable packages from the workspace.',
+                        name: '--recursive',
+                        shortAlias: '-r',
+                    },
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('stage'),
+        usages: [
+            'pnpm stage publish [<tarball>|<dir>] [--tag <tag>] [--access <public|restricted>] [options]',
+            'pnpm stage list [<package-spec>]',
+            'pnpm stage view <stage-id>',
+            'pnpm stage approve <stage-id>',
+            'pnpm stage reject <stage-id>',
+            'pnpm stage download <stage-id>',
+        ],
+    });
+}
+//# sourceMappingURL=help.js.map

package/lib/stage/index.d.ts

@@ -0,0 +1,13 @@
+import { help } from './help.js';
+import { type StageOptions } from './types.js';
+export { help };
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+export declare const completion: (_cliOpts: Record<string, unknown>, params: string[]) => Promise<Array<{
+    name: string;
+}>>;
+export declare function handler(opts: StageOptions, params: string[]): Promise<{
+    exitCode?: number;
+    output?: string;
+} | string | undefined>;

package/lib/stage/index.js

@@ -0,0 +1,57 @@
+import { types as allTypes } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { pick } from 'ramda';
+import * as publishCommand from '../publish/publish.js';
+import { stageApprove } from './approve.js';
+import { stageDownload } from './download.js';
+import { help } from './help.js';
+import { stageList } from './list.js';
+import { stagePublish } from './publish.js';
+import { stageReject } from './reject.js';
+import { STAGE_SUBCOMMANDS } from './types.js';
+import { stageView } from './view.js';
+export { help };
+export function rcOptionsTypes() {
+    return {
+        ...publishCommand.rcOptionsTypes(),
+        ...pick([
+            'registry',
+        ], allTypes),
+    };
+}
+export function cliOptionsTypes() {
+    return publishCommand.cliOptionsTypes();
+}
+export const commandNames = ['stage'];
+export const completion = async (_cliOpts, params) => {
+    if (params.length > 0)
+        return [];
+    return STAGE_SUBCOMMANDS.map((name) => ({ name }));
+};
+export async function handler(opts, params) {
+    const subcommand = params[0];
+    const subcommandParams = params.slice(1);
+    switch (subcommand) {
+        case 'publish':
+            return stagePublish(opts, subcommandParams);
+        case 'list':
+            return stageList(opts, subcommandParams);
+        case 'view':
+            return stageView(opts, subcommandParams);
+        case 'approve':
+            return stageApprove(opts, subcommandParams);
+        case 'reject':
+            return stageReject(opts, subcommandParams);
+        case 'download':
+            return stageDownload(opts, subcommandParams);
+        case undefined:
+            throw new PnpmError('STAGE_SUBCOMMAND_REQUIRED', 'Stage subcommand is required', {
+                hint: `Use one of: ${STAGE_SUBCOMMANDS.join(', ')}`,
+            });
+        default:
+            throw new PnpmError('STAGE_UNKNOWN_SUBCOMMAND', `Unknown stage subcommand "${subcommand}"`, {
+                hint: `Use one of: ${STAGE_SUBCOMMANDS.join(', ')}`,
+            });
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/stage/list.d.ts

@@ -0,0 +1,2 @@
+import type { StageOptions } from './types.js';
+export declare function stageList(opts: StageOptions, params: string[]): Promise<string>;

package/lib/stage/list.js

@@ -0,0 +1,49 @@
+import { PnpmError } from '@pnpm/error';
+import { createStageContext } from './context.js';
+import { parseStagePackageSpec } from './parsing.js';
+import { renderStageItem } from './rendering.js';
+import { stageJsonRequest } from './request.js';
+const PER_PAGE = 100;
+// Fail-safe bound on the pagination loop, so a registry that keeps answering
+// full pages with an inflated `total` cannot drive it forever.
+const MAX_PAGES = 1000;
+export async function stageList(opts, params) {
+    const packageFilter = parsePackageFilter(params[0]);
+    const context = createStageContext(opts, packageFilter);
+    const items = [];
+    let page = 0;
+    while (true) {
+        const url = new URL('-/stage', context.registry);
+        url.searchParams.set('page', page.toString());
+        url.searchParams.set('perPage', PER_PAGE.toString());
+        if (packageFilter) {
+            url.searchParams.set('package', packageFilter);
+        }
+        // eslint-disable-next-line no-await-in-loop
+        const res = await stageJsonRequest(context, { url: url.href, action: 'list staged packages' });
+        items.push(...res.items);
+        if (items.length >= res.total || res.items.length < PER_PAGE)
+            break;
+        page++;
+        if (page >= MAX_PAGES)
+            break;
+    }
+    if (opts.json)
+        return JSON.stringify(items, null, 2);
+    if (items.length === 0) {
+        return packageFilter
+            ? `No staged versions of package name "${packageFilter}".`
+            : 'No staged packages found.';
+    }
+    return items.map(renderStageItem).join('\n\n');
+}
+function parsePackageFilter(rawSpec) {
+    if (!rawSpec)
+        return undefined;
+    const spec = parseStagePackageSpec(rawSpec);
+    if (spec.rawSpec !== '' && spec.rawSpec !== '*') {
+        throw new PnpmError('STAGE_VERSION_SPECIFIER_UNSUPPORTED', 'Version specifiers are not supported for listing staged packages');
+    }
+    return spec.name;
+}
+//# sourceMappingURL=list.js.map

package/lib/stage/parsing.d.ts

@@ -0,0 +1,6 @@
+import type { StageSubcommand } from './types.js';
+export declare function parseStagePackageSpec(rawSpec: string): {
+    name: string;
+    rawSpec: string;
+};
+export declare function requireStageId(params: string[], subcommand: StageSubcommand): string;

package/lib/stage/parsing.js

@@ -0,0 +1,27 @@
+import { PnpmError } from '@pnpm/error';
+import npa from '@pnpm/npm-package-arg';
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function parseStagePackageSpec(rawSpec) {
+    let spec;
+    try {
+        spec = npa(rawSpec);
+    }
+    catch {
+        throw new PnpmError('INVALID_PACKAGE_SPEC', `Invalid package spec: ${rawSpec}`);
+    }
+    if (!spec.name) {
+        throw new PnpmError('INVALID_PACKAGE_SPEC', `Invalid package spec: ${rawSpec}`);
+    }
+    return { name: spec.name, rawSpec: spec.rawSpec };
+}
+export function requireStageId(params, subcommand) {
+    if (!params[0]) {
+        throw new PnpmError('STAGE_ID_REQUIRED', `Missing required <stage-id> for "pnpm stage ${subcommand}"`);
+    }
+    const stageId = params[0];
+    if (!UUID_REGEX.test(stageId)) {
+        throw new PnpmError('INVALID_STAGE_ID', 'stage-id must be a valid UUID');
+    }
+    return stageId;
+}
+//# sourceMappingURL=parsing.js.map