@pnpm/registry-access.commands 1100.0.0 → 1100.2.0

package/lib/common.d.ts

@@ -1,5 +1,7 @@
 export declare function rcOptionsTypes(): Record<string, unknown>;
 export declare function parsePackageSpec(spec: string): {
     name: string;
+    escapedName: string;
     versionRange: string | undefined;
 };
+export declare function normalizeRegistryUrl(registryUrl: string): string;

package/lib/common.js

@@ -15,10 +15,13 @@ export function parsePackageSpec(spec) {
     catch {
         throw new PnpmError('INVALID_PACKAGE_SPEC', `Invalid package spec: ${spec}`);
     }
-    if (!parsed.name) {
+    if (!parsed.name || !parsed.escapedName) {
         throw new PnpmError('INVALID_PACKAGE_SPEC', `Invalid package spec: ${spec}`);
     }
     const versionRange = parsed.rawSpec || undefined;
-    return { name: parsed.name, versionRange };
+    return { name: parsed.name, escapedName: parsed.escapedName, versionRange };
+}
+export function normalizeRegistryUrl(registryUrl) {
+    return registryUrl.endsWith('/') ? registryUrl : `${registryUrl}/`;
 }
 //# sourceMappingURL=common.js.map

package/lib/index.d.ts

@@ -1,5 +1,11 @@
 import * as deprecate from './deprecation/deprecate.js';
 import * as undeprecate from './deprecation/undeprecate.js';
 import * as distTag from './distTag.js';
+import * as ping from './ping.js';
+import * as search from './search.js';
+import * as star from './star/star.js';
+import * as stars from './star/stars.js';
+import * as unstar from './star/unstar.js';
 import * as unpublish from './unpublish.js';
-export { deprecate, distTag, undeprecate, unpublish };
+import * as whoami from './whoami.js';
+export { deprecate, distTag, ping, search, star, stars, undeprecate, unpublish, unstar, whoami };

package/lib/index.js

@@ -1,6 +1,12 @@
 import * as deprecate from './deprecation/deprecate.js';
 import * as undeprecate from './deprecation/undeprecate.js';
 import * as distTag from './distTag.js';
+import * as ping from './ping.js';
+import * as search from './search.js';
+import * as star from './star/star.js';
+import * as stars from './star/stars.js';
+import * as unstar from './star/unstar.js';
 import * as unpublish from './unpublish.js';
-export { deprecate, distTag, undeprecate, unpublish };
+import * as whoami from './whoami.js';
+export { deprecate, distTag, ping, search, star, stars, undeprecate, unpublish, unstar, whoami };
 //# sourceMappingURL=index.js.map

package/lib/ping.d.ts

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

package/lib/ping.js

@@ -0,0 +1,78 @@
+import util from 'node:util';
+import { docsUrl } from '@pnpm/cli.utils';
+import { PnpmError } from '@pnpm/error';
+import { createGetAuthHeaderByURI } from '@pnpm/network.auth-header';
+import { createFetchFromRegistry } from '@pnpm/network.fetch';
+import { renderHelp } from 'render-help';
+import { rcOptionsTypes as commonRcOptionsTypes } from './common.js';
+export function cliOptionsTypes() {
+    return {
+        ...commonRcOptionsTypes(),
+    };
+}
+export function rcOptionsTypes() {
+    return commonRcOptionsTypes();
+}
+export const commandNames = ['ping'];
+export function help() {
+    return renderHelp({
+        description: 'Test connectivity to the configured registry.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Test a specific registry URL',
+                        name: '--registry <url>',
+                    },
+                ],
+            },
+        ],
+        url: docsUrl('ping'),
+        usages: ['pnpm ping [--registry <url>]'],
+    });
+}
+export async function handler(opts) {
+    const registryUrl = opts.registry ?? opts.registries?.default ?? 'https://registry.npmjs.org/';
+    const normalizedRegistryUrl = registryUrl.endsWith('/') ? registryUrl : `${registryUrl}/`;
+    const pingUrlObject = new URL('./-/ping', normalizedRegistryUrl);
+    pingUrlObject.searchParams.set('write', 'true');
+    const pingUrl = pingUrlObject.toString();
+    const getAuthHeader = createGetAuthHeaderByURI(opts.configByUri ?? {}, normalizedRegistryUrl);
+    const authHeaderValue = getAuthHeader(normalizedRegistryUrl);
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const start = Date.now();
+    let response;
+    try {
+        response = await fetchFromRegistry(pingUrl, {
+            retry: { retries: 0 },
+            authHeaderValue,
+        });
+    }
+    catch (err) {
+        const errorMessage = util.types.isNativeError(err) ? err.message : String(err);
+        throw new PnpmError('PING_ERROR', `Failed to reach registry: ${errorMessage}`);
+    }
+    if (!response.ok) {
+        throw new PnpmError('PING_ERROR', `Failed to reach registry: ${response.status} ${response.statusText}`.trimEnd());
+    }
+    const body = await response.text();
+    const time = Date.now() - start;
+    let details = '';
+    if (body) {
+        try {
+            const parsed = JSON.parse(body);
+            if (parsed && typeof parsed === 'object' && Object.keys(parsed).length > 0) {
+                details = JSON.stringify(parsed, null, 2);
+            }
+        }
+        catch {
+            // non-JSON body — ignore
+        }
+    }
+    const lines = [`PING ${registryUrl}`, `PONG ${time}ms`];
+    if (details)
+        lines.push(`PONG ${details}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=ping.js.map

package/lib/search.d.ts

@@ -0,0 +1,33 @@
+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 SearchPackage {
+    name: string;
+    version: string;
+    description?: string;
+    date?: string;
+    author?: {
+        name: string;
+    } | string;
+    publisher?: {
+        username: string;
+    };
+    maintainers?: Array<{
+        username: string;
+    }>;
+    keywords?: string[];
+}
+export interface SearchResult {
+    package: SearchPackage;
+}
+export interface SearchOptions extends CreateFetchFromRegistryOptions {
+    configByUri?: Record<string, RegistryConfig>;
+    registries?: Registries;
+    json?: boolean;
+    searchLimit?: number;
+}
+export declare function handler(opts: SearchOptions, params: string[]): Promise<string>;

package/lib/search.js

@@ -0,0 +1,100 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { PnpmError } from '@pnpm/error';
+import { createGetAuthHeaderByURI } from '@pnpm/network.auth-header';
+import { createFetchFromRegistry } from '@pnpm/network.fetch';
+import chalk from 'chalk';
+import { renderHelp } from 'render-help';
+import { rcOptionsTypes } from './common.js';
+export { rcOptionsTypes };
+export function cliOptionsTypes() {
+    return {
+        ...rcOptionsTypes(),
+        json: Boolean,
+        'search-limit': Number,
+    };
+}
+export const commandNames = ['search', 's', 'se', 'find'];
+export function help() {
+    return renderHelp({
+        description: 'Search for packages in the registry.',
+        url: docsUrl('search'),
+        usages: [
+            'pnpm search <keyword> ...',
+        ],
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Show search results in JSON format',
+                        name: '--json',
+                    },
+                    {
+                        description: 'Maximum number of results to show (default: 20)',
+                        name: '--search-limit <number>',
+                    },
+                ],
+            },
+        ],
+    });
+}
+export async function handler(opts, params) {
+    const query = params.join(' ');
+    if (!query) {
+        throw new PnpmError('MISSING_SEARCH_QUERY', 'Search query is required. Usage: pnpm search <keyword>');
+    }
+    const registry = opts.registries?.default ?? 'https://registry.npmjs.org/';
+    const registryUrl = new URL(registry);
+    if (!registryUrl.pathname.endsWith('/')) {
+        registryUrl.pathname = `${registryUrl.pathname}/`;
+    }
+    const searchUrl = new URL('./-/v1/search', registryUrl);
+    searchUrl.searchParams.set('text', query);
+    searchUrl.searchParams.set('size', (opts.searchLimit ?? 20).toString());
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const getAuthHeader = createGetAuthHeaderByURI(opts.configByUri ?? {}, opts.registries?.default);
+    const response = await fetchFromRegistry(searchUrl.toString(), {
+        authHeaderValue: getAuthHeader(registry),
+    });
+    if (!response.ok) {
+        const errorBody = (await response.text()).trim();
+        throw new PnpmError('SEARCH_FAILED', errorBody
+            ? `Search failed with status ${response.status}: ${response.statusText}. ${errorBody}`
+            : `Search failed with status ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (opts.json) {
+        return JSON.stringify(data.objects.map(obj => obj.package), null, 2);
+    }
+    if (data.objects.length === 0) {
+        return 'No packages found';
+    }
+    return data.objects.map(obj => formatPackage(obj.package)).join('\n\n');
+}
+function formatPackage(pkg) {
+    const author = typeof pkg.author === 'object'
+        ? pkg.author.name
+        : (pkg.author ?? pkg.publisher?.username ?? '');
+    const date = pkg.date ? pkg.date.split('T')[0] : '';
+    const lines = [
+        chalk.bold(pkg.name),
+    ];
+    if (pkg.description) {
+        lines.push(pkg.description);
+    }
+    const versionLine = [`Version ${pkg.version}`];
+    if (date)
+        versionLine.push(`published ${date}`);
+    if (author)
+        versionLine.push(`by ${author}`);
+    lines.push(versionLine.join(' '));
+    if (pkg.maintainers?.length) {
+        lines.push(`Maintainers: ${pkg.maintainers.map(m => m.username).join(', ')}`);
+    }
+    if (pkg.keywords?.length) {
+        lines.push(`Keywords: ${pkg.keywords.join(', ')}`);
+    }
+    lines.push(chalk.blueBright(`https://npmx.dev/package/${pkg.name}`));
+    return lines.join('\n');
+}
+//# sourceMappingURL=search.js.map

package/lib/star/common.d.ts

@@ -0,0 +1,15 @@
+import { type CreateFetchFromRegistryOptions } from '@pnpm/network.fetch';
+import type { Registries, RegistryConfig } from '@pnpm/types';
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export interface StarOptions extends CreateFetchFromRegistryOptions {
+    configByUri?: Record<string, RegistryConfig>;
+    registries?: Registries;
+}
+interface StarActionArgs {
+    packageName: string;
+    star: boolean;
+}
+export declare function performStarAction(opts: StarOptions, { packageName, star }: StarActionArgs): Promise<void>;
+export declare function getAuthHeaderForRegistry(configByUri: Record<string, RegistryConfig> | undefined, registryUrl: string): string | undefined;
+export {};

package/lib/star/common.js

@@ -0,0 +1,93 @@
+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 { normalizeRegistryUrl, parsePackageSpec, rcOptionsTypes as commonRcOptionsTypes } from '../common.js';
+import { fetchWhoami } from '../whoami.js';
+export function cliOptionsTypes() {
+    return {
+        ...commonRcOptionsTypes(),
+    };
+}
+export function rcOptionsTypes() {
+    return commonRcOptionsTypes();
+}
+export async function performStarAction(opts, { packageName, star }) {
+    const { escapedName } = parsePackageSpec(packageName);
+    const registryUrl = normalizeRegistryUrl(pickRegistryForPackage(opts.registries ?? { default: 'https://registry.npmjs.org/' }, packageName));
+    const authHeader = getAuthHeaderForRegistry(opts.configByUri, registryUrl);
+    const action = star ? 'star' : 'unstar';
+    if (!authHeader) {
+        throw new PnpmError('STAR_UNAUTHORIZED', `You must be logged in to ${action} packages`);
+    }
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const method = star ? 'PUT' : 'DELETE';
+    const starUrl = new URL('./-/user/v1/star', registryUrl).href;
+    let response = await fetchFromRegistry(starUrl, {
+        authHeaderValue: authHeader,
+        method,
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({ name: packageName, package: packageName }),
+    });
+    if (!response.ok) {
+        const altStarUrl = new URL(`./-/user/package/${escapedName}/star`, registryUrl).href;
+        response = await fetchFromRegistry(altStarUrl, {
+            authHeaderValue: authHeader,
+            method,
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+    }
+    if (!response.ok) {
+        if (response.status === 404 || response.status === 405 || response.status === 400 || response.status === 500) {
+            return performLegacyStarAction({ packageName, escapedName, star, registryUrl, authHeader, fetchFromRegistry });
+        }
+        const errorBody = await response.text();
+        throw new PnpmError('REGISTRY_ERROR', `Failed to ${action} package: ${response.status} ${response.statusText}. ${errorBody}`);
+    }
+}
+async function performLegacyStarAction(args) {
+    const { packageName, escapedName, star, registryUrl, authHeader, fetchFromRegistry } = args;
+    const action = star ? 'star' : 'unstar';
+    const username = await fetchWhoami(registryUrl, fetchFromRegistry, authHeader);
+    const pkgUrl = new URL(`./${escapedName}`, registryUrl).href;
+    const response = await fetchFromRegistry(pkgUrl, {
+        authHeaderValue: authHeader,
+        fullMetadata: true,
+    });
+    if (!response.ok) {
+        if (response.status === 404) {
+            throw new PnpmError('PACKAGE_NOT_FOUND', `Package "${packageName}" not found in registry`);
+        }
+        throw new PnpmError('REGISTRY_ERROR', `Failed to fetch package info: ${response.status} ${response.statusText}`);
+    }
+    const pkgData = await response.json();
+    pkgData.users = pkgData.users || {};
+    if (star) {
+        pkgData.users[username] = true;
+    }
+    else {
+        delete pkgData.users[username];
+    }
+    const updateUrl = pkgData._rev ? `${pkgUrl}/-rev/${pkgData._rev}` : pkgUrl;
+    const updateResponse = await fetchFromRegistry(updateUrl, {
+        authHeaderValue: authHeader,
+        method: 'PUT',
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify(pkgData),
+    });
+    if (!updateResponse.ok) {
+        const errorBody = await updateResponse.text();
+        throw new PnpmError('REGISTRY_ERROR', `Failed to ${action} package (legacy): ${updateResponse.status} ${updateResponse.statusText}. ${errorBody}`);
+    }
+}
+export function getAuthHeaderForRegistry(configByUri, registryUrl) {
+    const getAuthHeader = createGetAuthHeaderByURI(configByUri ?? {}, registryUrl);
+    return getAuthHeader(registryUrl);
+}
+//# sourceMappingURL=common.js.map

package/lib/star/star.d.ts

@@ -0,0 +1,5 @@
+import { cliOptionsTypes, rcOptionsTypes, type StarOptions } from './common.js';
+export { cliOptionsTypes, rcOptionsTypes };
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: StarOptions, params: string[]): Promise<void>;

package/lib/star/star.js

@@ -0,0 +1,20 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { PnpmError } from '@pnpm/error';
+import { renderHelp } from 'render-help';
+import { cliOptionsTypes, performStarAction, rcOptionsTypes } from './common.js';
+export { cliOptionsTypes, rcOptionsTypes };
+export const commandNames = ['star'];
+export function help() {
+    return renderHelp({
+        description: 'Marks a package as a favorite.',
+        url: docsUrl('star'),
+        usages: ['pnpm star <package>'],
+    });
+}
+export async function handler(opts, params) {
+    if (params.length === 0) {
+        throw new PnpmError('STAR_PACKAGE_REQUIRED', 'Package name is required');
+    }
+    await performStarAction(opts, { packageName: params[0], star: true });
+}
+//# sourceMappingURL=star.js.map

package/lib/star/stars.d.ts

@@ -0,0 +1,5 @@
+import { cliOptionsTypes, rcOptionsTypes, type StarOptions } from './common.js';
+export { cliOptionsTypes, rcOptionsTypes };
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: StarOptions, params: string[]): Promise<string>;

package/lib/star/stars.js

@@ -0,0 +1,61 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { PnpmError } from '@pnpm/error';
+import { createFetchFromRegistry } from '@pnpm/network.fetch';
+import { renderHelp } from 'render-help';
+import { normalizeRegistryUrl } from '../common.js';
+import { fetchWhoami } from '../whoami.js';
+import { cliOptionsTypes, getAuthHeaderForRegistry, rcOptionsTypes } from './common.js';
+export { cliOptionsTypes, rcOptionsTypes };
+export const commandNames = ['stars'];
+export function help() {
+    return renderHelp({
+        description: 'Lists all packages starred by a specific user.',
+        url: docsUrl('stars'),
+        usages: ['pnpm stars [<user>]'],
+    });
+}
+export async function handler(opts, params) {
+    const registryUrl = normalizeRegistryUrl(opts.registries?.default ?? 'https://registry.npmjs.org/');
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const authHeader = getAuthHeaderForRegistry(opts.configByUri, registryUrl);
+    let username = params[0];
+    if (!username) {
+        if (!authHeader) {
+            throw new PnpmError('STARS_UNAUTHORIZED', 'You must be logged in to list your starred packages');
+        }
+        username = await fetchWhoami(registryUrl, fetchFromRegistry, authHeader);
+    }
+    if (!params[0]) {
+        const starUrl = new URL('./-/user/v1/star', registryUrl).href;
+        const response = await fetchFromRegistry(starUrl, {
+            authHeaderValue: authHeader,
+        });
+        if (response.ok) {
+            const starsData = await response.json();
+            if (Array.isArray(starsData))
+                return starsData.join('\n');
+            if (typeof starsData === 'object' && starsData !== null) {
+                return Object.keys(starsData).join('\n');
+            }
+        }
+    }
+    const starsUrl = new URL(`./-/user/${encodeURIComponent(username)}/stars`, registryUrl).href;
+    let response = await fetchFromRegistry(starsUrl, {
+        authHeaderValue: authHeader,
+    });
+    if (!response.ok) {
+        const utilStarsUrl = new URL(`./-/util/user/${encodeURIComponent(username)}/stars`, registryUrl).href;
+        response = await fetchFromRegistry(utilStarsUrl, {
+            authHeaderValue: authHeader,
+        });
+    }
+    if (!response.ok) {
+        if (response.status === 404) {
+            throw new PnpmError('USER_NOT_FOUND', `User "${username}" not found`);
+        }
+        throw new PnpmError('REGISTRY_ERROR', `Failed to fetch stars: ${response.status} ${response.statusText}`);
+    }
+    const starsData = await response.json();
+    return Object.keys(starsData).join('\n');
+}
+//# sourceMappingURL=stars.js.map

package/lib/star/unstar.d.ts

@@ -0,0 +1,5 @@
+import { cliOptionsTypes, rcOptionsTypes, type StarOptions } from './common.js';
+export { cliOptionsTypes, rcOptionsTypes };
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: StarOptions, params: string[]): Promise<void>;

package/lib/star/unstar.js

@@ -0,0 +1,20 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { PnpmError } from '@pnpm/error';
+import { renderHelp } from 'render-help';
+import { cliOptionsTypes, performStarAction, rcOptionsTypes } from './common.js';
+export { cliOptionsTypes, rcOptionsTypes };
+export const commandNames = ['unstar'];
+export function help() {
+    return renderHelp({
+        description: 'Removes a package from your favorites.',
+        url: docsUrl('unstar'),
+        usages: ['pnpm unstar <package>'],
+    });
+}
+export async function handler(opts, params) {
+    if (params.length === 0) {
+        throw new PnpmError('UNSTAR_PACKAGE_REQUIRED', 'Package name is required');
+    }
+    await performStarAction(opts, { packageName: params[0], star: false });
+}
+//# sourceMappingURL=unstar.js.map

package/lib/whoami.d.ts

@@ -0,0 +1,12 @@
+import { type CreateFetchFromRegistryOptions, type FetchFromRegistry } from '@pnpm/network.fetch';
+import type { Registries, RegistryConfig } from '@pnpm/types';
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export interface WhoamiOptions extends CreateFetchFromRegistryOptions {
+    configByUri?: Record<string, RegistryConfig>;
+    registries?: Registries;
+}
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: WhoamiOptions): Promise<string>;
+export declare function fetchWhoami(registryUrl: string, fetchFromRegistry: FetchFromRegistry, authHeader: string): Promise<string>;

package/lib/whoami.js

@@ -0,0 +1,43 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { PnpmError } from '@pnpm/error';
+import { createGetAuthHeaderByURI } from '@pnpm/network.auth-header';
+import { createFetchFromRegistry } from '@pnpm/network.fetch';
+import { renderHelp } from 'render-help';
+import { normalizeRegistryUrl, rcOptionsTypes as commonRcOptionsTypes } from './common.js';
+export function cliOptionsTypes() {
+    return {
+        ...commonRcOptionsTypes(),
+    };
+}
+export function rcOptionsTypes() {
+    return commonRcOptionsTypes();
+}
+export const commandNames = ['whoami'];
+export function help() {
+    return renderHelp({
+        description: 'Displays your pnpm username.',
+        url: docsUrl('whoami'),
+        usages: ['pnpm whoami'],
+    });
+}
+export async function handler(opts) {
+    const registryUrl = normalizeRegistryUrl(opts.registries?.default ?? 'https://registry.npmjs.org/');
+    const getAuthHeader = createGetAuthHeaderByURI(opts.configByUri ?? {}, registryUrl);
+    const authHeader = getAuthHeader(registryUrl);
+    if (!authHeader) {
+        throw new PnpmError('WHOAMI_UNAUTHORIZED', 'You must be logged in to use whoami');
+    }
+    return fetchWhoami(registryUrl, createFetchFromRegistry(opts), authHeader);
+}
+export async function fetchWhoami(registryUrl, fetchFromRegistry, authHeader) {
+    const whoamiUrl = new URL('./-/whoami', normalizeRegistryUrl(registryUrl)).href;
+    const response = await fetchFromRegistry(whoamiUrl, {
+        authHeaderValue: authHeader,
+    });
+    if (!response.ok) {
+        throw new PnpmError('WHOAMI_FAILED', `Failed to find the current user: ${response.status} ${response.statusText}`);
+    }
+    const { username } = await response.json();
+    return username;
+}
+//# sourceMappingURL=whoami.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/registry-access.commands",
-  "version": "1100.0.0",
+  "version": "1100.2.0",
   "description": "Commands for managing packages on the registry",
   "keywords": [
     "pnpm",
@@ -25,17 +25,18 @@
   ],
   "dependencies": {
     "@pnpm/npm-package-arg": "^2.0.0",
+    "chalk": "^5.6.0",
     "ramda": "npm:@pnpm/ramda@0.28.1",
     "render-help": "^2.0.0",
     "semver": "^7.7.2",
-    "@pnpm/cli.utils": "1100.0.0",
-    "@pnpm/config.pick-registry-for-package": "1100.0.0",
+    "@pnpm/cli.utils": "1101.0.0",
+    "@pnpm/config.reader": "1101.0.0",
+    "@pnpm/network.auth-header": "1100.0.1",
+    "@pnpm/network.fetch": "1100.0.1",
+    "@pnpm/config.pick-registry-for-package": "1100.0.1",
     "@pnpm/error": "1100.0.0",
-    "@pnpm/network.auth-header": "1100.0.0",
-    "@pnpm/network.fetch": "1100.0.0",
-    "@pnpm/resolving.registry.types": "1100.0.0",
-    "@pnpm/types": "1100.0.0",
-    "@pnpm/config.reader": "1100.0.0"
+    "@pnpm/resolving.registry.types": "1100.0.1",
+    "@pnpm/types": "1101.0.0"
   },
   "devDependencies": {
     "@jest/globals": "30.3.0",
@@ -43,10 +44,11 @@
     "@types/ramda": "0.31.1",
     "@types/semver": "7.7.1",
     "execa": "npm:safe-execa@0.3.0",
-    "@pnpm/prepare": "1100.0.0",
-    "@pnpm/releasing.commands": "1100.0.0",
-    "@pnpm/registry-access.commands": "1100.0.0",
-    "@pnpm/testing.command-defaults": "1100.0.0"
+    "@pnpm/prepare": "1100.0.1",
+    "@pnpm/registry-access.commands": "1100.2.0",
+    "@pnpm/testing.command-defaults": "1100.0.0",
+    "@pnpm/testing.mock-agent": "1100.0.1",
+    "@pnpm/releasing.commands": "1100.0.2"
   },
   "engines": {
     "node": ">=22.13"