@pnpm/config.commands 1000.2.10

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @pnpm/plugin-commands-config
+
+> Commands for reading and writing settings to/from config files
+
+[![npm version](https://img.shields.io/npm/v/@pnpm/plugin-commands-config.svg)](https://www.npmjs.com/package/@pnpm/plugin-commands-config)
+
+## Installation
+
+```sh
+pnpm add @pnpm/plugin-commands-config
+```
+
+## License
+
+MIT

package/lib/ConfigCommandOptions.d.ts

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

package/lib/ConfigCommandOptions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ConfigCommandOptions.js.map

package/lib/config.d.ts

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

package/lib/config.js

@@ -0,0 +1,119 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { PnpmError } from '@pnpm/error';
+import { renderHelp } from 'render-help';
+import { configGet } from './configGet.js';
+import { configList } from './configList.js';
+import { configSet } from './configSet.js';
+export function rcOptionsTypes() {
+    return {};
+}
+export function cliOptionsTypes() {
+    return {
+        global: Boolean,
+        location: ['global', 'project'],
+        json: Boolean,
+    };
+}
+export const commandNames = ['config', 'c'];
+export function help() {
+    return renderHelp({
+        description: 'Manage the pnpm configuration files.',
+        descriptionLists: [
+            {
+                title: 'Commands',
+                list: [
+                    {
+                        description: 'Set the config key to the value provided',
+                        name: 'set',
+                    },
+                    {
+                        description: 'Print the config value for the provided key',
+                        name: 'get',
+                    },
+                    {
+                        description: 'Remove the config key from the config file',
+                        name: 'delete',
+                    },
+                    {
+                        description: 'Show all the config settings',
+                        name: 'list',
+                    },
+                ],
+            },
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Sets the configuration in the global config file',
+                        name: '--global',
+                        shortAlias: '-g',
+                    },
+                    {
+                        description: 'When set to "project", the pnpm-workspace.yaml file will be used if it exists. If only .npmrc exists, it will be used. If neither exists, a pnpm-workspace.yaml file will be created.',
+                        name: '--location <project|global>',
+                    },
+                    {
+                        description: 'Show all types of values in JSON format (not just objects and arrays)',
+                        name: '--json',
+                    },
+                ],
+            },
+        ],
+        url: docsUrl('config'),
+        usages: [
+            'pnpm config set <key> <value>',
+            'pnpm config get <key>',
+            'pnpm config get --json <key>',
+            'pnpm config delete <key>',
+            'pnpm config list',
+        ],
+    });
+}
+export async function handler(opts, params) {
+    if (params.length === 0) {
+        throw new PnpmError('CONFIG_NO_SUBCOMMAND', 'Please specify the subcommand', {
+            hint: help(),
+        });
+    }
+    if (opts.location) {
+        opts.global = opts.location === 'global';
+    }
+    else if (opts.cliOptions['global'] == null) {
+        opts.global = true;
+    }
+    switch (params[0]) {
+        case 'set':
+        case 'delete': {
+            if (!params[1]) {
+                throw new PnpmError('CONFIG_NO_PARAMS', `\`pnpm config ${params[0]}\` requires the config key`);
+            }
+            if (params[0] === 'set') {
+                let [key, value] = params.slice(1);
+                if (value == null) {
+                    const parts = key.split('=');
+                    key = parts.shift();
+                    value = parts.join('=');
+                }
+                return configSet(opts, key, value ?? '');
+            }
+            else {
+                return configSet(opts, params[1], null);
+            }
+        }
+        case 'get': {
+            if (params[1]) {
+                return configGet(opts, params[1]);
+            }
+            else {
+                return configList(opts);
+            }
+        }
+        case 'list': {
+            return configList(opts);
+        }
+        default: {
+            throw new PnpmError('CONFIG_UNKNOWN_SUBCOMMAND', 'This subcommand is not known');
+        }
+    }
+}
+//# sourceMappingURL=config.js.map

package/lib/configGet.d.ts

@@ -0,0 +1,5 @@
+import type { ConfigCommandOptions } from './ConfigCommandOptions.js';
+export declare function configGet(opts: ConfigCommandOptions, key: string): {
+    output: string;
+    exitCode: number;
+};

package/lib/configGet.js

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { types } from '@pnpm/config.reader';
+import { runNpm } from '@pnpm/exec.run-npm';
+import { getObjectValueByPropertyPath } from '@pnpm/object.property-path';
+import { isCamelCase, isStrictlyKebabCase } from '@pnpm/text.naming-cases';
+import kebabCase from 'lodash.kebabcase';
+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 output = displayConfig(configResult?.value, opts);
+    return { output, exitCode: 0 };
+}
+function getRcConfig(rawConfig, key, isScopedKey) {
+    if (isScopedKey) {
+        const value = rawConfig[key];
+        return { value };
+    }
+    const rcKey = isCamelCase(key) ? kebabCase(key) : key;
+    if (Object.hasOwn(types, rcKey)) {
+        const value = rawConfig[rcKey];
+        return { value };
+    }
+    if (isStrictlyKebabCase(key)) {
+        const value = rawConfig[key];
+        return { value };
+    }
+    return undefined;
+}
+function getConfigByPropertyPath(rawConfig, propertyPath) {
+    const parsedPropertyPath = Array.from(parseConfigPropertyPath(propertyPath));
+    if (parsedPropertyPath.length === 0) {
+        return {
+            value: processConfig(rawConfig),
+        };
+    }
+    return {
+        value: getObjectValueByPropertyPath(rawConfig, parsedPropertyPath),
+    };
+}
+function displayConfig(config, opts) {
+    if (Boolean(opts.json) || Array.isArray(config)) {
+        return JSON.stringify(config, undefined, 2);
+    }
+    if (typeof config === 'object' && config != null) {
+        return JSON.stringify(config, undefined, 2);
+    }
+    return String(config);
+}
+//# sourceMappingURL=configGet.js.map

package/lib/configList.d.ts

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

package/lib/configList.js

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

package/lib/configSet.d.ts

@@ -0,0 +1,21 @@
+import { PnpmError } from '@pnpm/error';
+import type { ConfigCommandOptions } from './ConfigCommandOptions.js';
+export declare function configSet(opts: ConfigCommandOptions, key: string, valueParam: string | null): Promise<void>;
+export declare class ConfigSetKeyEmptyKeyError extends PnpmError {
+    constructor();
+}
+export declare class ConfigSetDeepKeyError extends PnpmError {
+    constructor();
+}
+export declare class ConfigSetUnsupportedIniConfigKeyError extends PnpmError {
+    readonly key: string;
+    constructor(key: string);
+}
+export declare class ConfigSetUnsupportedWorkspaceKeyError extends PnpmError {
+    readonly key: string;
+    constructor(key: string);
+}
+export declare class ConfigSetUnsupportedYamlConfigKeyError extends PnpmError {
+    readonly key: string;
+    constructor(key: string);
+}

package/lib/configSet.js

@@ -0,0 +1,231 @@
+import path from 'node:path';
+import util from 'node:util';
+import { isConfigFileKey, 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';
+import camelCase from 'camelcase';
+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) {
+        key = validateSimpleKey(key);
+        shouldFallbackToNpm = settingShouldFallBackToNpm(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;
+            }
+            throw new PnpmError('CONFIG_SET_AUTH_NON_STRING', `Cannot set ${key} to a non-string value (${JSON.stringify(value)})`);
+        }
+        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;
+        }
+    }
+    const { configDir, configFileName } = getConfigFileInfo(key, opts);
+    const configPath = path.join(configDir, configFileName);
+    switch (configFileName) {
+        case GLOBAL_CONFIG_YAML_FILENAME:
+        case WORKSPACE_MANIFEST_FILENAME: {
+            if (configFileName === GLOBAL_CONFIG_YAML_FILENAME) {
+                key = validateYamlConfigKey(key);
+            }
+            key = validateWorkspaceKey(key);
+            await updateWorkspaceManifest(configDir, {
+                fileName: configFileName,
+                updatedFields: ({
+                    [key]: castField(value, kebabCase(key)),
+                }),
+            });
+            break;
+        }
+        case 'rc':
+        case '.npmrc': {
+            const settings = await safeReadIniFile(configPath);
+            key = validateIniConfigKey(key);
+            if (value == null) {
+                if (settings[key] == null)
+                    return;
+                delete settings[key];
+            }
+            else {
+                settings[key] = value;
+            }
+            await writeIniFile(configPath, settings);
+            break;
+        }
+        default: {
+            const _typeGuard = configFileName;
+            throw new Error(`Unhandled case: ${JSON.stringify(_typeGuard)}`);
+        }
+    }
+}
+function castField(value, key) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const type = types[key];
+    const typeList = Array.isArray(type) ? type : [type];
+    const isNumber = typeList.includes(Number);
+    value = value.trim();
+    switch (value) {
+        case 'true': {
+            return true;
+        }
+        case 'false': {
+            return false;
+        }
+        case 'null': {
+            return null;
+        }
+        case 'undefined': {
+            return undefined;
+        }
+    }
+    if (isNumber && !isNaN(value)) {
+        value = Number(value);
+    }
+    return value;
+}
+export class ConfigSetKeyEmptyKeyError extends PnpmError {
+    constructor() {
+        super('CONFIG_SET_EMPTY_KEY', 'Cannot set config with an empty key');
+    }
+}
+export class ConfigSetDeepKeyError extends PnpmError {
+    constructor() {
+        // it shouldn't be supported until there is a mechanism to validate the config value
+        super('CONFIG_SET_DEEP_KEY', 'Setting deep property path is not supported');
+    }
+}
+/**
+ * Validate if {@link key} is a simple key or a property path.
+ *
+ * If it is an empty property path or a property path longer than 1, throw an error.
+ *
+ * If it is a simple key (or a property path with length of 1), return it.
+ */
+function validateSimpleKey(key) {
+    if (isStrictlyKebabCase(key))
+        return key;
+    const iter = parsePropertyPath(key);
+    const first = iter.next();
+    if (first.done)
+        throw new ConfigSetKeyEmptyKeyError();
+    const second = iter.next();
+    if (!second.done)
+        throw new ConfigSetDeepKeyError();
+    return first.value.toString();
+}
+export class ConfigSetUnsupportedIniConfigKeyError extends PnpmError {
+    key;
+    constructor(key) {
+        super('CONFIG_SET_UNSUPPORTED_INI_CONFIG_KEY', `Key ${JSON.stringify(key)} isn't supported by INI config files`, {
+            hint: `Add ${JSON.stringify(camelCase(key))} to the project workspace manifest instead`,
+        });
+        this.key = key;
+    }
+}
+/**
+ * Validate whether the kebab-case of {@link key} is supported by INI config files.
+ *
+ * Return the kebab-case if it is, throw an error otherwise.
+ *
+ * "INI config files" includes:
+ * * The global INI config file named `rc`.
+ * * The local INI config file named `.npmrc`.
+ */
+function validateIniConfigKey(key) {
+    const kebabKey = kebabCase(key);
+    if (Object.hasOwn(types, kebabKey)) {
+        return kebabKey;
+    }
+    throw new ConfigSetUnsupportedIniConfigKeyError(key);
+}
+export class ConfigSetUnsupportedWorkspaceKeyError extends PnpmError {
+    key;
+    constructor(key) {
+        super('CONFIG_SET_UNSUPPORTED_WORKSPACE_KEY', `The key ${JSON.stringify(key)} isn't supported by the workspace manifest`, {
+            hint: `Try ${JSON.stringify(camelCase(key))}`,
+        });
+        this.key = key;
+    }
+}
+/**
+ * Only an rc option key would be allowed to be kebab-case, otherwise, it must be camelCase.
+ *
+ * Return the camelCase of {@link key} if it's valid.
+ */
+function validateWorkspaceKey(key) {
+    if (Object.hasOwn(types, key))
+        return camelCase(key);
+    if (!isCamelCase(key))
+        throw new ConfigSetUnsupportedWorkspaceKeyError(key);
+    return key;
+}
+async function safeReadIniFile(configPath) {
+    try {
+        return await readIniFile(configPath);
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT')
+            return {};
+        throw err;
+    }
+}
+export class ConfigSetUnsupportedYamlConfigKeyError extends PnpmError {
+    key;
+    constructor(key) {
+        super('CONFIG_SET_UNSUPPORTED_YAML_CONFIG_KEY', `The key ${JSON.stringify(key)} isn't supported by the global config.yaml file`, {
+            hint: 'Try setting them instead to the local pnpm-workspace.yaml file',
+        });
+        this.key = key;
+    }
+}
+/**
+ * Validate whether the {@link key} is allowed in the global config.yaml file.
+ *
+ * Return the kebab-case if it is, throw an error otherwise.
+ */
+function validateYamlConfigKey(key) {
+    const kebabKey = kebabCase(key);
+    if (!isConfigFileKey(kebabKey)) {
+        throw new ConfigSetUnsupportedYamlConfigKeyError(key);
+    }
+    return kebabKey;
+}
+//# sourceMappingURL=configSet.js.map

package/lib/get.d.ts

@@ -0,0 +1,7 @@
+import * as configCmd from './config.js';
+import type { ConfigCommandOptions } from './ConfigCommandOptions.js';
+export declare const rcOptionsTypes: typeof configCmd.rcOptionsTypes;
+export declare const cliOptionsTypes: typeof configCmd.cliOptionsTypes;
+export declare const help: typeof configCmd.help;
+export declare const commandNames: string[];
+export declare function handler(opts: ConfigCommandOptions, params: string[]): Promise<configCmd.ConfigHandlerResult>;

package/lib/get.js

@@ -0,0 +1,9 @@
+import * as configCmd from './config.js';
+export const rcOptionsTypes = configCmd.rcOptionsTypes;
+export const cliOptionsTypes = configCmd.cliOptionsTypes;
+export const help = configCmd.help;
+export const commandNames = ['get'];
+export async function handler(opts, params) {
+    return configCmd.handler(opts, ['get', ...params]);
+}
+//# sourceMappingURL=get.js.map

package/lib/getConfigFileInfo.d.ts

@@ -0,0 +1,8 @@
+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 interface ConfigFilePathInfo {
+    configDir: string;
+    configFileName: ConfigFileName;
+}
+export declare function getConfigFileInfo(key: string, opts: Pick<ConfigCommandOptions, 'global' | 'configDir' | 'dir'>): ConfigFilePathInfo;

package/lib/getConfigFileInfo.js

@@ -0,0 +1,20 @@
+import { isIniConfigKey } from '@pnpm/config.reader';
+import { GLOBAL_CONFIG_YAML_FILENAME, WORKSPACE_MANIFEST_FILENAME } from '@pnpm/constants';
+import kebabCase from 'lodash.kebabcase';
+export function getConfigFileInfo(key, opts) {
+    key = kebabCase(key);
+    const configDir = opts.global ? opts.configDir : opts.dir;
+    if (isIniConfigKey(key)) {
+        // NOTE: The following code no longer does what the merged PR at <https://github.com/pnpm/pnpm/pull/10073> wants to do,
+        //       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';
+        return { configDir, configFileName };
+    }
+    else {
+        const configFileName = opts.global ? GLOBAL_CONFIG_YAML_FILENAME : WORKSPACE_MANIFEST_FILENAME;
+        return { configDir, configFileName };
+    }
+}
+//# sourceMappingURL=getConfigFileInfo.js.map

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+import * as config from './config.js';
+import * as getCommand from './get.js';
+import * as setCommand from './set.js';
+export { config, getCommand, setCommand };

package/lib/index.js

@@ -0,0 +1,5 @@
+import * as config from './config.js';
+import * as getCommand from './get.js';
+import * as setCommand from './set.js';
+export { config, getCommand, setCommand };
+//# sourceMappingURL=index.js.map

package/lib/parseConfigPropertyPath.d.ts

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

package/lib/parseConfigPropertyPath.js

@@ -0,0 +1,28 @@
+import { types } from '@pnpm/config.reader';
+import { parsePropertyPath } from '@pnpm/object.property-path';
+import kebabCase from 'lodash.kebabcase';
+/**
+ * Just like {@link parsePropertyPath} but the first element may be converted into kebab-case
+ * if it's part of {@link types}.
+ */
+export function* parseConfigPropertyPath(propertyPath) {
+    const iter = parsePropertyPath(propertyPath);
+    const first = iter.next();
+    if (first.done)
+        return;
+    yield normalizeTopLevelConfigName(first.value);
+    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/lib/processConfig.d.ts

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

package/lib/processConfig.js

@@ -0,0 +1,16 @@
+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/protectedSettings.d.ts

@@ -0,0 +1,4 @@
+/** Protected settings are settings which `npm config get` refuses to print. */
+export declare const isSettingProtected: (key: string) => boolean;
+/** Hide all protected settings by setting them to `(protected)`. */
+export declare function censorProtectedSettings(config: Record<string, unknown>): Record<string, unknown>;

package/lib/protectedSettings.js

@@ -0,0 +1,21 @@
+const PROTECTED_SUFFICES = [
+    '_auth',
+    '_authToken',
+    'username',
+    '_password',
+];
+/** Protected settings are settings which `npm config get` refuses to print. */
+export const isSettingProtected = (key) => key.startsWith('//')
+    ? PROTECTED_SUFFICES.some(suffix => key.endsWith(`:${suffix}`))
+    : PROTECTED_SUFFICES.includes(key);
+/** Hide all protected settings by setting them to `(protected)`. */
+export function censorProtectedSettings(config) {
+    config = { ...config };
+    for (const key in config) {
+        if (isSettingProtected(key)) {
+            config[key] = '(protected)';
+        }
+    }
+    return config;
+}
+//# sourceMappingURL=protectedSettings.js.map

package/lib/set.d.ts

@@ -0,0 +1,7 @@
+import * as configCmd from './config.js';
+import type { ConfigCommandOptions } from './ConfigCommandOptions.js';
+export declare const rcOptionsTypes: typeof configCmd.rcOptionsTypes;
+export declare const cliOptionsTypes: typeof configCmd.cliOptionsTypes;
+export declare const help: typeof configCmd.help;
+export declare const commandNames: string[];
+export declare function handler(opts: ConfigCommandOptions, params: string[]): Promise<configCmd.ConfigHandlerResult>;

package/lib/set.js

@@ -0,0 +1,9 @@
+import * as configCmd from './config.js';
+export const rcOptionsTypes = configCmd.rcOptionsTypes;
+export const cliOptionsTypes = configCmd.cliOptionsTypes;
+export const help = configCmd.help;
+export const commandNames = ['set'];
+export async function handler(opts, params) {
+    return configCmd.handler(opts, ['set', ...params]);
+}
+//# sourceMappingURL=set.js.map

package/lib/settingShouldFallBackToNpm.d.ts

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

package/lib/settingShouldFallBackToNpm.js

@@ -0,0 +1,9 @@
+// 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

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@pnpm/config.commands",
+  "version": "1000.2.10",
+  "description": "Commands for reading and writing settings to/from config files",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "config"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/config/commands",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/config/commands#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "camelcase": "^9.0.0",
+    "ini": "6.0.0",
+    "lodash.kebabcase": "^4.1.1",
+    "read-ini-file": "5.0.0",
+    "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"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@types/ini": "1.3.31",
+    "@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"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "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"
+  }
+}