auklet 0.1.1 → 0.1.2

package/README.md

@@ -131,6 +131,7 @@ auk publish --version patch --dry-run
 auk publish --no-format
 auk publish --no-git
 auk publish --otp 123456
+auk publish --token npm_xxx
 auk inspect publish --version patch
 auk inspect pack --filter @scope/ui
 auk inspect css --modules
@@ -161,8 +162,16 @@ Before writing versions, auklet checks npm authentication from each target
 package directory. Package-local `.npmrc` files and
 `package.json#publishConfig.registry` are respected.
 `--otp` is forwarded to `pnpm publish` for npm accounts or organizations that
-require publish 2FA, and to `pnpm owner add` for owner management 2FA. In CI,
-prefer an npm automation token.
+require publish 2FA, and to `pnpm owner add` for owner management 2FA.
+`--token` sets `NODE_AUTH_TOKEN` and `NPM_TOKEN` for publish subprocesses. The
+token still needs npmrc auth config, for example:
+
+```ini
+//registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}
+```
+
+When a package uses `package.json#publishConfig.registry`, the npmrc token entry
+must target that registry. In CI, prefer an npm automation token over `--otp`.
 
 `auk inspect publish` accepts the same publish selection and version flags as
 `auk publish`. It resolves the publish plan, checks package entry/export files,
@@ -177,7 +186,9 @@ and declared `files` paths point to existing package files.
 `auk inspect css` accepts the same build override flags as `auk build`. It
 prints the normalized CSS plan, including output entries, theme files, and
 module entries. When run from a pnpm workspace root, it inspects workspace child
-packages instead of the root package. It does not write CSS output.
+packages instead of the root package. It does not write CSS output, but
+dependency CSS files must already exist when the plan relies on external package
+style entries or component auto imports.
 
 ## Configuration
 

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import type { AukletConfig, StyleDependencyGroup } from '#auklet/types';
+import type { AukletConfig } from '#auklet/types';
 export declare const aukletConfigFiles: string[];
 export declare function isAukletConfigFile(file: string): boolean;
 export declare const aukletDefaultOptions: {
@@ -15,7 +15,6 @@ export declare const aukletDefaultOptions: {
         dependencies: {};
     };
 };
-export declare const aukletDefaultStyleDependencyConfig: StyleDependencyGroup;
 export declare function normalizeAukletConfig(config?: AukletConfig): {
     source: string;
     output: string;

package/dist/config.js

@@ -16,14 +16,6 @@ export const aukletDefaultOptions = {
         dependencies: {},
     },
 };
-export const aukletDefaultStyleDependencyConfig = {
-    entry: '/style.css',
-    components: ['/pages/**.css', '/components/**.css'],
-    themes: {
-        dark: '/themes/dark.css',
-        light: '/themes/light.css',
-    },
-};
 const normalizeStyleDependency = (dependency) => ({
     entry: dependency.entry,
     themes: dependency.themes,

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

@@ -0,0 +1,4 @@
+export declare function findNpmrcWithAuthToken(packageRoot: string, root: string, registry?: string): string | undefined;
+export declare function findNpmrcFiles(packageRoot: string, root: string): string[];
+export declare function hasAuthToken(content: string, registry?: string): boolean;
+export declare function toNpmrcRegistryKey(registry: string): string;

package/dist/publish/api/npmrc.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function findNpmrcWithAuthToken(packageRoot, root, registry) {
+    const npmrcFiles = findNpmrcFiles(packageRoot, root);
+    return npmrcFiles.find((file) => {
+        return hasAuthToken(fs.readFileSync(file, 'utf8'), registry);
+    });
+}
+export function findNpmrcFiles(packageRoot, root) {
+    const files = [];
+    let current = path.resolve(packageRoot);
+    const boundary = path.resolve(root);
+    while (true) {
+        const file = path.join(current, '.npmrc');
+        if (fs.existsSync(file))
+            files.push(file);
+        if (current === boundary)
+            break;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return files;
+}
+export function hasAuthToken(content, registry) {
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#') && !line.startsWith(';'));
+    if (!registry)
+        return lines.some((line) => line.includes('_authToken'));
+    const authKey = `${toNpmrcRegistryKey(registry)}:_authToken`;
+    return lines.some((line) => line.startsWith(authKey));
+}
+export function toNpmrcRegistryKey(registry) {
+    const url = parseRegistryUrl(registry);
+    const pathname = url.pathname.endsWith('/')
+        ? url.pathname
+        : `${url.pathname}/`;
+    return `//${url.host}${pathname}`;
+}
+const parseRegistryUrl = (registry) => {
+    try {
+        return new URL(registry);
+    }
+    catch (error) {
+        throw new Error(`[publish] invalid publishConfig.registry: ${registry}`, {
+            cause: error,
+        });
+    }
+};

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

@@ -11,20 +11,28 @@ export declare function withPnpmTimeout(subprocess: ReturnType<typeof execa>, ti
 export declare function ensurePnpm(): Promise<string>;
 export declare function readPnpmWorkspacePackages(root: string): Promise<WorkspacePackage[]>;
 export declare function runPnpmBuild(packageRoot: string): Promise<void>;
-export declare function runPnpmPublish(packageRoot: string, args: Array<string>): Promise<void>;
+export declare function runPnpmPublish(packageRoot: string, args: Array<string>, options?: {
+    token?: string;
+}): Promise<void>;
 export declare function runPnpmWhoami(packageRoot: string, options?: {
     packageName?: string;
     registry?: string;
     timeout?: number;
+    token?: string;
 }): Promise<string>;
 export declare function hasPublishedPackageVersion(packageRoot: string, packageName: string, version: string, options?: {
     registry?: string;
     timeout?: number;
+    token?: string;
 }): Promise<boolean>;
 export declare function runPnpmOwnerAdd(packageName: string, user: string, options: {
     cwd: string;
     otp?: string;
 }): Promise<void>;
+export declare function createPnpmAuthEnv(token?: string): {
+    NODE_AUTH_TOKEN: string;
+    NPM_TOKEN: string;
+} | undefined;
 export declare function hasNpmAuthChallenge(result: {
     stdout?: unknown;
     stderr?: unknown;

package/dist/publish/api/pnpmApi.js

@@ -89,10 +89,11 @@ export async function runPnpmBuild(packageRoot) {
         throw new Error(`[publish] build failed at ${packageRoot}.`);
     }
 }
-export async function runPnpmPublish(packageRoot, args) {
+export async function runPnpmPublish(packageRoot, args, options = {}) {
     const isDryRun = args.includes('--dry-run');
     const result = await runPnpm(['publish', ...args], {
         cwd: packageRoot,
+        env: createPnpmAuthEnv(options.token),
         stdio: isDryRun ? 'pipe' : 'inherit',
     });
     if (isDryRun)
@@ -110,6 +111,7 @@ export async function runPnpmWhoami(packageRoot, options = {}) {
         args.push('--registry', options.registry);
     const result = await runPnpm(args, {
         cwd: packageRoot,
+        env: createPnpmAuthEnv(options.token),
         timeout: options.timeout,
     });
     if (hasFailedPnpmResult(result)) {
@@ -128,6 +130,7 @@ export async function hasPublishedPackageVersion(packageRoot, packageName, versi
         args.push('--registry', options.registry);
     const result = await runPnpm(args, {
         cwd: packageRoot,
+        env: createPnpmAuthEnv(options.token),
         timeout: options.timeout,
     });
     if (!hasFailedPnpmResult(result)) {
@@ -151,6 +154,14 @@ export async function runPnpmOwnerAdd(packageName, user, options) {
         throw new Error(`[publish] pnpm owner add failed for ${user} -> ${packageName}.`);
     }
 }
+export function createPnpmAuthEnv(token) {
+    if (!token)
+        return undefined;
+    return {
+        NODE_AUTH_TOKEN: token,
+        NPM_TOKEN: token,
+    };
+}
 const isWorkspacePackage = (value) => {
     if (!isPlainObject(value)) {
         return false;

package/dist/publish/api/pnpmPublishApi.js

@@ -2,6 +2,11 @@ import { runPnpmPublish } from '#auklet/publish/api/pnpmApi';
 import { createPublishArgs } from '#auklet/publish/api/publishArgs';
 export class PnpmPublishApi {
     async publish(target, options) {
-        await runPnpmPublish(target.packageRoot, createPublishArgs(target, options));
+        const args = createPublishArgs(target, options);
+        if (options.token) {
+            await runPnpmPublish(target.packageRoot, args, { token: options.token });
+            return;
+        }
+        await runPnpmPublish(target.packageRoot, args);
     }
 }

package/dist/publish/cli.d.ts

@@ -9,5 +9,6 @@ export declare function resolvePublishCliOptions(args: Array<string>, cwd?: stri
     dryRun: boolean;
     allowDirty: boolean;
     ignoreScripts: boolean;
+    token: string | undefined;
 };
 export declare function runOwnerCli(args: Array<string>): Promise<void>;

package/dist/publish/cli.js

@@ -11,6 +11,7 @@ const publishFlags = new Set([
     'format',
     'git',
     'otp',
+    'token',
     'ignore-scripts',
     'allow-dirty',
 ]);
@@ -34,13 +35,14 @@ export function resolvePublishCliOptions(args, cwd = process.cwd()) {
         dryRun: argv['dry-run'] === true,
         allowDirty: argv['allow-dirty'] === true,
         ignoreScripts: argv['ignore-scripts'] === true,
+        token: stringOption(argv.token),
     };
 }
 const parsePublishArgs = (args) => {
     const cliArgs = stripLeadingArgsSeparator(args);
     validateNoPrefixedFlags(cliArgs, new Set(['--no-format', '--no-git']));
     const argv = minimist(cliArgs, {
-        string: ['filter', 'version', 'otp'],
+        string: ['filter', 'version', 'otp', 'token'],
         boolean: ['dry-run', 'format', 'git', 'ignore-scripts', 'allow-dirty'],
         default: {
             git: true,

package/dist/publish/inspect.js

@@ -22,6 +22,7 @@ export async function runInspectPublishCli(args) {
     const spinner = logger.spinner('Checking publish registry');
     spinner.start();
     const registryChecks = await inspectPublishRegistry(plan, {
+        token: options.token,
         onCheck: (info) => {
             spinner.text([
                 'Checking registry ',

package/dist/publish/inspectRegistry.d.ts

@@ -1,4 +1,4 @@
-import type { PublishPlan } from '#auklet/publish/types';
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
 export type PublishRegistryCheckStatus = 'success' | 'error';
 export type PublishRegistryCheck = {
     packageName: string;
@@ -17,6 +17,7 @@ export type PublishRegistryRetryInfo = {
 };
 export type PublishRegistryCheckInfo = Pick<PublishRegistryRetryInfo, 'packageName' | 'registry' | 'check'>;
 export type InspectPublishRegistryOptions = {
+    token?: PublishOptions['token'];
     onCheck?: (info: PublishRegistryCheckInfo) => void;
     onRetry?: (info: PublishRegistryRetryInfo) => void;
 };

package/dist/publish/inspectRegistry.js

@@ -35,6 +35,7 @@ const checkAuth = async (authResults, authKey, packageRoot, packageName, registr
         await retryWithLog(() => runPnpmWhoami(packageRoot, {
             packageName,
             registry,
+            token: options.token,
             timeout: registryCheckTimeout,
         }), {
             check: 'auth',
@@ -60,6 +61,7 @@ const checkVersion = async (packageRoot, packageName, version, registry, options
         });
         const exists = await retryWithLog(() => hasPublishedPackageVersion(packageRoot, packageName, version, {
             registry,
+            token: options.token,
             timeout: registryCheckTimeout,
         }), {
             check: 'version',

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,5 +1,6 @@
 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';
@@ -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,3 +80,20 @@ export class PublishPreflight {
         }
     }
 }
+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 = {

package/package.json

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