auklet 0.1.0 → 0.1.2

package/dist/publish/inspect.js

@@ -0,0 +1,221 @@
+import path from 'node:path';
+import { isString } from 'aidly';
+import { createAukletLogger } from '#auklet/logger';
+import { resolvePublishTag } from '#auklet/publish/api/publishArgs';
+import { getPublishRegistry } from '#auklet/publish/api/registry';
+import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
+import { resolvePublishCliOptions } from '#auklet/publish/cli';
+import { inspectPublishRegistry, } from '#auklet/publish/inspectRegistry';
+import { inspectPackageFiles, PackInspectReporter, } from '#auklet/publish/inspectPack';
+import { resolvePublishPlan } from '#auklet/publish/targetResolver';
+export async function runInspectPublishCli(args) {
+    await ensurePnpm();
+    const options = resolvePublishCliOptions(args);
+    const logger = createAukletLogger({ scope: 'inspect' });
+    const plan = await resolvePublishPlan(options, logger);
+    const packageFileChecks = inspectPackageFiles(plan.targets);
+    const packageFileCheckFailed = packageFileChecks.some((check) => check.status === 'missing');
+    if (packageFileCheckFailed) {
+        new PublishInspectReporter(options, plan, packageFileChecks, []).report();
+        return 1;
+    }
+    const spinner = logger.spinner('Checking publish registry');
+    spinner.start();
+    const registryChecks = await inspectPublishRegistry(plan, {
+        token: options.token,
+        onCheck: (info) => {
+            spinner.text([
+                'Checking registry ',
+                info.check,
+                ' for ',
+                logger.package(info.packageName),
+            ]);
+        },
+        onRetry: (info) => {
+            spinner.text([
+                'Checking registry ',
+                info.check,
+                ' for ',
+                logger.package(info.packageName),
+                ', retrying ',
+                logger.value(`${info.attempt}/${info.maxAttempts}`),
+            ]);
+        },
+    });
+    if (registryChecks.some((check) => check.reason)) {
+        spinner.fail('Publish registry checks failed');
+    }
+    else {
+        spinner.succeed('Publish registry checks passed');
+    }
+    new PublishInspectReporter(options, plan, packageFileChecks, registryChecks).report();
+    if (registryChecks.some((check) => check.reason)) {
+        return 1;
+    }
+    return 0;
+}
+class PublishInspectReporter {
+    options;
+    plan;
+    packageFileChecks;
+    registryChecks;
+    logger = createAukletLogger();
+    constructor(options, plan, packageFileChecks, registryChecks) {
+        this.options = options;
+        this.plan = plan;
+        this.packageFileChecks = packageFileChecks;
+        this.registryChecks = registryChecks;
+    }
+    report() {
+        const model = createPublishInspectModel(this.options, this.plan, this.packageFileChecks, this.registryChecks);
+        new PackInspectReporter(this.options.cwd, this.plan.targets, model.packageFileChecks, 'Package file checks').report();
+        this.logger.newline();
+        this.logger.result({
+            title: this.formatResultTitle('Publish inspect', model.registryChecks.some((check) => check.reason)),
+            status: 'info',
+            body: [
+                'Read-only publish plan. No files, git refs, or packages changed.',
+            ],
+            details: this.formatDetails(model),
+        });
+        this.logger.newline();
+        this.writeSectionTitle('Targets');
+        this.logger.rows({
+            columns: ['package', 'version', 'registry', 'access'],
+            rows: model.targets.map((target) => [
+                this.logger.package(target.packageName),
+                this.formatVersionChange(target.version, target.publishVersion),
+                this.logger.colors.gray(target.registry),
+                this.logger.colors.gray(target.access),
+            ]),
+        });
+        this.logger.newline();
+        this.writeSectionTitle('Registry checks');
+        this.logger.rows({
+            columns: ['package', 'registry', 'auth', 'version'],
+            rows: model.registryChecks.map((check) => [
+                this.logger.package(check.packageName),
+                this.logger.colors.gray(check.registry),
+                this.formatCheckStatus(check.auth),
+                this.formatCheckStatus(check.version),
+            ]),
+        });
+        const failedChecks = model.registryChecks.filter((check) => check.reason);
+        if (failedChecks.length) {
+            this.logger.newline();
+            this.writeSectionTitle('Registry issues', 'error');
+            this.writeRegistryIssues(failedChecks);
+        }
+        this.logger.newline();
+        this.writeSectionTitle('Hooks');
+        this.logger.rows({
+            columns: ['hook', 'configured'],
+            rows: model.hooks.map((hook) => [
+                this.logger.colors.gray(hook.name),
+                this.formatValue(hook.configured ? 'yes' : 'no'),
+            ]),
+        });
+        this.logger.newline();
+    }
+    formatDetails(model) {
+        return {
+            mode: this.formatValue(model.details.mode),
+            publish: this.formatValue(model.details.publish),
+            packages: this.formatValue(model.details.packages),
+            version: this.logger.version(model.details.version),
+            tag: this.formatValue(model.details.tag),
+            git: this.formatValue(model.details.git),
+            format: this.formatValue(model.details.format),
+            root: this.logger.path(model.details.root),
+        };
+    }
+    formatVersionChange(from, to) {
+        return [
+            this.logger.version(from),
+            this.logger.colors.gray(' -> '),
+            this.logger.version(to),
+        ];
+    }
+    formatValue(value) {
+        return this.logger.colors.bold(this.logger.colors.cyan(String(value)));
+    }
+    formatResultTitle(title, failed) {
+        return this.logger.colors.bold(failed ? this.logger.colors.red(title) : this.logger.colors.green(title));
+    }
+    formatCheckStatus(status) {
+        if (status === 'success')
+            return this.logger.colors.green('ok');
+        return this.logger.colors.red('failed');
+    }
+    writeSectionTitle(title, status = 'normal') {
+        const content = status === 'error' ? this.logger.colors.red(title) : title;
+        this.logger.raw(content);
+    }
+    writeRegistryIssues(checks) {
+        for (const [index, check] of checks.entries()) {
+            if (index > 0)
+                this.logger.newline();
+            const [firstLine, ...restLines] = String(check.reason ?? '').split('\n');
+            this.logger.item(this.logger.package(check.packageName), ': ', this.logger.colors.red(firstLine));
+            for (const line of restLines) {
+                this.logger.raw(`    ${this.logger.colors.red(line)}`);
+            }
+        }
+    }
+}
+export function createPublishInspectModel(options, plan, packageFileChecks = [], registryChecks = []) {
+    return {
+        details: {
+            mode: plan.workspaceMode,
+            publish: plan.dryRun ? 'dry-run' : 'real',
+            packages: plan.targets.length,
+            version: plan.version,
+            tag: resolvePublishTag(options.version) ?? 'latest',
+            git: getGitMode(options),
+            format: options.format ? 'enabled' : 'disabled',
+            root: path.relative(options.cwd, plan.root) || '.',
+        },
+        packageFileChecks,
+        targets: plan.targets.map((target) => ({
+            packageName: target.packageName,
+            version: target.version,
+            publishVersion: target.publishVersion,
+            registry: getRegistry(target.packageJson),
+            access: getAccess(target),
+        })),
+        registryChecks,
+        hooks: getHookRows(plan.config),
+    };
+}
+const getGitMode = (options) => {
+    if (options.dryRun)
+        return 'skipped (dry-run)';
+    if (options.allowDirty)
+        return 'skipped (--allow-dirty)';
+    if (options.git === false)
+        return 'skipped (--no-git)';
+    return 'commit + tag';
+};
+const getHookRows = (config) => {
+    const hooks = [
+        ['beforeBuild', config.beforeBuild],
+        ['afterBuild', config.afterBuild],
+        ['beforePublish', config.beforePublish],
+        ['afterPublish', config.afterPublish],
+    ];
+    return hooks.map(([name, value]) => ({
+        name,
+        configured: Boolean(value),
+    }));
+};
+const getRegistry = (packageJson) => {
+    return getPublishRegistry(packageJson.publishConfig) ?? 'default';
+};
+const getAccess = (target) => {
+    const access = target.packageJson.publishConfig?.access;
+    if (isString(access) && access)
+        return access;
+    if (target.packageName.startsWith('@') && !target.private)
+        return 'public';
+    return 'default';
+};

package/dist/publish/inspectPack.d.ts

@@ -0,0 +1,28 @@
+import type { PublishTarget } from '#auklet/publish/types';
+export type PackFileCheckStatus = 'exists' | 'missing' | 'pattern' | 'skipped';
+export type PackFileCheck = {
+    target: PublishTarget;
+    field: string;
+    file: string;
+    status: PackFileCheckStatus;
+};
+export declare function runInspectPackCli(args: Array<string>): Promise<0 | 1>;
+export declare function inspectPackageFiles(targets: Array<PublishTarget>): {
+    target: PublishTarget;
+    field: string;
+    file: string;
+    status: PackFileCheckStatus;
+}[];
+export declare class PackInspectReporter {
+    private readonly cwd;
+    private readonly targets;
+    private readonly checks;
+    private readonly title;
+    private readonly logger;
+    constructor(cwd: string, targets: Array<PublishTarget>, checks: Array<PackFileCheck>, title?: string);
+    report(): void;
+    private writeSectionTitle;
+    private formatStatus;
+    private formatValue;
+    private formatResultTitle;
+}

package/dist/publish/inspectPack.js

@@ -0,0 +1,206 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isArray, isPlainObject, isString } from 'aidly';
+import { createAukletLogger } from '#auklet/logger';
+import { resolvePublishPlan } from '#auklet/publish/targetResolver';
+export async function runInspectPackCli(args) {
+    const options = resolveInspectPackOptions(args);
+    const logger = createAukletLogger({ scope: 'inspect' });
+    const plan = await resolvePublishPlan({
+        cwd: options.cwd,
+        filters: options.filters,
+        dryRun: true,
+        version: undefined,
+    }, logger);
+    const checks = inspectPackageFiles(plan.targets);
+    new PackInspectReporter(options.cwd, plan.targets, checks).report();
+    return checks.some((check) => check.status === 'missing') ? 1 : 0;
+}
+const resolveInspectPackOptions = (args) => {
+    const filters = [];
+    const cliArgs = args.filter((arg) => arg !== '--');
+    for (let index = 0; index < cliArgs.length; index += 1) {
+        const arg = cliArgs[index];
+        if (arg === '--filter') {
+            const value = cliArgs[index + 1];
+            if (!value)
+                throw new Error('[inspect] --filter requires a value.');
+            filters.push(value);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--filter=')) {
+            filters.push(arg.slice('--filter='.length));
+            continue;
+        }
+        throw new Error(`[inspect] unknown inspect pack argument: ${arg}`);
+    }
+    return {
+        cwd: process.cwd(),
+        filters,
+    };
+};
+export function inspectPackageFiles(targets) {
+    return targets.flatMap((target) => inspectTargetPackage(target));
+}
+const inspectTargetPackage = (target) => {
+    return collectPackageFileReferences(target.packageJson).map((reference) => ({
+        target,
+        field: reference.field,
+        file: reference.file,
+        status: getFileStatus(target.packageRoot, reference.file),
+    }));
+};
+const collectPackageFileReferences = (packageJson) => {
+    const references = [];
+    addStringField(references, packageJson, 'main');
+    addStringField(references, packageJson, 'module');
+    addStringField(references, packageJson, 'types');
+    addStringField(references, packageJson, 'typings');
+    addStringField(references, packageJson, 'style');
+    addStringField(references, packageJson, 'stylesheet');
+    addBinFields(references, packageJson.bin);
+    addExportFields(references, packageJson.exports, 'exports');
+    addFilesFields(references, packageJson.files);
+    return references;
+};
+const addStringField = (references, packageJson, field) => {
+    const value = Reflect.get(packageJson, field);
+    if (isString(value))
+        references.push({ field, file: value });
+};
+const addBinFields = (references, value) => {
+    if (isString(value)) {
+        references.push({ field: 'bin', file: value });
+        return;
+    }
+    if (!isPlainObject(value))
+        return;
+    for (const [name, file] of Object.entries(value)) {
+        if (isString(file))
+            references.push({ field: `bin.${name}`, file });
+    }
+};
+const addExportFields = (references, value, field) => {
+    if (isString(value)) {
+        references.push({ field, file: value });
+        return;
+    }
+    if (isArray(value)) {
+        value.forEach((item, index) => {
+            addExportFields(references, item, `${field}[${index}]`);
+        });
+        return;
+    }
+    if (!isPlainObject(value))
+        return;
+    for (const [key, item] of Object.entries(value)) {
+        addExportFields(references, item, formatFieldKey(field, key));
+    }
+};
+const addFilesFields = (references, value) => {
+    if (!isArray(value))
+        return;
+    value.forEach((file, index) => {
+        if (isString(file))
+            references.push({ field: `files[${index}]`, file });
+    });
+};
+const getFileStatus = (packageRoot, file) => {
+    if (file.startsWith('!'))
+        return 'skipped';
+    if (file.startsWith('#') || file.includes('://'))
+        return 'skipped';
+    if (file.includes('*'))
+        return 'pattern';
+    const absolutePath = path.resolve(packageRoot, file);
+    const relativePath = path.relative(packageRoot, absolutePath);
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        return 'skipped';
+    }
+    return fs.existsSync(absolutePath) ? 'exists' : 'missing';
+};
+const formatFieldKey = (field, key) => {
+    return /^[a-zA-Z_$][\w$-]*$/.test(key)
+        ? `${field}.${key}`
+        : `${field}[${JSON.stringify(key)}]`;
+};
+export class PackInspectReporter {
+    cwd;
+    targets;
+    checks;
+    title;
+    logger = createAukletLogger();
+    constructor(cwd, targets, checks, title = 'Pack inspect') {
+        this.cwd = cwd;
+        this.targets = targets;
+        this.checks = checks;
+        this.title = title;
+    }
+    report() {
+        const missingChecks = this.checks.filter((check) => check.status === 'missing');
+        this.logger.newline();
+        this.logger.result({
+            title: this.formatResultTitle(this.title, missingChecks.length > 0),
+            status: missingChecks.length ? 'error' : 'info',
+            body: ['Read-only package file checks. No files or packages changed.'],
+            details: {
+                packages: this.formatValue(this.targets.length),
+                checks: this.formatValue(this.checks.length),
+                missing: missingChecks.length
+                    ? this.logger.colors.bold(this.logger.colors.red(missingChecks.length))
+                    : this.formatValue(0),
+            },
+        });
+        this.logger.newline();
+        this.writeSectionTitle('Package files');
+        this.logger.rows({
+            columns: ['package', 'field', 'file', 'status'],
+            rows: this.checks.map((check) => [
+                this.logger.package(check.target.packageName),
+                this.logger.colors.gray(check.field),
+                this.logger.path(check.file),
+                this.formatStatus(check.status),
+            ]),
+            empty: this.logger.colors.gray('No package file references found.'),
+        });
+        this.logger.newline();
+        this.writeSectionTitle('Package roots');
+        this.logger.rows({
+            columns: ['package', 'root'],
+            rows: this.targets.map((target) => [
+                this.logger.package(target.packageName),
+                this.logger.path(path.relative(this.cwd, target.packageRoot) || '.'),
+            ]),
+        });
+        if (missingChecks.length) {
+            this.logger.newline();
+            this.writeSectionTitle('Missing files', 'error');
+            for (const [index, check] of missingChecks.entries()) {
+                if (index > 0)
+                    this.logger.newline();
+                this.logger.item(this.logger.package(check.target.packageName), ': ', this.logger.colors.red(check.field), ' -> ', this.logger.colors.red(check.file));
+            }
+        }
+        this.logger.newline();
+    }
+    writeSectionTitle(title, status = 'normal') {
+        const content = status === 'error' ? this.logger.colors.red(title) : title;
+        this.logger.raw(content);
+    }
+    formatStatus(status) {
+        if (status === 'exists')
+            return this.logger.colors.green('exists');
+        if (status === 'missing')
+            return this.logger.colors.red('missing');
+        if (status === 'pattern')
+            return this.logger.colors.yellow('pattern');
+        return this.logger.colors.gray('skipped');
+    }
+    formatValue(value) {
+        return this.logger.colors.bold(this.logger.colors.cyan(String(value)));
+    }
+    formatResultTitle(title, failed) {
+        return this.logger.colors.bold(failed ? this.logger.colors.red(title) : this.logger.colors.green(title));
+    }
+}

package/dist/publish/inspectRegistry.d.ts

@@ -0,0 +1,24 @@
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+export type PublishRegistryCheckStatus = 'success' | 'error';
+export type PublishRegistryCheck = {
+    packageName: string;
+    registry: string;
+    auth: PublishRegistryCheckStatus;
+    version: PublishRegistryCheckStatus;
+    reason: string | null;
+};
+export type PublishRegistryRetryInfo = {
+    packageName: string;
+    registry: string;
+    check: 'auth' | 'version';
+    attempt: number;
+    maxAttempts: number;
+    error: Error;
+};
+export type PublishRegistryCheckInfo = Pick<PublishRegistryRetryInfo, 'packageName' | 'registry' | 'check'>;
+export type InspectPublishRegistryOptions = {
+    token?: PublishOptions['token'];
+    onCheck?: (info: PublishRegistryCheckInfo) => void;
+    onRetry?: (info: PublishRegistryRetryInfo) => void;
+};
+export declare function inspectPublishRegistry(plan: PublishPlan, options?: InspectPublishRegistryOptions): Promise<PublishRegistryCheck[]>;

package/dist/publish/inspectRegistry.js

@@ -0,0 +1,109 @@
+import { retry } from 'aidly';
+import { getPublishRegistry } from '#auklet/publish/api/registry';
+import { hasPublishedPackageVersion, runPnpmWhoami, } from '#auklet/publish/api/pnpmApi';
+const registryCheckTimeout = 5_000;
+const registryCheckRetryTimes = 2;
+export async function inspectPublishRegistry(plan, options = {}) {
+    const authResults = new Map();
+    const checks = [];
+    for (const target of plan.targets) {
+        const registry = getPublishRegistry(target.packageJson.publishConfig);
+        const registryLabel = registry ?? 'default';
+        const authKey = `${target.packageRoot}\n${registryLabel}`;
+        if (!authResults.has(authKey)) {
+            await checkAuth(authResults, authKey, target.packageRoot, target.packageName, registry, options);
+        }
+        const authError = authResults.get(authKey) ?? null;
+        const versionError = await checkVersion(target.packageRoot, target.packageName, target.publishVersion, registry, options);
+        checks.push({
+            packageName: target.packageName,
+            registry: registryLabel,
+            auth: authError ? 'error' : 'success',
+            version: versionError ? 'error' : 'success',
+            reason: getReason(authError, versionError),
+        });
+    }
+    return checks;
+}
+const checkAuth = async (authResults, authKey, packageRoot, packageName, registry, options) => {
+    try {
+        options.onCheck?.({
+            packageName,
+            registry: registry ?? 'default',
+            check: 'auth',
+        });
+        await retryWithLog(() => runPnpmWhoami(packageRoot, {
+            packageName,
+            registry,
+            token: options.token,
+            timeout: registryCheckTimeout,
+        }), {
+            check: 'auth',
+            packageName,
+            registry,
+            onRetry: options.onRetry,
+        });
+        authResults.set(authKey, null);
+        return null;
+    }
+    catch (error) {
+        const authError = toError(error);
+        authResults.set(authKey, authError);
+        return authError;
+    }
+};
+const checkVersion = async (packageRoot, packageName, version, registry, options) => {
+    try {
+        options.onCheck?.({
+            packageName,
+            registry: registry ?? 'default',
+            check: 'version',
+        });
+        const exists = await retryWithLog(() => hasPublishedPackageVersion(packageRoot, packageName, version, {
+            registry,
+            token: options.token,
+            timeout: registryCheckTimeout,
+        }), {
+            check: 'version',
+            packageName,
+            registry,
+            onRetry: options.onRetry,
+        });
+        return exists
+            ? new Error(`version already exists: ${packageName}@${version}`)
+            : null;
+    }
+    catch (error) {
+        return toError(error);
+    }
+};
+const getReason = (authError, versionError) => {
+    return authError?.message ?? versionError?.message ?? null;
+};
+const toError = (error) => {
+    return error instanceof Error ? error : new Error(String(error));
+};
+const retryWithLog = (fn, options) => {
+    let attempt = 0;
+    let previousError = null;
+    return retry(async () => {
+        attempt += 1;
+        if (attempt > 1) {
+            options.onRetry?.({
+                packageName: options.packageName,
+                registry: options.registry ?? 'default',
+                check: options.check,
+                attempt: attempt - 1,
+                maxAttempts: registryCheckRetryTimes,
+                error: previousError ?? new Error('publish registry check failed.'),
+            });
+        }
+        try {
+            return await fn();
+        }
+        catch (error) {
+            previousError = toError(error);
+            throw error;
+        }
+    }, registryCheckRetryTimes);
+};

package/dist/publish/runner/publishPreflight.d.ts

@@ -7,6 +7,7 @@ export declare class PublishPreflight {
     constructor(options: PublishOptions, logger: AukletLogger);
     run(plan: PublishPlan): Promise<void>;
     verifyBeforeBuild(plan: PublishPlan): Promise<void>;
+    private verifyTokenConfig;
     private verifyAuthentication;
     private verifyPnpmPublishDryRun;
     private verifyPackageVersions;

package/dist/publish/runner/publishPreflight.js

@@ -1,6 +1,7 @@
-import { isPlainObject, isString } from 'aidly';
 import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
 import { hasPublishedPackageVersion, NpmPackageVersionExistsError, runPnpmWhoami, } from '#auklet/publish/api/pnpmApi';
+import { findNpmrcFiles, findNpmrcWithAuthToken, toNpmrcRegistryKey, } from '#auklet/publish/api/npmrc';
+import { getPublishRegistry } from '#auklet/publish/api/registry';
 import { logAuthenticationError } from '#auklet/publish/runner/packagePublisher';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PublishPreflight {
@@ -15,11 +16,23 @@ export class PublishPreflight {
         await this.verifyPnpmPublishDryRun(plan);
     }
     async verifyBeforeBuild(plan) {
+        this.verifyTokenConfig(plan);
         if (plan.dryRun)
             return;
         await this.verifyAuthentication(plan);
         await this.verifyPackageVersions(plan);
     }
+    verifyTokenConfig(plan) {
+        if (!this.options.token)
+            return;
+        for (const target of plan.targets) {
+            const registry = getPublishRegistry(target.packageJson.publishConfig);
+            const npmrc = findNpmrcWithAuthToken(target.packageRoot, plan.root, registry);
+            if (npmrc)
+                continue;
+            throw new PublishTargetError(target, 'preflight', new Error(createMissingNpmrcAuthMessage(target, plan.root, registry)), []);
+        }
+    }
     async verifyAuthentication(plan) {
         const checked = new Set();
         for (const target of plan.targets) {
@@ -30,6 +43,7 @@ export class PublishPreflight {
             await runPnpmWhoami(target.packageRoot, {
                 packageName: target.packageName,
                 registry,
+                token: this.options.token,
             });
             checked.add(key);
         }
@@ -52,7 +66,7 @@ export class PublishPreflight {
     async verifyPackageVersions(plan) {
         for (const target of plan.targets) {
             const registry = getPublishRegistry(target.packageJson.publishConfig);
-            const exists = await hasPublishedPackageVersion(target.packageRoot, target.packageName, target.publishVersion, { registry });
+            const exists = await hasPublishedPackageVersion(target.packageRoot, target.packageName, target.publishVersion, { registry, token: this.options.token });
             if (!exists)
                 continue;
             this.logExistingVersion(target, registry);
@@ -66,9 +80,20 @@ export class PublishPreflight {
         }
     }
 }
-const getPublishRegistry = (publishConfig) => {
-    if (!isPlainObject(publishConfig))
-        return undefined;
-    const registry = Reflect.get(publishConfig, 'registry');
-    return isString(registry) && registry.length > 0 ? registry : undefined;
-};
+function createMissingNpmrcAuthMessage(target, root, registry) {
+    const npmrcFiles = findNpmrcFiles(target.packageRoot, root);
+    const authTarget = registry
+        ? `${toNpmrcRegistryKey(registry)}:_authToken`
+        : '_authToken';
+    const registryHint = registry
+        ? `[publish] ${target.packageName} uses publishConfig.registry: ${registry}.\n`
+        : '';
+    const location = npmrcFiles.length
+        ? 'found npmrc files, but none declares'
+        : 'could not find an npmrc file declaring';
+    return (`[publish] --token requires npmrc auth config for ${target.packageName}.\n` +
+        registryHint +
+        `[publish] ${location} ${authTarget}.\n` +
+        '[publish] Add an npmrc entry such as:\n' +
+        `  ${authTarget}=\${NODE_AUTH_TOKEN}`);
+}

package/dist/publish/types.d.ts

@@ -50,6 +50,7 @@ export type PublishOptions = {
     filters: Array<string>;
     git?: boolean;
     otp?: string;
+    token?: string;
     version?: string;
 };
 export type OwnerOptions = {