@bobfrankston/npmglobalize 1.0.199 → 1.0.201

package/lib/npm.js

@@ -1,306 +0,0 @@
-/**
- * npm registry operations: version checks, access control, authentication, dependency updates
- */
-import path from 'path';
-import { spawnSafe, colors, DEP_KEYS } from './types.js';
-import { isFileRef } from './config.js';
-/** Get the latest version of a package from npm */
-export function getLatestVersion(packageName) {
-    try {
-        const result = spawnSafe('npm', ['view', packageName, 'version'], {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            shell: true // Required on Windows to find npm.cmd
-        });
-        if (result.status === 0 && result.stdout) {
-            return result.stdout.trim();
-        }
-        return null;
-    }
-    catch (error) {
-        return null;
-    }
-}
-/** Check if a specific version of a package exists on npm */
-export function checkVersionExists(packageName, version) {
-    try {
-        const result = spawnSafe('npm', ['view', `${packageName}@${version}`, 'version'], {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            shell: true // Required on Windows to find npm.cmd
-        });
-        return result.status === 0 && result.stdout.trim() === version;
-    }
-    catch (error) {
-        return false;
-    }
-}
-/** Check if a package exists on npm (any version) */
-export function checkPackageExists(packageName) {
-    try {
-        const result = spawnSafe('npm', ['view', packageName, 'version'], {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            shell: true // Required on Windows to find npm.cmd
-        });
-        return result.status === 0 && result.stdout.trim().length > 0;
-    }
-    catch (error) {
-        return false;
-    }
-}
-/** Check npm package access level (public/restricted/null if not published) */
-export function checkNpmAccess(packageName) {
-    try {
-        // For scoped packages, use npm access to check actual access level
-        if (packageName.startsWith('@')) {
-            // First check if the package actually exists on npm
-            // npm access returns read-write for unpublished packages in owned scopes
-            const viewResult = spawnSafe('npm', ['view', packageName, 'name'], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-                shell: true
-            });
-            if (viewResult.status === 0 && viewResult.stdout && viewResult.stdout.trim()) {
-                // Package exists - check public/private status
-                const accessResult = spawnSafe('npm', ['access', 'get', 'status', packageName], {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                    shell: true
-                });
-                if (accessResult.status === 0 && accessResult.stdout) {
-                    const output = accessResult.stdout.trim();
-                    if (output.includes('public')) {
-                        return 'public';
-                    }
-                }
-                return 'restricted'; // Exists but not publicly accessible
-            }
-            // Package not viewable - check if it's restricted or unpublished
-            const checkResult = spawnSafe('npm', ['view', packageName, '--json'], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-                shell: true
-            });
-            if (checkResult.status !== 0) {
-                // Check if it's a 404 (not found) vs 401/403 (restricted)
-                const stderr = checkResult.stderr || '';
-                if (stderr.includes('404') || stderr.includes('not found')) {
-                    return null; // Not published
-                }
-                return 'restricted'; // Exists but restricted
-            }
-            return 'restricted'; // Default for scoped
-        }
-        else {
-            // Unscoped packages are always public if they exist — but only if we own them
-            const result = spawnSafe('npm', ['view', packageName, 'name'], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-                shell: true
-            });
-            if (result.status === 0 && result.stdout && result.stdout.trim()) {
-                // Package exists on npm — check if current user is a maintainer
-                const maintResult = spawnSafe('npm', ['view', packageName, 'maintainers', '--json'], {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                    shell: true
-                });
-                if (maintResult.status === 0 && maintResult.stdout) {
-                    const auth = checkNpmAuth();
-                    if (auth.username) {
-                        try {
-                            const maintainers = JSON.parse(maintResult.stdout.trim());
-                            const names = Array.isArray(maintainers)
-                                ? maintainers.map((m) => typeof m === 'string' ? m.replace(/ <.*/, '') : m.name)
-                                : [];
-                            if (!names.includes(auth.username)) {
-                                return null; // Exists but we don't own it
-                            }
-                        }
-                        catch {
-                            // Parse failed — fall through to return public
-                        }
-                    }
-                }
-                return 'public';
-            }
-            return null;
-        }
-    }
-    catch (error) {
-        return null;
-    }
-}
-/** Check if public package has private/inaccessible dependencies */
-export function checkPrivateDependencies(pkg, verbose = false) {
-    const privateDeps = [];
-    for (const depType of DEP_KEYS) {
-        if (!pkg[depType])
-            continue;
-        for (const [name, value] of Object.entries(pkg[depType])) {
-            // Skip file: references - those are handled separately
-            if (isFileRef(value))
-                continue;
-            // Check if this dependency is publicly accessible
-            if (!checkPackageExists(name)) {
-                privateDeps.push({ name, depType });
-                if (verbose) {
-                    console.log(`  Checking ${name}... not publicly accessible`);
-                }
-            }
-            else if (verbose) {
-                console.log(`  Checking ${name}... ok`);
-            }
-        }
-    }
-    return privateDeps;
-}
-/** Parse semver version string to major.minor.patch */
-function parseSemver(version) {
-    const clean = version.replace(/^[^\d]*/, ''); // Remove ^, ~, etc.
-    const match = clean.match(/^(\d+)\.(\d+)\.(\d+)/);
-    if (!match)
-        return null;
-    return {
-        major: parseInt(match[1], 10),
-        minor: parseInt(match[2], 10),
-        patch: parseInt(match[3], 10)
-    };
-}
-/** Check if update is within semver range (^1.0.0 allows minor/patch, not major) */
-function isCompatibleUpdate(currentSpec, latestVersion) {
-    const current = parseSemver(currentSpec);
-    const latest = parseSemver(latestVersion);
-    if (!current || !latest) {
-        return { compatible: true, isMajor: false }; // Can't parse, allow update
-    }
-    const isMajor = latest.major > current.major;
-    const prefix = currentSpec.match(/^[^\d]*/) ? currentSpec.match(/^[^\d]*/)[0] : '^';
-    // ^ allows minor and patch updates within same major version
-    // ~ allows only patch updates
-    if (prefix === '^') {
-        return { compatible: !isMajor, isMajor };
-    }
-    else if (prefix === '~') {
-        return { compatible: latest.major === current.major && latest.minor === current.minor, isMajor };
-    }
-    // For exact versions or other formats, allow all updates
-    return { compatible: true, isMajor };
-}
-/** Update existing npm dependencies to latest versions */
-export function updateNpmDeps(pkg, verbose = false, allowMajor = false) {
-    const changes = [];
-    const majorAvailable = [];
-    let updated = false;
-    for (const key of DEP_KEYS) {
-        if (!pkg[key])
-            continue;
-        for (const [name, value] of Object.entries(pkg[key])) {
-            // Skip file: references - those are handled separately
-            if (isFileRef(value))
-                continue;
-            // Get current and latest versions
-            const currentSpec = value;
-            const latest = getLatestVersion(name);
-            if (latest) {
-                const { compatible, isMajor } = isCompatibleUpdate(currentSpec, latest);
-                const newSpec = '^' + latest;
-                if (currentSpec !== newSpec) {
-                    if (isMajor && !allowMajor) {
-                        // Major update available but not allowed
-                        majorAvailable.push({ name, current: currentSpec, latest: newSpec });
-                        if (verbose) {
-                            console.log(colors.yellow(`  ${name}: ${currentSpec} (major update ${newSpec} available, use --update-major)`));
-                        }
-                    }
-                    else if (compatible || allowMajor) {
-                        // Safe update or major updates allowed
-                        pkg[key][name] = newSpec;
-                        changes.push(`${name}: ${currentSpec} → ${newSpec}`);
-                        if (isMajor) {
-                            console.log(colors.red(`  ${name}: ${currentSpec} → ${newSpec} (MAJOR)`));
-                        }
-                        else {
-                            console.log(colors.yellow(`  ${name}: ${currentSpec} → ${newSpec}`));
-                        }
-                        updated = true;
-                    }
-                }
-                else if (verbose) {
-                    console.log(colors.green(`  ${name}: ${currentSpec} is up to date`));
-                }
-            }
-            else if (verbose) {
-                console.log(colors.italic(`  ${name}: couldn't check npm registry`));
-            }
-        }
-    }
-    return { updated, changes, majorAvailable };
-}
-/** Check npm authentication status */
-export function checkNpmAuth() {
-    try {
-        // Must use shell:true on Windows to find npm.cmd in PATH
-        // Must pass env: process.env to inherit NPM_TOKEN environment variable
-        const result = spawnSafe('npm', ['whoami'], {
-            encoding: 'utf-8',
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: process.env,
-            shell: true
-        });
-        if (result.status === 0 && result.stdout && result.stdout.trim()) {
-            return { authenticated: true, username: result.stdout.trim() };
-        }
-        // Parse error message to determine the issue
-        const stderr = (result.stderr || '').toLowerCase();
-        if (stderr.includes('code eneedauth') || stderr.includes('not logged in')) {
-            return { authenticated: false, error: 'not logged in' };
-        }
-        else if (stderr.includes('token') && (stderr.includes('expired') || stderr.includes('revoked'))) {
-            return { authenticated: false, error: 'token expired' };
-        }
-        else if (stderr) {
-            return { authenticated: false, error: 'unknown auth error' };
-        }
-        else {
-            // npm whoami failed but with no stderr - likely auth issue
-            return { authenticated: false, error: 'not logged in' };
-        }
-    }
-    catch (error) {
-        return { authenticated: false, error: error.message };
-    }
-}
-/** Get authentication setup instructions */
-function getAuthInstructions() {
-    const npmrcPath = path.join(process.env.USERPROFILE || process.env.HOME || '~', '.npmrc');
-    return `
-Authentication Options:
-
-1. ${colors.yellow('Create a Granular Access Token')} (recommended):
-   - Go to: https://www.npmjs.com/settings/[username]/tokens
-   - Click "Generate New Token" → "Granular Access Token"
-   - Set permissions: ${colors.green('Read and write')} for packages
-   - Enable: ${colors.green('Bypass 2FA requirement')} (if available)
-   - Copy the token and save it securely
-
-2. ${colors.yellow('Set token via environment variable')}:
-   - Set: ${colors.green('NPM_TOKEN=npm_xxx...')}
-   - Or run: ${colors.green('$env:NPM_TOKEN="npm_xxx..."')} (PowerShell)
-
-3. ${colors.yellow('Set token in .npmrc')}:
-   - Edit: ${colors.green(npmrcPath)}
-   - Add: ${colors.green('//registry.npmjs.org/:_authToken=npm_xxx...')}
-
-4. ${colors.yellow('Use classic login')} (may require 2FA):
-   - Run: ${colors.green('npm login')}
-   - Follow interactive prompts
-
-${colors.italic('Note: y:\\dev\\utils\\npmglobalize has set-npm-token.ps1 that may help fix token')}
-${colors.italic('      problems, but no promises.')}
-
-Note: npm now requires either 2FA or a granular token with bypass enabled.
-`;
-}
-//# sourceMappingURL=npm.js.map

package/lib/types.d.ts

@@ -1,135 +0,0 @@
-/**
- * npmglobalize shared types, constants, and utility functions.
- * Leaf module — no internal dependencies.
- */
-import { type SpawnSyncOptions, type SpawnSyncReturns } from 'child_process';
-/** Wrapper for spawnSync that avoids DEP0190 (args + shell: true).
- *  When shell is true, joins cmd+args into a single command string. */
-export declare function spawnSafe(cmd: string, args: string[], options?: SpawnSyncOptions): SpawnSyncReturns<string>;
-/** Semantic color functions — adapts to terminal light/dark theme */
-export declare const colors: import("@bobfrankston/themecolors").SemanticColors;
-/** Get npm command for current platform (npm.cmd on Windows, npm elsewhere) */
-export declare function getNpmCommand(): string;
-/** Options for the globalize operation */
-export interface GlobalizeOptions {
-    /** Bump type: patch (default), minor, major */
-    bump?: 'patch' | 'minor' | 'major';
-    /** Just transform, don't publish */
-    noPublish?: boolean;
-    /** Restore from .dependencies */
-    cleanup?: boolean;
-    /** Global install after publish (from registry) */
-    install?: boolean;
-    /** Global install via symlink (npm install -g .) */
-    link?: boolean;
-    /** Also install in WSL */
-    wsl?: boolean;
-    /** Continue despite git errors */
-    force?: boolean;
-    /** Keep file: paths after publish (default true) */
-    files?: boolean;
-    /** Show what would happen */
-    dryRun?: boolean;
-    /** Suppress npm warnings (default true) */
-    quiet?: boolean;
-    /** Show verbose output */
-    verbose?: boolean;
-    /** Initialize git/npm if needed */
-    init?: boolean;
-    /** Git visibility: private (default) or public */
-    gitVisibility?: 'private' | 'public';
-    /** npm visibility: private (default) or public */
-    npmVisibility?: 'private' | 'public';
-    /** Custom commit message */
-    message?: string;
-    /** Check and update ignore files to conform to best practices */
-    conform?: boolean;
-    /** Keep ignore files as-is without checking */
-    asis?: boolean;
-    /** Check and update existing npm dependencies to latest versions */
-    updateDeps?: boolean;
-    /** Allow major version updates (breaking changes) */
-    updateMajor?: boolean;
-    /** Publish file: dependencies before converting them */
-    publishDeps?: boolean;
-    /** Auto-yes to dep-cascade prompts (add scope for private); does NOT auto-yes public prompts */
-    publishDepsYes?: boolean;
-    /** Cascade npmVisibility:"public" to all transitive workspace/file: deps without prompting. */
-    publicDeps?: boolean;
-    /** Skip the upfront dep-graph prescan */
-    noPrescan?: boolean;
-    /** Force republish dependencies even if version exists on npm */
-    forcePublish?: boolean;
-    /** Run npm audit and fix vulnerabilities */
-    fix?: boolean;
-    /** Automatically fix version/tag mismatches */
-    fixTags?: boolean;
-    /** Automatically rebase if local is behind remote */
-    rebase?: boolean;
-    /** Show package.json dependency changes */
-    show?: boolean;
-    /** Filter to specific workspace packages (by name or dir name) */
-    workspaceFilter?: string[];
-    /** Disable workspace mode even at a workspace root */
-    noWorkspace?: boolean;
-    /** Continue processing remaining packages if one fails (workspace mode) */
-    continueOnError?: boolean;
-    /** Update package.json scripts to use npmglobalize */
-    package?: boolean;
-    /** Don't persist CLI flags to .globalize.json5 */
-    once?: boolean;
-    /** Run importgen to update import maps before publishing */
-    importgen?: boolean;
-    /** Use filesystem paths for `file:` deps (default true). Set false to
-     *  mark a package as publishable/installable even when sibling checkouts
-     *  are absent. Currently declarative (recorded in config and displayed);
-     *  the actual conversion path is TODO. */
-    usePaths?: boolean;
-    /** Local install only — skip transform/publish, just npm install -g . */
-    local?: boolean;
-    /** Freeze node_modules: replace symlinks/junctions with real copies for network share use */
-    freeze?: boolean;
-    /** Before `npm pack`, delete `node_modules/` inside each `file:` dep target.
-     *  Works around arborist crashes when siblings have nested node_modules. */
-    cleanNestedModules?: boolean;
-    /** Internal: signals this call is from workspace orchestrator */
-    _fromWorkspace?: boolean;
-    /** Internal: signals this call is from CLI (version already printed) */
-    _fromCli?: boolean;
-    /** Internal: tracks which options were explicitly set on the CLI */
-    explicitKeys?: Set<string>;
-}
-/** Result from a single package in workspace mode */
-export interface WorkspacePackageResult {
-    name: string;
-    dir: string;
-    success: boolean;
-    version?: string;
-    error?: string;
-}
-/** Aggregate result from workspace orchestration */
-export interface WorkspaceResult {
-    success: boolean;
-    packages: WorkspacePackageResult[];
-    publishOrder: string[];
-}
-export declare const DEP_KEYS: string[];
-/** Git status checks */
-export interface GitStatus {
-    isRepo: boolean;
-    hasRemote: boolean;
-    hasUncommitted: boolean;
-    hasUnpushed: boolean;
-    hasMergeConflict: boolean;
-    isDetachedHead: boolean;
-    currentBranch: string;
-    remoteBranch: string;
-    isBehindRemote: boolean;
-}
-/** Prompt user for confirmation */
-export declare function confirm(message: string, defaultYes?: boolean): Promise<boolean>;
-/** Prompt user for free text input */
-export declare function promptText(message: string, defaultValue?: string): Promise<string>;
-/** Prompt user for multiple choice */
-export declare function promptChoice(message: string, choices: string[]): Promise<string | null>;
-//# sourceMappingURL=types.d.ts.map

package/lib/types.js

@@ -1,80 +0,0 @@
-/**
- * npmglobalize shared types, constants, and utility functions.
- * Leaf module — no internal dependencies.
- */
-import { spawnSync } from 'child_process';
-import { themeColors } from '@bobfrankston/themecolors';
-import readline from 'readline';
-/** Wrapper for spawnSync that avoids DEP0190 (args + shell: true).
- *  When shell is true, joins cmd+args into a single command string. */
-export function spawnSafe(cmd, args, options = {}) {
-    const opts = { ...options, encoding: 'utf-8' };
-    if (opts.shell && args.length > 0) {
-        // Join into a single command string to avoid DEP0190
-        const cmdStr = [cmd, ...args].map(a => /[\s"&|<>^]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a).join(' ');
-        return spawnSync(cmdStr, opts);
-    }
-    return spawnSync(cmd, args, opts);
-}
-/** Semantic color functions — adapts to terminal light/dark theme */
-export const colors = themeColors();
-/** Get npm command for current platform (npm.cmd on Windows, npm elsewhere) */
-export function getNpmCommand() {
-    return process.platform === 'win32' ? 'npm.cmd' : 'npm';
-}
-export const DEP_KEYS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
-/** Prompt user for confirmation */
-export async function confirm(message, defaultYes = false) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    const suffix = defaultYes ? '[Y/n]' : '[y/N]';
-    return new Promise((resolve) => {
-        rl.question(`${message} ${suffix} `, (answer) => {
-            rl.close();
-            const a = answer.trim().toLowerCase();
-            if (a === '') {
-                resolve(defaultYes);
-            }
-            else {
-                resolve(a === 'y' || a === 'yes');
-            }
-        });
-    });
-}
-/** Prompt user for free text input */
-export async function promptText(message, defaultValue) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    const suffix = defaultValue ? ` [${defaultValue}]` : '';
-    return new Promise((resolve) => {
-        rl.question(`${message}${suffix} `, (answer) => {
-            rl.close();
-            const a = answer.trim();
-            resolve(a || defaultValue || '');
-        });
-    });
-}
-/** Prompt user for multiple choice */
-export async function promptChoice(message, choices) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    return new Promise((resolve) => {
-        rl.question(`${message} `, (answer) => {
-            rl.close();
-            const a = answer.trim().toLowerCase();
-            if (choices.includes(a)) {
-                resolve(a);
-            }
-            else {
-                resolve(null);
-            }
-        });
-    });
-}
-//# sourceMappingURL=types.js.map