@pnpm/engine.pm.commands 1000.0.0

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/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { selfUpdate } from './self-updater/index.js';
+export { installPnpm, installPnpmToStore, linkExePlatformBinary } from './self-updater/installPnpm.js';
+export { setup } from './setup/index.js';

package/lib/index.js

@@ -0,0 +1,4 @@
+export { selfUpdate } from './self-updater/index.js';
+export { installPnpm, installPnpmToStore, linkExePlatformBinary } from './self-updater/installPnpm.js';
+export { setup } from './setup/index.js';
+//# sourceMappingURL=index.js.map

package/lib/self-updater/index.d.ts

@@ -0,0 +1,3 @@
+import * as selfUpdate from './selfUpdate.js';
+export { installPnpm, installPnpmToStore, linkExePlatformBinary } from './installPnpm.js';
+export { selfUpdate };

package/lib/self-updater/index.js

@@ -0,0 +1,4 @@
+import * as selfUpdate from './selfUpdate.js';
+export { installPnpm, installPnpmToStore, linkExePlatformBinary } from './installPnpm.js';
+export { selfUpdate };
+//# sourceMappingURL=index.js.map

package/lib/self-updater/installPnpm.d.ts

@@ -0,0 +1,42 @@
+import { type GlobalAddOptions } from '@pnpm/global.commands';
+import type { EnvLockfile } from '@pnpm/lockfile.types';
+import type { StoreController } from '@pnpm/store.controller';
+import type { Registries } from '@pnpm/types';
+export interface InstallPnpmResult {
+    binDir: string;
+    baseDir: string;
+    alreadyExisted: boolean;
+}
+export interface InstallPnpmOptions extends GlobalAddOptions {
+    envLockfile?: EnvLockfile;
+    storeController?: StoreController;
+    storeDir?: string;
+    packageManager?: {
+        name: string;
+        version: string;
+    };
+}
+/**
+ * Installs pnpm to the global packages directory (for self-update).
+ * Creates an entry in globalPkgDir that is visible to `pnpm ls -g`.
+ */
+export declare function installPnpm(pnpmVersion: string, opts: InstallPnpmOptions): Promise<InstallPnpmResult>;
+/**
+ * Installs pnpm to the global virtual store (for version switching).
+ * Does NOT create an entry in globalPkgDir — the package lives only in the store.
+ * Returns the bin directory where the pnpm binary can be found.
+ */
+export declare function installPnpmToStore(pnpmVersion: string, opts: {
+    envLockfile: EnvLockfile;
+    storeController: StoreController;
+    storeDir: string;
+    registries: Registries;
+    virtualStoreDirMaxLength: number;
+    packageManager?: {
+        name: string;
+        version: string;
+    };
+}): Promise<{
+    binDir: string;
+}>;
+export declare function linkExePlatformBinary(installDir: string): void;

package/lib/self-updater/installPnpm.js

@@ -0,0 +1,280 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import { linkBins } from '@pnpm/bins.linker';
+import { getCurrentPackageName } from '@pnpm/cli.meta';
+import { iterateHashedGraphNodes, iteratePkgMeta, lockfileToDepGraph, } from '@pnpm/deps.graph-hasher';
+import { installGlobalPackages } from '@pnpm/global.commands';
+import { cleanOrphanedInstallDirs, createGlobalCacheKey, createInstallDir, findGlobalPackage, getHashLink, } from '@pnpm/global.packages';
+import { headlessInstall } from '@pnpm/installing.deps-restorer';
+import symlinkDir from 'symlink-dir';
+/**
+ * Installs pnpm to the global packages directory (for self-update).
+ * Creates an entry in globalPkgDir that is visible to `pnpm ls -g`.
+ */
+export async function installPnpm(pnpmVersion, opts) {
+    const currentPkgName = getCurrentPackageName();
+    const wantedLockfile = opts.envLockfile
+        ? buildLockfileFromEnvLockfile(opts.envLockfile, currentPkgName, pnpmVersion)
+        : undefined;
+    const result = await installPnpmToGlobalDir(opts, currentPkgName, pnpmVersion, wantedLockfile);
+    return {
+        alreadyExisted: result.alreadyExisted,
+        baseDir: result.installDir,
+        binDir: result.binDir,
+    };
+}
+/**
+ * Installs pnpm to the global virtual store (for version switching).
+ * Does NOT create an entry in globalPkgDir — the package lives only in the store.
+ * Returns the bin directory where the pnpm binary can be found.
+ */
+export async function installPnpmToStore(pnpmVersion, opts) {
+    const currentPkgName = getCurrentPackageName();
+    const wantedLockfile = buildLockfileFromEnvLockfile(opts.envLockfile, currentPkgName, pnpmVersion);
+    const globalVirtualStoreDir = path.join(opts.storeDir, 'links');
+    // Compute the GVS hash for the pnpm package to find its path
+    const pnpmGvsPath = findPnpmGvsPath(wantedLockfile, currentPkgName, globalVirtualStoreDir);
+    const pnpmPkgDir = path.join(pnpmGvsPath, 'node_modules', currentPkgName);
+    const binDir = path.join(pnpmGvsPath, 'bin');
+    // Check if already installed in the GVS
+    if (fs.existsSync(path.join(pnpmPkgDir, 'package.json'))) {
+        if (!fs.existsSync(binDir)) {
+            await linkBins(path.join(pnpmGvsPath, 'node_modules'), binDir, { warn: noop });
+        }
+        return { binDir };
+    }
+    // Install to a temporary directory — headless install with GVS enabled
+    // will populate the global virtual store
+    const tmpInstallDir = path.join(opts.storeDir, '.tmp', `pnpm-${pnpmVersion}-${Date.now()}`);
+    fs.mkdirSync(tmpInstallDir, { recursive: true });
+    try {
+        await installFromLockfile(tmpInstallDir, binDir, {
+            wantedLockfile,
+            storeController: opts.storeController,
+            storeDir: opts.storeDir,
+            registries: opts.registries,
+            virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+            packageManager: opts.packageManager,
+        });
+        // Now the GVS should be populated — create bins alongside the GVS entry
+        linkExePlatformBinary(pnpmGvsPath);
+        await linkBins(path.join(pnpmGvsPath, 'node_modules'), binDir, { warn: noop });
+        return { binDir };
+    }
+    finally {
+        try {
+            fs.rmSync(tmpInstallDir, { recursive: true, force: true });
+        }
+        catch { }
+    }
+}
+function noop(_message) { }
+function findPnpmGvsPath(lockfile, pkgName, globalVirtualStoreDir) {
+    const graph = lockfileToDepGraph(lockfile);
+    const pkgMetaIterator = iteratePkgMeta(lockfile, graph);
+    for (const { hash, pkgMeta } of iterateHashedGraphNodes(graph, pkgMetaIterator)) {
+        if (pkgMeta.name === pkgName) {
+            return path.join(globalVirtualStoreDir, hash);
+        }
+    }
+    throw new Error(`Could not find ${pkgName} in lockfile`);
+}
+/**
+ * Installs pnpm to the global packages directory.
+ * Bins are created within the install dir's own bin/ subdirectory.
+ *
+ * When a `wantedLockfile` is provided, a frozen headless install is performed
+ * using the lockfile's integrity hashes for security. Otherwise, full resolution
+ * is performed via `installGlobalPackages`.
+ */
+async function installPnpmToGlobalDir(opts, pkgName, version, wantedLockfile) {
+    const globalDir = opts.globalPkgDir;
+    cleanOrphanedInstallDirs(globalDir);
+    // Check if already installed globally
+    const existing = findGlobalPackage(globalDir, pkgName);
+    if (existing) {
+        const pkgJsonPath = path.join(existing.installDir, 'node_modules', pkgName, 'package.json');
+        try {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+            if (pkgJson.version === version) {
+                const binDir = path.join(existing.installDir, 'bin');
+                return { alreadyExisted: true, installDir: existing.installDir, binDir };
+            }
+        }
+        catch { }
+    }
+    const installDir = createInstallDir(globalDir);
+    const binDir = path.join(installDir, 'bin');
+    try {
+        if (wantedLockfile != null && opts.storeController != null && opts.storeDir != null) {
+            await installFromLockfile(installDir, binDir, {
+                wantedLockfile,
+                storeController: opts.storeController,
+                storeDir: opts.storeDir,
+                registries: opts.registries,
+                virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+                packageManager: opts.packageManager,
+            });
+        }
+        else {
+            await installFromResolution(installDir, opts, [`${pkgName}@${version}`]);
+        }
+        linkExePlatformBinary(installDir);
+        await linkBins(path.join(installDir, 'node_modules'), binDir, { warn: noop });
+        // Create hash symlink for the global packages system
+        const pkgJson = JSON.parse(fs.readFileSync(path.join(installDir, 'package.json'), 'utf8'));
+        const aliases = Object.keys(pkgJson.dependencies ?? {});
+        const cacheHash = createGlobalCacheKey({ aliases, registries: opts.registries });
+        const hashLink = getHashLink(globalDir, cacheHash);
+        await symlinkDir(installDir, hashLink, { overwrite: true });
+        return { alreadyExisted: false, installDir, binDir };
+    }
+    catch (err) {
+        try {
+            fs.rmSync(installDir, { recursive: true, force: true });
+        }
+        catch { }
+        throw err;
+    }
+}
+async function installFromLockfile(installDir, binDir, opts) {
+    const rootImporter = opts.wantedLockfile.importers['.'];
+    const dependencies = rootImporter?.dependencies ?? {};
+    fs.writeFileSync(path.join(installDir, 'package.json'), JSON.stringify({ dependencies }));
+    await headlessInstall({
+        wantedLockfile: opts.wantedLockfile,
+        lockfileDir: installDir,
+        storeController: opts.storeController,
+        storeDir: opts.storeDir,
+        registries: opts.registries,
+        enableGlobalVirtualStore: true,
+        globalVirtualStoreDir: path.join(opts.storeDir, 'links'),
+        ignoreScripts: true,
+        ignoreDepScripts: true,
+        force: false,
+        engineStrict: false,
+        currentEngine: {
+            pnpmVersion: opts.packageManager?.version ?? '',
+        },
+        include: {
+            dependencies: true,
+            devDependencies: false,
+            optionalDependencies: true,
+        },
+        selectedProjectDirs: [installDir],
+        allProjects: {
+            [installDir]: {
+                binsDir: binDir,
+                buildIndex: 0,
+                manifest: { dependencies },
+                modulesDir: path.join(installDir, 'node_modules'),
+                id: '.',
+                rootDir: installDir,
+            },
+        },
+        hoistedDependencies: {},
+        virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+        sideEffectsCacheRead: false,
+        sideEffectsCacheWrite: false,
+        rawConfig: {},
+        unsafePerm: false,
+        userAgent: '',
+        packageManager: opts.packageManager ?? { name: 'pnpm', version: '' },
+        pruneStore: false,
+        pendingBuilds: [],
+        skipped: new Set(),
+    });
+}
+async function installFromResolution(installDir, opts, params) {
+    const include = {
+        dependencies: true,
+        devDependencies: false,
+        optionalDependencies: true,
+    };
+    const fetchFullMetadata = Boolean(opts.supportedArchitectures?.libc);
+    await installGlobalPackages({
+        ...opts,
+        global: false,
+        bin: path.join(installDir, 'node_modules/.bin'),
+        dir: installDir,
+        lockfileDir: installDir,
+        rootProjectManifestDir: installDir,
+        rootProjectManifest: undefined,
+        saveProd: true,
+        saveDev: false,
+        saveOptional: false,
+        savePeer: false,
+        workspaceDir: undefined,
+        sharedWorkspaceLockfile: false,
+        lockfileOnly: false,
+        fetchFullMetadata,
+        include,
+        includeDirect: include,
+        allowBuilds: {},
+    }, params);
+}
+// @pnpm/exe bundles Node.js via optional platform-specific packages (e.g. @pnpm/macos-arm64).
+// Its postinstall script links the correct binary into the @pnpm/exe package dir.
+// Since scripts are disabled during install (to support systems without Node.js),
+// we replicate that linking here.
+export function linkExePlatformBinary(installDir) {
+    const platform = process.platform === 'win32'
+        ? 'win'
+        : process.platform === 'darwin'
+            ? 'macos'
+            : process.platform;
+    const arch = platform === 'win' && process.arch === 'ia32' ? 'x86' : process.arch;
+    const exePkgDir = path.join(installDir, 'node_modules', '@pnpm', 'exe');
+    if (!fs.existsSync(exePkgDir))
+        return;
+    // In pnpm's symlinked node_modules layout, the platform package is not hoisted
+    // to the top-level node_modules. It's a dependency of @pnpm/exe and lives as a
+    // sibling in the virtual store. Resolve through the @pnpm/exe symlink to find it.
+    const exeRealDir = fs.realpathSync(exePkgDir);
+    const platformPkgDir = path.join(path.dirname(exeRealDir), `${platform}-${arch}`);
+    const executable = platform === 'win' ? 'pnpm.exe' : 'pnpm';
+    const src = path.join(platformPkgDir, executable);
+    if (!fs.existsSync(src))
+        return;
+    const dest = path.join(exePkgDir, executable);
+    try {
+        fs.unlinkSync(dest);
+    }
+    catch (err) {
+        if (!util.types.isNativeError(err) || !('code' in err) || err.code !== 'ENOENT') {
+            throw err;
+        }
+    }
+    fs.linkSync(src, dest);
+    fs.chmodSync(dest, 0o755);
+    if (platform === 'win') {
+        const exePkgJsonPath = path.join(exePkgDir, 'package.json');
+        const exePkg = JSON.parse(fs.readFileSync(exePkgJsonPath, 'utf8'));
+        fs.writeFileSync(path.join(exePkgDir, 'pnpm'), 'This file intentionally left blank');
+        exePkg.bin.pnpm = 'pnpm.exe';
+        fs.writeFileSync(exePkgJsonPath, JSON.stringify(exePkg, null, 2));
+    }
+}
+function buildLockfileFromEnvLockfile(envLockfile, pkgName, version) {
+    const dependencies = {};
+    dependencies[pkgName] = version;
+    const packages = {};
+    for (const [depPath, snapshot] of Object.entries(envLockfile.snapshots)) {
+        packages[depPath] = {
+            ...snapshot,
+            ...envLockfile.packages[depPath],
+        };
+    }
+    return {
+        lockfileVersion: envLockfile.lockfileVersion,
+        importers: {
+            ['.']: {
+                specifiers: { [pkgName]: version },
+                dependencies,
+            },
+        },
+        packages: packages,
+    };
+}
+//# sourceMappingURL=installPnpm.js.map

package/lib/self-updater/selfUpdate.d.ts

@@ -0,0 +1,9 @@
+import { type Config } from '@pnpm/config.reader';
+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 commandNames: string[];
+export declare const skipPackageManagerCheck = true;
+export declare function help(): string;
+export type SelfUpdateCommandOptions = CreateStoreControllerOptions & Pick<Config, 'globalPkgDir' | 'lockfileDir' | 'managePackageManagerVersions' | 'modulesDir' | 'pnpmHomeDir' | 'rootProjectManifestDir' | 'wantedPackageManager'>;
+export declare function handler(opts: SelfUpdateCommandOptions, params: string[]): Promise<undefined | string>;

package/lib/self-updater/selfUpdate.js

@@ -0,0 +1,149 @@
+import path from 'node:path';
+import { linkBins } from '@pnpm/bins.linker';
+import { isExecutedByCorepack, packageManager } from '@pnpm/cli.meta';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { createResolver } from '@pnpm/installing.client';
+import { resolvePackageManagerIntegrities } from '@pnpm/installing.env-installer';
+import { globalWarn } from '@pnpm/logger';
+import { whichVersionIsPinned } from '@pnpm/resolving.npm-resolver';
+import { createStoreController } from '@pnpm/store.connection-manager';
+import { readProjectManifest } from '@pnpm/workspace.project-manifest-reader';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import semver from 'semver';
+import { installPnpm } from './installPnpm.js';
+export function rcOptionsTypes() {
+    return pick([], allTypes);
+}
+export function cliOptionsTypes() {
+    return {
+        ...rcOptionsTypes(),
+    };
+}
+export const commandNames = ['self-update'];
+export const skipPackageManagerCheck = true;
+export function help() {
+    return renderHelp({
+        description: 'Updates pnpm to the latest version (or the one specified)',
+        descriptionLists: [],
+        url: docsUrl('self-update'),
+        usages: [
+            'pnpm self-update',
+            'pnpm self-update 9',
+            'pnpm self-update next-10',
+            'pnpm self-update 9.10.0',
+        ],
+    });
+}
+export async function handler(opts, params) {
+    if (isExecutedByCorepack()) {
+        throw new PnpmError('CANT_SELF_UPDATE_IN_COREPACK', 'You should update pnpm with corepack');
+    }
+    const { resolve } = createResolver({ ...opts, authConfig: opts.rawConfig });
+    const pkgName = 'pnpm';
+    const bareSpecifier = params[0] ?? 'latest';
+    const resolution = await resolve({ alias: pkgName, bareSpecifier }, {
+        lockfileDir: opts.lockfileDir ?? opts.dir,
+        preferredVersions: {},
+        projectDir: opts.dir,
+    });
+    if (!resolution?.manifest) {
+        throw new PnpmError('CANNOT_RESOLVE_PNPM', `Cannot find "${bareSpecifier}" version of pnpm`);
+    }
+    if (opts.wantedPackageManager?.name === packageManager.name) {
+        if (opts.wantedPackageManager?.version !== resolution.manifest.version) {
+            const { manifest, writeProjectManifest } = await readProjectManifest(opts.rootProjectManifestDir);
+            if (manifest.devEngines?.packageManager) {
+                if (Array.isArray(manifest.devEngines.packageManager)) {
+                    const pnpmEntry = manifest.devEngines.packageManager.find((e) => e.name === 'pnpm');
+                    if (pnpmEntry) {
+                        const updated = updateVersionConstraint(pnpmEntry.version, resolution.manifest.version);
+                        if (updated !== pnpmEntry.version) {
+                            pnpmEntry.version = updated;
+                            await writeProjectManifest(manifest);
+                        }
+                    }
+                }
+                else if (manifest.devEngines.packageManager.name === 'pnpm') {
+                    const updated = updateVersionConstraint(manifest.devEngines.packageManager.version, resolution.manifest.version);
+                    if (updated !== manifest.devEngines.packageManager.version) {
+                        manifest.devEngines.packageManager.version = updated;
+                        await writeProjectManifest(manifest);
+                    }
+                }
+                const store = await createStoreController(opts);
+                await resolvePackageManagerIntegrities(resolution.manifest.version, {
+                    registries: opts.registries,
+                    rootDir: opts.rootProjectManifestDir,
+                    storeController: store.ctrl,
+                    storeDir: store.dir,
+                });
+            }
+            else {
+                manifest.packageManager = `pnpm@${resolution.manifest.version}`;
+                await writeProjectManifest(manifest);
+            }
+            return `The current project has been updated to use pnpm v${resolution.manifest.version}`;
+        }
+        else {
+            return `The current project is already set to use pnpm v${resolution.manifest.version}`;
+        }
+    }
+    if (resolution.manifest.version === packageManager.version) {
+        return `The currently active ${packageManager.name} v${packageManager.version} is already "${bareSpecifier}" and doesn't need an update`;
+    }
+    const store = await createStoreController(opts);
+    // Resolve integrities and write env lockfile to pnpm-lock.yaml
+    const envLockfile = await resolvePackageManagerIntegrities(resolution.manifest.version, {
+        registries: opts.registries,
+        rootDir: opts.pnpmHomeDir,
+        storeController: store.ctrl,
+        storeDir: store.dir,
+    });
+    const { baseDir, alreadyExisted } = await installPnpm(resolution.manifest.version, {
+        ...opts,
+        envLockfile,
+        storeController: store.ctrl,
+        storeDir: store.dir,
+    });
+    // Link bins to pnpmHomeDir so the updated pnpm is the active global binary
+    await linkBins(path.join(baseDir, 'node_modules'), opts.pnpmHomeDir, { warn: globalWarn });
+    if (alreadyExisted) {
+        return `The ${bareSpecifier} version, v${resolution.manifest.version}, is already present on the system. It was activated by linking it from ${baseDir}.`;
+    }
+    return undefined;
+}
+/**
+ * Returns the updated version constraint for devEngines.packageManager.
+ * - Exact versions and simple ranges (^, ~) are updated to the new version,
+ *   preserving the range operator.
+ * - Ranges that still satisfy the new version are returned unchanged
+ *   (the exact version will be pinned in the lockfile instead).
+ * - Complex ranges (>=x <y, etc.) that no longer satisfy the new version
+ *   fall back to a caret range with the new version (`^${newVersion}`).
+ */
+function updateVersionConstraint(current, newVersion) {
+    if (current == null)
+        return newVersion;
+    // Range that still satisfies the new version — leave it as-is (lockfile handles pinning)
+    if (semver.satisfies(newVersion, current, { includePrerelease: true }))
+        return current;
+    // Determine the pinning style of the current specifier
+    const pinnedVersion = whichVersionIsPinned(current);
+    if (pinnedVersion == null) {
+        // Complex range that can't be updated while preserving its structure — fall back to ^version
+        return `^${newVersion}`;
+    }
+    return versionSpecFromPinned(newVersion, pinnedVersion);
+}
+function versionSpecFromPinned(version, pinnedVersion) {
+    switch (pinnedVersion) {
+        case 'none':
+        case 'major': return `^${version}`;
+        case 'minor': return `~${version}`;
+        case 'patch': return version;
+    }
+}
+//# sourceMappingURL=selfUpdate.js.map

package/lib/setup/index.d.ts

@@ -0,0 +1,2 @@
+import * as setup from './setup.js';
+export { setup };

package/lib/setup/index.js

@@ -0,0 +1,3 @@
+import * as setup from './setup.js';
+export { setup };
+//# sourceMappingURL=index.js.map

package/lib/setup/setup.d.ts

@@ -0,0 +1,9 @@
+export declare const rcOptionsTypes: () => Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare const shorthands: {};
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: {
+    force?: boolean;
+    pnpmHomeDir: string;
+}): Promise<string>;

package/lib/setup/setup.js

@@ -0,0 +1,165 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { detectIfCurrentPkgIsExecutable, packageManager } from '@pnpm/cli.meta';
+import { docsUrl } from '@pnpm/cli.utils';
+import { logger } from '@pnpm/logger';
+import { addDirToEnvPath, } from '@pnpm/os.env.path-extender';
+import { renderHelp } from 'render-help';
+export const rcOptionsTypes = () => ({});
+export const cliOptionsTypes = () => ({
+    force: Boolean,
+});
+export const shorthands = {};
+export const commandNames = ['setup'];
+export function help() {
+    return renderHelp({
+        description: 'Sets up pnpm',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Override the PNPM_HOME env variable in case it already exists',
+                        name: '--force',
+                        shortAlias: '-f',
+                    },
+                ],
+            },
+        ],
+        url: docsUrl('setup'),
+        usages: ['pnpm setup'],
+    });
+}
+function getExecPath() {
+    if (detectIfCurrentPkgIsExecutable()) {
+        // If the pnpm CLI is a single executable application (SEA), we use the path
+        // to the exe file instead of the js path.
+        return process.execPath;
+    }
+    return process.argv[1] ?? process.cwd();
+}
+/**
+ * Install the CLI as a global package using `pnpm add -g file:<dir>`.
+ * This places pnpm in the standard global directory alongside other
+ * globally installed packages.
+ */
+function installCliGlobally(execPath, pnpmHomeDir) {
+    const execDir = path.dirname(execPath);
+    const execName = path.basename(execPath);
+    const pkgJsonPath = path.join(execDir, 'package.json');
+    // Write a package.json if one doesn't already exist.
+    // (Updated tarballs on GitHub Pages will ship with package.json already.)
+    let createdPkgJson = false;
+    if (!fs.existsSync(pkgJsonPath)) {
+        fs.writeFileSync(pkgJsonPath, JSON.stringify({
+            name: '@pnpm/exe',
+            version: packageManager.version,
+            bin: { pnpm: execName },
+        }));
+        createdPkgJson = true;
+    }
+    logger.info({
+        message: `Installing pnpm CLI globally from ${execDir}`,
+        prefix: process.cwd(),
+    });
+    try {
+        const { status, error } = spawnSync(execPath, ['add', '-g', `file:${execDir}`], {
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                PNPM_HOME: pnpmHomeDir,
+            },
+        });
+        if (error)
+            throw error;
+        if (status !== 0) {
+            throw new Error(`Failed to install pnpm globally (exit code ${status})`);
+        }
+    }
+    finally {
+        if (createdPkgJson) {
+            fs.unlinkSync(pkgJsonPath);
+        }
+    }
+}
+function createPnpxScripts(targetDir) {
+    // Why script files instead of aliases?
+    // 1. Aliases wouldn't work on all platform, such as Windows Command Prompt or POSIX `sh`.
+    // 2. Aliases wouldn't work on all environments, such as non-interactive shells and CI environments.
+    // 3. Aliases must be set for different shells while script files are limited to only 2 types: POSIX and Windows.
+    // 4. Aliases cannot be located with the `which` or `where` command.
+    // 5. Editing rc files is more error-prone than just write new files to the filesystem.
+    fs.mkdirSync(targetDir, { recursive: true });
+    // windows can also use shell script via mingw or cygwin so no filter
+    const shellScript = [
+        '#!/bin/sh',
+        'exec pnpm dlx "$@"',
+    ].join('\n');
+    fs.writeFileSync(path.join(targetDir, 'pnpx'), shellScript, { mode: 0o755 });
+    if (process.platform === 'win32') {
+        const batchScript = [
+            '@echo off',
+            'pnpm dlx %*',
+        ].join('\n');
+        fs.writeFileSync(path.join(targetDir, 'pnpx.cmd'), batchScript);
+        const powershellScript = 'pnpm dlx @args';
+        fs.writeFileSync(path.join(targetDir, 'pnpx.ps1'), powershellScript);
+    }
+}
+export async function handler(opts) {
+    const execPath = getExecPath();
+    if (execPath.match(/\.[cm]?js$/) == null) {
+        installCliGlobally(execPath, opts.pnpmHomeDir);
+        createPnpxScripts(opts.pnpmHomeDir);
+    }
+    try {
+        const report = await addDirToEnvPath(opts.pnpmHomeDir, {
+            configSectionName: 'pnpm',
+            proxyVarName: 'PNPM_HOME',
+            overwrite: opts.force,
+            position: 'start',
+        });
+        return renderSetupOutput(report);
+    }
+    catch (err) { // eslint-disable-line
+        switch (err.code) {
+            case 'ERR_PNPM_BAD_ENV_FOUND':
+                err.hint = 'If you want to override the existing env variable, use the --force option';
+                break;
+            case 'ERR_PNPM_BAD_SHELL_SECTION':
+                err.hint = 'If you want to override the existing configuration section, use the --force option';
+                break;
+        }
+        throw err;
+    }
+}
+function renderSetupOutput(report) {
+    if (report.oldSettings === report.newSettings) {
+        return 'No changes to the environment were made. Everything is already up to date.';
+    }
+    const output = [];
+    if (report.configFile) {
+        output.push(reportConfigChange(report.configFile));
+    }
+    output.push(`Next configuration changes were made:
+${report.newSettings}`);
+    if (report.configFile == null) {
+        output.push('Setup complete. Open a new terminal to start using pnpm.');
+    }
+    else if (report.configFile.changeType !== 'skipped') {
+        output.push(`To start using pnpm, run:
+source ${report.configFile.path}
+`);
+    }
+    return output.join('\n\n');
+}
+function reportConfigChange(configReport) {
+    switch (configReport.changeType) {
+        case 'created': return `Created ${configReport.path}`;
+        case 'appended': return `Appended new lines to ${configReport.path}`;
+        case 'modified': return `Replaced configuration in ${configReport.path}`;
+        case 'skipped': return `Configuration already up to date in ${configReport.path}`;
+    }
+}
+//# sourceMappingURL=setup.js.map

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@pnpm/engine.pm.commands",
+  "version": "1000.0.0",
+  "description": "pnpm commands for self-updating and setting up pnpm",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/engine/pm/commands",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/engine/pm/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": {
+    "@pnpm/os.env.path-extender": "^2.0.3",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "render-help": "^2.0.0",
+    "semver": "^7.7.2",
+    "symlink-dir": "^7.0.0",
+    "@pnpm/bins.linker": "1000.2.6",
+    "@pnpm/cli.meta": "1000.0.11",
+    "@pnpm/deps.graph-hasher": "1002.0.8",
+    "@pnpm/cli.utils": "1001.2.8",
+    "@pnpm/config.reader": "1004.4.2",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/global.packages": "1000.0.0-0",
+    "@pnpm/installing.client": "1001.1.4",
+    "@pnpm/global.commands": "1000.0.0-0",
+    "@pnpm/installing.deps-restorer": "1006.0.0",
+    "@pnpm/lockfile.types": "1002.0.2",
+    "@pnpm/resolving.npm-resolver": "1004.4.1",
+    "@pnpm/installing.env-installer": "1000.0.19",
+    "@pnpm/store.connection-manager": "1002.2.4",
+    "@pnpm/store.controller": "1004.0.0",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/workspace.project-manifest-reader": "1001.1.4"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/ramda": "0.29.12",
+    "@types/semver": "7.7.1",
+    "cross-spawn": "^7.0.6",
+    "nock": "13.3.4",
+    "@pnpm/engine.pm.commands": "1000.0.0",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/prepare": "1000.0.4",
+    "@pnpm/shell.path": "1000.0.0"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest"
+  }
+}