auklet 0.0.29 → 0.1.1

package/dist/publish/api/pnpmApi.d.ts

@@ -1,3 +1,4 @@
+import { execa, type Options } from 'execa';
 import type { WorkspacePackage } from '#auklet/publish/types';
 export declare class NpmPublishAuthenticationError extends Error {
     readonly packageRoot: string;
@@ -6,6 +7,7 @@ export declare class NpmPublishAuthenticationError extends Error {
 export declare class NpmPackageVersionExistsError extends Error {
     constructor(packageName: string, version: string, registry?: string);
 }
+export declare function withPnpmTimeout(subprocess: ReturnType<typeof execa>, timeout: number): Promise<import("node_modules/execa/types/return/result").CommonResult<false, Options> & import("node_modules/execa/types/return/result").OmitErrorIfReject<boolean | undefined>>;
 export declare function ensurePnpm(): Promise<string>;
 export declare function readPnpmWorkspacePackages(root: string): Promise<WorkspacePackage[]>;
 export declare function runPnpmBuild(packageRoot: string): Promise<void>;
@@ -13,9 +15,11 @@ export declare function runPnpmPublish(packageRoot: string, args: Array<string>)
 export declare function runPnpmWhoami(packageRoot: string, options?: {
     packageName?: string;
     registry?: string;
+    timeout?: number;
 }): Promise<string>;
 export declare function hasPublishedPackageVersion(packageRoot: string, packageName: string, version: string, options?: {
     registry?: string;
+    timeout?: number;
 }): Promise<boolean>;
 export declare function runPnpmOwnerAdd(packageName: string, user: string, options: {
     cwd: string;

package/dist/publish/api/pnpmApi.js

@@ -17,15 +17,43 @@ export class NpmPackageVersionExistsError extends Error {
     }
 }
 const runPnpm = async (args, options = {}) => {
-    return execa('pnpm', args, {
+    const timeout = options.timeout;
+    const subprocess = execa('pnpm', args, {
         reject: false,
         ...options,
+        timeout: undefined,
     });
+    if (!timeout)
+        return subprocess;
+    return withPnpmTimeout(subprocess, timeout);
 };
+export async function withPnpmTimeout(subprocess, timeout) {
+    let timeoutId = null;
+    const result = await Promise.race([
+        subprocess,
+        new Promise((resolve) => {
+            timeoutId = setTimeout(() => {
+                const error = new Error(`pnpm command timed out after ${timeout}ms.`);
+                subprocess.kill('SIGKILL', error);
+                resolve({
+                    failed: true,
+                    timedOut: true,
+                    exitCode: undefined,
+                    stdout: '',
+                    stderr: error.message,
+                });
+            }, timeout);
+        }),
+    ]);
+    if (timeoutId)
+        clearTimeout(timeoutId);
+    subprocess.catch(() => { });
+    return result;
+}
 export async function ensurePnpm() {
     const result = await runPnpm(['--version']);
     const stdout = String(result.stdout ?? '');
-    if (result.failed || !stdout) {
+    if (hasFailedPnpmResult(result) || !stdout) {
         throw new Error('[publish] pnpm is required for publishing.\n' +
             '[publish] Install pnpm first:\n' +
             '  corepack enable\n' +
@@ -57,7 +85,7 @@ export async function runPnpmBuild(packageRoot) {
         cwd: packageRoot,
         stdio: 'inherit',
     });
-    if (result.exitCode) {
+    if (hasFailedPnpmResult(result)) {
         throw new Error(`[publish] build failed at ${packageRoot}.`);
     }
 }
@@ -69,7 +97,7 @@ export async function runPnpmPublish(packageRoot, args) {
     });
     if (isDryRun)
         writeProcessOutput(result);
-    if (result.exitCode) {
+    if (hasFailedPnpmResult(result)) {
         if (hasNpmAuthChallenge(result)) {
             throw new NpmPublishAuthenticationError(packageRoot);
         }
@@ -82,12 +110,15 @@ export async function runPnpmWhoami(packageRoot, options = {}) {
         args.push('--registry', options.registry);
     const result = await runPnpm(args, {
         cwd: packageRoot,
+        timeout: options.timeout,
     });
-    if (result.exitCode) {
+    if (hasFailedPnpmResult(result)) {
         const target = options.packageName ? ` for ${options.packageName}` : '';
         const registry = options.registry ? ` at ${options.registry}` : '';
+        const reason = getPnpmFailureReason(result);
         throw new Error(`[publish] npm authentication is required${target}${registry} before publishing.\n` +
-            '[publish] Run `pnpm login` or configure an npm token before retrying.');
+            '[publish] Run `pnpm login` or configure an npm token before retrying.' +
+            (reason ? `\n[publish] Reason: ${reason}` : ''));
     }
     return String(result.stdout ?? '').trim();
 }
@@ -97,12 +128,16 @@ export async function hasPublishedPackageVersion(packageRoot, packageName, versi
         args.push('--registry', options.registry);
     const result = await runPnpm(args, {
         cwd: packageRoot,
+        timeout: options.timeout,
     });
-    if (!result.exitCode)
+    if (!hasFailedPnpmResult(result)) {
         return String(result.stdout ?? '').trim() === version;
+    }
     if (isPackageNotFound(result))
         return false;
-    throw new Error(`[publish] failed to check published version for ${packageName}@${version}.`);
+    const reason = getPnpmFailureReason(result);
+    throw new Error(`[publish] failed to check published version for ${packageName}@${version}.` +
+        (reason ? `\n[publish] Reason: ${reason}` : ''));
 }
 export async function runPnpmOwnerAdd(packageName, user, options) {
     const args = ['owner', 'add', user, packageName];
@@ -112,7 +147,7 @@ export async function runPnpmOwnerAdd(packageName, user, options) {
         cwd: options.cwd,
         stdio: 'inherit',
     });
-    if (result.exitCode) {
+    if (hasFailedPnpmResult(result)) {
         throw new Error(`[publish] pnpm owner add failed for ${user} -> ${packageName}.`);
     }
 }
@@ -128,6 +163,16 @@ const isWorkspacePackage = (value) => {
         value.version.length > 0 &&
         (value.private === undefined || typeof value.private === 'boolean'));
 };
+const hasFailedPnpmResult = (result) => {
+    return result.failed === true || result.exitCode !== 0;
+};
+const getPnpmFailureReason = (result) => {
+    const stderr = String(result.stderr ?? '').trim();
+    if (stderr)
+        return stderr;
+    const stdout = String(result.stdout ?? '').trim();
+    return stdout || null;
+};
 function throwInvalidWorkspacePackages() {
     throw new Error('[publish] failed to read pnpm workspace packages.\n' +
         '[publish] Expected `pnpm list -r --depth -1 --json` to return package objects with name/path/version.');

package/dist/publish/api/publishArgs.d.ts

@@ -1,2 +1,3 @@
 import type { PublishOptions, PublishTarget } from '#auklet/publish/types';
 export declare function createPublishArgs(target: PublishTarget, options: PublishOptions): string[];
+export declare function resolvePublishTag(versionSpec?: string): "alpha" | "beta" | null;

package/dist/publish/api/publishArgs.js

@@ -8,7 +8,7 @@ export function createPublishArgs(target, options) {
         args.push('--ignore-scripts');
     if (shouldAddPublicAccess(target))
         args.push('--access', 'public');
-    const tag = getPublishTag(options.version);
+    const tag = resolvePublishTag(options.version);
     if (tag)
         args.push('--tag', tag);
     return args;
@@ -18,8 +18,8 @@ const shouldAddPublicAccess = (target) => {
         !target.private &&
         !target.packageJson.publishConfig?.access);
 };
-const getPublishTag = (versionSpec) => {
+export function resolvePublishTag(versionSpec) {
     if (versionSpec === 'alpha' || versionSpec === 'beta')
         return versionSpec;
     return null;
-};
+}

package/dist/publish/api/registry.d.ts

@@ -0,0 +1 @@
+export declare function getPublishRegistry(publishConfig: unknown): string | undefined;

package/dist/publish/api/registry.js

@@ -0,0 +1,7 @@
+import { isPlainObject, isString } from 'aidly';
+export function getPublishRegistry(publishConfig) {
+    if (!isPlainObject(publishConfig))
+        return undefined;
+    const registry = Reflect.get(publishConfig, 'registry');
+    return isString(registry) && registry.length > 0 ? registry : undefined;
+}

package/dist/publish/cli.d.ts

@@ -1,2 +1,13 @@
 export declare function runPublishCli(args: Array<string>): Promise<void>;
+export declare function resolvePublishCliOptions(args: Array<string>, cwd?: string): {
+    cwd: string;
+    otp: string | undefined;
+    filters: string[];
+    version: string | undefined;
+    git: boolean;
+    format: boolean;
+    dryRun: boolean;
+    allowDirty: boolean;
+    ignoreScripts: boolean;
+};
 export declare function runOwnerCli(args: Array<string>): Promise<void>;

package/dist/publish/cli.js

@@ -9,37 +9,47 @@ const publishFlags = new Set([
     'version',
     'dry-run',
     'format',
+    'git',
     'otp',
     'ignore-scripts',
     'allow-dirty',
 ]);
 const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
 export async function runPublishCli(args) {
-    const cliArgs = stripLeadingArgsSeparator(args);
-    validateNoPrefixedFlags(cliArgs, new Set(['--no-format']));
-    const argv = minimist(cliArgs, {
-        string: ['filter', 'version', 'otp'],
-        boolean: ['dry-run', 'format', 'ignore-scripts', 'allow-dirty'],
-        default: {
-            format: true,
-        },
-    });
-    validateFlags(argv, publishFlags);
+    await ensurePnpm();
+    await new PublishRunner(resolvePublishCliOptions(args)).run();
+}
+export function resolvePublishCliOptions(args, cwd = process.cwd()) {
+    const argv = parsePublishArgs(args);
     if (argv._.length) {
         throw new Error(`[publish] unknown publish argument: ${argv._.join(' ')}`);
     }
-    await ensurePnpm();
-    await new PublishRunner({
-        cwd: process.cwd(),
+    return {
+        cwd,
+        otp: stringOption(argv.otp),
         filters: toArray(argv.filter),
         version: stringOption(argv.version),
-        dryRun: argv['dry-run'] === true,
+        git: argv.git !== false,
         format: argv.format !== false,
-        otp: stringOption(argv.otp),
+        dryRun: argv['dry-run'] === true,
         allowDirty: argv['allow-dirty'] === true,
         ignoreScripts: argv['ignore-scripts'] === true,
-    }).run();
+    };
 }
+const parsePublishArgs = (args) => {
+    const cliArgs = stripLeadingArgsSeparator(args);
+    validateNoPrefixedFlags(cliArgs, new Set(['--no-format', '--no-git']));
+    const argv = minimist(cliArgs, {
+        string: ['filter', 'version', 'otp'],
+        boolean: ['dry-run', 'format', 'git', 'ignore-scripts', 'allow-dirty'],
+        default: {
+            git: true,
+            format: true,
+        },
+    });
+    validateFlags(argv, publishFlags);
+    return argv;
+};
 export async function runOwnerCli(args) {
     const cliArgs = stripLeadingArgsSeparator(args);
     validateNoPrefixedFlags(cliArgs, new Set());

package/dist/publish/inspect.d.ts

@@ -0,0 +1,29 @@
+import { type PublishRegistryCheck } from '#auklet/publish/inspectRegistry';
+import { type PackFileCheck } from '#auklet/publish/inspectPack';
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+export declare function runInspectPublishCli(args: Array<string>): Promise<0 | 1>;
+export declare function createPublishInspectModel(options: PublishOptions, plan: PublishPlan, packageFileChecks?: Array<PackFileCheck>, registryChecks?: Array<PublishRegistryCheck>): {
+    details: {
+        mode: "monorepo" | "single";
+        publish: string;
+        packages: number;
+        version: string;
+        tag: string;
+        git: string;
+        format: string;
+        root: string;
+    };
+    packageFileChecks: PackFileCheck[];
+    targets: {
+        packageName: string;
+        version: string;
+        publishVersion: string;
+        registry: string;
+        access: string;
+    }[];
+    registryChecks: PublishRegistryCheck[];
+    hooks: {
+        name: string;
+        configured: boolean;
+    }[];
+};

package/dist/publish/inspect.js

@@ -0,0 +1,220 @@
+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, {
+        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;
+}