auklet 0.0.27 → 0.0.29

package/dist/cli/main.js

@@ -90,6 +90,7 @@ export async function runAukletCli(argv = process.argv) {
     catch (error) {
         const logger = createAukletLogger({ scope: 'cli' });
         logger.error(error);
+        logger.newline();
         process.exit(1);
     }
 }

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

@@ -1,5 +1,6 @@
 import type { WorkspacePackage } from '#auklet/publish/types';
 export declare class NpmPublishAuthenticationError extends Error {
+    readonly packageRoot: string;
     constructor(packageRoot: string);
 }
 export declare class NpmPackageVersionExistsError extends Error {

package/dist/publish/api/pnpmApi.js

@@ -4,9 +4,10 @@ import semver from 'semver';
 import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
 const supportedPnpmRange = '>=10.0.0';
 export class NpmPublishAuthenticationError extends Error {
+    packageRoot;
     constructor(packageRoot) {
-        super(`[publish] pnpm publish failed at ${packageRoot}: ` +
-            `npm publish requires additional authentication.`);
+        super('npm publish requires additional authentication.');
+        this.packageRoot = packageRoot;
     }
 }
 export class NpmPackageVersionExistsError extends Error {
@@ -61,16 +62,18 @@ export async function runPnpmBuild(packageRoot) {
     }
 }
 export async function runPnpmPublish(packageRoot, args) {
+    const isDryRun = args.includes('--dry-run');
     const result = await runPnpm(['publish', ...args], {
         cwd: packageRoot,
-        stdio: 'pipe',
+        stdio: isDryRun ? 'pipe' : 'inherit',
     });
-    writeProcessOutput(result);
+    if (isDryRun)
+        writeProcessOutput(result);
     if (result.exitCode) {
         if (hasNpmAuthChallenge(result)) {
             throw new NpmPublishAuthenticationError(packageRoot);
         }
-        throw new Error(`[publish] pnpm publish failed at ${packageRoot}.`);
+        throw new Error('pnpm publish failed.');
     }
 }
 export async function runPnpmWhoami(packageRoot, options = {}) {
@@ -139,9 +142,12 @@ const writeProcessOutput = (result) => {
     const stdout = String(result.stdout ?? '');
     const stderr = String(result.stderr ?? '');
     if (stdout)
-        process.stdout.write(stdout);
+        process.stdout.write(withTrailingLineBreak(stdout));
     if (stderr)
-        process.stderr.write(stderr);
+        process.stderr.write(withTrailingLineBreak(stderr));
+};
+const withTrailingLineBreak = (value) => {
+    return value.endsWith('\n') ? value : `${value}\n`;
 };
 const isNpmAuthChallenge = (output) => {
     return [

package/dist/publish/cli.js

@@ -36,8 +36,8 @@ export async function runPublishCli(args) {
         dryRun: argv['dry-run'] === true,
         format: argv.format !== false,
         otp: stringOption(argv.otp),
-        ignoreScripts: argv['ignore-scripts'] === true,
         allowDirty: argv['allow-dirty'] === true,
+        ignoreScripts: argv['ignore-scripts'] === true,
     }).run();
 }
 export async function runOwnerCli(args) {

package/dist/publish/publishRunner.js

@@ -60,7 +60,6 @@ export class PublishRunner {
             await this.preflight.run(plan);
             return;
         }
-        await this.preflight.run(plan);
         await this.git.commitAndTag(plan);
         await this.publisher.run(plan);
     }
@@ -79,7 +78,7 @@ export class PublishRunner {
             this.logger.error?.(hookError);
         }
         if (error instanceof PublishTargetError) {
-            reportPublishFailure(error, plan.version, this.logger);
+            reportPublishFailure(error, plan.version);
         }
         reportPublishSummary({
             plan,

package/dist/publish/runner/packagePublisher.js

@@ -27,6 +27,6 @@ export function logAuthenticationError(logger, error) {
     if (!(error instanceof NpmPublishAuthenticationError))
         return;
     logger.error('npm publish requires additional authentication.');
-    logger.error('If publish 2FA is enabled, retry with `auk publish --otp <code>`.');
+    logger.error('If publish 2FA is enabled, retry with `--otp <code>`.');
     logger.error('For CI, use an npm automation token.');
 }

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

@@ -1,3 +1,2 @@
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
-import type { AukletLogger } from '#auklet/logger';
-export declare function reportPublishFailure(error: PublishTargetError, version: string, logger: AukletLogger): void;
+export declare function reportPublishFailure(error: PublishTargetError, version: string): void;

package/dist/publish/runner/publishFailureReporter.js

@@ -1,14 +1,18 @@
-export function reportPublishFailure(error, version, logger) {
-    if (error.phase === 'publish' && error.publishedTargets.length) {
-        logger.error('partial publish detected');
-        logger.error('published packages:');
-        for (const target of error.publishedTargets) {
-            logger.error(formatPublishedTarget(logger, target.packageName, version));
-        }
-    }
-    logger.error('failed package:');
-    logger.error(formatPublishedTarget(logger, error.target.packageName, version));
+import { createAukletLogger } from '#auklet/logger';
+export function reportPublishFailure(error, version) {
+    if (!error.publishedTargets.length)
+        return;
+    const logger = createAukletLogger();
+    const noteBody = logger.colors.rgb(184, 140, 40);
+    const body = [
+        noteBody('  Some packages were already published before the failure.'),
+        '',
+        ...error.publishedTargets.map((target) => noteBody(`  published  ${target.packageName}@${version}`)),
+        noteBody(`  failed     ${error.target.packageName}@${version}`),
+    ];
+    logger.newline();
+    logger.note({
+        title: logger.colors.yellow(logger.colors.bold('Partial publish detected')),
+        body,
+    });
 }
-const formatPublishedTarget = (logger, packageName, version) => {
-    return ['- ', logger.package(packageName), '@', logger.version(version)];
-};

package/dist/publish/runner/publishTargetError.js

@@ -5,7 +5,7 @@ export class PublishTargetError extends Error {
     originalError;
     publishedTargets;
     constructor(target, phase, originalError, publishedTargets) {
-        super(`[publish] ${phase} failed for ${target.packageName} at ${path.relative(process.cwd(), target.packageRoot) || target.packageRoot}.`);
+        super(`${phase} failed for ${target.packageName} at ${path.relative(process.cwd(), target.packageRoot) || target.packageRoot}.`);
         this.target = target;
         this.phase = phase;
         this.originalError = originalError;

package/dist/publish/runner/versionWriter.js

@@ -1,4 +1,5 @@
 import { readPackageJson, writePackageJson, } from '#auklet/publish/api/packageJsonApi';
+import { createAukletLogger } from '#auklet/logger';
 export class VersionWriter {
     options;
     logger;
@@ -48,7 +49,19 @@ export class VersionWriter {
     }
     logWrittenVersionFailure(plan) {
         if (!plan.dryRun && this.options.version) {
-            this.logger.error('package.json versions may have been written. Auklet will not roll them back; check publish output before retrying.');
+            const logger = createAukletLogger();
+            const noteBody = logger.colors.rgb(184, 140, 40);
+            logger.newline();
+            logger.note({
+                title: logger.colors.yellow(logger.colors.bold('Version files may have changed')),
+                body: [
+                    [noteBody('  package.json versions may have been written.')],
+                    [
+                        noteBody('  Auklet will not roll them back; check publish output before retrying.'),
+                    ],
+                ],
+            });
+            logger.newline();
         }
     }
     writeVersions(plan) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",