auklet 0.1.3 → 0.1.5

package/dist/env.js

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseEnv } from 'node:util';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
+const envFileNames = ['.env', '.env.local'];
+export class AukletEnvContext {
+    packageRoot;
+    root;
+    env;
+    processEnv;
+    constructor(packageRoot, root, options = {}) {
+        this.packageRoot = packageRoot;
+        this.root = root;
+        this.processEnv = { ...(options.processEnv ?? process.env) };
+        this.env = this.createProcessEnvOverrides(this.readEnv());
+    }
+    get values() {
+        return this.env;
+    }
+    get normalizedValues() {
+        return Object.keys(this.values).length ? this.values : undefined;
+    }
+    createPackageContext(packageRoot) {
+        return new AukletEnvContext(packageRoot, this.root, {
+            processEnv: this.processEnv,
+        });
+    }
+    resolveValue(value, options) {
+        if (!value)
+            return undefined;
+        if (!value.startsWith('env:'))
+            return value;
+        const name = value.slice('env:'.length);
+        if (!name) {
+            throw new Error(`${options.label} env: requires an environment name.`);
+        }
+        const resolved = this.processEnv[name] ?? this.values[name];
+        if (!resolved) {
+            throw new Error(`${options.label} environment is missing: ${name}`);
+        }
+        return resolved;
+    }
+    resolveBoolean(value, options) {
+        if (value === undefined)
+            return false;
+        if (typeof value === 'boolean')
+            return value;
+        if (!value)
+            return true;
+        const resolved = this.resolveValue(value, options);
+        if (resolved === undefined || !resolved)
+            return true;
+        const normalized = resolved.toLowerCase();
+        if (['1', 'true', 'yes', 'on'].includes(normalized))
+            return true;
+        if (['0', 'false', 'no', 'off'].includes(normalized))
+            return false;
+        throw new Error(`${options.label} requires a boolean value.`);
+    }
+    async run(fn) {
+        const originalEnv = { ...process.env };
+        for (const [key, value] of Object.entries(this.values)) {
+            if (originalEnv[key] === undefined && value !== undefined) {
+                process.env[key] = value;
+            }
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            process.env = originalEnv;
+        }
+    }
+    readEnv() {
+        const env = {};
+        for (const file of this.findEnvFiles()) {
+            Object.assign(env, parseEnv(fs.readFileSync(file, 'utf8')));
+        }
+        return env;
+    }
+    findEnvFiles() {
+        const files = [];
+        const packageDir = path.resolve(this.packageRoot);
+        const rootDir = path.resolve(this.root ?? findWorkspaceRoot(packageDir) ?? packageDir);
+        // Files are read in order and later files override earlier ones.
+        // Final priority is process.env > package .env.local > package .env >
+        // root .env.local > root .env.
+        const rootEnvFiles = envFileNames.map((fileName) => path.join(rootDir, fileName));
+        const packageEnvFiles = envFileNames.map((fileName) => path.join(packageDir, fileName));
+        for (const file of rootEnvFiles) {
+            if (fs.existsSync(file)) {
+                files.push(file);
+            }
+        }
+        for (const file of packageEnvFiles) {
+            if (!files.includes(file) && fs.existsSync(file)) {
+                files.push(file);
+            }
+        }
+        return files;
+    }
+    createProcessEnvOverrides(env) {
+        return Object.fromEntries(Object.entries(env).filter(([key]) => this.processEnv[key] === undefined));
+    }
+}

package/dist/logger.d.ts

@@ -2,4 +2,3 @@ import { Logger, type LoggerOptions } from 'briefing';
 export type AukletLogger = Logger;
 export type CreateAukletLoggerOptions = Pick<LoggerOptions, 'scope' | 'prefix' | 'colors' | 'silent' | 'verbose' | 'sink'>;
 export declare function createAukletLogger(options?: CreateAukletLoggerOptions): Logger;
-export declare function createScopedAukletLogger(scope: string): Logger;

package/dist/logger.js

@@ -9,6 +9,3 @@ export function createAukletLogger(options = {}) {
         sink: options.sink,
     });
 }
-export function createScopedAukletLogger(scope) {
-    return createAukletLogger({ scope });
-}

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

@@ -1,5 +1,5 @@
 export type NpmrcAuthEnvOptions = {
-    token?: string;
+    env?: Record<string, string | undefined>;
 };
 export declare function findNpmrcWithAuthToken(packageRoot: string, root: string, registry?: string): string | undefined;
 export declare function findNpmrcFiles(packageRoot: string, root: string): string[];

package/dist/publish/api/npmrc.js

@@ -79,11 +79,8 @@ const getNpmrcAuthLines = (content) => {
         line.includes('_authToken'));
 };
 const createAvailableAuthEnv = (options) => {
-    if (!options.token)
-        return process.env;
     return {
         ...process.env,
-        NODE_AUTH_TOKEN: options.token,
-        NPM_TOKEN: options.token,
+        ...options.env,
     };
 };

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

@@ -1,5 +1,4 @@
 import { execa, type Options } from 'execa';
-import type { WorkspacePackage } from '#auklet/publish/types';
 export declare class NpmPublishAuthenticationError extends Error {
     readonly packageRoot: string;
     constructor(packageRoot: string);
@@ -9,36 +8,29 @@ export declare class NpmPackageVersionExistsError extends Error {
 }
 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(options?: {
-    token?: string;
+    env?: Record<string, string | undefined>;
 }): Promise<string>;
-export declare function readPnpmWorkspacePackages(root: string, options?: {
-    token?: string;
-}): Promise<WorkspacePackage[]>;
 export declare function runPnpmBuild(packageRoot: string, options?: {
-    token?: string;
+    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

@@ -1,7 +1,5 @@
-import { isPlainObject, isString } from 'aidly';
 import { execa } from 'execa';
 import semver from 'semver';
-import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
 const supportedPnpmRange = '>=10.0.0';
 export class NpmPublishAuthenticationError extends Error {
     packageRoot;
@@ -52,7 +50,7 @@ export async function withPnpmTimeout(subprocess, timeout) {
 }
 export async function ensurePnpm(options = {}) {
     const result = await runPnpm(['--version'], {
-        env: createPnpmAuthEnv(options.token),
+        env: options.env,
     });
     const stdout = String(result.stdout ?? '');
     if (hasFailedPnpmResult(result) || !stdout) {
@@ -68,26 +66,10 @@ export async function ensurePnpm(options = {}) {
     }
     return version;
 }
-export async function readPnpmWorkspacePackages(root, options = {}) {
-    try {
-        return (await readPnpmWorkspacePackageInfo(root, {
-            env: createPnpmAuthEnv(options.token),
-        })).map((item) => {
-            if (!isWorkspacePackage(item))
-                throwInvalidWorkspacePackages();
-            return item;
-        });
-    }
-    catch (error) {
-        throw new Error('[publish] failed to read pnpm workspace packages.', {
-            cause: error,
-        });
-    }
-}
 export async function runPnpmBuild(packageRoot, options = {}) {
     const result = await runPnpm(['run', 'build'], {
         cwd: packageRoot,
-        env: createPnpmAuthEnv(options.token),
+        env: options.env,
         stdio: 'inherit',
     });
     if (hasFailedPnpmResult(result)) {
@@ -98,7 +80,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)
@@ -116,7 +98,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)) {
@@ -135,7 +117,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)) {
@@ -159,26 +141,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;
-    }
-    return (isString(value.name) &&
-        value.name.length > 0 &&
-        isString(value.path) &&
-        value.path.length > 0 &&
-        isString(value.version) &&
-        value.version.length > 0 &&
-        (value.private === undefined || typeof value.private === 'boolean'));
-};
 const hasFailedPnpmResult = (result) => {
     return result.failed === true || result.exitCode !== 0;
 };
@@ -189,10 +151,6 @@ const getPnpmFailureReason = (result) => {
     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.');
-}
 export function hasNpmAuthChallenge(result) {
     const output = [result.stdout, result.stderr]
         .map((value) => String(value ?? ''))

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,14 +1,2 @@
 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;
-    token: string | undefined;
-};
 export declare function runOwnerCli(args: Array<string>): Promise<void>;

package/dist/publish/cli.js

@@ -1,116 +1,37 @@
-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 { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
-import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
+import { createPublishRootEnv } from '#auklet/publish/publishEnv';
 import { findWorkspaceRoot } from '#auklet/workspace/root';
-const publishFlags = new Set([
-    '_',
-    'filter',
-    'version',
-    'dry-run',
-    'format',
-    'git',
-    'otp',
-    'token',
-    'ignore-scripts',
-    'allow-dirty',
-]);
-const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
+import { parseOwnerCommand } from '#auklet/cli/parse/owner';
+import { parsePublishCommand } from '#auklet/cli/parse/publish';
 export async function runPublishCli(args) {
-    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);
-    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),
-    };
-}
-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,
-        },
+    const cwd = process.cwd();
+    const root = findWorkspaceRoot(cwd) ?? cwd;
+    const envContext = new AukletEnvContext(cwd, root);
+    await envContext.run(async () => {
+        const runtime = { envContext };
+        const options = parsePublishCommand(args, { cwd, envContext });
+        const { env } = createPublishRootEnv(options, runtime);
+        validatePublishCliNpmrcAuthEnv(options.cwd, env);
+        await ensurePnpm({ env });
+        await new PublishRunner(options, runtime).run();
     });
-    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'],
-    });
-    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 cwd = process.cwd();
-    validatePublishCliNpmrcAuthEnv(cwd);
-    await ensurePnpm();
-    await new OwnerRunner({
-        cwd,
-        users,
-        filters: toArray(argv.filter),
-        packages: toArray(argv.package),
-        otp: stringOption(argv.otp),
-    }).run();
+    const root = findWorkspaceRoot(cwd) ?? cwd;
+    const envContext = new AukletEnvContext(cwd, root);
+    await envContext.run(async () => {
+        const options = parseOwnerCommand(args, { cwd, envContext });
+        const env = envContext.values;
+        validatePublishCliNpmrcAuthEnv(cwd, env);
+        await ensurePnpm({ env: envContext.normalizedValues });
+        await new OwnerRunner(options).run();
+    });
 }
-const validateFlags = (argv, allowedFlags) => {
-    for (const flag of Object.keys(argv)) {
-        if (!allowedFlags.has(flag)) {
-            throw new Error(`[publish] unknown option: --${flag}`);
-        }
-    }
-};
-const validateNoPrefixedFlags = (args, allowedFlags) => {
-    const flag = args.find((arg) => arg.startsWith('--no-') && !allowedFlags.has(arg));
-    if (flag) {
-        throw new Error(`[publish] unknown option: ${flag}`);
-    }
-};
-const stripLeadingArgsSeparator = (args) => {
-    return args.filter((arg) => arg !== '--');
-};
-const toArray = (value) => {
-    if (value === undefined)
-        return [];
-    return isArray(value)
-        ? value.map(String).filter(Boolean)
-        : [String(value)].filter(Boolean);
-};
-const stringOption = (value) => {
-    if (value === undefined)
-        return undefined;
-    if (isArray(value))
-        return String(value.at(-1));
-    return String(value);
-};
-const validatePublishCliNpmrcAuthEnv = (cwd, token) => {
-    validateNpmrcAuthEnv(cwd, findWorkspaceRoot(cwd) ?? cwd, { token });
+const validatePublishCliNpmrcAuthEnv = (cwd, env) => {
+    validateNpmrcAuthEnv(cwd, findWorkspaceRoot(cwd) ?? cwd, { env });
 };

package/dist/publish/inspect.js

@@ -1,23 +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 { parsePublishCommand } from '#auklet/cli/parse/publish';
 import { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
-import { resolvePublishCliOptions } from '#auklet/publish/cli';
-import { findWorkspaceRoot } from '#auklet/workspace/root';
+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) {
-    const options = resolvePublishCliOptions(args);
-    validateNpmrcAuthEnv(options.cwd, findWorkspaceRoot(options.cwd) ?? options.cwd, {
-        token: options.token,
+    const cwd = process.cwd();
+    const root = findWorkspaceRoot(cwd) ?? cwd;
+    const envContext = new AukletEnvContext(cwd, root);
+    return envContext.run(async () => {
+        const options = parsePublishCommand(args, { cwd, envContext });
+        return runInspectPublish(options, root, { envContext });
     });
-    await ensurePnpm({ token: options.token });
+}
+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) {
@@ -28,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,
+    };
+};