auklet 0.1.0 → 0.1.2

package/dist/css/watch/watcher.js

@@ -3,69 +3,112 @@ import path from 'node:path';
 import chokidar from 'chokidar';
 import { isString } from 'aidly';
 import { aukletConfigFiles, aukletDefaultOptions, isAukletConfigFile, } from '#auklet/config';
-import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
+import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { ModuleStyleBuilder } from '#auklet/css/production/builder';
+import { createAukletLogger } from '#auklet/logger';
+const errorLogInterval = 2_000;
 export class ModuleStyleWatcher {
-    config;
     context;
+    config;
+    logger;
     timer = null;
+    closed = false;
     isBuilding = false;
     shouldRebuild = false;
     watcher = null;
-    constructor(context = {}, config = moduleStyleBuildConfig) {
-        this.config = config;
+    lastErrorLogTimes = new Map();
+    constructor(context = {}, config = moduleStyleBuildConfig, logger = null) {
         this.context = {
             packageRoot: process.cwd(),
             ...context,
         };
+        this.config = config;
+        this.logger = logger ?? createAukletLogger({ scope: 'css' });
     }
     async watch() {
+        if (this.closed)
+            return;
         await this.rebuild();
     }
     async rebuild() {
+        if (this.closed)
+            return;
         if (this.isBuilding) {
             this.shouldRebuild = true;
             return;
         }
         this.isBuilding = true;
         try {
-            const builder = new ModuleStyleBuilder(this.context, this.config);
-            await builder.build();
-            await this.refreshWatcher();
-        }
-        catch (error) {
-            // Watch mode keeps running after transient build or watcher errors.
+            try {
+                const builder = new ModuleStyleBuilder(this.context, this.config);
+                await builder.build();
+            }
+            catch (error) {
+                this.logError('build', 'CSS build failed; waiting for changes.', error);
+            }
+            if (!this.closed) {
+                try {
+                    await this.refreshWatcher();
+                }
+                catch (error) {
+                    this.logError('watch-refresh', 'CSS watcher failed; waiting for changes.', error);
+                }
+            }
         }
         finally {
             this.isBuilding = false;
-            if (this.shouldRebuild) {
+            if (this.shouldRebuild && !this.closed) {
                 this.shouldRebuild = false;
                 this.scheduleBuild();
             }
         }
     }
     async refreshWatcher() {
+        if (this.closed)
+            return;
         const aukletConfig = this.context.aukletConfig ?? {};
         const sourceDir = this.context.source ?? aukletConfig.source ?? aukletDefaultOptions.source;
         const sourceRoot = path.join(this.context.packageRoot, sourceDir);
         const configPaths = aukletConfigFiles.map((file) => path.join(this.context.packageRoot, file));
         const watchPaths = [sourceRoot, ...configPaths].filter((file) => fs.existsSync(file));
-        await this.watcher?.close();
+        const previousWatcher = this.watcher;
+        this.watcher = null;
+        await previousWatcher?.close();
+        if (this.closed)
+            return;
         this.watcher = chokidar.watch(watchPaths, {
             ignoreInitial: true,
             interval: 300,
             usePolling: true,
         });
         this.watcher.on('all', (_event, file) => {
+            if (this.closed)
+                return;
             if (isString(file) && !this.shouldRebuildForFile(file)) {
                 return;
             }
             this.scheduleBuild();
         });
-        this.watcher.on('error', () => undefined);
+        this.watcher.on('error', (error) => {
+            if (this.closed)
+                return;
+            this.logError('watch-event', 'CSS watcher error; waiting for changes.', error);
+            this.scheduleBuild();
+        });
+    }
+    logError(kind, message, error) {
+        const now = Date.now();
+        const lastLogTime = this.lastErrorLogTimes.get(kind) ?? 0;
+        if (now - lastLogTime < errorLogInterval)
+            return;
+        this.lastErrorLogTimes.set(kind, now);
+        this.logger.error(message);
+        this.logger.error(error);
     }
     scheduleBuild() {
+        if (this.closed)
+            return;
         if (this.timer)
             clearTimeout(this.timer);
         this.timer = setTimeout(() => {
@@ -81,8 +124,14 @@ export class ModuleStyleWatcher {
         return this.config.styleExtensions.includes(path.extname(file));
     }
     async close() {
-        if (this.timer)
+        this.closed = true;
+        this.shouldRebuild = false;
+        if (this.timer) {
             clearTimeout(this.timer);
-        await this.watcher?.close();
+            this.timer = null;
+        }
+        const watcher = this.watcher;
+        this.watcher = null;
+        await watcher?.close();
     }
 }

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

@@ -1,3 +1,4 @@
+import { execa, type Options } from 'execa';
 import type { WorkspacePackage } from '#auklet/publish/types';
 export declare class NpmPublishAuthenticationError extends Error {
     readonly packageRoot: string;
@@ -6,21 +7,32 @@ export declare class NpmPublishAuthenticationError extends Error {
 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 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

@@ -17,15 +17,43 @@ export class NpmPackageVersionExistsError extends Error {
     }
 }
 const runPnpm = async (args, options = {}) => {
-    return execa('pnpm', args, {
+    const timeout = options.timeout;
+    const subprocess = execa('pnpm', args, {
         reject: false,
         ...options,
+        timeout: undefined,
     });
+    if (!timeout)
+        return subprocess;
+    return withPnpmTimeout(subprocess, timeout);
 };
+export async function withPnpmTimeout(subprocess, timeout) {
+    let timeoutId = null;
+    const result = await Promise.race([
+        subprocess,
+        new Promise((resolve) => {
+            timeoutId = setTimeout(() => {
+                const error = new Error(`pnpm command timed out after ${timeout}ms.`);
+                subprocess.kill('SIGKILL', error);
+                resolve({
+                    failed: true,
+                    timedOut: true,
+                    exitCode: undefined,
+                    stdout: '',
+                    stderr: error.message,
+                });
+            }, timeout);
+        }),
+    ]);
+    if (timeoutId)
+        clearTimeout(timeoutId);
+    subprocess.catch(() => { });
+    return result;
+}
 export async function ensurePnpm() {
     const result = await runPnpm(['--version']);
     const stdout = String(result.stdout ?? '');
-    if (result.failed || !stdout) {
+    if (hasFailedPnpmResult(result) || !stdout) {
         throw new Error('[publish] pnpm is required for publishing.\n' +
             '[publish] Install pnpm first:\n' +
             '  corepack enable\n' +
@@ -57,19 +85,20 @@ export async function runPnpmBuild(packageRoot) {
         cwd: packageRoot,
         stdio: 'inherit',
     });
-    if (result.exitCode) {
+    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)
         writeProcessOutput(result);
-    if (result.exitCode) {
+    if (hasFailedPnpmResult(result)) {
         if (hasNpmAuthChallenge(result)) {
             throw new NpmPublishAuthenticationError(packageRoot);
         }
@@ -82,12 +111,16 @@ 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 (result.exitCode) {
+    if (hasFailedPnpmResult(result)) {
         const target = options.packageName ? ` for ${options.packageName}` : '';
         const registry = options.registry ? ` at ${options.registry}` : '';
+        const reason = getPnpmFailureReason(result);
         throw new Error(`[publish] npm authentication is required${target}${registry} before publishing.\n` +
-            '[publish] Run `pnpm login` or configure an npm token before retrying.');
+            '[publish] Run `pnpm login` or configure an npm token before retrying.' +
+            (reason ? `\n[publish] Reason: ${reason}` : ''));
     }
     return String(result.stdout ?? '').trim();
 }
@@ -97,12 +130,17 @@ 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 (!result.exitCode)
+    if (!hasFailedPnpmResult(result)) {
         return String(result.stdout ?? '').trim() === version;
+    }
     if (isPackageNotFound(result))
         return false;
-    throw new Error(`[publish] failed to check published version for ${packageName}@${version}.`);
+    const reason = getPnpmFailureReason(result);
+    throw new Error(`[publish] failed to check published version for ${packageName}@${version}.` +
+        (reason ? `\n[publish] Reason: ${reason}` : ''));
 }
 export async function runPnpmOwnerAdd(packageName, user, options) {
     const args = ['owner', 'add', user, packageName];
@@ -112,10 +150,18 @@ export async function runPnpmOwnerAdd(packageName, user, options) {
         cwd: options.cwd,
         stdio: 'inherit',
     });
-    if (result.exitCode) {
+    if (hasFailedPnpmResult(result)) {
         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;
@@ -128,6 +174,16 @@ const isWorkspacePackage = (value) => {
         value.version.length > 0 &&
         (value.private === undefined || typeof value.private === 'boolean'));
 };
+const hasFailedPnpmResult = (result) => {
+    return result.failed === true || result.exitCode !== 0;
+};
+const getPnpmFailureReason = (result) => {
+    const stderr = String(result.stderr ?? '').trim();
+    if (stderr)
+        return stderr;
+    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.');

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/api/publishArgs.d.ts

@@ -1,2 +1,3 @@
 import type { PublishOptions, PublishTarget } from '#auklet/publish/types';
 export declare function createPublishArgs(target: PublishTarget, options: PublishOptions): string[];
+export declare function resolvePublishTag(versionSpec?: string): "alpha" | "beta" | null;

package/dist/publish/api/publishArgs.js

@@ -8,7 +8,7 @@ export function createPublishArgs(target, options) {
         args.push('--ignore-scripts');
     if (shouldAddPublicAccess(target))
         args.push('--access', 'public');
-    const tag = getPublishTag(options.version);
+    const tag = resolvePublishTag(options.version);
     if (tag)
         args.push('--tag', tag);
     return args;
@@ -18,8 +18,8 @@ const shouldAddPublicAccess = (target) => {
         !target.private &&
         !target.packageJson.publishConfig?.access);
 };
-const getPublishTag = (versionSpec) => {
+export function resolvePublishTag(versionSpec) {
     if (versionSpec === 'alpha' || versionSpec === 'beta')
         return versionSpec;
     return null;
-};
+}

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

@@ -0,0 +1 @@
+export declare function getPublishRegistry(publishConfig: unknown): string | undefined;

package/dist/publish/api/registry.js

@@ -0,0 +1,7 @@
+import { isPlainObject, isString } from 'aidly';
+export function getPublishRegistry(publishConfig) {
+    if (!isPlainObject(publishConfig))
+        return undefined;
+    const registry = Reflect.get(publishConfig, 'registry');
+    return isString(registry) && registry.length > 0 ? registry : undefined;
+}

package/dist/publish/cli.d.ts

@@ -1,2 +1,14 @@
 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

@@ -11,28 +11,22 @@ const publishFlags = new Set([
     'format',
     'git',
     'otp',
+    'token',
     'ignore-scripts',
     'allow-dirty',
 ]);
 const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
 export async function runPublishCli(args) {
-    const cliArgs = stripLeadingArgsSeparator(args);
-    validateNoPrefixedFlags(cliArgs, new Set(['--no-format', '--no-git']));
-    const argv = minimist(cliArgs, {
-        string: ['filter', 'version', 'otp'],
-        boolean: ['dry-run', 'format', 'git', 'ignore-scripts', 'allow-dirty'],
-        default: {
-            git: true,
-            format: true,
-        },
-    });
-    validateFlags(argv, publishFlags);
+    await ensurePnpm();
+    await new PublishRunner(resolvePublishCliOptions(args)).run();
+}
+export function resolvePublishCliOptions(args, cwd = process.cwd()) {
+    const argv = parsePublishArgs(args);
     if (argv._.length) {
         throw new Error(`[publish] unknown publish argument: ${argv._.join(' ')}`);
     }
-    await ensurePnpm();
-    await new PublishRunner({
-        cwd: process.cwd(),
+    return {
+        cwd,
         otp: stringOption(argv.otp),
         filters: toArray(argv.filter),
         version: stringOption(argv.version),
@@ -41,8 +35,23 @@ export async function runPublishCli(args) {
         dryRun: argv['dry-run'] === true,
         allowDirty: argv['allow-dirty'] === true,
         ignoreScripts: argv['ignore-scripts'] === true,
-    }).run();
+        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,
+        },
+    });
+    validateFlags(argv, publishFlags);
+    return argv;
+};
 export async function runOwnerCli(args) {
     const cliArgs = stripLeadingArgsSeparator(args);
     validateNoPrefixedFlags(cliArgs, new Set());

package/dist/publish/inspect.d.ts

@@ -0,0 +1,29 @@
+import { type PublishRegistryCheck } from '#auklet/publish/inspectRegistry';
+import { type PackFileCheck } from '#auklet/publish/inspectPack';
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+export declare function runInspectPublishCli(args: Array<string>): Promise<0 | 1>;
+export declare function createPublishInspectModel(options: PublishOptions, plan: PublishPlan, packageFileChecks?: Array<PackFileCheck>, registryChecks?: Array<PublishRegistryCheck>): {
+    details: {
+        mode: "monorepo" | "single";
+        publish: string;
+        packages: number;
+        version: string;
+        tag: string;
+        git: string;
+        format: string;
+        root: string;
+    };
+    packageFileChecks: PackFileCheck[];
+    targets: {
+        packageName: string;
+        version: string;
+        publishVersion: string;
+        registry: string;
+        access: string;
+    }[];
+    registryChecks: PublishRegistryCheck[];
+    hooks: {
+        name: string;
+        configured: boolean;
+    }[];
+};