@pnpm/store.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,2 @@
+export { catFile, catIndex, findHash } from './inspecting/index.js';
+export { store } from './store/index.js';

package/lib/index.js

@@ -0,0 +1,3 @@
+export { catFile, catIndex, findHash } from './inspecting/index.js';
+export { store } from './store/index.js';
+//# sourceMappingURL=index.js.map

package/lib/inspecting/catFile.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '@pnpm/config.reader';
+export declare const skipPackageManagerCheck = true;
+export declare const commandNames: string[];
+export declare const rcOptionsTypes: typeof cliOptionsTypes;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare function help(): string;
+export type CatFileCommandOptions = Pick<Config, 'storeDir' | 'pnpmHomeDir'>;
+export declare function handler(opts: CatFileCommandOptions, params: string[]): Promise<string>;

package/lib/inspecting/catFile.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import util from 'node:util';
+import { PnpmError } from '@pnpm/error';
+import gfs from '@pnpm/fs.graceful-fs';
+import { getStorePath } from '@pnpm/store.path';
+import { renderHelp } from 'render-help';
+const INTEGRITY_REGEX = /^[^-]+-([a-z0-9+/=]+)$/i;
+export const skipPackageManagerCheck = true;
+export const commandNames = ['cat-file'];
+export const rcOptionsTypes = cliOptionsTypes;
+export function cliOptionsTypes() {
+    return {};
+}
+export function help() {
+    return renderHelp({
+        description: 'Prints the contents of a file based on the hash value stored in the index file.',
+        descriptionLists: [],
+        usages: ['pnpm cat-file <hash>'],
+    });
+}
+export async function handler(opts, params) {
+    if (!params || params.length === 0) {
+        throw new PnpmError('MISSING_HASH', 'Missing file hash', {
+            hint: help(),
+        });
+    }
+    const [, integrityHash] = params[0].match(INTEGRITY_REGEX);
+    const toHex = Buffer.from(integrityHash, 'base64').toString('hex');
+    const storeDir = await getStorePath({
+        pkgRoot: process.cwd(),
+        storePath: opts.storeDir,
+        pnpmHomeDir: opts.pnpmHomeDir,
+    });
+    const cafsDir = path.join(storeDir, 'files');
+    const filePath = path.resolve(cafsDir, toHex.slice(0, 2), toHex.slice(2));
+    try {
+        return gfs.readFileSync(filePath, 'utf8');
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            throw new PnpmError('INVALID_HASH', 'Corresponding hash file not found');
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=catFile.js.map

package/lib/inspecting/catIndex.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '@pnpm/config.reader';
+export declare const skipPackageManagerCheck = true;
+export declare const commandNames: string[];
+export declare const rcOptionsTypes: typeof cliOptionsTypes;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare function help(): string;
+export type CatIndexCommandOptions = Pick<Config, 'rawConfig' | 'pnpmHomeDir' | 'storeDir' | 'lockfileDir' | 'dir' | 'registries' | 'cacheDir' | 'sslConfigs'>;
+export declare function handler(opts: CatIndexCommandOptions, params: string[]): Promise<string>;

package/lib/inspecting/catIndex.js

@@ -0,0 +1,69 @@
+import util from 'node:util';
+import { PnpmError } from '@pnpm/error';
+import { createResolver } from '@pnpm/installing.client';
+import { sortDeepKeys } from '@pnpm/object.key-sorting';
+import { parseWantedDependency } from '@pnpm/resolving.parse-wanted-dependency';
+import { StoreIndex, storeIndexKey } from '@pnpm/store.index';
+import { getStorePath } from '@pnpm/store.path';
+import { lexCompare } from '@pnpm/util.lex-comparator';
+import { renderHelp } from 'render-help';
+export const skipPackageManagerCheck = true;
+export const commandNames = ['cat-index'];
+export const rcOptionsTypes = cliOptionsTypes;
+export function cliOptionsTypes() {
+    return {};
+}
+export function help() {
+    return renderHelp({
+        description: 'Prints the index file of a specific package from the store.',
+        descriptionLists: [],
+        usages: ['pnpm cat-index <pkg name>@<pkg version>'],
+    });
+}
+export async function handler(opts, params) {
+    if (!params || params.length === 0) {
+        throw new PnpmError('MISSING_PACKAGE_NAME', 'Specify a package', {
+            hint: help(),
+        });
+    }
+    const wantedDependency = params[0];
+    const { alias, bareSpecifier } = parseWantedDependency(wantedDependency) || {};
+    if (!alias) {
+        throw new PnpmError('INVALID_SELECTOR', `Cannot parse the "${wantedDependency}" selector`);
+    }
+    const storeDir = await getStorePath({
+        pkgRoot: process.cwd(),
+        storePath: opts.storeDir,
+        pnpmHomeDir: opts.pnpmHomeDir,
+    });
+    const { resolve } = createResolver({
+        ...opts,
+        authConfig: opts.rawConfig,
+    });
+    const pkgSnapshot = await resolve({ alias, bareSpecifier }, {
+        lockfileDir: opts.lockfileDir ?? opts.dir,
+        preferredVersions: {},
+        projectDir: opts.dir,
+    });
+    const filesIndexFile = storeIndexKey(pkgSnapshot.resolution.integrity.toString(), `${alias}@${bareSpecifier}`);
+    const storeIndex = new StoreIndex(storeDir);
+    try {
+        const pkgFilesIndex = storeIndex.get(filesIndexFile);
+        if (!pkgFilesIndex) {
+            throw new PnpmError('INVALID_PACKAGE', 'No corresponding index file found. You can use pnpm list to see if the package is installed.');
+        }
+        return JSON.stringify(sortDeepKeys(pkgFilesIndex), replacer, 2);
+    }
+    finally {
+        storeIndex.close();
+    }
+}
+function replacer(key, value) {
+    if (util.types.isMap(value)) {
+        const entries = Array.from(value.entries());
+        entries.sort(([key1], [key2]) => lexCompare(key1, key2));
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+//# sourceMappingURL=catIndex.js.map

package/lib/inspecting/findHash.d.ts

@@ -0,0 +1,15 @@
+import type { Config } from '@pnpm/config.reader';
+export declare const PACKAGE_INFO_CLR: import("chalk").ChalkInstance;
+export declare const INDEX_PATH_CLR: import("chalk").ChalkInstance;
+export declare const skipPackageManagerCheck = true;
+export declare const commandNames: string[];
+export declare const rcOptionsTypes: typeof cliOptionsTypes;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare function help(): string;
+export type FindHashCommandOptions = Pick<Config, 'storeDir' | 'pnpmHomeDir'>;
+export interface FindHashResult {
+    name: string;
+    version: string;
+    indexKey: string;
+}
+export declare function handler(opts: FindHashCommandOptions, params: string[]): Promise<string>;

package/lib/inspecting/findHash.js

@@ -0,0 +1,85 @@
+import { PnpmError } from '@pnpm/error';
+import { StoreIndex } from '@pnpm/store.index';
+import { getStorePath } from '@pnpm/store.path';
+import chalk from 'chalk';
+import { renderHelp } from 'render-help';
+export const PACKAGE_INFO_CLR = chalk.greenBright;
+export const INDEX_PATH_CLR = chalk.hex('#078487');
+export const skipPackageManagerCheck = true;
+export const commandNames = ['find-hash'];
+export const rcOptionsTypes = cliOptionsTypes;
+export function cliOptionsTypes() {
+    return {};
+}
+export function help() {
+    return renderHelp({
+        description: 'Experimental! Lists the packages that include the file with the specified hash.',
+        descriptionLists: [],
+        usages: ['pnpm find-hash <hash>'],
+    });
+}
+export async function handler(opts, params) {
+    if (!params || params.length === 0) {
+        throw new PnpmError('MISSING_HASH', '`pnpm find-hash` requires the hash');
+    }
+    // Convert the input hash to hex format for comparison
+    // Input can be either:
+    // - A hex string (used directly)
+    // - A base64 integrity string like "sha512-..." (converted to hex)
+    let hash = params[0];
+    if (hash.includes('-')) {
+        // Looks like an integrity string (algo-base64), extract and convert the base64 part
+        const base64Part = hash.split('-').slice(1).join('-');
+        hash = Buffer.from(base64Part, 'base64').toString('hex');
+    }
+    // Stored digests are lowercase hex, so normalize the input to lowercase
+    hash = hash.toLowerCase();
+    const storeDir = await getStorePath({
+        pkgRoot: process.cwd(),
+        storePath: opts.storeDir,
+        pnpmHomeDir: opts.pnpmHomeDir,
+    });
+    const result = [];
+    const storeIndex = new StoreIndex(storeDir);
+    try {
+        for (const [indexKey, data] of storeIndex.entries()) {
+            const pkgFilesIndex = data;
+            if (!pkgFilesIndex)
+                continue;
+            if (pkgFilesIndex.files) {
+                for (const file of pkgFilesIndex.files.values()) {
+                    if (file?.digest === hash) {
+                        result.push({ name: pkgFilesIndex.manifest?.name ?? 'unknown', version: pkgFilesIndex.manifest?.version ?? 'unknown', indexKey });
+                        // a package is only found once.
+                        continue;
+                    }
+                }
+            }
+            if (pkgFilesIndex.sideEffects) {
+                for (const { added } of pkgFilesIndex.sideEffects.values()) {
+                    if (!added)
+                        continue;
+                    for (const file of added.values()) {
+                        if (file?.digest === hash) {
+                            result.push({ name: pkgFilesIndex.manifest?.name ?? 'unknown', version: pkgFilesIndex.manifest?.version ?? 'unknown', indexKey });
+                            // a package is only found once.
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        storeIndex.close();
+    }
+    if (!result.length) {
+        throw new PnpmError('INVALID_FILE_HASH', 'No package or index file matching this hash was found.');
+    }
+    let acc = '';
+    for (const { name, version, indexKey } of result) {
+        acc += `${PACKAGE_INFO_CLR(name)}@${PACKAGE_INFO_CLR(version)}  ${INDEX_PATH_CLR(indexKey)}\n`;
+    }
+    return acc;
+}
+//# sourceMappingURL=findHash.js.map

package/lib/inspecting/index.d.ts

@@ -0,0 +1,4 @@
+import * as catFile from './catFile.js';
+import * as catIndex from './catIndex.js';
+import * as findHash from './findHash.js';
+export { catFile, catIndex, findHash };

package/lib/inspecting/index.js

@@ -0,0 +1,5 @@
+import * as catFile from './catFile.js';
+import * as catIndex from './catIndex.js';
+import * as findHash from './findHash.js';
+export { catFile, catIndex, findHash };
+//# sourceMappingURL=index.js.map

package/lib/store/cleanExpiredDlxCache.d.ts

@@ -0,0 +1,6 @@
+export declare function cleanExpiredDlxCache({ cacheDir, dlxCacheMaxAge, now }: {
+    cacheDir: string;
+    dlxCacheMaxAge: number;
+    now: Date;
+}): Promise<void>;
+export declare function cleanOrphans(dlxCacheDir: string): Promise<void>;

package/lib/store/cleanExpiredDlxCache.js

@@ -0,0 +1,97 @@
+import { promises as fs, readdirSync } from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+export async function cleanExpiredDlxCache({ cacheDir, dlxCacheMaxAge, now, }) {
+    if (dlxCacheMaxAge === Infinity)
+        return;
+    const dlxCacheDir = path.join(cacheDir, 'dlx');
+    const dlxCacheNames = readOptDir(dlxCacheDir);
+    if (!dlxCacheNames)
+        return;
+    await Promise.all(dlxCacheNames.map(async (dlxCacheName) => {
+        const dlxCachePath = path.join(dlxCacheDir, dlxCacheName);
+        const dlxCacheLink = path.join(dlxCachePath, 'pkg');
+        let shouldClean;
+        if (dlxCacheMaxAge <= 0) {
+            shouldClean = true;
+        }
+        else {
+            const dlxCacheLinkStats = await getStats(dlxCacheLink);
+            shouldClean = dlxCacheLinkStats !== 'ENOENT' && isOutdated(dlxCacheLinkStats, dlxCacheMaxAge, now);
+        }
+        if (shouldClean) {
+            // delete the symlink, the symlink's target, and orphans (if any)
+            await fs.rm(dlxCachePath, { recursive: true, force: true });
+        }
+    }));
+    await cleanOrphans(dlxCacheDir);
+}
+export async function cleanOrphans(dlxCacheDir) {
+    const dlxCacheNames = readOptDir(dlxCacheDir);
+    if (!dlxCacheNames)
+        return;
+    await Promise.all(dlxCacheNames.map(async dlxCacheName => {
+        const dlxCachePath = path.join(dlxCacheDir, dlxCacheName);
+        const dlxCacheLink = path.join(dlxCachePath, 'pkg');
+        const dlxCacheLinkStats = await getStats(dlxCacheLink);
+        if (dlxCacheLinkStats === 'ENOENT') {
+            return fs.rm(dlxCachePath, { recursive: true, force: true });
+        }
+        const dlxCacheLinkTarget = await getRealPath(dlxCacheLink);
+        const children = await fs.readdir(dlxCachePath);
+        await Promise.all(children.map(async name => {
+            if (name === 'pkg')
+                return;
+            const fullPath = path.join(dlxCachePath, name);
+            if (fullPath === dlxCacheLinkTarget)
+                return;
+            await fs.rm(fullPath, { recursive: true, force: true });
+        }));
+    }));
+}
+function isOutdated(stats, dlxCacheMaxAge, now) {
+    return stats.mtime.getTime() + dlxCacheMaxAge * 60_000 < now.getTime();
+}
+async function getStats(path) {
+    try {
+        return await fs.lstat(path);
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return 'ENOENT';
+        }
+        throw err;
+    }
+}
+function readOptDir(dirPath) {
+    try {
+        const dirEntries = [];
+        for (const entry of readdirSync(dirPath, {
+            encoding: 'utf-8',
+            withFileTypes: true,
+        })) {
+            if (entry.isDirectory()) {
+                dirEntries.push(entry.name);
+            }
+        }
+        return dirEntries;
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return null;
+        }
+        throw err;
+    }
+}
+async function getRealPath(linkPath) {
+    try {
+        return await fs.realpath(linkPath);
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return null;
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=cleanExpiredDlxCache.js.map

package/lib/store/index.d.ts

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

package/lib/store/index.js

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

package/lib/store/store.d.ts

@@ -0,0 +1,12 @@
+import { type Config } from '@pnpm/config.reader';
+import { type LogBase } from '@pnpm/logger';
+import { type CreateStoreControllerOptions } from '@pnpm/store.connection-manager';
+export declare const skipPackageManagerCheck = true;
+export declare const rcOptionsTypes: typeof cliOptionsTypes;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export type StoreCommandOptions = Pick<Config, 'dir' | 'lockfileDir' | 'registries' | 'tag' | 'storeDir' | 'force' | 'dlxCacheMaxAge'> & Partial<Pick<Config, 'globalPkgDir'>> & CreateStoreControllerOptions & {
+    reporter?: (logObj: LogBase) => void;
+};
+export declare function handler(opts: StoreCommandOptions, params: string[]): Promise<string | undefined>;

package/lib/store/store.js

@@ -0,0 +1,121 @@
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { logger } from '@pnpm/logger';
+import { createStoreController } from '@pnpm/store.connection-manager';
+import { getStorePath } from '@pnpm/store.path';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { storeAdd } from './storeAdd.js';
+import { storePrune } from './storePrune.js';
+import { storeStatus } from './storeStatus/index.js';
+export const skipPackageManagerCheck = true;
+export const rcOptionsTypes = cliOptionsTypes;
+export function cliOptionsTypes() {
+    return pick([
+        'registry',
+        'store-dir',
+        'force',
+    ], allTypes);
+}
+export const commandNames = ['store'];
+export function help() {
+    return renderHelp({
+        description: 'Reads and performs actions on pnpm store that is on the current filesystem.',
+        descriptionLists: [
+            {
+                title: 'Commands',
+                list: [
+                    {
+                        description: '\
+Checks for modified packages in the store. \
+Returns exit code 0 if the content of the package is the same as it was at the time of unpacking',
+                        name: 'status',
+                    },
+                    {
+                        description: 'Adds new packages to the store. Example: pnpm store add express@4 typescript@2.1.0',
+                        name: 'add <pkg>...',
+                    },
+                    {
+                        description: '\
+Removes unreferenced (extraneous, orphan) packages from the store. \
+Pruning the store is not harmful, but might slow down future installations. \
+Visit the documentation for more information on unreferenced packages and why they occur',
+                        name: 'prune',
+                    },
+                    {
+                        description: 'If there are alien directories in the store, this command removes them. \
+Alien directories are directories/files that were not created by the package manager.',
+                        name: 'prune --force',
+                    },
+                    {
+                        description: 'Returns the path to the active store directory.',
+                        name: 'path',
+                    },
+                ],
+            },
+        ],
+        url: docsUrl('store'),
+        usages: ['pnpm store <command>'],
+    });
+}
+class StoreStatusError extends PnpmError {
+    modified;
+    constructor(modified) {
+        super('MODIFIED_DEPENDENCY', '');
+        this.modified = modified;
+    }
+}
+export async function handler(opts, params) {
+    let store;
+    switch (params[0]) {
+        case 'status':
+            return statusCmd(opts);
+        case 'path':
+            return getStorePath({
+                pkgRoot: opts.workspaceDir ?? opts.dir,
+                storePath: opts.storeDir,
+                pnpmHomeDir: opts.pnpmHomeDir,
+            });
+        case 'prune': {
+            store = await createStoreController(opts);
+            const storePruneOptions = Object.assign(opts, {
+                storeController: store.ctrl,
+                storeDir: store.dir,
+                removeAlienFiles: opts.force,
+                cacheDir: opts.cacheDir,
+                dlxCacheMaxAge: opts.dlxCacheMaxAge,
+            });
+            return storePrune(storePruneOptions);
+        }
+        case 'add':
+            store = await createStoreController(opts);
+            return storeAdd(params.slice(1), {
+                prefix: opts.dir,
+                reporter: opts.reporter,
+                storeController: store.ctrl,
+                tag: opts.tag,
+            });
+        default:
+            return help();
+    }
+}
+async function statusCmd(opts) {
+    const modifiedPkgs = await storeStatus(Object.assign(opts, {
+        lockfileDir: opts.lockfileDir ?? opts.workspaceDir ?? opts.dir,
+        storeDir: await getStorePath({
+            pkgRoot: opts.workspaceDir ?? opts.dir,
+            storePath: opts.storeDir,
+            pnpmHomeDir: opts.pnpmHomeDir,
+        }),
+    }));
+    if (!modifiedPkgs || (modifiedPkgs.length === 0)) {
+        logger.info({
+            message: 'Packages in the store are untouched',
+            prefix: opts.dir,
+        });
+        return;
+    }
+    throw new StoreStatusError(modifiedPkgs);
+}
+//# sourceMappingURL=store.js.map

package/lib/store/storeAdd.d.ts

@@ -0,0 +1,10 @@
+import type { StoreController } from '@pnpm/store.controller-types';
+import type { SupportedArchitectures } from '@pnpm/types';
+import type { ReporterFunction } from './types.js';
+export declare function storeAdd(fuzzyDeps: string[], opts: {
+    prefix?: string;
+    reporter?: ReporterFunction;
+    storeController: StoreController;
+    tag?: string;
+    supportedArchitectures?: SupportedArchitectures;
+}): Promise<void>;

package/lib/store/storeAdd.js

@@ -0,0 +1,36 @@
+import { PnpmError } from '@pnpm/error';
+import { globalInfo, logger, streamParser } from '@pnpm/logger';
+import { parseWantedDependency } from '@pnpm/resolving.parse-wanted-dependency';
+export async function storeAdd(fuzzyDeps, opts) {
+    const reporter = opts?.reporter;
+    if ((reporter != null) && typeof reporter === 'function') {
+        streamParser.on('data', reporter);
+    }
+    const deps = fuzzyDeps.map((dep) => parseWantedDependency(dep));
+    let hasFailures = false;
+    const prefix = opts.prefix ?? process.cwd();
+    await Promise.all(deps.map(async (dep) => {
+        try {
+            const pkgResponse = await opts.storeController.requestPackage(dep, {
+                downloadPriority: 1,
+                lockfileDir: prefix,
+                preferredVersions: {},
+                projectDir: prefix,
+                supportedArchitectures: opts.supportedArchitectures,
+            });
+            await pkgResponse.fetching();
+            globalInfo(`+ ${pkgResponse.body.id}`);
+        }
+        catch (e) { // eslint-disable-line
+            hasFailures = true;
+            logger('store').error(e);
+        }
+    }));
+    if ((reporter != null) && typeof reporter === 'function') {
+        streamParser.removeListener('data', reporter);
+    }
+    if (hasFailures) {
+        throw new PnpmError('STORE_ADD_FAILURE', 'Some packages have not been added correctly');
+    }
+}
+//# sourceMappingURL=storeAdd.js.map

package/lib/store/storePrune.d.ts

@@ -0,0 +1,10 @@
+import type { StoreController } from '@pnpm/store.controller-types';
+import type { ReporterFunction } from './types.js';
+export declare function storePrune(opts: {
+    reporter?: ReporterFunction;
+    storeController: StoreController;
+    removeAlienFiles?: boolean;
+    cacheDir: string;
+    dlxCacheMaxAge: number;
+    globalPkgDir?: string;
+}): Promise<void>;

package/lib/store/storePrune.js

@@ -0,0 +1,23 @@
+import { cleanOrphanedInstallDirs } from '@pnpm/global.packages';
+import { streamParser } from '@pnpm/logger';
+import { cleanExpiredDlxCache } from './cleanExpiredDlxCache.js';
+export async function storePrune(opts) {
+    const reporter = opts?.reporter;
+    if ((reporter != null) && typeof reporter === 'function') {
+        streamParser.on('data', reporter);
+    }
+    await opts.storeController.prune(opts.removeAlienFiles);
+    await opts.storeController.close();
+    await cleanExpiredDlxCache({
+        cacheDir: opts.cacheDir,
+        dlxCacheMaxAge: opts.dlxCacheMaxAge,
+        now: new Date(),
+    });
+    if (opts.globalPkgDir) {
+        cleanOrphanedInstallDirs(opts.globalPkgDir);
+    }
+    if ((reporter != null) && typeof reporter === 'function') {
+        streamParser.removeListener('data', reporter);
+    }
+}
+//# sourceMappingURL=storePrune.js.map

package/lib/store/storeStatus/extendStoreStatusOptions.d.ts

@@ -0,0 +1,23 @@
+import type { Registries } from '@pnpm/types';
+import type { ReporterFunction } from '../types.js';
+export interface StrictStoreStatusOptions {
+    autoInstallPeers: boolean;
+    excludeLinksFromLockfile: boolean;
+    lockfileDir: string;
+    dir: string;
+    storeDir: string;
+    force: boolean;
+    nodeLinker: 'isolated' | 'hoisted' | 'pnp';
+    useLockfile: boolean;
+    registries: Registries;
+    shamefullyHoist: boolean;
+    reporter: ReporterFunction;
+    production: boolean;
+    development: boolean;
+    optional: boolean;
+    binsDir: string;
+    virtualStoreDirMaxLength: number;
+    peersSuffixMaxLength: number;
+}
+export type StoreStatusOptions = Partial<StrictStoreStatusOptions> & Pick<StrictStoreStatusOptions, 'storeDir' | 'virtualStoreDirMaxLength'>;
+export declare function extendStoreStatusOptions(opts: StoreStatusOptions): Promise<StrictStoreStatusOptions>;

package/lib/store/storeStatus/extendStoreStatusOptions.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import { DEFAULT_REGISTRIES, normalizeRegistries } from '@pnpm/config.normalize-registries';
+const defaults = async (opts) => {
+    const dir = opts.dir ?? process.cwd();
+    const lockfileDir = opts.lockfileDir ?? dir;
+    return {
+        binsDir: path.join(dir, 'node_modules', '.bin'),
+        dir,
+        force: false,
+        lockfileDir,
+        nodeLinker: 'isolated',
+        registries: DEFAULT_REGISTRIES,
+        shamefullyHoist: false,
+        storeDir: opts.storeDir,
+        useLockfile: true,
+    };
+};
+export async function extendStoreStatusOptions(opts) {
+    if (opts) {
+        for (const key in opts) {
+            if (opts[key] === undefined) {
+                delete opts[key];
+            }
+        }
+    }
+    const defaultOpts = await defaults(opts);
+    const extendedOpts = { ...defaultOpts, ...opts, storeDir: defaultOpts.storeDir };
+    extendedOpts.registries = normalizeRegistries(extendedOpts.registries);
+    return extendedOpts;
+}
+//# sourceMappingURL=extendStoreStatusOptions.js.map

package/lib/store/storeStatus/index.d.ts

@@ -0,0 +1,2 @@
+import { type StoreStatusOptions } from './extendStoreStatusOptions.js';
+export declare function storeStatus(maybeOpts: StoreStatusOptions): Promise<string[]>;

package/lib/store/storeStatus/index.js

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import { formatIntegrity } from '@pnpm/crypto.integrity';
+import * as dp from '@pnpm/deps.path';
+import { getContextForSingleImporter } from '@pnpm/installing.context';
+import { nameVerFromPkgSnapshot, packageIdFromSnapshot, } from '@pnpm/lockfile.utils';
+import { streamParser } from '@pnpm/logger';
+import { gitHostedStoreIndexKey, storeIndexKey } from '@pnpm/store.index';
+import { StoreIndex } from '@pnpm/store.index';
+import dint from 'dint';
+import pFilter from 'p-filter';
+import { extendStoreStatusOptions, } from './extendStoreStatusOptions.js';
+export async function storeStatus(maybeOpts) {
+    const reporter = maybeOpts?.reporter;
+    if ((reporter != null) && typeof reporter === 'function') {
+        streamParser.on('data', reporter);
+    }
+    const opts = await extendStoreStatusOptions(maybeOpts);
+    const { storeDir, skipped, virtualStoreDir, wantedLockfile, } = await getContextForSingleImporter({}, {
+        ...opts,
+        extraBinPaths: [], // ctx.extraBinPaths is not needed, so this is fine
+    });
+    if (!wantedLockfile)
+        return [];
+    const pkgs = Object.entries(wantedLockfile.packages ?? {})
+        .filter(([depPath]) => !skipped.has(depPath))
+        .map(([depPath, pkgSnapshot]) => {
+        const id = packageIdFromSnapshot(depPath, pkgSnapshot);
+        return {
+            depPath,
+            id,
+            integrity: pkgSnapshot.resolution.integrity,
+            pkgPath: depPath,
+            ...nameVerFromPkgSnapshot(depPath, pkgSnapshot),
+        };
+    });
+    const storeIndex = new StoreIndex(storeDir);
+    try {
+        const modified = await pFilter(pkgs, async ({ id, integrity, depPath, name }) => {
+            const pkgIndexFilePath = integrity
+                ? storeIndexKey(integrity, id)
+                : gitHostedStoreIndexKey(id, { built: true });
+            const pkgFilesIndex = storeIndex.get(pkgIndexFilePath);
+            if (!pkgFilesIndex) {
+                return false;
+            }
+            const { algo, files } = pkgFilesIndex;
+            // Transform files to dint format: { integrity: '<algo>-<base64>', size: number }
+            const dintFiles = {};
+            for (const [filePath, { digest, size }] of files) {
+                dintFiles[filePath] = {
+                    integrity: formatIntegrity(algo, digest),
+                    size,
+                };
+            }
+            return (await dint.check(path.join(virtualStoreDir, dp.depPathToFilename(depPath, maybeOpts.virtualStoreDirMaxLength), 'node_modules', name), dintFiles)) === false;
+        }, { concurrency: 8 });
+        if ((reporter != null) && typeof reporter === 'function') {
+            streamParser.removeListener('data', reporter);
+        }
+        return modified.map(({ pkgPath }) => pkgPath);
+    }
+    finally {
+        storeIndex.close();
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/store/types.d.ts

@@ -0,0 +1,2 @@
+import type { LogBase } from '@pnpm/logger';
+export type ReporterFunction = (logObj: LogBase) => void;

package/lib/store/types.js

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

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@pnpm/store.commands",
+  "version": "1000.0.0",
+  "description": "Commands for controlling and inspecting the store",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "scripts"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/store/commands",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/store/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/util.lex-comparator": "^3.0.2",
+    "archy": "^1.0.0",
+    "chalk": "^5.6.0",
+    "dint": "^5.1.0",
+    "p-filter": "^4.1.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "render-help": "^2.0.0",
+    "@pnpm/cli.utils": "1001.2.8",
+    "@pnpm/config.normalize-registries": "1000.1.4",
+    "@pnpm/config.reader": "1004.4.2",
+    "@pnpm/fs.graceful-fs": "1000.0.1",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/global.packages": "1000.0.0-0",
+    "@pnpm/deps.path": "1001.1.3",
+    "@pnpm/installing.client": "1001.1.4",
+    "@pnpm/crypto.integrity": "1100.0.0-0",
+    "@pnpm/installing.context": "1001.1.8",
+    "@pnpm/lockfile.types": "1002.0.2",
+    "@pnpm/resolving.parse-wanted-dependency": "1001.0.0",
+    "@pnpm/lockfile.utils": "1003.0.3",
+    "@pnpm/store.cafs": "1000.0.19",
+    "@pnpm/store.connection-manager": "1002.2.4",
+    "@pnpm/object.key-sorting": "1000.0.1",
+    "@pnpm/store.controller-types": "1004.1.0",
+    "@pnpm/store.index": "1000.0.0-0",
+    "@pnpm/store.path": "1000.0.5",
+    "@pnpm/types": "1000.9.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@pnpm/registry-mock": "5.2.4",
+    "@types/archy": "0.0.36",
+    "@types/ramda": "0.29.12",
+    "@types/ssri": "^7.1.5",
+    "@zkochan/rimraf": "^4.0.0",
+    "execa": "npm:safe-execa@0.3.0",
+    "load-json-file": "^7.0.1",
+    "ssri": "13.0.0",
+    "tempy": "3.0.0",
+    "@pnpm/assert-store": "1000.0.3",
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/exec.commands": "1001.0.15",
+    "@pnpm/lockfile.fs": "1001.1.21",
+    "@pnpm/store.commands": "1000.0.0",
+    "@pnpm/prepare": "1000.0.4",
+    "@pnpm/store.controller": "1004.0.0",
+    "@pnpm/logger": "1001.0.1"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config/with-registry"
+  },
+  "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"
+  }
+}