@pnpm/releasing.commands 1000.0.0

package/lib/publish/otp.d.ts

@@ -0,0 +1,89 @@
+import { PnpmError } from '@pnpm/error';
+import type { ExportedManifest } from '@pnpm/releasing.exportable-manifest';
+import type { PublishOptions } from 'libnpmpublish';
+import { SHARED_CONTEXT } from './utils/shared-context.js';
+export interface OtpWebAuthFetchOptions {
+    method: 'GET';
+    retry?: {
+        factor?: number;
+        maxTimeout?: number;
+        minTimeout?: number;
+        randomize?: boolean;
+        retries?: number;
+    };
+    timeout?: number;
+}
+export interface OtpWebAuthFetchResponseHeaders {
+    get: (this: this, name: 'retry-after') => string | null;
+}
+export interface OtpWebAuthFetchResponse {
+    readonly headers: OtpWebAuthFetchResponseHeaders;
+    readonly json: (this: this) => Promise<unknown>;
+    readonly ok: boolean;
+    readonly status: number;
+}
+export interface OtpPublishResponse {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly text: () => Promise<string>;
+}
+export interface OtpEnquirer {
+    prompt: (this: this, options: OtpEnquirerOptions) => Promise<OtpEnquirerResponse | undefined>;
+}
+export interface OtpEnquirerOptions {
+    message: string;
+    name: 'otp';
+    type: 'input';
+}
+export interface OtpEnquirerResponse {
+    otp?: string;
+}
+export type OtpPublishFn = (manifest: ExportedManifest, tarballData: Buffer, options: PublishOptions) => Promise<OtpPublishResponse>;
+export interface OtpDate {
+    now: () => number;
+}
+export interface OtpContext {
+    Date: OtpDate;
+    setTimeout: (cb: () => void, ms: number) => void;
+    enquirer: OtpEnquirer;
+    fetch: (url: string, options: OtpWebAuthFetchOptions) => Promise<OtpWebAuthFetchResponse>;
+    globalInfo: (message: string) => void;
+    process: Record<'stdin' | 'stdout', {
+        isTTY?: boolean;
+    }>;
+    publish: OtpPublishFn;
+}
+export interface OtpParams {
+    context?: OtpContext;
+    manifest: ExportedManifest;
+    publishOptions: PublishOptions;
+    tarballData: Buffer;
+}
+export { SHARED_CONTEXT };
+/**
+ * Publish a package, handling OTP challenges:
+ * - Web based authentication flow (authUrl/doneUrl in error body with doneUrl polling)
+ * - Classic OTP prompt (manual code entry)
+ *
+ * @throws {@link OtpWebAuthTimeoutError} if the webauth browser flow times out.
+ * @throws {@link OtpNonInteractiveError} if OTP is required but the terminal is not interactive.
+ * @throws {@link OtpSecondChallengeError} if the registry requests OTP a second time after one was submitted.
+ * @throws the original error if OTP handling is not applicable.
+ *
+ * @see https://github.com/npm/cli/blob/7d900c46/lib/utils/otplease.js for npm's implementation.
+ * @see https://github.com/npm/npm-profile/blob/main/lib/index.js for the webauth polling flow.
+ */
+export declare function publishWithOtpHandling({ context: { Date, setTimeout, enquirer, fetch, globalInfo, process, publish }, manifest, publishOptions, tarballData }: OtpParams): Promise<OtpPublishResponse>;
+export declare class OtpWebAuthTimeoutError extends PnpmError {
+    readonly endTime: number;
+    readonly startTime: number;
+    readonly timeout: number;
+    constructor(endTime: number, startTime: number, timeout: number);
+}
+export declare class OtpNonInteractiveError extends PnpmError {
+    constructor();
+}
+export declare class OtpSecondChallengeError extends PnpmError {
+    constructor();
+}

package/lib/publish/otp.js

@@ -0,0 +1,165 @@
+import { PnpmError } from '@pnpm/error';
+import qrcodeTerminal from 'qrcode-terminal';
+import { SHARED_CONTEXT } from './utils/shared-context.js';
+export { SHARED_CONTEXT };
+const isOtpError = (error) => error != null &&
+    typeof error === 'object' &&
+    'code' in error &&
+    error.code === 'EOTP';
+/**
+ * Publish a package, handling OTP challenges:
+ * - Web based authentication flow (authUrl/doneUrl in error body with doneUrl polling)
+ * - Classic OTP prompt (manual code entry)
+ *
+ * @throws {@link OtpWebAuthTimeoutError} if the webauth browser flow times out.
+ * @throws {@link OtpNonInteractiveError} if OTP is required but the terminal is not interactive.
+ * @throws {@link OtpSecondChallengeError} if the registry requests OTP a second time after one was submitted.
+ * @throws the original error if OTP handling is not applicable.
+ *
+ * @see https://github.com/npm/cli/blob/7d900c46/lib/utils/otplease.js for npm's implementation.
+ * @see https://github.com/npm/npm-profile/blob/main/lib/index.js for the webauth polling flow.
+ */
+export async function publishWithOtpHandling({ context: { Date, setTimeout, enquirer, fetch, globalInfo, process, publish, } = SHARED_CONTEXT, manifest, publishOptions, tarballData, }) {
+    let response;
+    try {
+        response = await publish(manifest, tarballData, publishOptions);
+    }
+    catch (error) {
+        if (!isOtpError(error))
+            throw error;
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new OtpNonInteractiveError();
+        }
+        const fetchOptions = {
+            method: 'GET',
+            retry: {
+                factor: publishOptions.fetchRetryFactor,
+                maxTimeout: publishOptions.fetchRetryMaxtimeout,
+                minTimeout: publishOptions.fetchRetryMintimeout,
+                retries: publishOptions.fetchRetries,
+            },
+            timeout: publishOptions.timeout,
+        };
+        let otp;
+        if (error.body?.authUrl && error.body?.doneUrl) {
+            otp = await webAuthOtp(error.body.authUrl, error.body.doneUrl, { Date, setTimeout, fetch, globalInfo }, fetchOptions);
+        }
+        else {
+            const enquirerResponse = await enquirer.prompt({
+                message: 'This operation requires a one-time password.\nEnter OTP:',
+                name: 'otp',
+                type: 'input',
+            });
+            // Use || (not ??) so that empty-string input is treated as "no OTP provided"
+            otp = enquirerResponse?.otp || undefined;
+        }
+        if (otp != null) {
+            try {
+                return await publish(manifest, tarballData, { ...publishOptions, otp });
+            }
+            catch (retryError) {
+                if (isOtpError(retryError)) {
+                    throw new OtpSecondChallengeError();
+                }
+                throw retryError;
+            }
+        }
+        throw error;
+    }
+    return response;
+}
+async function webAuthOtp(authUrl, doneUrl, { Date, setTimeout, fetch, globalInfo }, fetchOptions) {
+    const qrCode = generateQrCode(authUrl);
+    globalInfo(`Authenticate your account at:\n${authUrl}\n\n${qrCode}`);
+    const startTime = Date.now();
+    const timeout = 5 * 60 * 1000; // 5 minutes
+    const pollIntervalMs = 1000;
+    while (true) {
+        const now = Date.now();
+        if (now - startTime > timeout) {
+            throw new OtpWebAuthTimeoutError(now, startTime, timeout);
+        }
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+        let response;
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            response = await fetch(doneUrl, fetchOptions);
+        }
+        catch {
+            continue;
+        }
+        if (!response.ok)
+            continue;
+        if (response.status === 202) {
+            // Registry is still waiting for authentication.
+            // Respect Retry-After header if present by waiting the additional time
+            // beyond the default poll interval already elapsed above, but do not
+            // exceed the overall timeout.
+            const retryAfterSeconds = Number(response.headers.get('retry-after'));
+            if (Number.isFinite(retryAfterSeconds)) {
+                const additionalMs = retryAfterSeconds * 1000 - pollIntervalMs;
+                if (additionalMs > 0) {
+                    const nowAfterPoll = Date.now();
+                    const remainingMs = timeout - (nowAfterPoll - startTime);
+                    if (remainingMs <= 0) {
+                        throw new OtpWebAuthTimeoutError(nowAfterPoll, startTime, timeout);
+                    }
+                    const sleepMs = Math.min(additionalMs, remainingMs);
+                    // eslint-disable-next-line no-await-in-loop
+                    await new Promise(resolve => setTimeout(resolve, sleepMs));
+                }
+            }
+            continue;
+        }
+        let body;
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            body = await response.json();
+        }
+        catch {
+            continue;
+        }
+        if (body.token) {
+            return body.token;
+        }
+    }
+}
+function generateQrCode(text) {
+    let qrCode;
+    qrcodeTerminal.generate(text, { small: true }, (code) => {
+        qrCode = code;
+    });
+    if (qrCode != null)
+        return qrCode;
+    /* istanbul ignore next */
+    throw new Error('we were expecting qrcode-terminal to be fully synchronous, but it fails to execute the callback');
+}
+export class OtpWebAuthTimeoutError extends PnpmError {
+    endTime;
+    startTime;
+    timeout;
+    constructor(endTime, startTime, timeout) {
+        super('WEBAUTH_TIMEOUT', 'Web-based authentication timed out before it could be completed', {
+            hint: 'Re-run this command and complete the authentication step in your browser before the time limit is reached',
+        });
+        this.endTime = endTime;
+        this.startTime = startTime;
+        this.timeout = timeout;
+    }
+}
+export class OtpNonInteractiveError extends PnpmError {
+    constructor() {
+        super('OTP_NON_INTERACTIVE', 'The registry requires additional authentication, but pnpm is not running in an interactive terminal', {
+            hint: 'Re-run this command in an interactive terminal to complete authentication, or provide the --otp option if you are using a classic one-time password (OTP)',
+        });
+    }
+}
+export class OtpSecondChallengeError extends PnpmError {
+    constructor() {
+        super('OTP_SECOND_CHALLENGE', 'The registry requested a one-time password (OTP) a second time after one was already provided', {
+            hint: 'This is unexpected behavior from the registry. Try the command again later and, if the issue persists, verify that your registry supports OTP-based authentication or contact the registry administrator.',
+        });
+    }
+}
+//# sourceMappingURL=otp.js.map

package/lib/publish/otpEnv.d.ts

@@ -0,0 +1,7 @@
+declare const ENV_KEY = "PNPM_CONFIG_OTP";
+type EnvBase = Partial<Readonly<Record<string, string>>> & Partial<Readonly<Record<typeof ENV_KEY, string>>>;
+interface OptionsBase {
+    readonly otp?: string;
+}
+export declare const optionsWithOtpEnv: <Options extends OptionsBase>(opts: Options, { [ENV_KEY]: otp }: EnvBase) => Options;
+export {};

package/lib/publish/otpEnv.js

@@ -0,0 +1,5 @@
+const ENV_KEY = 'PNPM_CONFIG_OTP';
+export const optionsWithOtpEnv = (opts, { [ENV_KEY]: otp }) => Boolean(opts.otp) || !otp // empty string is considered "not defined" here
+    ? opts
+    : { ...opts, otp };
+//# sourceMappingURL=otpEnv.js.map

package/lib/publish/pack.d.ts

@@ -0,0 +1,32 @@
+import { type Config, type UniversalOptions } from '@pnpm/config.reader';
+import { type ExportedManifest } from '@pnpm/releasing.exportable-manifest';
+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 PackOptions = Pick<UniversalOptions, 'dir'> & Pick<Config, 'catalogs' | 'ignoreScripts' | 'rawConfig' | 'embedReadme' | 'packGzipLevel' | 'nodeLinker'> & Partial<Pick<Config, 'extraBinPaths' | 'extraEnv' | 'hooks' | 'recursive' | 'selectedProjectsGraph' | 'workspaceConcurrency' | 'workspaceDir'>> & {
+    argv: {
+        original: string[];
+    };
+    dryRun?: boolean;
+    engineStrict?: boolean;
+    packDestination?: string;
+    out?: string;
+    json?: boolean;
+    unicode?: boolean;
+};
+export interface PackResultJson {
+    name: string;
+    version: string;
+    filename: string;
+    files: Array<{
+        path: string;
+    }>;
+}
+export declare function handler(opts: PackOptions): Promise<string>;
+export declare function api(opts: PackOptions): Promise<PackResult>;
+export interface PackResult {
+    publishedManifest: ExportedManifest;
+    contents: string[];
+    tarballPath: string;
+}

package/lib/publish/pack.js

@@ -0,0 +1,303 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createGzip } from 'node:zlib';
+import { getBinsFromPackageManifest } from '@pnpm/bins.resolver';
+import { FILTERING } from '@pnpm/cli.common-cli-options-help';
+import { readProjectManifest } from '@pnpm/cli.utils';
+import { getDefaultWorkspaceConcurrency, getWorkspaceConcurrency, types as allTypes } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { packlist } from '@pnpm/fs.packlist';
+import { logger } from '@pnpm/logger';
+import { createExportableManifest } from '@pnpm/releasing.exportable-manifest';
+import { sortProjects } from '@pnpm/workspace.projects-sorter';
+import chalk from 'chalk';
+import pLimit from 'p-limit';
+import { pick } from 'ramda';
+import { realpathMissing } from 'realpath-missing';
+import { renderHelp } from 'render-help';
+import tar from 'tar-stream';
+import { glob } from 'tinyglobby';
+import validateNpmPackageName from 'validate-npm-package-name';
+import { runScriptsIfPresent } from './publish.js';
+const LICENSE_GLOB = 'LICEN{S,C}E{,.*}'; // cspell:disable-line
+export function rcOptionsTypes() {
+    return {
+        ...cliOptionsTypes(),
+        ...pick([
+            'npm-path',
+        ], allTypes),
+    };
+}
+export function cliOptionsTypes() {
+    return {
+        out: String,
+        recursive: Boolean,
+        ...pick([
+            'dry-run',
+            'pack-destination',
+            'pack-gzip-level',
+            'json',
+            'workspace-concurrency',
+        ], allTypes),
+    };
+}
+export const commandNames = ['pack'];
+export function help() {
+    return renderHelp({
+        description: 'Create a tarball from a package',
+        usages: ['pnpm pack'],
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Does everything `pnpm pack` would do except actually writing the tarball to disk.',
+                        name: '--dry-run',
+                    },
+                    {
+                        description: 'Directory in which `pnpm pack` will save tarballs. The default is the current working directory.',
+                        name: '--pack-destination <dir>',
+                    },
+                    {
+                        description: 'Prints the packed tarball and contents in the json format.',
+                        name: '--json',
+                    },
+                    {
+                        description: 'Customizes the output path for the tarball. Use `%s` and `%v` to include the package name and version, e.g., `%s.tgz` or `some-dir/%s-%v.tgz`. By default, the tarball is saved in the current working directory with the name `<package-name>-<version>.tgz`.',
+                        name: '--out <path>',
+                    },
+                    {
+                        description: 'Pack all packages from the workspace',
+                        name: '--recursive',
+                        shortAlias: '-r',
+                    },
+                    {
+                        description: `Set the maximum number of concurrency. Default is ${getDefaultWorkspaceConcurrency()}. For unlimited concurrency use Infinity.`,
+                        name: '--workspace-concurrency <number>',
+                    },
+                ],
+            },
+            FILTERING,
+        ],
+    });
+}
+export async function handler(opts) {
+    const packedPackages = [];
+    if (opts.recursive) {
+        const selectedProjectsGraph = opts.selectedProjectsGraph;
+        const pkgsToPack = [];
+        for (const { package: pkg } of Object.values(selectedProjectsGraph)) {
+            if (pkg.manifest.name && pkg.manifest.version) {
+                pkgsToPack.push(pkg);
+            }
+        }
+        const packedPkgDirs = new Set(pkgsToPack.map(({ rootDir }) => rootDir));
+        if (packedPkgDirs.size === 0) {
+            logger.info({
+                message: 'There are no packages that should be packed',
+                prefix: opts.dir,
+            });
+        }
+        const chunks = sortProjects(selectedProjectsGraph);
+        const limitPack = pLimit(getWorkspaceConcurrency(opts.workspaceConcurrency));
+        const resolvedOpts = { ...opts };
+        if (opts.out) {
+            resolvedOpts.out = path.resolve(opts.dir, opts.out);
+        }
+        else if (opts.packDestination) {
+            resolvedOpts.packDestination = path.resolve(opts.dir, opts.packDestination);
+        }
+        else {
+            resolvedOpts.packDestination = path.resolve(opts.dir);
+        }
+        for (const chunk of chunks) {
+            // eslint-disable-next-line no-await-in-loop
+            await Promise.all(chunk.map(pkgDir => limitPack(async () => {
+                if (!packedPkgDirs.has(pkgDir))
+                    return;
+                const pkg = selectedProjectsGraph[pkgDir].package;
+                const packResult = await api({
+                    ...resolvedOpts,
+                    dir: pkg.rootDir,
+                });
+                packedPackages.push(toPackResultJson(packResult));
+            })));
+        }
+    }
+    else {
+        const packResult = await api(opts);
+        packedPackages.push(toPackResultJson(packResult));
+    }
+    if (opts.json) {
+        return JSON.stringify(packedPackages.length > 1 ? packedPackages : packedPackages[0], null, 2);
+    }
+    return packedPackages.map(({ name, version, filename, files }) => `${opts.unicode ? '📦 ' : 'package:'} ${name}@${version}
+${chalk.blueBright('Tarball Contents')}
+${files.map(({ path }) => path).join('\n')}
+${chalk.blueBright('Tarball Details')}
+${filename}`).join('\n\n');
+}
+export async function api(opts) {
+    const { manifest: entryManifest, fileName: manifestFileName } = await readProjectManifest(opts.dir, opts);
+    preventBundledDependenciesWithoutHoistedNodeLinker(opts.nodeLinker, entryManifest);
+    const _runScriptsIfPresent = runScriptsIfPresent.bind(null, {
+        depPath: opts.dir,
+        extraBinPaths: opts.extraBinPaths,
+        extraEnv: opts.extraEnv,
+        pkgRoot: opts.dir,
+        rawConfig: opts.rawConfig,
+        rootModulesDir: await realpathMissing(path.join(opts.dir, 'node_modules')),
+        stdio: 'inherit',
+        unsafePerm: true, // when running scripts explicitly, assume that they're trusted.
+    });
+    if (!opts.ignoreScripts) {
+        await _runScriptsIfPresent([
+            'prepack',
+            'prepare',
+        ], entryManifest);
+    }
+    const dir = entryManifest.publishConfig?.directory
+        ? path.join(opts.dir, entryManifest.publishConfig.directory)
+        : opts.dir;
+    // always read the latest manifest, as "prepack" or "prepare" script may modify package manifest.
+    const { manifest } = await readProjectManifest(dir, opts);
+    preventBundledDependenciesWithoutHoistedNodeLinker(opts.nodeLinker, manifest);
+    if (!manifest.name) {
+        throw new PnpmError('PACKAGE_NAME_NOT_FOUND', `Package name is not defined in the ${manifestFileName}.`);
+    }
+    if (!validateNpmPackageName(manifest.name).validForOldPackages) {
+        throw new PnpmError('INVALID_PACKAGE_NAME', `Invalid package name "${manifest.name}".`);
+    }
+    if (!manifest.version) {
+        throw new PnpmError('PACKAGE_VERSION_NOT_FOUND', `Package version is not defined in the ${manifestFileName}.`);
+    }
+    let tarballName;
+    let packDestination;
+    const normalizedName = manifest.name.replace('@', '').replace('/', '-');
+    if (opts.out) {
+        if (opts.packDestination) {
+            throw new PnpmError('INVALID_OPTION', 'Cannot use --pack-destination and --out together');
+        }
+        const preparedOut = opts.out.replaceAll('%s', normalizedName).replaceAll('%v', manifest.version);
+        const parsedOut = path.parse(preparedOut);
+        packDestination = parsedOut.dir ? parsedOut.dir : opts.packDestination;
+        tarballName = parsedOut.base;
+    }
+    else {
+        tarballName = `${normalizedName}-${manifest.version}.tgz`;
+        packDestination = opts.packDestination;
+    }
+    const publishManifest = await createPublishManifest({
+        projectDir: dir,
+        modulesDir: path.join(opts.dir, 'node_modules'),
+        manifest,
+        embedReadme: opts.embedReadme,
+        catalogs: opts.catalogs ?? {},
+        hooks: opts.hooks,
+    });
+    const files = await packlist(dir, {
+        manifest: publishManifest,
+    });
+    const filesMap = Object.fromEntries(files.map((file) => [`package/${file}`, path.join(dir, file)]));
+    // cspell:disable-next-line
+    if (opts.workspaceDir != null && dir !== opts.workspaceDir && !files.some((file) => /LICEN[CS]E(?:\..+)?/i.test(file))) {
+        const licenses = await glob([LICENSE_GLOB], { cwd: opts.workspaceDir, expandDirectories: false });
+        for (const license of licenses) {
+            filesMap[`package/${license}`] = path.join(opts.workspaceDir, license);
+        }
+    }
+    const destDir = packDestination
+        ? (path.isAbsolute(packDestination) ? packDestination : path.join(dir, packDestination ?? '.'))
+        : dir;
+    if (!opts.dryRun) {
+        await fs.promises.mkdir(destDir, { recursive: true });
+        await packPkg({
+            destFile: path.join(destDir, tarballName),
+            filesMap,
+            modulesDir: path.join(opts.dir, 'node_modules'),
+            packGzipLevel: opts.packGzipLevel,
+            manifest: publishManifest,
+            bins: [
+                ...(await getBinsFromPackageManifest(publishManifest, dir)).map(({ path }) => path),
+                ...(manifest.publishConfig?.executableFiles ?? [])
+                    .map((executableFile) => path.join(dir, executableFile)),
+            ],
+        });
+        if (!opts.ignoreScripts) {
+            await _runScriptsIfPresent(['postpack'], entryManifest);
+        }
+    }
+    let packedTarballPath;
+    if (opts.dir !== destDir) {
+        packedTarballPath = path.join(destDir, tarballName);
+    }
+    else {
+        packedTarballPath = path.relative(opts.dir, path.join(dir, tarballName));
+    }
+    const packedContents = files.sort((a, b) => a.localeCompare(b, 'en'));
+    return {
+        publishedManifest: publishManifest,
+        contents: packedContents,
+        tarballPath: packedTarballPath,
+    };
+}
+function preventBundledDependenciesWithoutHoistedNodeLinker(nodeLinker, manifest) {
+    if (nodeLinker === 'hoisted')
+        return;
+    for (const key of ['bundledDependencies', 'bundleDependencies']) {
+        const bundledDependencies = manifest[key];
+        if (bundledDependencies) {
+            throw new PnpmError('BUNDLED_DEPENDENCIES_WITHOUT_HOISTED', `${key} does not work with "nodeLinker: ${nodeLinker}"`, {
+                hint: `Add "nodeLinker: hoisted" to pnpm-workspace.yaml or delete ${key} from the root package.json to resolve this error`,
+            });
+        }
+    }
+}
+async function readReadmeFile(projectDir) {
+    const files = await fs.promises.readdir(projectDir);
+    const readmePath = files.find(name => /readme\.md$/i.test(name));
+    const readmeFile = readmePath ? await fs.promises.readFile(path.join(projectDir, readmePath), 'utf8') : undefined;
+    return readmeFile;
+}
+async function packPkg(opts) {
+    const { destFile, filesMap, bins, manifest, } = opts;
+    const mtime = new Date('1985-10-26T08:15:00.000Z');
+    const pack = tar.pack();
+    await Promise.all(Object.entries(filesMap).map(async ([name, source]) => {
+        const isExecutable = bins.some((bin) => path.relative(bin, source) === '');
+        const mode = isExecutable ? 0o755 : 0o644;
+        if (/^package\/package\.(?:json|json5|yaml)$/.test(name)) {
+            pack.entry({ mode, mtime, name: 'package/package.json' }, JSON.stringify(manifest, null, 2));
+            return;
+        }
+        pack.entry({ mode, mtime, name }, fs.readFileSync(source));
+    }));
+    const tarball = fs.createWriteStream(destFile);
+    pack.pipe(createGzip({ level: opts.packGzipLevel })).pipe(tarball);
+    pack.finalize();
+    return new Promise((resolve, reject) => {
+        tarball.on('close', () => {
+            resolve();
+        }).on('error', reject);
+    });
+}
+async function createPublishManifest(opts) {
+    const { projectDir, embedReadme, modulesDir, manifest, catalogs, hooks } = opts;
+    const readmeFile = embedReadme ? await readReadmeFile(projectDir) : undefined;
+    return createExportableManifest(projectDir, manifest, {
+        catalogs,
+        hooks,
+        readmeFile,
+        modulesDir,
+    });
+}
+function toPackResultJson(packResult) {
+    const { publishedManifest, contents, tarballPath } = packResult;
+    return {
+        name: publishedManifest.name,
+        version: publishedManifest.version,
+        filename: tarballPath,
+        files: contents.map((file) => ({ path: file })),
+    };
+}
+//# sourceMappingURL=pack.js.map

package/lib/publish/publish.d.ts

@@ -0,0 +1,31 @@
+import { type Config } from '@pnpm/config.reader';
+import { type RunLifecycleHookOptions } from '@pnpm/exec.lifecycle';
+import type { ProjectManifest } from '@pnpm/types';
+import { type PublishRecursiveOpts } from './recursivePublish.js';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: Omit<PublishRecursiveOpts, 'workspaceDir'> & {
+    argv: {
+        original: string[];
+    };
+    engineStrict?: boolean;
+    recursive?: boolean;
+    workspaceDir?: string;
+} & Pick<Config, 'allProjects' | 'bin' | 'gitChecks' | 'ignoreScripts' | 'pnpmHomeDir' | 'publishBranch' | 'embedReadme'>, params: string[]): Promise<{
+    exitCode?: number;
+} | undefined>;
+export interface PublishResult {
+    exitCode?: number;
+    manifest?: ProjectManifest;
+}
+export declare function publish(opts: Omit<PublishRecursiveOpts, 'workspaceDir'> & {
+    argv: {
+        original: string[];
+    };
+    engineStrict?: boolean;
+    recursive?: boolean;
+    workspaceDir?: string;
+} & Pick<Config, 'allProjects' | 'bin' | 'gitChecks' | 'ignoreScripts' | 'pnpmHomeDir' | 'publishBranch' | 'embedReadme' | 'packGzipLevel'>, params: string[]): Promise<PublishResult>;
+export declare function runScriptsIfPresent(opts: RunLifecycleHookOptions, scriptNames: string[], manifest: ProjectManifest): Promise<void>;