auklet 0.1.1 → 0.1.3

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,8 @@
+export type NpmrcAuthEnvOptions = {
+    token?: string;
+};
+export declare function findNpmrcWithAuthToken(packageRoot: string, root: string, registry?: string): string | undefined;
+export declare function findNpmrcFiles(packageRoot: string, root: string): string[];
+export declare function validateNpmrcAuthEnv(packageRoot: string, root: string, options?: NpmrcAuthEnvOptions): void;
+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,89 @@
+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 validateNpmrcAuthEnv(packageRoot, root, options = {}) {
+    const env = createAvailableAuthEnv(options);
+    for (const file of findNpmrcFiles(packageRoot, root)) {
+        const missing = findMissingNpmrcEnvVars(fs.readFileSync(file, 'utf8'), env);
+        if (!missing.length)
+            continue;
+        const variable = missing[0];
+        throw new Error(`[publish] npmrc auth environment is missing: ${variable}\n` +
+            `[publish] file: ${file}\n` +
+            `[publish] Set ${variable} before retrying, or use --token with an npmrc entry such as:\n` +
+            '  //registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}');
+    }
+}
+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,
+        });
+    }
+};
+const findMissingNpmrcEnvVars = (content, env) => {
+    return getNpmrcAuthLines(content)
+        .flatMap((line) => [...line.matchAll(/\$\{([^}]+)\}/g)])
+        .map((match) => match[1])
+        .filter((name) => name && !env[name]);
+};
+const getNpmrcAuthLines = (content) => {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line &&
+        !line.startsWith('#') &&
+        !line.startsWith(';') &&
+        line.includes('_authToken'));
+};
+const createAvailableAuthEnv = (options) => {
+    if (!options.token)
+        return process.env;
+    return {
+        ...process.env,
+        NODE_AUTH_TOKEN: options.token,
+        NPM_TOKEN: options.token,
+    };
+};

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

@@ -8,23 +8,37 @@ 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>;
-export declare function runPnpmPublish(packageRoot: string, args: Array<string>): Promise<void>;
+export declare function ensurePnpm(options?: {
+    token?: string;
+}): Promise<string>;
+export declare function readPnpmWorkspacePackages(root: string, options?: {
+    token?: string;
+}): Promise<WorkspacePackage[]>;
+export declare function runPnpmBuild(packageRoot: string, options?: {
+    token?: 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

@@ -50,8 +50,10 @@ export async function withPnpmTimeout(subprocess, timeout) {
     subprocess.catch(() => { });
     return result;
 }
-export async function ensurePnpm() {
-    const result = await runPnpm(['--version']);
+export async function ensurePnpm(options = {}) {
+    const result = await runPnpm(['--version'], {
+        env: createPnpmAuthEnv(options.token),
+    });
     const stdout = String(result.stdout ?? '');
     if (hasFailedPnpmResult(result) || !stdout) {
         throw new Error('[publish] pnpm is required for publishing.\n' +
@@ -66,9 +68,11 @@ export async function ensurePnpm() {
     }
     return version;
 }
-export async function readPnpmWorkspacePackages(root) {
+export async function readPnpmWorkspacePackages(root, options = {}) {
     try {
-        return (await readPnpmWorkspacePackageInfo(root)).map((item) => {
+        return (await readPnpmWorkspacePackageInfo(root, {
+            env: createPnpmAuthEnv(options.token),
+        })).map((item) => {
             if (!isWorkspacePackage(item))
                 throwInvalidWorkspacePackages();
             return item;
@@ -80,19 +84,21 @@ export async function readPnpmWorkspacePackages(root) {
         });
     }
 }
-export async function runPnpmBuild(packageRoot) {
+export async function runPnpmBuild(packageRoot, options = {}) {
     const result = await runPnpm(['run', 'build'], {
         cwd: packageRoot,
+        env: createPnpmAuthEnv(options.token),
         stdio: 'inherit',
     });
     if (hasFailedPnpmResult(result)) {
         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 +116,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 +135,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 +159,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

@@ -2,7 +2,9 @@ import minimist from 'minimist';
 import { isArray } from 'aidly';
 import { OwnerRunner } from '#auklet/publish/ownerRunner';
 import { PublishRunner } from '#auklet/publish/publishRunner';
+import { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
 import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
 const publishFlags = new Set([
     '_',
     'filter',
@@ -11,13 +13,16 @@ const publishFlags = new Set([
     'format',
     'git',
     'otp',
+    'token',
     'ignore-scripts',
     'allow-dirty',
 ]);
 const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
 export async function runPublishCli(args) {
-    await ensurePnpm();
-    await new PublishRunner(resolvePublishCliOptions(args)).run();
+    const options = resolvePublishCliOptions(args);
+    validatePublishCliNpmrcAuthEnv(options.cwd, options.token);
+    await ensurePnpm({ token: options.token });
+    await new PublishRunner(options).run();
 }
 export function resolvePublishCliOptions(args, cwd = process.cwd()) {
     const argv = parsePublishArgs(args);
@@ -34,13 +39,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,
@@ -64,9 +70,11 @@ export async function runOwnerCli(args) {
     if (!users.length) {
         throw new Error('[publish] owner add requires at least one user.');
     }
+    const cwd = process.cwd();
+    validatePublishCliNpmrcAuthEnv(cwd);
     await ensurePnpm();
     await new OwnerRunner({
-        cwd: process.cwd(),
+        cwd,
         users,
         filters: toArray(argv.filter),
         packages: toArray(argv.package),
@@ -103,3 +111,6 @@ const stringOption = (value) => {
         return String(value.at(-1));
     return String(value);
 };
+const validatePublishCliNpmrcAuthEnv = (cwd, token) => {
+    validateNpmrcAuthEnv(cwd, findWorkspaceRoot(cwd) ?? cwd, { token });
+};

package/dist/publish/inspect.js

@@ -4,13 +4,18 @@ 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 { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
 import { resolvePublishCliOptions } from '#auklet/publish/cli';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
 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);
+    validateNpmrcAuthEnv(options.cwd, findWorkspaceRoot(options.cwd) ?? options.cwd, {
+        token: options.token,
+    });
+    await ensurePnpm({ token: options.token });
     const logger = createAukletLogger({ scope: 'inspect' });
     const plan = await resolvePublishPlan(options, logger);
     const packageFileChecks = inspectPackageFiles(plan.targets);
@@ -22,6 +27,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/publishRunner.js

@@ -36,7 +36,7 @@ export class PublishRunner {
             await runPublishHook({ status: 'beforeBuild', plan });
             failureHookEnabled = true;
             this.versions.writeBeforeBuild(plan);
-            await runPackageBuilds(plan.targets, this.logger);
+            await runPackageBuilds(plan.targets, this.logger, this.options);
             await runPublishHook({ status: 'afterBuild', plan });
             await formatPublishOutputs(plan.targets, this.options.format);
             await runPublishHook({ status: 'beforePublish', plan });

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

@@ -1,4 +1,5 @@
 import type { PublishTarget } from '#auklet/publish/types';
 import type { AukletLogger } from '#auklet/logger';
+import type { PublishOptions } from '#auklet/publish/types';
 export declare function validateBuildScript(targets: Array<PublishTarget>): void;
-export declare function runPackageBuilds(targets: Array<PublishTarget>, logger: AukletLogger): Promise<void>;
+export declare function runPackageBuilds(targets: Array<PublishTarget>, logger: AukletLogger, options?: Pick<PublishOptions, 'token'>): Promise<void>;

package/dist/publish/runner/packageBuilder.js

@@ -8,9 +8,13 @@ export function validateBuildScript(targets) {
         }
     }
 }
-export async function runPackageBuilds(targets, logger) {
+export async function runPackageBuilds(targets, logger, options = {}) {
     for (const target of targets) {
         logger.step('build ', logger.package(target.packageName));
+        if (options.token) {
+            await runPnpmBuild(target.packageRoot, { token: options.token });
+            continue;
+        }
         await runPnpmBuild(target.packageRoot);
     }
 }

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

@@ -7,6 +7,8 @@ export declare class PublishPreflight {
     constructor(options: PublishOptions, logger: AukletLogger);
     run(plan: PublishPlan): Promise<void>;
     verifyBeforeBuild(plan: PublishPlan): Promise<void>;
+    private verifyNpmrcAuthEnv;
+    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, validateNpmrcAuthEnv, } 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,31 @@ export class PublishPreflight {
         await this.verifyPnpmPublishDryRun(plan);
     }
     async verifyBeforeBuild(plan) {
+        this.verifyNpmrcAuthEnv(plan);
+        this.verifyTokenConfig(plan);
         if (plan.dryRun)
             return;
         await this.verifyAuthentication(plan);
         await this.verifyPackageVersions(plan);
     }
+    verifyNpmrcAuthEnv(plan) {
+        for (const target of plan.targets) {
+            validateNpmrcAuthEnv(target.packageRoot, plan.root, {
+                token: this.options.token,
+            });
+        }
+    }
+    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 +51,7 @@ export class PublishPreflight {
             await runPnpmWhoami(target.packageRoot, {
                 packageName: target.packageName,
                 registry,
+                token: this.options.token,
             });
             checked.add(key);
         }
@@ -52,7 +74,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 +88,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/targetResolver.d.ts

@@ -1,6 +1,6 @@
 import { type AukletLogger } from '#auklet/logger';
 import type { OwnerOptions, PublishOptions, PublishPlan } from '#auklet/publish/types';
-type ResolvePublishTargetsOptions = Pick<PublishOptions, 'cwd' | 'filters' | 'version' | 'dryRun'>;
+type ResolvePublishTargetsOptions = Pick<PublishOptions, 'cwd' | 'filters' | 'version' | 'dryRun' | 'token'>;
 type ResolveOwnerTargetsOptions = Pick<OwnerOptions, 'cwd' | 'filters' | 'packages'>;
 export declare function resolvePublishPlan(options: ResolvePublishTargetsOptions, logger?: AukletLogger): Promise<PublishPlan>;
 export declare function resolveOwnerPackageNames(options: ResolveOwnerTargetsOptions): Promise<string[]>;

package/dist/publish/targetResolver.js

@@ -59,7 +59,9 @@ const resolveMonorepoPublishPlan = async (options, logger) => {
     const root = requireWorkspaceRoot(options.cwd);
     const rootPackageJson = readPackageJson(root);
     const rootVersion = requirePackageVersion(root, rootPackageJson);
-    const workspacePackages = await readPnpmWorkspacePackages(root);
+    const workspacePackages = await readPnpmWorkspacePackages(root, {
+        token: options.token,
+    });
     const selectedPackages = filterWorkspacePackages(workspacePackages, options.filters);
     const targets = selectedPackages
         .filter((item) => {

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.3",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",