auklet 0.1.2 → 0.1.4

package/dist/publish/api/npmrc.js

@@ -23,6 +23,19 @@ export function findNpmrcFiles(packageRoot, root) {
     }
     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/)
@@ -50,3 +63,24 @@ const parseRegistryUrl = (registry) => {
         });
     }
 };
+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) => {
+    return {
+        ...process.env,
+        ...options.env,
+    };
+};

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

@@ -8,31 +8,33 @@ 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 ensurePnpm(options?: {
+    env?: Record<string, string | undefined>;
+}): Promise<string>;
+export declare function readPnpmWorkspacePackages(root: string, options?: {
+    env?: Record<string, string | undefined>;
+}): Promise<WorkspacePackage[]>;
+export declare function runPnpmBuild(packageRoot: string, options?: {
+    env?: Record<string, string | undefined>;
+}): Promise<void>;
 export declare function runPnpmPublish(packageRoot: string, args: Array<string>, options?: {
-    token?: string;
+    env?: Record<string, string | undefined>;
 }): Promise<void>;
 export declare function runPnpmWhoami(packageRoot: string, options?: {
     packageName?: string;
     registry?: string;
     timeout?: number;
-    token?: string;
+    env?: Record<string, string | undefined>;
 }): Promise<string>;
 export declare function hasPublishedPackageVersion(packageRoot: string, packageName: string, version: string, options?: {
     registry?: string;
     timeout?: number;
-    token?: string;
+    env?: Record<string, string | undefined>;
 }): 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: options.env,
+    });
     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: options.env,
+        })).map((item) => {
             if (!isWorkspacePackage(item))
                 throwInvalidWorkspacePackages();
             return item;
@@ -80,9 +84,10 @@ 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: options.env,
         stdio: 'inherit',
     });
     if (hasFailedPnpmResult(result)) {
@@ -93,7 +98,7 @@ 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),
+        env: options.env,
         stdio: isDryRun ? 'pipe' : 'inherit',
     });
     if (isDryRun)
@@ -111,7 +116,7 @@ export async function runPnpmWhoami(packageRoot, options = {}) {
         args.push('--registry', options.registry);
     const result = await runPnpm(args, {
         cwd: packageRoot,
-        env: createPnpmAuthEnv(options.token),
+        env: options.env,
         timeout: options.timeout,
     });
     if (hasFailedPnpmResult(result)) {
@@ -130,7 +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),
+        env: options.env,
         timeout: options.timeout,
     });
     if (!hasFailedPnpmResult(result)) {
@@ -154,14 +159,6 @@ 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.d.ts

@@ -1,4 +1,4 @@
-import type { PublishOptions, PublishTarget } from '#auklet/publish/types';
+import type { PublishOptions, PublishRuntime, PublishTarget } from '#auklet/publish/types';
 export declare class PnpmPublishApi {
-    publish(target: PublishTarget, options: PublishOptions): Promise<void>;
+    publish(target: PublishTarget, options: PublishOptions, runtime: PublishRuntime): Promise<void>;
 }

package/dist/publish/api/pnpmPublishApi.js

@@ -1,10 +1,12 @@
 import { runPnpmPublish } from '#auklet/publish/api/pnpmApi';
 import { createPublishArgs } from '#auklet/publish/api/publishArgs';
+import { createPublishTargetEnv } from '#auklet/publish/publishEnv';
 export class PnpmPublishApi {
-    async publish(target, options) {
+    async publish(target, options, runtime) {
         const args = createPublishArgs(target, options);
-        if (options.token) {
-            await runPnpmPublish(target.packageRoot, args, { token: options.token });
+        const { env } = createPublishTargetEnv(options, runtime, target);
+        if (env) {
+            await runPnpmPublish(target.packageRoot, args, { env });
             return;
         }
         await runPnpmPublish(target.packageRoot, args);

package/dist/publish/cli.d.ts

@@ -1,5 +1,6 @@
+import { AukletEnvContext } from '#auklet/env';
 export declare function runPublishCli(args: Array<string>): Promise<void>;
-export declare function resolvePublishCliOptions(args: Array<string>, cwd?: string): {
+export declare function resolvePublishCliOptions(args: Array<string>, cwd?: string, envContext?: AukletEnvContext): {
     cwd: string;
     otp: string | undefined;
     filters: string[];
@@ -9,6 +10,9 @@ export declare function resolvePublishCliOptions(args: Array<string>, cwd?: stri
     dryRun: boolean;
     allowDirty: boolean;
     ignoreScripts: boolean;
-    token: string | undefined;
+    token: {
+        raw: string;
+        resolve(context: AukletEnvContext): string | undefined;
+    } | undefined;
 };
 export declare function runOwnerCli(args: Array<string>): Promise<void>;

package/dist/publish/cli.js

@@ -1,8 +1,13 @@
 import minimist from 'minimist';
 import { isArray } from 'aidly';
+import { AukletEnvContext } from '#auklet/env';
+import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
 import { OwnerRunner } from '#auklet/publish/ownerRunner';
 import { PublishRunner } from '#auklet/publish/publishRunner';
-import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
+import { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
+import { resolveCliBoolean, resolveCliValue, createDeferredCliValue, } from '#auklet/cli/values';
+import { createPublishRootEnv } from '#auklet/publish/publishEnv';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
 const publishFlags = new Set([
     '_',
     'filter',
@@ -17,63 +22,84 @@ const publishFlags = new Set([
 ]);
 const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
 export async function runPublishCli(args) {
-    await ensurePnpm();
-    await new PublishRunner(resolvePublishCliOptions(args)).run();
+    const cwd = process.cwd();
+    const root = findWorkspaceRoot(cwd) ?? cwd;
+    const envContext = new AukletEnvContext(cwd, root);
+    await envContext.run(async () => {
+        const runtime = { envContext };
+        const options = resolvePublishCliOptions(args, cwd, envContext);
+        const { env } = createPublishRootEnv(options, runtime);
+        validatePublishCliNpmrcAuthEnv(options.cwd, env);
+        await ensurePnpm({ env });
+        await new PublishRunner(options, runtime).run();
+    });
 }
-export function resolvePublishCliOptions(args, cwd = process.cwd()) {
+export function resolvePublishCliOptions(args, cwd = process.cwd(), envContext = new AukletEnvContext(cwd)) {
     const argv = parsePublishArgs(args);
     if (argv._.length) {
         throw new Error(`[publish] unknown publish argument: ${argv._.join(' ')}`);
     }
     return {
         cwd,
-        otp: stringOption(argv.otp),
-        filters: toArray(argv.filter),
-        version: stringOption(argv.version),
-        git: argv.git !== false,
-        format: argv.format !== false,
-        dryRun: argv['dry-run'] === true,
-        allowDirty: argv['allow-dirty'] === true,
-        ignoreScripts: argv['ignore-scripts'] === true,
-        token: stringOption(argv.token),
+        otp: stringOption(argv.otp, '--otp', envContext),
+        filters: toArray(argv.filter, '--filter', envContext),
+        version: stringOption(argv.version, '--version', envContext),
+        git: booleanOption(argv.git, '--git', envContext, true),
+        format: booleanOption(argv.format, '--format', envContext, true),
+        dryRun: booleanOption(argv['dry-run'], '--dry-run', envContext),
+        allowDirty: booleanOption(argv['allow-dirty'], '--allow-dirty', envContext),
+        ignoreScripts: booleanOption(argv['ignore-scripts'], '--ignore-scripts', envContext),
+        token: deferredStringOption(argv.token, '--token'),
     };
 }
 const parsePublishArgs = (args) => {
     const cliArgs = stripLeadingArgsSeparator(args);
     validateNoPrefixedFlags(cliArgs, new Set(['--no-format', '--no-git']));
     const argv = minimist(cliArgs, {
-        string: ['filter', 'version', 'otp', 'token'],
-        boolean: ['dry-run', 'format', 'git', 'ignore-scripts', 'allow-dirty'],
-        default: {
-            git: true,
-            format: true,
-        },
+        string: [
+            'filter',
+            'version',
+            'otp',
+            'token',
+            'dry-run',
+            'format',
+            'git',
+            'ignore-scripts',
+            'allow-dirty',
+        ],
     });
     validateFlags(argv, publishFlags);
     return argv;
 };
 export async function runOwnerCli(args) {
-    const cliArgs = stripLeadingArgsSeparator(args);
-    validateNoPrefixedFlags(cliArgs, new Set());
-    const argv = minimist(cliArgs, {
-        string: ['filter', 'package', 'otp'],
+    const cwd = process.cwd();
+    const root = findWorkspaceRoot(cwd) ?? cwd;
+    const envContext = new AukletEnvContext(cwd, root);
+    await envContext.run(async () => {
+        const cliArgs = stripLeadingArgsSeparator(args);
+        validateNoPrefixedFlags(cliArgs, new Set());
+        const argv = minimist(cliArgs, {
+            string: ['filter', 'package', 'otp'],
+        });
+        validateFlags(argv, ownerFlags);
+        const [subcommand, ...users] = argv._;
+        if (subcommand !== 'add') {
+            throw new Error('[publish] expected owner command: auk owner add <user...>');
+        }
+        if (!users.length) {
+            throw new Error('[publish] owner add requires at least one user.');
+        }
+        const env = envContext.values;
+        validatePublishCliNpmrcAuthEnv(cwd, env);
+        await ensurePnpm({ env: envContext.normalizedValues });
+        await new OwnerRunner({
+            cwd,
+            users,
+            filters: toArray(argv.filter, '--filter', envContext),
+            packages: toArray(argv.package, '--package', envContext),
+            otp: stringOption(argv.otp, '--otp', envContext),
+        }).run();
     });
-    validateFlags(argv, ownerFlags);
-    const [subcommand, ...users] = argv._;
-    if (subcommand !== 'add') {
-        throw new Error('[publish] expected owner command: auk owner add <user...>');
-    }
-    if (!users.length) {
-        throw new Error('[publish] owner add requires at least one user.');
-    }
-    await ensurePnpm();
-    await new OwnerRunner({
-        cwd: process.cwd(),
-        users,
-        filters: toArray(argv.filter),
-        packages: toArray(argv.package),
-        otp: stringOption(argv.otp),
-    }).run();
 }
 const validateFlags = (argv, allowedFlags) => {
     for (const flag of Object.keys(argv)) {
@@ -91,17 +117,38 @@ const validateNoPrefixedFlags = (args, allowedFlags) => {
 const stripLeadingArgsSeparator = (args) => {
     return args.filter((arg) => arg !== '--');
 };
-const toArray = (value) => {
+const toArray = (value, label, envContext) => {
     if (value === undefined)
         return [];
-    return isArray(value)
-        ? value.map(String).filter(Boolean)
-        : [String(value)].filter(Boolean);
+    const values = isArray(value)
+        ? value.map((item) => stringOption(item, label, envContext)).filter(Boolean)
+        : [stringOption(value, label, envContext)].filter(Boolean);
+    return values.filter((item) => Boolean(item));
 };
-const stringOption = (value) => {
+const stringOption = (value, label, envContext) => {
     if (value === undefined)
         return undefined;
     if (isArray(value))
-        return String(value.at(-1));
-    return String(value);
+        return stringOption(value.at(-1), label, envContext);
+    return resolveCliValue(String(value), { label, context: envContext });
+};
+const deferredStringOption = (value, label) => {
+    if (value === undefined)
+        return undefined;
+    if (isArray(value))
+        return deferredStringOption(value.at(-1), label);
+    return createDeferredCliValue(String(value), { label });
+};
+const booleanOption = (value, label, envContext, defaultValue = false) => {
+    if (value === undefined)
+        return defaultValue;
+    if (isArray(value)) {
+        return booleanOption(value.at(-1), label, envContext, defaultValue);
+    }
+    if (typeof value === 'boolean')
+        return value;
+    return resolveCliBoolean(String(value), { label, context: envContext });
+};
+const validatePublishCliNpmrcAuthEnv = (cwd, env) => {
+    validateNpmrcAuthEnv(cwd, findWorkspaceRoot(cwd) ?? cwd, { env });
 };

package/dist/publish/inspect.js

@@ -1,18 +1,32 @@
 import path from 'node:path';
 import { isString } from 'aidly';
+import { AukletEnvContext } from '#auklet/env';
 import { createAukletLogger } from '#auklet/logger';
-import { resolvePublishTag } from '#auklet/publish/api/publishArgs';
-import { getPublishRegistry } from '#auklet/publish/api/registry';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
 import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
+import { getPublishRegistry } from '#auklet/publish/api/registry';
+import { resolvePublishTag } from '#auklet/publish/api/publishArgs';
 import { resolvePublishCliOptions } from '#auklet/publish/cli';
+import { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
+import { createPublishRootEnv } from '#auklet/publish/publishEnv';
 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 cwd = process.cwd();
+    const root = findWorkspaceRoot(cwd) ?? cwd;
+    const envContext = new AukletEnvContext(cwd, root);
+    return envContext.run(async () => {
+        const options = resolvePublishCliOptions(args, cwd, envContext);
+        return runInspectPublish(options, root, { envContext });
+    });
+}
+async function runInspectPublish(options, root, runtime) {
+    const { env } = createPublishRootEnv(options, runtime);
+    validateNpmrcAuthEnv(options.cwd, root, { env });
+    await ensurePnpm({ env });
     const logger = createAukletLogger({ scope: 'inspect' });
-    const plan = await resolvePublishPlan(options, logger);
+    const plan = await resolvePublishPlan(options, runtime, logger);
     const packageFileChecks = inspectPackageFiles(plan.targets);
     const packageFileCheckFailed = packageFileChecks.some((check) => check.status === 'missing');
     if (packageFileCheckFailed) {
@@ -23,6 +37,7 @@ export async function runInspectPublishCli(args) {
     spinner.start();
     const registryChecks = await inspectPublishRegistry(plan, {
         token: options.token,
+        runtime,
         onCheck: (info) => {
             spinner.text([
                 'Checking registry ',

package/dist/publish/inspectPack.js

@@ -1,17 +1,21 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { isArray, isPlainObject, isString } from 'aidly';
+import { AukletEnvContext } from '#auklet/env';
 import { createAukletLogger } from '#auklet/logger';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
 import { resolvePublishPlan } from '#auklet/publish/targetResolver';
 export async function runInspectPackCli(args) {
     const options = resolveInspectPackOptions(args);
+    const root = findWorkspaceRoot(options.cwd) ?? options.cwd;
+    const envContext = new AukletEnvContext(options.cwd, root);
     const logger = createAukletLogger({ scope: 'inspect' });
-    const plan = await resolvePublishPlan({
+    const plan = await envContext.run(() => resolvePublishPlan({
         cwd: options.cwd,
         filters: options.filters,
         dryRun: true,
         version: undefined,
-    }, logger);
+    }, { envContext }, logger));
     const checks = inspectPackageFiles(plan.targets);
     new PackInspectReporter(options.cwd, plan.targets, checks).report();
     return checks.some((check) => check.status === 'missing') ? 1 : 0;

package/dist/publish/inspectRegistry.d.ts

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

package/dist/publish/inspectRegistry.js

@@ -1,9 +1,10 @@
 import { retry } from 'aidly';
 import { getPublishRegistry } from '#auklet/publish/api/registry';
-import { hasPublishedPackageVersion, runPnpmWhoami, } from '#auklet/publish/api/pnpmApi';
+import { runPnpmWhoami, hasPublishedPackageVersion, } from '#auklet/publish/api/pnpmApi';
+import { createPublishTargetEnv } from '#auklet/publish/publishEnv';
 const registryCheckTimeout = 5_000;
 const registryCheckRetryTimes = 2;
-export async function inspectPublishRegistry(plan, options = {}) {
+export async function inspectPublishRegistry(plan, options) {
     const authResults = new Map();
     const checks = [];
     for (const target of plan.targets) {
@@ -26,6 +27,9 @@ export async function inspectPublishRegistry(plan, options = {}) {
     return checks;
 }
 const checkAuth = async (authResults, authKey, packageRoot, packageName, registry, options) => {
+    const { env } = createPublishTargetEnv(options, options.runtime, {
+        packageRoot,
+    });
     try {
         options.onCheck?.({
             packageName,
@@ -35,7 +39,7 @@ const checkAuth = async (authResults, authKey, packageRoot, packageName, registr
         await retryWithLog(() => runPnpmWhoami(packageRoot, {
             packageName,
             registry,
-            token: options.token,
+            env,
             timeout: registryCheckTimeout,
         }), {
             check: 'auth',
@@ -53,6 +57,9 @@ const checkAuth = async (authResults, authKey, packageRoot, packageName, registr
     }
 };
 const checkVersion = async (packageRoot, packageName, version, registry, options) => {
+    const { env } = createPublishTargetEnv(options, options.runtime, {
+        packageRoot,
+    });
     try {
         options.onCheck?.({
             packageName,
@@ -61,7 +68,7 @@ const checkVersion = async (packageRoot, packageName, version, registry, options
         });
         const exists = await retryWithLog(() => hasPublishedPackageVersion(packageRoot, packageName, version, {
             registry,
-            token: options.token,
+            env,
             timeout: registryCheckTimeout,
         }), {
             check: 'version',

package/dist/publish/publishEnv.d.ts

@@ -0,0 +1,13 @@
+import type { PublishOptions, PublishRuntime, PublishTarget } from '#auklet/publish/types';
+export type PublishPnpmEnv = {
+    env?: Record<string, string | undefined>;
+    token?: string;
+};
+export declare function createPublishRootEnv(options: Pick<PublishOptions, 'token'>, runtime: PublishRuntime): {
+    env: Record<string, string | undefined> | undefined;
+    token: string | undefined;
+};
+export declare function createPublishTargetEnv(options: Pick<PublishOptions, 'token'>, runtime: PublishRuntime, target: Pick<PublishTarget, 'packageRoot'>): {
+    env: Record<string, string | undefined> | undefined;
+    token: string | undefined;
+};

package/dist/publish/publishEnv.js

@@ -0,0 +1,21 @@
+export function createPublishRootEnv(options, runtime) {
+    return createPublishPnpmEnv(options.token, runtime.envContext);
+}
+export function createPublishTargetEnv(options, runtime, target) {
+    const envContext = runtime.envContext.createPackageContext(target.packageRoot);
+    return createPublishPnpmEnv(options.token, envContext);
+}
+const createPublishPnpmEnv = (token, envContext) => {
+    const resolvedToken = token?.resolve(envContext);
+    const resolvedEnv = resolvedToken
+        ? {
+            ...envContext.values,
+            NODE_AUTH_TOKEN: resolvedToken,
+            NPM_TOKEN: resolvedToken,
+        }
+        : envContext.values;
+    return {
+        env: Object.keys(resolvedEnv).length ? resolvedEnv : undefined,
+        token: resolvedToken,
+    };
+};

package/dist/publish/publishRunner.d.ts

@@ -1,4 +1,4 @@
-import type { PublishOptions } from '#auklet/publish/types';
+import type { PublishOptions, PublishRuntime } from '#auklet/publish/types';
 export declare class PublishRunner {
     private readonly git;
     private readonly publisher;
@@ -6,7 +6,8 @@ export declare class PublishRunner {
     private readonly versions;
     private readonly logger;
     private readonly options;
-    constructor(options: PublishOptions);
+    private readonly runtime;
+    constructor(options: PublishOptions, runtime: PublishRuntime);
     run(): Promise<void>;
     private publishWithPlan;
     private handleFailure;

package/dist/publish/publishRunner.js

@@ -1,4 +1,4 @@
-import { createScopedAukletLogger } from '#auklet/logger';
+import { createAukletLogger } from '#auklet/logger';
 import { runPublishHook } from '#auklet/publish/api/publishHookApi';
 import { runPackageBuilds, validateBuildScript, } from '#auklet/publish/runner/packageBuilder';
 import { formatPublishOutputs } from '#auklet/publish/runner/publishOutputFormatter';
@@ -17,16 +17,18 @@ export class PublishRunner {
     versions;
     logger;
     options;
-    constructor(options) {
+    runtime;
+    constructor(options, runtime) {
         this.options = options;
-        this.logger = createScopedAukletLogger('publish');
+        this.runtime = runtime;
+        this.logger = createAukletLogger({ scope: 'publish' });
         this.git = new ReleaseGitController(this.options, this.logger);
-        this.publisher = new PackagePublisher(this.options, this.logger);
-        this.preflight = new PublishPreflight(this.options, this.logger);
+        this.publisher = new PackagePublisher(this.options, this.runtime, this.logger);
+        this.preflight = new PublishPreflight(this.options, this.runtime, this.logger);
         this.versions = new VersionWriter(this.options, this.logger);
     }
     async run() {
-        const plan = await resolvePublishPlan(this.options, this.logger);
+        const plan = await resolvePublishPlan(this.options, this.runtime, this.logger);
         let failureHookEnabled = false;
         try {
             validateBuildScript(plan.targets);
@@ -36,7 +38,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, this.runtime);
             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,4 @@
-import type { PublishTarget } from '#auklet/publish/types';
 import type { AukletLogger } from '#auklet/logger';
+import type { PublishTarget, PublishOptions, PublishRuntime } 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'>, runtime: PublishRuntime): Promise<void>;