@pnpm/registry-access.commands 1100.3.6 → 1100.4.0

package/lib/access.d.ts

@@ -0,0 +1,16 @@
+import { type CreateFetchFromRegistryOptions } from '@pnpm/network.fetch';
+import type { Registries, RegistryConfig } from '@pnpm/types';
+import { rcOptionsTypes } from './common.js';
+export { rcOptionsTypes };
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export interface AccessOptions extends CreateFetchFromRegistryOptions {
+    cliOptions?: {
+        json?: boolean;
+        otp?: string;
+    };
+    configByUri?: Record<string, RegistryConfig>;
+    registries?: Registries;
+}
+export declare function handler(opts: AccessOptions, params: string[]): Promise<string>;

package/lib/access.js

@@ -0,0 +1,496 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { pickRegistryForPackage } from '@pnpm/config.pick-registry-for-package';
+import { PnpmError } from '@pnpm/error';
+import { createGetAuthHeaderByURI } from '@pnpm/network.auth-header';
+import { createFetchFromRegistry } from '@pnpm/network.fetch';
+import npa from '@pnpm/npm-package-arg';
+import { renderHelp } from 'render-help';
+import { normalizeRegistryUrl, rcOptionsTypes } from './common.js';
+export { rcOptionsTypes };
+const DEFAULT_REGISTRY_URL = 'https://registry.npmjs.org/';
+const ERROR_BODY_LIMIT = 64 * 1024;
+function getRegistries(opts) {
+    return opts.registries ?? { default: DEFAULT_REGISTRY_URL };
+}
+export function cliOptionsTypes() {
+    return {
+        ...rcOptionsTypes(),
+        json: Boolean,
+        otp: String,
+    };
+}
+export const commandNames = ['access'];
+export function help() {
+    return renderHelp({
+        description: 'Manages package access and visibility on the registry.',
+        descriptionLists: [
+            {
+                title: 'Commands',
+                list: [
+                    {
+                        description: 'List packages a user, scope, or team can access.',
+                        name: 'list packages',
+                    },
+                    {
+                        description: 'List collaborators on a package.',
+                        name: 'list collaborators',
+                    },
+                    {
+                        description: 'Get the public/restricted status of a package.',
+                        name: 'get status',
+                    },
+                    {
+                        description: 'Set the package visibility (public/private).',
+                        name: 'set status',
+                    },
+                    {
+                        description: 'Set the 2FA requirement for a package (none/publish/automation).',
+                        name: 'set mfa',
+                    },
+                    {
+                        description: 'Grant read-only or read-write access to a team.',
+                        name: 'grant',
+                    },
+                    {
+                        description: 'Revoke a team\'s access to a package.',
+                        name: 'revoke',
+                    },
+                ],
+            },
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'The base URL of the npm registry.',
+                        name: '--registry <url>',
+                    },
+                    {
+                        description: 'Output results in JSON format.',
+                        name: '--json',
+                    },
+                    {
+                        description: 'One-time password for registries that require two-factor authentication.',
+                        name: '--otp',
+                    },
+                ],
+            },
+        ],
+        url: docsUrl('access'),
+        usages: [
+            'pnpm access list packages [<user>|<scope>|<scope:team>]',
+            'pnpm access list collaborators [<package> [<user>]]',
+            'pnpm access get status [<package>]',
+            'pnpm access set status=public|private [<package>]',
+            'pnpm access set mfa=none|publish|automation [<package>]',
+            'pnpm access grant <read-only|read-write> <scope:team> [<package>]',
+            'pnpm access revoke <scope:team> [<package>]',
+        ],
+    });
+}
+export async function handler(opts, params) {
+    if (params.length === 0) {
+        throw new PnpmError('ACCESS_SUBCOMMAND_REQUIRED', 'A subcommand is required (e.g., "list packages", "get status", "set status=public", "grant", "revoke")');
+    }
+    const first = params[0];
+    const second = params[1];
+    if (first === 'list' && second === 'packages') {
+        return listPackages(opts, params.slice(2));
+    }
+    if (first === 'list' && second === 'collaborators') {
+        return listCollaborators(opts, params.slice(2));
+    }
+    if (first === 'ls' && (second == null || second === 'packages')) {
+        return listPackages(opts, second === 'packages' ? params.slice(2) : params.slice(1));
+    }
+    if (first === 'get' && second === 'status') {
+        return getStatus(opts, params.slice(2));
+    }
+    if (first === 'set') {
+        if (second == null) {
+            throw new PnpmError('ACCESS_SET_REQUIRED', 'A value is required (e.g., "status=public" or "mfa=none")');
+        }
+        if (second.startsWith('status=')) {
+            return setStatus(opts, params.slice(1));
+        }
+        if (second.startsWith('mfa=')) {
+            return setMfa(opts, params.slice(1));
+        }
+        throw new PnpmError('ACCESS_SET_INVALID', `Unknown set parameter "${second}". Use "status=public|private" or "mfa=none|publish|automation".`);
+    }
+    if (first === 'grant') {
+        return grantAccess(opts, params.slice(1));
+    }
+    if (first === 'revoke') {
+        return revokeAccess(opts, params.slice(1));
+    }
+    // Handle deprecated npm access forms: public/restricted
+    if (first === 'public') {
+        return setStatus(opts, ['status=public', ...params.slice(1)]);
+    }
+    if (first === 'restricted') {
+        return setStatus(opts, ['status=restricted', ...params.slice(1)]);
+    }
+    throw new PnpmError('ACCESS_UNKNOWN_SUBCOMMAND', `Unknown subcommand: ${params.join(' ')}. Run "pnpm help access" for available subcommands.`);
+}
+async function listPackages(opts, params) {
+    const registries = getRegistries(opts);
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const authHeader = getAuthHeaderForRegistry(opts.configByUri, registries.default ?? DEFAULT_REGISTRY_URL);
+    const jsonMode = opts.cliOptions?.json ?? false;
+    const ctx = { registries, fetchFromRegistry, authHeader, jsonMode };
+    let entity;
+    let entityType;
+    if (params.length > 0) {
+        const raw = params[0];
+        if (raw.includes(':')) {
+            entityType = 'team';
+            entity = raw;
+        }
+        else if (raw.startsWith('@')) {
+            entityType = 'org';
+            entity = raw.replace(/^@/, '');
+        }
+        else {
+            entityType = 'user';
+            entity = raw;
+        }
+    }
+    if (entityType == null || entity == null) {
+        return listOwnPackages(ctx);
+    }
+    return listEntityPackages(entityType, entity, ctx);
+}
+async function listOwnPackages(ctx) {
+    const registryUrl = normalizeRegistryUrl(ctx.registries.default ?? DEFAULT_REGISTRY_URL);
+    const url = new URL('-/-/package?format=cli', registryUrl).href;
+    return fetchListResponse(url, ctx);
+}
+async function listEntityPackages(entityType, entity, ctx) {
+    const registryUrl = normalizeRegistryUrl(ctx.registries.default ?? DEFAULT_REGISTRY_URL);
+    let listUrl;
+    if (entityType === 'team') {
+        const [scope, team] = entity.split(':');
+        listUrl = new URL(`-/team/${encodeURIComponent(scope.startsWith('@') ? scope.slice(1) : scope)}/${encodeURIComponent(team)}/package?format=cli`, registryUrl).href;
+    }
+    else if (entityType === 'org') {
+        listUrl = new URL(`-/org/${encodeURIComponent(entity)}/package?format=cli`, registryUrl).href;
+    }
+    else {
+        listUrl = new URL(`-/user/${encodeURIComponent(entity)}/package?format=cli`, registryUrl).href;
+    }
+    return fetchListResponse(listUrl, ctx);
+}
+async function fetchListResponse(url, ctx) {
+    const response = await ctx.fetchFromRegistry(url, {
+        authHeaderValue: ctx.authHeader,
+    });
+    if (!response.ok) {
+        await throwRegistryError(response, 'list packages from');
+    }
+    const data = await response.json();
+    if (ctx.jsonMode) {
+        return JSON.stringify(data, null, 2);
+    }
+    return formatPackagesList(data);
+}
+function formatPackagesList(data) {
+    const lines = [];
+    for (const [pkg, access] of Object.entries(data)) {
+        if (typeof access === 'string') {
+            lines.push(`${pkg}: ${access}`);
+        }
+        else {
+            lines.push(pkg);
+        }
+    }
+    return lines.sort().join('\n');
+}
+async function listCollaborators(opts, params) {
+    if (params.length === 0) {
+        throw new PnpmError('ACCESS_LIST_COLLABORATORS_PACKAGE_REQUIRED', 'Package name is required (e.g., pnpm access list collaborators @scope/pkg)');
+    }
+    const packageName = params[0];
+    const user = params[1];
+    const registries = getRegistries(opts);
+    const registryUrl = pickRegistryForPackage(registries, packageName);
+    const authHeader = getAuthHeaderForRegistry(opts.configByUri, registryUrl, packageName);
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const jsonMode = opts.cliOptions?.json ?? false;
+    let collaboratorsUrl;
+    if (user) {
+        collaboratorsUrl = new URL(`-/package/${escapePackageName(packageName)}/collaborators?format=cli&user=${encodeURIComponent(user)}`, normalizeRegistryUrl(registryUrl)).href;
+    }
+    else {
+        collaboratorsUrl = new URL(`-/package/${escapePackageName(packageName)}/collaborators?format=cli`, normalizeRegistryUrl(registryUrl)).href;
+    }
+    const response = await fetchFromRegistry(collaboratorsUrl, {
+        authHeaderValue: authHeader,
+    });
+    if (!response.ok) {
+        if (response.status === 404) {
+            throw new PnpmError('PACKAGE_NOT_FOUND', `Package "${packageName}" not found in registry`);
+        }
+        await throwRegistryError(response, 'list collaborators for');
+    }
+    const data = await response.json();
+    if (jsonMode) {
+        return JSON.stringify(data, null, 2);
+    }
+    return formatCollaboratorsList(data);
+}
+function formatCollaboratorsList(data) {
+    const lines = [];
+    for (const entry of data) {
+        const user = entry.user ?? entry.username ?? 'unknown';
+        const email = entry.email ?? '';
+        const permissions = entry.permissions ?? 'read-only';
+        lines.push(`${String(user)}${email ? ` <${email}>` : ''}: ${permissions}`);
+    }
+    return lines.sort().join('\n');
+}
+async function getStatus(opts, params) {
+    if (params.length === 0) {
+        throw new PnpmError('ACCESS_GET_STATUS_PACKAGE_REQUIRED', 'Package name is required (e.g., pnpm access get status @scope/pkg)');
+    }
+    const packageName = params[0];
+    const registries = getRegistries(opts);
+    const registryUrl = pickRegistryForPackage(registries, packageName);
+    const authHeader = getAuthHeaderForRegistry(opts.configByUri, registryUrl, packageName);
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const jsonMode = opts.cliOptions?.json ?? false;
+    const accessUrl = new URL(`-/package/${escapePackageName(packageName)}/access`, normalizeRegistryUrl(registryUrl)).href;
+    const response = await fetchFromRegistry(accessUrl, {
+        authHeaderValue: authHeader,
+    });
+    if (!response.ok) {
+        if (response.status === 404) {
+            throw new PnpmError('PACKAGE_NOT_FOUND', `Package "${packageName}" not found in registry`);
+        }
+        await throwRegistryError(response, 'get status of');
+    }
+    const data = await response.json();
+    if (jsonMode) {
+        return JSON.stringify(data, null, 2);
+    }
+    const lines = [];
+    if (data.access) {
+        lines.push(`package: ${packageName}`);
+        lines.push(`access: ${data.access}`);
+    }
+    else {
+        lines.push(`package: ${packageName}`);
+        lines.push('access: public');
+    }
+    return lines.join('\n');
+}
+async function setStatus(opts, params) {
+    if (params.length === 0 || !params[0].startsWith('status=')) {
+        throw new PnpmError('ACCESS_SET_STATUS_REQUIRED', 'Package visibility is required (e.g., pnpm access set status=public @scope/pkg)');
+    }
+    const accessValue = params[0].slice('status='.length);
+    if (accessValue !== 'public' && accessValue !== 'private' && accessValue !== 'restricted') {
+        throw new PnpmError('ACCESS_SET_STATUS_INVALID', `Invalid access value "${accessValue}". Must be "public" or "private".`);
+    }
+    const normalizedAccess = accessValue === 'private' || accessValue === 'restricted' ? 'restricted' : 'public';
+    const packageName = params[1];
+    if (!packageName) {
+        throw new PnpmError('ACCESS_SET_STATUS_PACKAGE_REQUIRED', 'Package name is required (e.g., pnpm access set status=public @scope/pkg)');
+    }
+    if (!packageName.startsWith('@')) {
+        throw new PnpmError('ACCESS_SET_STATUS_UNSCOPED', 'Access settings can only be changed for scoped packages (@scope/name). Unscoped packages are always public.');
+    }
+    const registries = getRegistries(opts);
+    const registryUrl = pickRegistryForPackage(registries, packageName);
+    const authHeader = getAuthHeaderForRegistry(opts.configByUri, registryUrl, packageName);
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const otp = opts.cliOptions?.otp;
+    const accessUrl = new URL(`-/package/${escapePackageName(packageName)}/access`, normalizeRegistryUrl(registryUrl)).href;
+    const response = await fetchFromRegistry(accessUrl, {
+        authHeaderValue: authHeader,
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            ...(otp ? { 'npm-otp': otp } : {}),
+        },
+        body: JSON.stringify({ access: normalizedAccess }),
+    });
+    if (!response.ok) {
+        await throwRegistryError(response, `set access to "${normalizedAccess}" for`);
+    }
+    return `${packageName}: ${normalizedAccess === 'public' ? 'public' : 'restricted'}`;
+}
+async function setMfa(opts, params) {
+    if (params.length === 0 || !params[0].startsWith('mfa=')) {
+        throw new PnpmError('ACCESS_SET_MFA_REQUIRED', 'MFA level is required (e.g., pnpm access set mfa=automation @scope/pkg)');
+    }
+    const mfaValue = params[0].slice('mfa='.length);
+    if (!['none', 'publish', 'automation'].includes(mfaValue)) {
+        throw new PnpmError('ACCESS_SET_MFA_INVALID', `Invalid MFA value "${mfaValue}". Must be "none", "publish", or "automation".`);
+    }
+    const packageName = params[1];
+    if (!packageName) {
+        throw new PnpmError('ACCESS_SET_MFA_PACKAGE_REQUIRED', 'Package name is required (e.g., pnpm access set mfa=automation @scope/pkg)');
+    }
+    const registries = getRegistries(opts);
+    const registryUrl = pickRegistryForPackage(registries, packageName);
+    const authHeader = getAuthHeaderForRegistry(opts.configByUri, registryUrl, packageName);
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const otp = opts.cliOptions?.otp;
+    const accessUrl = new URL(`-/package/${escapePackageName(packageName)}/access`, normalizeRegistryUrl(registryUrl)).href;
+    const publishRequiresTfa = mfaValue !== 'none';
+    const response = await fetchFromRegistry(accessUrl, {
+        authHeaderValue: authHeader,
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            ...(otp ? { 'npm-otp': otp } : {}),
+        },
+        body: JSON.stringify({ publish_requires_tfa: publishRequiresTfa }),
+    });
+    if (!response.ok) {
+        await throwRegistryError(response, 'set MFA for');
+    }
+    return `${packageName}: mfa=${mfaValue}`;
+}
+async function grantAccess(opts, params) {
+    if (params.length < 2) {
+        throw new PnpmError('ACCESS_GRANT_ARGS_REQUIRED', 'Permissions and scope:team are required (e.g., pnpm access grant read-only @scope:developers @scope/pkg)');
+    }
+    const permissions = params[0];
+    if (permissions !== 'read-only' && permissions !== 'read-write') {
+        throw new PnpmError('ACCESS_GRANT_INVALID_PERMISSIONS', `Invalid permissions "${permissions}". Must be "read-only" or "read-write".`);
+    }
+    const scopeTeam = params[1];
+    if (!scopeTeam.includes(':')) {
+        throw new PnpmError('ACCESS_GRANT_INVALID_TEAM', `Invalid team "${scopeTeam}". Format must be "scope:team".`);
+    }
+    const packageName = params[2];
+    if (!packageName) {
+        throw new PnpmError('ACCESS_GRANT_PACKAGE_REQUIRED', 'Package name is required (e.g., pnpm access grant read-only @scope:developers @scope/pkg)');
+    }
+    const [scope, team] = scopeTeam.split(':');
+    const registries = getRegistries(opts);
+    const registryUrl = pickRegistryForPackage(registries, packageName);
+    const authHeader = getAuthHeaderForRegistry(opts.configByUri, registryUrl, packageName);
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const otp = opts.cliOptions?.otp;
+    const grantUrl = new URL(`-/team/${encodeURIComponent(scope.startsWith('@') ? scope.slice(1) : scope)}/${encodeURIComponent(team)}/package`, normalizeRegistryUrl(registryUrl)).href;
+    const response = await fetchFromRegistry(grantUrl, {
+        authHeaderValue: authHeader,
+        method: 'PUT',
+        headers: {
+            'content-type': 'application/json',
+            ...(otp ? { 'npm-otp': otp } : {}),
+        },
+        body: JSON.stringify({ package: packageName, permissions }),
+    });
+    if (!response.ok) {
+        await throwRegistryError(response, `grant ${permissions} access for ${scopeTeam} on`);
+    }
+    return `+${scopeTeam} (${permissions}): ${packageName}`;
+}
+async function revokeAccess(opts, params) {
+    if (params.length < 1) {
+        throw new PnpmError('ACCESS_REVOKE_ARGS_REQUIRED', 'scope:team and package name are required (e.g., pnpm access revoke @scope:developers @scope/pkg)');
+    }
+    const scopeTeam = params[0];
+    if (!scopeTeam.includes(':')) {
+        throw new PnpmError('ACCESS_REVOKE_INVALID_TEAM', `Invalid team "${scopeTeam}". Format must be "scope:team".`);
+    }
+    const packageName = params[1];
+    if (!packageName) {
+        throw new PnpmError('ACCESS_REVOKE_PACKAGE_REQUIRED', 'Package name is required (e.g., pnpm access revoke @scope:developers @scope/pkg)');
+    }
+    const [scope, team] = scopeTeam.split(':');
+    const registries = getRegistries(opts);
+    const registryUrl = pickRegistryForPackage(registries, packageName);
+    const authHeader = getAuthHeaderForRegistry(opts.configByUri, registryUrl, packageName);
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const otp = opts.cliOptions?.otp;
+    const revokeUrl = new URL(`-/team/${encodeURIComponent(scope.startsWith('@') ? scope.slice(1) : scope)}/${encodeURIComponent(team)}/package`, normalizeRegistryUrl(registryUrl)).href;
+    const response = await fetchFromRegistry(revokeUrl, {
+        authHeaderValue: authHeader,
+        method: 'DELETE',
+        headers: {
+            'content-type': 'application/json',
+            ...(otp ? { 'npm-otp': otp } : {}),
+        },
+        body: JSON.stringify({ package: packageName }),
+    });
+    if (!response.ok) {
+        await throwRegistryError(response, `revoke ${scopeTeam}'s access to`);
+    }
+    return `-${scopeTeam}: ${packageName}`;
+}
+function getAuthHeaderForRegistry(configByUri, registryUrl, packageName) {
+    const getAuthHeader = createGetAuthHeaderByURI(configByUri ?? {});
+    return getAuthHeader(registryUrl, packageName ? { pkgName: packageName } : undefined);
+}
+function escapePackageName(packageName) {
+    let parsed;
+    try {
+        parsed = npa(packageName);
+    }
+    catch {
+        throw new PnpmError('ACCESS_INVALID_PACKAGE_NAME', `Invalid package name "${packageName}"`);
+    }
+    return parsed.escapedName ?? encodeURIComponent(packageName).replace(/^%40/, '@');
+}
+async function throwRegistryError(response, action) {
+    const errorBody = sanitize(await readErrorBody(response));
+    if (response.status === 401) {
+        throw new PnpmError('UNAUTHORIZED', `You must be logged in to ${action} packages. ${errorBody}`);
+    }
+    if (response.status === 403) {
+        throw new PnpmError('FORBIDDEN', `You do not have permission to ${action} this package. ${errorBody}`);
+    }
+    if (response.status === 404) {
+        throw new PnpmError('PACKAGE_NOT_FOUND', `Package not found in registry. ${errorBody}`);
+    }
+    if (response.status === 422) {
+        throw new PnpmError('ACCESS_VALIDATION_ERROR', `Invalid request: ${errorBody}`);
+    }
+    throw new PnpmError('REGISTRY_ERROR', `Failed to ${action} package: ${response.status} ${response.statusText}. ${errorBody}`);
+}
+async function readErrorBody(response) {
+    const reader = response.body?.getReader();
+    if (reader == null)
+        return '';
+    const chunks = [];
+    let total = 0;
+    let truncated = false;
+    while (total < ERROR_BODY_LIMIT) {
+        // eslint-disable-next-line no-await-in-loop
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        const need = ERROR_BODY_LIMIT - total;
+        if (value.length > need) {
+            chunks.push(value.subarray(0, need));
+            truncated = true;
+            break;
+        }
+        chunks.push(value);
+        total += value.length;
+    }
+    reader.cancel().catch(() => { });
+    let body = new TextDecoder().decode(Buffer.concat(chunks));
+    if (truncated) {
+        if (body.length > 0 && !body.endsWith(' ')) {
+            body += ' ';
+        }
+        body += '(response body truncated)';
+    }
+    return body;
+}
+function sanitize(text) {
+    let result = '';
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        if ((code > 31 && code !== 127) || code === 9 || code === 10) {
+            result += text[i];
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=access.js.map

package/lib/index.d.ts

@@ -1,3 +1,4 @@
+import * as access from './access.js';
 import * as deprecate from './deprecation/deprecate.js';
 import * as undeprecate from './deprecation/undeprecate.js';
 import * as distTag from './distTag.js';
@@ -9,4 +10,4 @@ import * as stars from './star/stars.js';
 import * as unstar from './star/unstar.js';
 import * as unpublish from './unpublish.js';
 import * as whoami from './whoami.js';
-export { deprecate, distTag, owner, ping, search, star, stars, undeprecate, unpublish, unstar, whoami };
+export { access, deprecate, distTag, owner, ping, search, star, stars, undeprecate, unpublish, unstar, whoami };

package/lib/index.js

@@ -1,3 +1,4 @@
+import * as access from './access.js';
 import * as deprecate from './deprecation/deprecate.js';
 import * as undeprecate from './deprecation/undeprecate.js';
 import * as distTag from './distTag.js';
@@ -9,5 +10,5 @@ import * as stars from './star/stars.js';
 import * as unstar from './star/unstar.js';
 import * as unpublish from './unpublish.js';
 import * as whoami from './whoami.js';
-export { deprecate, distTag, owner, ping, search, star, stars, undeprecate, unpublish, unstar, whoami };
+export { access, deprecate, distTag, owner, ping, search, star, stars, undeprecate, unpublish, unstar, whoami };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/registry-access.commands",
-  "version": "1100.3.6",
+  "version": "1100.4.0",
   "description": "Commands for managing packages on the registry",
   "keywords": [
     "pnpm",
@@ -33,16 +33,16 @@
     "ramda": "npm:@pnpm/ramda@0.28.1",
     "render-help": "^2.0.0",
     "semver": "^7.8.4",
-    "@pnpm/config.reader": "1101.10.1",
     "@pnpm/cli.utils": "1101.0.13",
+    "@pnpm/config.pick-registry-for-package": "1100.0.9",
+    "@pnpm/config.reader": "1101.11.1",
     "@pnpm/error": "1100.0.1",
     "@pnpm/network.fetch": "1100.1.4",
-    "@pnpm/config.pick-registry-for-package": "1100.0.9",
-    "@pnpm/registry-access.client": "1100.1.5",
-    "@pnpm/network.web-auth": "1101.1.2",
+    "@pnpm/network.web-auth": "1101.2.0",
+    "@pnpm/network.auth-header": "1101.1.3",
+    "@pnpm/registry-access.client": "1100.1.6",
     "@pnpm/resolving.registry.types": "1100.1.3",
-    "@pnpm/types": "1101.3.2",
-    "@pnpm/network.auth-header": "1101.1.3"
+    "@pnpm/types": "1101.3.2"
   },
   "peerDependencies": {
     "@pnpm/logger": "^1100.0.0"
@@ -53,12 +53,12 @@
     "@types/semver": "7.7.1",
     "execa": "npm:safe-execa@0.3.0",
     "@pnpm/logger": "1100.0.0",
-    "@pnpm/prepare": "1100.0.17",
-    "@pnpm/releasing.commands": "1100.5.2",
-    "@pnpm/registry-access.commands": "1100.3.6",
-    "@pnpm/testing.registry-mock": "1100.0.7",
+    "@pnpm/registry-access.commands": "1100.4.0",
+    "@pnpm/releasing.commands": "1100.5.4",
+    "@pnpm/testing.command-defaults": "1100.0.8",
     "@pnpm/testing.mock-agent": "1101.0.4",
-    "@pnpm/testing.command-defaults": "1100.0.7"
+    "@pnpm/prepare": "1100.0.18",
+    "@pnpm/testing.registry-mock": "1100.0.8"
   },
   "engines": {
     "node": ">=22.13"