@pnpm/config.commands 1000.2.10 → 1100.0.0

package/lib/ConfigCommandOptions.d.ts

@@ -1,5 +1,7 @@
-import type { Config } from '@pnpm/config.reader';
-export type ConfigCommandOptions = Pick<Config, 'configDir' | 'cliOptions' | 'dir' | 'global' | 'npmPath' | 'rawConfig' | 'workspaceDir'> & {
+import type { Config, ConfigContext } from '@pnpm/config.reader';
+export type ConfigCommandOptions = Pick<Config, 'configDir' | 'dir' | 'global' | 'authConfig' | 'workspaceDir'> & Pick<ConfigContext, 'cliOptions'> & {
+    _config: Config;
+    _context: ConfigContext;
     json?: boolean;
     location?: 'global' | 'project';
 };

package/lib/configGet.js

@@ -1,54 +1,61 @@
-import path from 'node:path';
-import { types } from '@pnpm/config.reader';
-import { runNpm } from '@pnpm/exec.run-npm';
+import { isIniConfigKey, types } from '@pnpm/config.reader';
 import { getObjectValueByPropertyPath } from '@pnpm/object.property-path';
-import { isCamelCase, isStrictlyKebabCase } from '@pnpm/text.naming-cases';
+import { isCamelCase } from '@pnpm/text.naming-cases';
+import camelcase from 'camelcase';
 import kebabCase from 'lodash.kebabcase';
+import { configToRecord } from './configToRecord.js';
 import { parseConfigPropertyPath } from './parseConfigPropertyPath.js';
-import { processConfig } from './processConfig.js';
-import { settingShouldFallBackToNpm } from './settingShouldFallBackToNpm.js';
 export function configGet(opts, key) {
     const isScopedKey = key.startsWith('@');
-    // Exclude scoped keys from npm fallback because they are pnpm-native config
-    // that can be read directly from rawConfig (e.g., '@scope:registry')
-    if (opts.global && settingShouldFallBackToNpm(key) && !isScopedKey) {
-        const { status: exitCode } = runNpm(opts.npmPath, ['config', 'get', key], {
-            location: 'user',
-            userConfigPath: path.join(opts.configDir, 'rc'),
-        });
-        return { output: '', exitCode: exitCode ?? 0 };
-    }
-    const configResult = getRcConfig(opts.rawConfig, key, isScopedKey) ?? getConfigByPropertyPath(opts.rawConfig, key);
+    const configResult = lookupConfig(opts, key, isScopedKey) ?? (isPropertyPath(key) ? lookupByPropertyPath(opts, key) : { value: undefined });
     const output = displayConfig(configResult?.value, opts);
     return { output, exitCode: 0 };
 }
-function getRcConfig(rawConfig, key, isScopedKey) {
+function lookupConfig(opts, key, isScopedKey) {
     if (isScopedKey) {
-        const value = rawConfig[key];
-        return { value };
+        return { value: opts.authConfig[key] };
+    }
+    const kebabKey = isCamelCase(key) ? kebabCase(key) : key;
+    // Resolve typed keys from Config — check explicitly set values first,
+    // then fall back to authConfig (for keys like registry set in .npmrc)
+    if (Object.hasOwn(types, kebabKey)) {
+        const camelKey = camelcase(kebabKey, { locale: 'en-US' });
+        const explicit = opts._context.explicitlySetKeys;
+        if (!explicit || explicit.has(camelKey)) {
+            return { value: opts._config[camelKey] };
+        }
+        // Fall back to authConfig for INI keys (registry, ca, etc.)
+        if (kebabKey in opts.authConfig) {
+            return { value: opts.authConfig[kebabKey] };
+        }
+        return { value: undefined };
     }
-    const rcKey = isCamelCase(key) ? kebabCase(key) : key;
-    if (Object.hasOwn(types, rcKey)) {
-        const value = rawConfig[rcKey];
-        return { value };
+    // Auth-specific INI keys (//host:_authToken, _auth, etc.) from authConfig
+    if (isIniConfigKey(key)) {
+        return { value: opts.authConfig[key] };
     }
-    if (isStrictlyKebabCase(key)) {
-        const value = rawConfig[key];
-        return { value };
+    // For keys not in types (e.g., package-extensions), look up via configToRecord
+    // which excludes internal/sensitive fields.
+    const camelKey = camelcase(key, { locale: 'en-US' });
+    const record = configToRecord(opts._config, opts._context.explicitlySetKeys);
+    if (Object.hasOwn(record, camelKey)) {
+        return { value: record[camelKey] };
     }
     return undefined;
 }
-function getConfigByPropertyPath(rawConfig, propertyPath) {
+function lookupByPropertyPath(opts, propertyPath) {
     const parsedPropertyPath = Array.from(parseConfigPropertyPath(propertyPath));
     if (parsedPropertyPath.length === 0) {
-        return {
-            value: processConfig(rawConfig),
-        };
+        return { value: configToRecord(opts._config, opts._context.explicitlySetKeys) };
     }
+    const record = configToRecord(opts._config, opts._context.explicitlySetKeys);
     return {
-        value: getObjectValueByPropertyPath(rawConfig, parsedPropertyPath),
+        value: getObjectValueByPropertyPath(record, parsedPropertyPath),
     };
 }
+function isPropertyPath(key) {
+    return key === '' || key.includes('.') || key.includes('[');
+}
 function displayConfig(config, opts) {
     if (Boolean(opts.json) || Array.isArray(config)) {
         return JSON.stringify(config, undefined, 2);

package/lib/configList.d.ts

@@ -1,3 +1,2 @@
 import type { ConfigCommandOptions } from './ConfigCommandOptions.js';
-export type ConfigListOptions = Pick<ConfigCommandOptions, 'rawConfig'>;
-export declare function configList(opts: ConfigListOptions): Promise<string>;
+export declare function configList(opts: ConfigCommandOptions): Promise<string>;

package/lib/configList.js

@@ -1,6 +1,5 @@
-import { processConfig } from './processConfig.js';
+import { configToRecord } from './configToRecord.js';
 export async function configList(opts) {
-    const processedConfig = processConfig(opts.rawConfig);
-    return JSON.stringify(processedConfig, undefined, 2);
+    return JSON.stringify(configToRecord(opts._config, opts._context.explicitlySetKeys), undefined, 2);
 }
 //# sourceMappingURL=configList.js.map

package/lib/configSet.js

@@ -1,9 +1,8 @@
 import path from 'node:path';
 import util from 'node:util';
-import { isConfigFileKey, types } from '@pnpm/config.reader';
+import { isConfigFileKey, isIniConfigKey, types } from '@pnpm/config.reader';
 import { GLOBAL_CONFIG_YAML_FILENAME, WORKSPACE_MANIFEST_FILENAME } from '@pnpm/constants';
 import { PnpmError } from '@pnpm/error';
-import { runNpm } from '@pnpm/exec.run-npm';
 import { parsePropertyPath } from '@pnpm/object.property-path';
 import { isCamelCase, isStrictlyKebabCase } from '@pnpm/text.naming-cases';
 import { updateWorkspaceManifest } from '@pnpm/workspace.workspace-manifest-writer';
@@ -12,49 +11,34 @@ import kebabCase from 'lodash.kebabcase';
 import { readIniFile } from 'read-ini-file';
 import { writeIniFile } from 'write-ini-file';
 import { getConfigFileInfo } from './getConfigFileInfo.js';
-import { settingShouldFallBackToNpm } from './settingShouldFallBackToNpm.js';
 export async function configSet(opts, key, valueParam) {
-    let shouldFallbackToNpm = settingShouldFallBackToNpm(key);
-    if (!shouldFallbackToNpm) {
+    let isAuthSetting = isIniConfigKey(key);
+    if (!isAuthSetting) {
         key = validateSimpleKey(key);
-        shouldFallbackToNpm = settingShouldFallBackToNpm(key);
+        isAuthSetting = isIniConfigKey(key);
     }
     let value = valueParam;
     if (valueParam != null && opts.json) {
         value = JSON.parse(valueParam);
     }
-    if (shouldFallbackToNpm) {
-        if (opts.global) {
-            const configPath = path.join(opts.configDir, 'rc');
-            const runNpmOpts = {
-                location: 'user',
-                userConfigPath: configPath,
-            };
-            const _runNpm = runNpm.bind(null, opts.npmPath);
-            if (value == null) {
-                _runNpm(['config', 'delete', key], runNpmOpts);
-                return;
-            }
-            if (typeof value === 'string') {
-                _runNpm(['config', 'set', `${key}=${value}`], runNpmOpts);
-                return;
-            }
+    if (isAuthSetting) {
+        const configPath = opts.global
+            ? path.join(opts.configDir, 'auth.ini')
+            : path.join(opts.dir, '.npmrc');
+        if (value != null && typeof value !== 'string' && isStringOnlyIniKey(key)) {
             throw new PnpmError('CONFIG_SET_AUTH_NON_STRING', `Cannot set ${key} to a non-string value (${JSON.stringify(value)})`);
         }
+        const settings = await safeReadIniFile(configPath);
+        if (value == null) {
+            if (settings[key] == null)
+                return;
+            delete settings[key];
+        }
         else {
-            const configPath = path.join(opts.dir, '.npmrc');
-            const settings = await safeReadIniFile(configPath);
-            if (value == null) {
-                if (settings[key] == null)
-                    return;
-                delete settings[key];
-            }
-            else {
-                settings[key] = value;
-            }
-            await writeIniFile(configPath, settings);
-            return;
+            settings[key] = value;
         }
+        await writeIniFile(configPath, settings);
+        return;
     }
     const { configDir, configFileName } = getConfigFileInfo(key, opts);
     const configPath = path.join(configDir, configFileName);
@@ -73,7 +57,7 @@ export async function configSet(opts, key, valueParam) {
             });
             break;
         }
-        case 'rc':
+        case 'auth.ini':
         case '.npmrc': {
             const settings = await safeReadIniFile(configPath);
             key = validateIniConfigKey(key);
@@ -197,6 +181,16 @@ function validateWorkspaceKey(key) {
         throw new ConfigSetUnsupportedWorkspaceKeyError(key);
     return key;
 }
+const STRING_ONLY_INI_KEYS = ['_auth', '_authToken', '_password', 'username', 'registry'];
+function isStringOnlyIniKey(key) {
+    if (STRING_ONLY_INI_KEYS.includes(key))
+        return true;
+    if (key.startsWith('@'))
+        return true;
+    if (key.startsWith('//'))
+        return true;
+    return false;
+}
 async function safeReadIniFile(configPath) {
     try {
         return await readIniFile(configPath);

package/lib/configToRecord.d.ts

@@ -0,0 +1,10 @@
+import { type Config } from '@pnpm/config.reader';
+/**
+ * Convert a Config object to a camelCase record for display.
+ * Only includes explicitly set values (from CLI, env vars, or workspace yaml),
+ * not default values. Auth/registry keys from authConfig are always included.
+ *
+ * Accepts a clean Config object (without ConfigContext fields mixed in),
+ * so no INTERNAL_CONFIG_KEYS exclusion list is needed.
+ */
+export declare function configToRecord(config: Config, explicitlySetKeys: Set<string>): Record<string, unknown>;

package/lib/configToRecord.js

@@ -0,0 +1,49 @@
+import { types } from '@pnpm/config.reader';
+import { sortDirectKeys } from '@pnpm/object.key-sorting';
+import camelcase from 'camelcase';
+import { censorProtectedSettings } from './protectedSettings.js';
+// Auth-related Config fields that are internal objects, not user settings.
+const NON_SETTING_CONFIG_KEYS = new Set([
+    'authConfig', 'configByUri',
+]);
+/**
+ * Convert a Config object to a camelCase record for display.
+ * Only includes explicitly set values (from CLI, env vars, or workspace yaml),
+ * not default values. Auth/registry keys from authConfig are always included.
+ *
+ * Accepts a clean Config object (without ConfigContext fields mixed in),
+ * so no INTERNAL_CONFIG_KEYS exclusion list is needed.
+ */
+export function configToRecord(config, explicitlySetKeys) {
+    const result = {};
+    // Add typed settings (only explicitly set ones if tracking is available)
+    for (const kebabKey of Object.keys(types)) {
+        const camelKey = camelcase(kebabKey, { locale: 'en-US' });
+        if (!explicitlySetKeys.has(camelKey))
+            continue;
+        const value = config[camelKey];
+        if (value !== undefined) {
+            result[camelKey] = value;
+        }
+    }
+    // Add non-types config properties (e.g., packageExtensions, overrides)
+    for (const [key, value] of Object.entries(config)) {
+        if (value === undefined || NON_SETTING_CONFIG_KEYS.has(key))
+            continue;
+        if (!(key in result) && explicitlySetKeys.has(key)) {
+            result[key] = value;
+        }
+    }
+    // Add auth/registry keys (scoped keys, auth tokens) — keep original casing
+    for (const [key, value] of Object.entries(config.authConfig)) {
+        if (!(key in result)) {
+            result[key] = value;
+        }
+    }
+    // Always include user-agent for debugging connectivity issues
+    if (config.userAgent) {
+        result.userAgent = config.userAgent;
+    }
+    return censorProtectedSettings(sortDirectKeys(result));
+}
+//# sourceMappingURL=configToRecord.js.map

package/lib/getConfigFileInfo.d.ts

@@ -1,6 +1,6 @@
 import { GLOBAL_CONFIG_YAML_FILENAME, WORKSPACE_MANIFEST_FILENAME } from '@pnpm/constants';
 import type { ConfigCommandOptions } from './ConfigCommandOptions.js';
-export type ConfigFileName = 'rc' | '.npmrc' | typeof GLOBAL_CONFIG_YAML_FILENAME | typeof WORKSPACE_MANIFEST_FILENAME;
+export type ConfigFileName = 'auth.ini' | '.npmrc' | typeof GLOBAL_CONFIG_YAML_FILENAME | typeof WORKSPACE_MANIFEST_FILENAME;
 export interface ConfigFilePathInfo {
     configDir: string;
     configFileName: ConfigFileName;

package/lib/getConfigFileInfo.js

@@ -9,7 +9,7 @@ export function getConfigFileInfo(key, opts) {
         //       but considering the settings are now clearly divided into 2 separate categories, it should no longer be relevant.
         // TODO: Auth, network, and proxy settings should belong only to INI files.
         //       Add more settings to `isIniConfigKey` to make it complete.
-        const configFileName = opts.global ? 'rc' : '.npmrc';
+        const configFileName = opts.global ? 'auth.ini' : '.npmrc';
         return { configDir, configFileName };
     }
     else {

package/lib/parseConfigPropertyPath.d.ts

@@ -1,5 +1,5 @@
 /**
- * Just like {@link parsePropertyPath} but the first element may be converted into kebab-case
- * if it's part of {@link types}.
+ * Just like {@link parsePropertyPath} but the first element is converted to camelCase
+ * to match the camelCase keys produced by {@link configToRecord}.
  */
 export declare function parseConfigPropertyPath(propertyPath: string): Generator<string | number, void, void>;

package/lib/parseConfigPropertyPath.js

@@ -1,28 +1,15 @@
-import { types } from '@pnpm/config.reader';
 import { parsePropertyPath } from '@pnpm/object.property-path';
-import kebabCase from 'lodash.kebabcase';
+import camelcase from 'camelcase';
 /**
- * Just like {@link parsePropertyPath} but the first element may be converted into kebab-case
- * if it's part of {@link types}.
+ * Just like {@link parsePropertyPath} but the first element is converted to camelCase
+ * to match the camelCase keys produced by {@link configToRecord}.
  */
 export function* parseConfigPropertyPath(propertyPath) {
     const iter = parsePropertyPath(propertyPath);
     const first = iter.next();
     if (first.done)
         return;
-    yield normalizeTopLevelConfigName(first.value);
+    yield typeof first.value === 'number' ? first.value : camelcase(first.value, { locale: 'en-US' });
     yield* iter;
 }
-/**
- * Turn a top-level config name into kebab-case if it's part of {@link types}.
- * Otherwise, return the string as-is.
- */
-function normalizeTopLevelConfigName(configName) {
-    if (typeof configName === 'number')
-        return configName.toString();
-    const kebabKey = kebabCase(configName);
-    if (Object.hasOwn(types, kebabKey))
-        return kebabKey;
-    return configName;
-}
 //# sourceMappingURL=parseConfigPropertyPath.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/config.commands",
-  "version": "1000.2.10",
+  "version": "1100.0.0",
   "description": "Commands for reading and writing settings to/from config files",
   "keywords": [
     "pnpm",
@@ -32,27 +32,26 @@
     "render-help": "^2.0.0",
     "write-ini-file": "5.0.0",
     "write-yaml-file": "^6.0.0",
-    "@pnpm/cli.utils": "1001.2.8",
-    "@pnpm/config.reader": "1004.4.2",
-    "@pnpm/error": "1000.0.5",
-    "@pnpm/constants": "1001.3.1",
-    "@pnpm/exec.run-npm": "1000.0.0",
-    "@pnpm/object.key-sorting": "1000.0.1",
-    "@pnpm/object.property-path": "1000.0.1",
-    "@pnpm/text.naming-cases": "1100.0.0-0",
-    "@pnpm/workspace.workspace-manifest-writer": "1001.0.3"
+    "@pnpm/constants": "1100.0.0",
+    "@pnpm/error": "1100.0.0",
+    "@pnpm/cli.utils": "1100.0.0",
+    "@pnpm/object.key-sorting": "1100.0.0",
+    "@pnpm/object.property-path": "1100.0.0",
+    "@pnpm/text.naming-cases": "1100.0.0",
+    "@pnpm/config.reader": "1100.0.0",
+    "@pnpm/workspace.workspace-manifest-writer": "1100.0.0"
   },
   "peerDependencies": {
     "@pnpm/logger": ">=1001.0.0 <1002.0.0"
   },
   "devDependencies": {
-    "@jest/globals": "30.0.5",
-    "@types/ini": "1.3.31",
+    "@jest/globals": "30.3.0",
+    "@types/ini": "4.1.1",
     "@types/lodash.kebabcase": "4.1.9",
     "read-yaml-file": "^3.0.0",
-    "@pnpm/config.commands": "1000.2.10",
-    "@pnpm/logger": "1001.0.1",
-    "@pnpm/prepare": "1000.0.4"
+    "@pnpm/logger": "1100.0.0",
+    "@pnpm/prepare": "1100.0.0",
+    "@pnpm/config.commands": "1100.0.0"
   },
   "engines": {
     "node": ">=22.13"
@@ -62,8 +61,8 @@
   },
   "scripts": {
     "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
-    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
-    "test": "pnpm run compile && pnpm run _test",
-    "compile": "tsgo --build && pnpm run lint --fix"
+    "test": "pn compile && pn .test",
+    "compile": "tsgo --build && pn lint --fix",
+    ".test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest"
   }
 }

package/lib/processConfig.d.ts

@@ -1,4 +0,0 @@
-export interface ProcessConfigOptions {
-    json?: boolean;
-}
-export declare function processConfig(rawConfig: Record<string, unknown>): Record<string, unknown>;

package/lib/processConfig.js

@@ -1,16 +0,0 @@
-import { sortDirectKeys } from '@pnpm/object.key-sorting';
-import camelcase from 'camelcase';
-import { censorProtectedSettings } from './protectedSettings.js';
-const shouldChangeCase = (key) => key[0] !== '@' && !key.startsWith('//');
-function camelCaseConfig(rawConfig) {
-    const result = {};
-    for (const key in rawConfig) {
-        const targetKey = shouldChangeCase(key) ? camelcase(key) : key;
-        result[targetKey] = rawConfig[key];
-    }
-    return result;
-}
-export function processConfig(rawConfig) {
-    return camelCaseConfig(censorProtectedSettings(sortDirectKeys(rawConfig)));
-}
-//# sourceMappingURL=processConfig.js.map

package/lib/settingShouldFallBackToNpm.d.ts

@@ -1 +0,0 @@
-export declare function settingShouldFallBackToNpm(key: string): boolean;

package/lib/settingShouldFallBackToNpm.js

@@ -1,9 +0,0 @@
-// NOTE: The logic may be duplicated with `isIniConfigKey` from `@pnpm/config.reader`,
-//       but we have not the time to refactor it right now.
-// TODO: Refactor it when we have the time.
-export function settingShouldFallBackToNpm(key) {
-    return (['registry', '_auth', '_authToken', 'username', '_password'].includes(key) ||
-        key[0] === '@' ||
-        key.startsWith('//'));
-}
-//# sourceMappingURL=settingShouldFallBackToNpm.js.map