@pnpm/patching.commands 1000.3.21

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,13 @@
+# @pnpm/plugin-commands-patches
+
+> Commands for creating patches
+
+## Installation
+
+```sh
+pnpm add @pnpm/plugin-commands-patching
+```
+
+## License
+
+MIT

package/lib/getEditDirPath.d.ts

@@ -0,0 +1,5 @@
+import type { ParseWantedDependencyResult } from '@pnpm/resolving.parse-wanted-dependency';
+export interface GetEditDirOptions {
+    modulesDir: string;
+}
+export declare function getEditDirPath(param: string, patchedDep: ParseWantedDependencyResult, opts: GetEditDirOptions): string;

package/lib/getEditDirPath.js

@@ -0,0 +1,16 @@
+import path from 'node:path';
+export function getEditDirPath(param, patchedDep, opts) {
+    const editDirName = getEditDirNameFromParsedDep(patchedDep) ?? param;
+    return path.join(opts.modulesDir, '.pnpm_patches', editDirName);
+}
+function getEditDirNameFromParsedDep(patchedDep) {
+    if (patchedDep.alias && patchedDep.bareSpecifier) {
+        const bareSpecifier = patchedDep.bareSpecifier.replace(/[\\/:*?"<>|]+/g, '+');
+        return `${patchedDep.alias}@${bareSpecifier}`;
+    }
+    if (patchedDep.alias) {
+        return patchedDep.alias;
+    }
+    return undefined;
+}
+//# sourceMappingURL=getEditDirPath.js.map

package/lib/getPatchedDependency.d.ts

@@ -0,0 +1,21 @@
+import type { Config } from '@pnpm/config.reader';
+import { type ParseWantedDependencyResult } from '@pnpm/resolving.parse-wanted-dependency';
+export type GetPatchedDependencyOptions = {
+    lockfileDir: string;
+} & Pick<Config, 'virtualStoreDir' | 'modulesDir'>;
+export type GetPatchedDependencyResult = ParseWantedDependencyResult & {
+    applyToAll: boolean;
+};
+export declare function getPatchedDependency(rawDependency: string, opts: GetPatchedDependencyOptions): Promise<GetPatchedDependencyResult>;
+export declare function isPkgPrNewUrl(url: string): boolean;
+export interface LockfileVersion {
+    gitTarballUrl?: string;
+    name: string;
+    peerDepGraphHash?: string;
+    version: string;
+}
+export interface LockfileVersionsList {
+    versions: LockfileVersion[];
+    preferredVersions: LockfileVersion[];
+}
+export declare function getVersionsFromLockfile(dep: ParseWantedDependencyResult, opts: GetPatchedDependencyOptions): Promise<LockfileVersionsList>;

package/lib/getPatchedDependency.js

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import { PnpmError } from '@pnpm/error';
+import { isGitHostedPkgUrl } from '@pnpm/fetching.pick-fetcher';
+import { readCurrentLockfile } from '@pnpm/lockfile.fs';
+import { nameVerFromPkgSnapshot } from '@pnpm/lockfile.utils';
+import { parseWantedDependency } from '@pnpm/resolving.parse-wanted-dependency';
+import enquirer from 'enquirer';
+import { realpathMissing } from 'realpath-missing';
+import semver from 'semver';
+export async function getPatchedDependency(rawDependency, opts) {
+    const dep = parseWantedDependency(rawDependency);
+    const { versions, preferredVersions } = await getVersionsFromLockfile(dep, opts);
+    if (!preferredVersions.length) {
+        throw new PnpmError('PATCH_VERSION_NOT_FOUND', `Can not find ${rawDependency} in project ${opts.lockfileDir}, ${versions.length ? `you can specify currently installed version: ${versions.map(({ version }) => version).join(', ')}.` : `did you forget to install ${rawDependency}?`}`);
+    }
+    dep.alias = dep.alias ?? rawDependency;
+    if (preferredVersions.length > 1) {
+        const { version, applyToAll } = await enquirer.prompt([{
+                type: 'select',
+                name: 'version',
+                message: 'Choose which version to patch',
+                choices: preferredVersions.map(preferred => ({
+                    name: preferred.version,
+                    message: preferred.version,
+                    value: preferred.gitTarballUrl ?? preferred.version,
+                    hint: preferred.gitTarballUrl ? 'Git Hosted' : undefined,
+                })),
+                result(selected) {
+                    const selectedVersion = preferredVersions.find(preferred => preferred.version === selected);
+                    return selectedVersion.gitTarballUrl ?? selected;
+                },
+            }, {
+                type: 'confirm',
+                name: 'applyToAll',
+                message: 'Apply this patch to all versions?',
+            }]);
+        return {
+            ...dep,
+            applyToAll,
+            bareSpecifier: version,
+        };
+    }
+    else {
+        const preferred = preferredVersions[0];
+        if (preferred.gitTarballUrl) {
+            return {
+                ...opts,
+                applyToAll: false,
+                bareSpecifier: preferred.gitTarballUrl,
+            };
+        }
+        return {
+            ...dep,
+            applyToAll: !dep.bareSpecifier,
+            bareSpecifier: preferred.version,
+        };
+    }
+}
+// https://github.com/stackblitz-labs/pkg.pr.new
+// With pkg.pr.new, each of your commits and pull requests will trigger an instant preview release without publishing anything to NPM.
+// This enables users to access features and bug-fixes without the need to wait for release cycles using npm or pull request merges.
+// When a package is installed via pkg.pr.new and has never been published to npm,
+// the version or name obtained is incorrect, and an error will occur when patching. We can treat it as a tarball url.
+export function isPkgPrNewUrl(url) {
+    return url.startsWith('https://pkg.pr.new/');
+}
+export async function getVersionsFromLockfile(dep, opts) {
+    const modulesDir = await realpathMissing(path.join(opts.lockfileDir, opts.modulesDir ?? 'node_modules'));
+    const lockfile = await readCurrentLockfile(path.join(modulesDir, '.pnpm'), {
+        ignoreIncompatible: true,
+    }) ?? null;
+    if (!lockfile) {
+        throw new PnpmError('PATCH_NO_LOCKFILE', 'The modules directory is not ready for patching', {
+            hint: 'Run pnpm install first',
+        });
+    }
+    const pkgName = dep.alias && dep.bareSpecifier ? dep.alias : (dep.bareSpecifier ?? dep.alias);
+    const versions = Object.entries(lockfile.packages ?? {})
+        .map(([depPath, pkgSnapshot]) => {
+        const tarball = pkgSnapshot.resolution?.tarball ?? '';
+        return {
+            ...nameVerFromPkgSnapshot(depPath, pkgSnapshot),
+            gitTarballUrl: (isGitHostedPkgUrl(tarball) || isPkgPrNewUrl(tarball)) ? tarball : undefined,
+        };
+    })
+        .filter(({ name }) => name === pkgName)
+        .sort((v1, v2) => semver.compare(v1.version, v2.version));
+    return {
+        versions,
+        preferredVersions: versions.filter(({ version }) => dep.alias && dep.bareSpecifier ? semver.satisfies(version, dep.bareSpecifier) : true),
+    };
+}
+//# sourceMappingURL=getPatchedDependency.js.map

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import * as patch from './patch.js';
+import * as patchCommit from './patchCommit.js';
+import * as patchRemove from './patchRemove.js';
+export { type PatchCommandOptions } from './patch.js';
+export { type PatchRemoveCommandOptions } from './patchRemove.js';
+export { patch, patchCommit, patchRemove };

package/lib/index.js

@@ -0,0 +1,7 @@
+import * as patch from './patch.js';
+import * as patchCommit from './patchCommit.js';
+import * as patchRemove from './patchRemove.js';
+export {} from './patch.js';
+export {} from './patchRemove.js';
+export { patch, patchCommit, patchRemove };
+//# sourceMappingURL=index.js.map

package/lib/patch.d.ts

@@ -0,0 +1,16 @@
+import { type Config } from '@pnpm/config.reader';
+import type { LogBase } from '@pnpm/logger';
+import type { CreateStoreControllerOptions } from '@pnpm/store.connection-manager';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const shorthands: {
+    d: string;
+};
+export declare const commandNames: string[];
+export declare function help(): string;
+export type PatchCommandOptions = Pick<Config, 'dir' | 'patchedDependencies' | 'registries' | 'tag' | 'storeDir' | 'rootProjectManifest' | 'lockfileDir' | 'modulesDir' | 'virtualStoreDir' | 'sharedWorkspaceLockfile'> & CreateStoreControllerOptions & {
+    editDir?: string;
+    reporter?: (logObj: LogBase) => void;
+    ignoreExisting?: boolean;
+};
+export declare function handler(opts: PatchCommandOptions, params: string[]): Promise<string>;

package/lib/patch.js

@@ -0,0 +1,113 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { applyPatchToDir } from '@pnpm/patching.apply-patch';
+import chalk from 'chalk';
+import isWindows from 'is-windows';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import terminalLink from 'terminal-link';
+import { getEditDirPath } from './getEditDirPath.js';
+import { getPatchedDependency } from './getPatchedDependency.js';
+import { writeEditDirState } from './stateFile.js';
+import { writePackage } from './writePackage.js';
+export function rcOptionsTypes() {
+    return pick([], allTypes);
+}
+export function cliOptionsTypes() {
+    return { ...rcOptionsTypes(), 'edit-dir': String, 'ignore-existing': Boolean };
+}
+export const shorthands = {
+    d: '--edit-dir',
+};
+export const commandNames = ['patch'];
+export function help() {
+    return renderHelp({
+        description: 'Prepare a package for patching',
+        descriptionLists: [{
+                title: 'Options',
+                list: [
+                    {
+                        description: 'The package that needs to be modified will be extracted to this directory',
+                        name: '--edit-dir',
+                    },
+                    {
+                        description: 'Ignore existing patch files when patching',
+                        name: '--ignore-existing',
+                    },
+                ],
+            }],
+        url: docsUrl('patch'),
+        usages: ['pnpm patch <pkg name>@<version>'],
+    });
+}
+export async function handler(opts, params) {
+    if (opts.editDir && fs.existsSync(opts.editDir) && fs.readdirSync(opts.editDir).length > 0) {
+        throw new PnpmError('PATCH_EDIT_DIR_EXISTS', `The target directory already exists: '${opts.editDir}'`);
+    }
+    if (!params[0]) {
+        throw new PnpmError('MISSING_PACKAGE_NAME', '`pnpm patch` requires the package name');
+    }
+    const lockfileDir = opts.lockfileDir ?? opts.dir ?? process.cwd();
+    const patchedDep = await getPatchedDependency(params[0], {
+        lockfileDir,
+        modulesDir: opts.modulesDir,
+        virtualStoreDir: opts.virtualStoreDir,
+    });
+    const quote = isWindows() ? '"' : "'";
+    const modulesDir = path.join(lockfileDir, opts.modulesDir ?? 'node_modules');
+    const editDir = opts.editDir
+        ? path.resolve(opts.dir, opts.editDir)
+        : getEditDirPath(params[0], patchedDep, { modulesDir });
+    if (fs.existsSync(editDir) && fs.readdirSync(editDir).length !== 0) {
+        throw new PnpmError('EDIT_DIR_NOT_EMPTY', `The directory ${editDir} is not empty`, {
+            hint: 'Either run `pnpm patch-commit ' + quote + editDir + quote + '` to commit or delete it then run `pnpm patch` to recreate it',
+        });
+    }
+    await writePackage(patchedDep, editDir, opts);
+    writeEditDirState({
+        editDir,
+        modulesDir,
+        patchedPkg: params[0],
+        applyToAll: patchedDep.applyToAll,
+    });
+    if (!opts.ignoreExisting && opts.patchedDependencies) {
+        tryPatchWithExistingPatchFile({
+            patchedDep,
+            patchedDir: editDir,
+            patchedDependencies: opts.patchedDependencies,
+            lockfileDir,
+        });
+    }
+    return `Patch: You can now edit the package at:
+
+  ${terminalLink(chalk.blue(editDir), 'file://' + editDir, { fallback: false })}
+
+To commit your changes, run:
+
+  ${chalk.green(`pnpm patch-commit ${quote}${editDir}${quote}`)}
+
+`;
+}
+function tryPatchWithExistingPatchFile({ patchedDep: { applyToAll, alias, bareSpecifier }, patchedDir, patchedDependencies, lockfileDir, }) {
+    if (!alias)
+        return;
+    let existingPatchFile;
+    if (bareSpecifier) {
+        existingPatchFile = patchedDependencies[`${alias}@${bareSpecifier}`];
+    }
+    if (!existingPatchFile && applyToAll) {
+        existingPatchFile = patchedDependencies[alias];
+    }
+    if (!existingPatchFile) {
+        return;
+    }
+    const existingPatchFilePath = path.resolve(lockfileDir, existingPatchFile);
+    if (!fs.existsSync(existingPatchFilePath)) {
+        throw new PnpmError('PATCH_FILE_NOT_FOUND', `Unable to find patch file ${existingPatchFilePath}`);
+    }
+    applyPatchToDir({ patchedDir, patchFilePath: existingPatchFilePath });
+}
+//# sourceMappingURL=patch.js.map

package/lib/patchCommit.d.ts

@@ -0,0 +1,9 @@
+import { type Config } from '@pnpm/config.reader';
+import { install } from '@pnpm/installing.commands';
+export declare const rcOptionsTypes: typeof cliOptionsTypes;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+export declare function help(): string;
+type PatchCommitCommandOptions = install.InstallCommandOptions & Pick<Config, 'patchesDir' | 'rootProjectManifest' | 'rootProjectManifestDir' | 'patchedDependencies'>;
+export declare function handler(opts: PatchCommitCommandOptions, params: string[]): Promise<string | undefined>;
+export {};

package/lib/patchCommit.js

@@ -0,0 +1,216 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { createShortHash } from '@pnpm/crypto.hash';
+import { PnpmError } from '@pnpm/error';
+import { packlist } from '@pnpm/fs.packlist';
+import { install } from '@pnpm/installing.commands';
+import { globalWarn } from '@pnpm/logger';
+import { readPackageJsonFromDir } from '@pnpm/pkg-manifest.reader';
+import { parseWantedDependency } from '@pnpm/resolving.parse-wanted-dependency';
+import { getStorePath } from '@pnpm/store.path';
+import escapeStringRegexp from 'escape-string-regexp';
+import { makeEmptyDir } from 'make-empty-dir';
+import normalizePath from 'normalize-path';
+import { equals, pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { safeExeca as execa } from 'safe-execa';
+import { glob } from 'tinyglobby';
+import { getVersionsFromLockfile } from './getPatchedDependency.js';
+import { readEditDirState } from './stateFile.js';
+import { updatePatchedDependencies } from './updatePatchedDependencies.js';
+import { writePackage } from './writePackage.js';
+export const rcOptionsTypes = cliOptionsTypes;
+export function cliOptionsTypes() {
+    return pick(['patches-dir'], allTypes);
+}
+export const commandNames = ['patch-commit'];
+export function help() {
+    return renderHelp({
+        description: 'Generate a patch out of a directory',
+        descriptionLists: [{
+                title: 'Options',
+                list: [
+                    {
+                        description: 'The generated patch file will be saved to this directory',
+                        name: '--patches-dir',
+                    },
+                ],
+            }],
+        url: docsUrl('patch-commit'),
+        usages: ['pnpm patch-commit <patchDir>'],
+    });
+}
+export async function handler(opts, params) {
+    const userDir = params[0];
+    const lockfileDir = (opts.lockfileDir ?? opts.dir ?? process.cwd());
+    const patchesDirName = normalizePath(path.normalize(opts.patchesDir ?? 'patches'));
+    const patchesDir = path.join(lockfileDir, patchesDirName);
+    const patchedPkgManifest = await readPackageJsonFromDir(userDir);
+    const editDir = path.resolve(opts.dir, userDir);
+    const stateValue = readEditDirState({
+        editDir,
+        modulesDir: path.join(lockfileDir, opts.modulesDir ?? 'node_modules'),
+    });
+    if (!stateValue) {
+        throw new PnpmError('INVALID_PATCH_DIR', `${userDir} is not a valid patch directory`, {
+            hint: 'A valid patch directory should be created by `pnpm patch`',
+        });
+    }
+    const { applyToAll } = stateValue;
+    const nameAndVersion = `${patchedPkgManifest.name}@${patchedPkgManifest.version}`;
+    const patchKey = applyToAll ? patchedPkgManifest.name : nameAndVersion;
+    let gitTarballUrl;
+    if (!applyToAll) {
+        gitTarballUrl = await getGitTarballUrlFromLockfile({
+            alias: patchedPkgManifest.name,
+            bareSpecifier: patchedPkgManifest.version || undefined,
+        }, {
+            lockfileDir,
+            modulesDir: opts.modulesDir,
+            virtualStoreDir: opts.virtualStoreDir,
+        });
+    }
+    const patchedPkg = parseWantedDependency(gitTarballUrl ? `${patchedPkgManifest.name}@${gitTarballUrl}` : nameAndVersion);
+    const patchedPkgDir = await preparePkgFilesForDiff(userDir);
+    const patchContent = await getPatchContent({
+        patchedPkg,
+        patchedPkgDir,
+        tmpName: createShortHash(editDir),
+    }, opts);
+    if (patchedPkgDir !== userDir) {
+        fs.rmSync(patchedPkgDir, { recursive: true });
+    }
+    if (!patchContent.length) {
+        return `No changes were found to the following directory: ${userDir}`;
+    }
+    await fs.promises.mkdir(patchesDir, { recursive: true });
+    const patchFileName = patchKey.replace('/', '__');
+    await fs.promises.writeFile(path.join(patchesDir, `${patchFileName}.patch`), patchContent, 'utf8');
+    const patchedDependencies = {
+        ...opts.patchedDependencies,
+        [patchKey]: `${patchesDirName}/${patchFileName}.patch`,
+    };
+    await updatePatchedDependencies(patchedDependencies, {
+        ...opts,
+        workspaceDir: opts.workspaceDir ?? opts.rootProjectManifestDir,
+    });
+    return install.handler({
+        ...opts,
+        patchedDependencies,
+        rawLocalConfig: {
+            ...opts.rawLocalConfig,
+            'frozen-lockfile': false,
+        },
+    });
+}
+async function getPatchContent(ctx, opts) {
+    const storeDir = await getStorePath({
+        pkgRoot: opts.dir,
+        storePath: opts.storeDir,
+        pnpmHomeDir: opts.pnpmHomeDir,
+    });
+    const srcDir = path.join(storeDir, 'tmp', 'patch-commit', ctx.tmpName);
+    await writePackage(ctx.patchedPkg, srcDir, opts);
+    const patchContent = await diffFolders(srcDir, ctx.patchedPkgDir);
+    try {
+        fs.rmSync(srcDir, { recursive: true });
+    }
+    catch (error) {
+        globalWarn(`Failed to clean up temporary directory at ${srcDir} with error: ${String(error)}`);
+    }
+    return patchContent;
+}
+async function diffFolders(folderA, folderB) {
+    const folderAN = folderA.replace(/\\/g, '/');
+    const folderBN = folderB.replace(/\\/g, '/');
+    let stdout;
+    let stderr;
+    try {
+        const result = await execa('git', ['-c', 'core.safecrlf=false', 'diff', '--src-prefix=a/', '--dst-prefix=b/', '--ignore-cr-at-eol', '--irreversible-delete', '--full-index', '--no-index', '--text', '--no-ext-diff', '--no-color', folderAN, folderBN], {
+            cwd: process.cwd(),
+            env: {
+                ...process.env,
+                // #region Predictable output
+                // These variables aim to ignore the global git config so we get predictable output
+                // https://git-scm.com/docs/git#Documentation/git.txt-codeGITCONFIGNOSYSTEMcode
+                GIT_CONFIG_NOSYSTEM: '1',
+                // Redirect the global git config to /dev/null instead of setting
+                // HOME to an empty string. An empty HOME causes git to resolve '~' as
+                // '/' (root), which triggers a "Permission denied" warning when git
+                // tries to access '/.config/git/attributes', making pnpm throw an
+                // error because any stderr output is treated as a failure.
+                // We do not set XDG_CONFIG_HOME to avoid the same issue: an empty
+                // value would make git resolve paths like /git/config and /git/attributes.
+                // We use '/dev/null' literally instead of os.devNull because on Windows
+                // os.devNull is '\\.\nul', which git cannot open as a config file path
+                // (fatal: unable to access '\\.\nul': Invalid argument). Git for Windows
+                // translates '/dev/null' correctly via its MSYS2 layer.
+                GIT_CONFIG_GLOBAL: '/dev/null',
+                // #endregion
+            },
+            stripFinalNewline: false,
+        });
+        stdout = result.stdout;
+        stderr = result.stderr;
+    }
+    catch (err) { // eslint-disable-line
+        stdout = err.stdout;
+        stderr = err.stderr;
+    }
+    // we cannot rely on exit code, because --no-index implies --exit-code
+    // i.e. git diff will exit with 1 if there were differences
+    if (stderr.length > 0)
+        throw new Error(`Unable to diff directories. Make sure you have a recent version of 'git' available in PATH.\nThe following error was reported by 'git':\n${stderr}`);
+    return stdout
+        .replace(new RegExp(`(a|b)(${escapeStringRegexp(`/${removeTrailingAndLeadingSlash(folderAN)}/`)})`, 'g'), '$1/')
+        .replace(new RegExp(`(a|b)${escapeStringRegexp(`/${removeTrailingAndLeadingSlash(folderBN)}/`)}`, 'g'), '$1/')
+        .replace(new RegExp(escapeStringRegexp(`${folderAN}/`), 'g'), '')
+        .replace(new RegExp(escapeStringRegexp(`${folderBN}/`), 'g'), '')
+        .replace(/\n\\n$/, '\n')
+        .replace(/^diff --git a\/.*\.DS_Store b\/.*\.DS_Store[\s\S]+?(?=^diff --git)/gm, '')
+        .replace(/^diff --git a\/.*\.DS_Store b\/.*\.DS_Store[\s\S]*$/gm, '');
+}
+function removeTrailingAndLeadingSlash(p) {
+    if (p[0] === '/' || p.endsWith('/')) {
+        return p.replace(/^\/|\/$/g, '');
+    }
+    return p;
+}
+/**
+ * Link files from the source directory to a new temporary directory,
+ * but only if not all files in the source directory should be included in the package.
+ * If all files should be included, return the original source directory without creating any links.
+ * This is required in order for the diff to not include files that are not part of the package.
+ */
+async function preparePkgFilesForDiff(src) {
+    const files = Array.from(new Set((await packlist(src)).map((f) => path.join(f))));
+    // If there are no extra files in the source directories, then there is no reason
+    // to copy.
+    if (await areAllFilesInPkg(files, src)) {
+        return src;
+    }
+    const dest = `${src}_tmp`;
+    await makeEmptyDir(dest);
+    await Promise.all(files.map(async (file) => {
+        const srcFile = path.join(src, file);
+        const destFile = path.join(dest, file);
+        const destDir = path.dirname(destFile);
+        await fs.promises.mkdir(destDir, { recursive: true });
+        await fs.promises.link(srcFile, destFile);
+    }));
+    return dest;
+}
+async function areAllFilesInPkg(files, basePath) {
+    const allFiles = await glob('**', {
+        cwd: basePath,
+        expandDirectories: false,
+    });
+    return equals(allFiles.sort(), files.sort());
+}
+async function getGitTarballUrlFromLockfile(dep, opts) {
+    const { preferredVersions } = await getVersionsFromLockfile(dep, opts);
+    return preferredVersions[0]?.gitTarballUrl;
+}
+//# sourceMappingURL=patchCommit.js.map

package/lib/patchRemove.d.ts

@@ -0,0 +1,8 @@
+import { type Config } from '@pnpm/config.reader';
+import { install } from '@pnpm/installing.commands';
+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 PatchRemoveCommandOptions = install.InstallCommandOptions & Pick<Config, 'dir' | 'lockfileDir' | 'patchesDir' | 'rootProjectManifest' | 'patchedDependencies'>;
+export declare function handler(opts: PatchRemoveCommandOptions, params: string[]): Promise<void>;

package/lib/patchRemove.js

@@ -0,0 +1,74 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { install } from '@pnpm/installing.commands';
+import enquirer from 'enquirer';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { updatePatchedDependencies } from './updatePatchedDependencies.js';
+export function rcOptionsTypes() {
+    return pick([], allTypes);
+}
+export function cliOptionsTypes() {
+    return { ...rcOptionsTypes() };
+}
+export const commandNames = ['patch-remove'];
+export function help() {
+    return renderHelp({
+        description: 'Remove existing patch files',
+        url: docsUrl('patch-remove'),
+        usages: ['pnpm patch-remove [pkg...]'],
+    });
+}
+export async function handler(opts, params) {
+    let patchesToRemove = params;
+    const patchedDependencies = opts.patchedDependencies ?? {};
+    if (!params.length) {
+        const allPatches = Object.keys(patchedDependencies);
+        if (allPatches.length) {
+            ({ patches: patchesToRemove } = await enquirer.prompt({
+                type: 'multiselect',
+                name: 'patches',
+                message: 'Select the patch to be removed',
+                choices: allPatches,
+                validate(value) {
+                    return value.length === 0 ? 'Select at least one option.' : true;
+                },
+            }));
+        }
+    }
+    if (!patchesToRemove.length) {
+        throw new PnpmError('NO_PATCHES_TO_REMOVE', 'There are no patches that need to be removed');
+    }
+    for (const patch of patchesToRemove) {
+        if (!Object.hasOwn(patchedDependencies, patch)) {
+            throw new PnpmError('PATCH_NOT_FOUND', `Patch "${patch}" not found in patched dependencies`);
+        }
+    }
+    const patchesDirs = new Set();
+    await Promise.all(patchesToRemove.map(async (patch) => {
+        if (Object.hasOwn(patchedDependencies, patch)) {
+            const patchFile = patchedDependencies[patch];
+            patchesDirs.add(path.dirname(patchFile));
+            await fs.rm(patchFile, { force: true });
+            delete patchedDependencies[patch];
+        }
+    }));
+    await Promise.all(Array.from(patchesDirs).map(async (dir) => {
+        try {
+            const files = await fs.readdir(dir);
+            if (!files.length) {
+                await fs.rmdir(dir);
+            }
+        }
+        catch { }
+    }));
+    await updatePatchedDependencies(patchedDependencies, {
+        ...opts,
+        workspaceDir: opts.workspaceDir ?? opts.rootProjectManifestDir,
+    });
+    return install.handler(opts);
+}
+//# sourceMappingURL=patchRemove.js.map

package/lib/stateFile.d.ts

@@ -0,0 +1,18 @@
+export type EditDir = string & {
+    __brand: 'patch-edit-dir';
+};
+export interface EditDirState {
+    patchedPkg: string;
+    applyToAll: boolean;
+}
+export type State = Record<EditDir, EditDirState>;
+export interface EditDirKeyInput {
+    editDir: string;
+}
+export interface ReadEditDirStateOptions extends EditDirKeyInput {
+    modulesDir: string;
+}
+export declare function readEditDirState(opts: ReadEditDirStateOptions): EditDirState | undefined;
+export interface WriteEditDirStateOptions extends ReadEditDirStateOptions, EditDirState {
+}
+export declare function writeEditDirState(opts: WriteEditDirStateOptions): void;

package/lib/stateFile.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+const createEditDirKey = (opts) => opts.editDir;
+export function readEditDirState(opts) {
+    const state = readStateFile(opts.modulesDir);
+    if (!state)
+        return undefined;
+    const key = createEditDirKey(opts);
+    return state[key];
+}
+export function writeEditDirState(opts) {
+    modifyStateFile(opts.modulesDir, state => {
+        const key = createEditDirKey(opts);
+        state[key] = {
+            patchedPkg: opts.patchedPkg,
+            applyToAll: opts.applyToAll,
+        };
+    });
+}
+function modifyStateFile(modulesDir, modifyState) {
+    const filePath = getStateFilePath(modulesDir);
+    let state = readStateFile(modulesDir);
+    if (!state) {
+        state = {};
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+    modifyState(state);
+    fs.writeFileSync(filePath, JSON.stringify(state, undefined, 2));
+}
+function readStateFile(modulesDir) {
+    let fileContent;
+    try {
+        fileContent = fs.readFileSync(getStateFilePath(modulesDir), 'utf-8');
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return undefined;
+        }
+        throw err;
+    }
+    return JSON.parse(fileContent);
+}
+function getStateFilePath(modulesDir) {
+    return path.join(modulesDir, '.pnpm_patches', 'state.json');
+}
+//# sourceMappingURL=stateFile.js.map

package/lib/updatePatchedDependencies.d.ts

@@ -0,0 +1,2 @@
+import { type WriteSettingsOptions } from '@pnpm/config.writer';
+export declare function updatePatchedDependencies(patchedDependencies: Record<string, string>, opts: Omit<WriteSettingsOptions, 'updatedSettings'>): Promise<void>;

package/lib/updatePatchedDependencies.js

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import { writeSettings } from '@pnpm/config.writer';
+import normalizePath from 'normalize-path';
+export async function updatePatchedDependencies(patchedDependencies, opts) {
+    const workspaceDir = opts.workspaceDir ?? opts.rootProjectManifestDir;
+    for (const [patchName, patchPath] of Object.entries(patchedDependencies)) {
+        if (path.isAbsolute(patchPath)) {
+            patchedDependencies[patchName] = normalizePath(path.relative(workspaceDir, patchPath));
+        }
+    }
+    await writeSettings({
+        ...opts,
+        workspaceDir,
+        updatedSettings: {
+            patchedDependencies: Object.keys(patchedDependencies).length ? patchedDependencies : undefined,
+        },
+    });
+}
+//# sourceMappingURL=updatePatchedDependencies.js.map

package/lib/writePackage.d.ts

@@ -0,0 +1,5 @@
+import type { Config } from '@pnpm/config.reader';
+import type { ParseWantedDependencyResult } from '@pnpm/resolving.parse-wanted-dependency';
+import { type CreateStoreControllerOptions } from '@pnpm/store.connection-manager';
+export type WritePackageOptions = CreateStoreControllerOptions & Pick<Config, 'registries'>;
+export declare function writePackage(dep: ParseWantedDependencyResult, dest: string, opts: WritePackageOptions): Promise<void>;

package/lib/writePackage.js

@@ -0,0 +1,19 @@
+import { createStoreController, } from '@pnpm/store.connection-manager';
+export async function writePackage(dep, dest, opts) {
+    const store = await createStoreController({
+        ...opts,
+        packageImportMethod: 'clone-or-copy',
+    });
+    const pkgResponse = await store.ctrl.requestPackage(dep, {
+        downloadPriority: 1,
+        lockfileDir: opts.dir,
+        preferredVersions: {},
+        projectDir: opts.dir,
+    });
+    const { files } = await pkgResponse.fetching();
+    await store.ctrl.importPackage(dest, {
+        filesResponse: files,
+        force: true,
+    });
+}
+//# sourceMappingURL=writePackage.js.map

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@pnpm/patching.commands",
+  "version": "1000.3.21",
+  "description": "Commands for creating patches",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "scripts"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/patching/commands",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/patching/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": {
+    "chalk": "^5.6.0",
+    "enquirer": "^2.4.1",
+    "escape-string-regexp": "^5.0.0",
+    "is-windows": "^1.0.2",
+    "make-empty-dir": "^4.0.0",
+    "normalize-path": "^3.0.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "realpath-missing": "^2.0.0",
+    "render-help": "^2.0.0",
+    "safe-execa": "^0.3.0",
+    "semver": "^7.7.2",
+    "terminal-link": "^4.0.0",
+    "tinyglobby": "^0.2.14",
+    "@pnpm/config.reader": "1004.4.2",
+    "@pnpm/config.writer": "1000.0.14",
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/crypto.hash": "1000.2.1",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/cli.utils": "1001.2.8",
+    "@pnpm/fetching.pick-fetcher": "1001.0.0",
+    "@pnpm/fs.packlist": "1000.0.0",
+    "@pnpm/installing.modules-yaml": "1000.3.6",
+    "@pnpm/lockfile.fs": "1001.1.21",
+    "@pnpm/installing.commands": "1004.6.10",
+    "@pnpm/lockfile.utils": "1003.0.3",
+    "@pnpm/patching.apply-patch": "1000.0.7",
+    "@pnpm/pkg-manifest.reader": "1000.1.2",
+    "@pnpm/resolving.parse-wanted-dependency": "1001.0.0",
+    "@pnpm/store.connection-manager": "1002.2.4",
+    "@pnpm/store.path": "1000.0.5",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/workspace.project-manifest-reader": "1001.1.4",
+    "@pnpm/workspace.workspace-manifest-reader": "1000.2.5"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@pnpm/registry-mock": "5.2.4",
+    "@types/is-windows": "^1.0.2",
+    "@types/normalize-path": "^3.0.2",
+    "@types/ramda": "0.29.12",
+    "@types/semver": "7.7.1",
+    "tempy": "3.0.0",
+    "write-yaml-file": "^6.0.0",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/patching.commands": "1000.3.21",
+    "@pnpm/prepare": "1000.0.4",
+    "@pnpm/workspace.projects-filter": "1000.0.43",
+    "@pnpm/test-fixtures": "1000.0.0"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config/with-registry"
+  },
+  "scripts": {
+    "start": "tsgo --watch",
+    "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"
+  }
+}