@bobfrankston/npmglobalize 1.0.121 → 1.0.123

package/lib.js

@@ -2998,16 +2998,18 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         console.log('  No file: dependencies found.');
     }
     // Hoist workspace sub-package deps into root for publishing/global install.
-    // npm install -g only installs root-level dependencies, so sub-package deps
-    // like express must be present in the root package.json.
-    // These are added temporarily — restoreDeps removes them via .dependencies backup.
+    // npm install -g only installs root-level dependencies and doesn't process
+    // the workspaces field, so:
+    //   1. Third-party deps (express, ws, etc.) must be in root dependencies
+    //   2. Sibling workspace packages must be in bundledDependencies so npm
+    //      includes them in the tarball's node_modules/
+    // All changes are temporary — restoreDeps removes them via .dependencies backup.
     if (pkg.workspaces) {
         const wsPatterns = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages || [];
         // Collect all workspace sub-package dirs
         const wsDirs = [];
         for (const pattern of wsPatterns) {
             if (pattern.includes('*')) {
-                // Glob pattern like "packages/*" — enumerate subdirectories
                 const baseDir = path.resolve(cwd, pattern.replace(/\/?\*$/, ''));
                 if (!fs.existsSync(baseDir))
                     continue;
@@ -3017,14 +3019,13 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 }
             }
             else {
-                // Direct directory like "client"
                 const dir = path.resolve(cwd, pattern);
                 if (fs.existsSync(dir))
                     wsDirs.push(dir);
             }
         }
-        // Collect all workspace package names (siblings to skip)
-        const wsNames = new Set();
+        // Collect workspace package names and their relative paths
+        const wsPackages = new Map(); // name -> relative dir
         for (const dir of wsDirs) {
             const pkgJsonPath = path.join(dir, 'package.json');
             if (!fs.existsSync(pkgJsonPath))
@@ -3032,11 +3033,11 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
             try {
                 const subPkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
                 if (subPkg.name)
-                    wsNames.add(subPkg.name);
+                    wsPackages.set(subPkg.name, path.relative(cwd, dir).replace(/\\/g, '/'));
             }
             catch { /* skip */ }
         }
-        // Find deps in sub-packages not present in root
+        // Find third-party deps in sub-packages not present in root
         const rootDeps = { ...pkg.dependencies, ...pkg.devDependencies };
         const hoisted = [];
         for (const dir of wsDirs) {
@@ -3052,8 +3053,8 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
             }
             const deps = subPkg.dependencies || {};
             for (const [dep, ver] of Object.entries(deps)) {
-                if (wsNames.has(dep))
-                    continue; // sibling workspace — bundled
+                if (wsPackages.has(dep))
+                    continue; // sibling workspace — handled via bundledDependencies
                 if (dep in rootDeps)
                     continue; // already in root
                 if (hoisted.some(m => m.dep === dep))
@@ -3061,7 +3062,8 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 hoisted.push({ dep, version: ver, from: subPkg.name || path.basename(dir) });
             }
         }
-        if (hoisted.length > 0) {
+        const needsUpdate = hoisted.length > 0 || wsPackages.size > 0;
+        if (needsUpdate) {
             // Ensure .dependencies backup exists so restoreDeps will remove hoisted deps
             if (!pkg['.dependencies']) {
                 pkg['.dependencies'] = { ...(pkg.dependencies || {}) };
@@ -3069,6 +3071,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
             }
             if (!pkg.dependencies)
                 pkg.dependencies = {};
+            // Hoist third-party deps
             for (const m of hoisted) {
                 let version = m.version;
                 if (typeof version === 'string' && version.startsWith('file:')) {
@@ -3225,40 +3228,56 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                         }
                     }
                     else if (install) {
-                        // Quick check: does this version actually exist on npm?
-                        const vCheck = spawnSafe('npm', ['view', `${pkgName}@${pkgVersion}`, 'version'], {
-                            shell: process.platform === 'win32',
-                            stdio: ['pipe', 'pipe', 'pipe'],
-                            encoding: 'utf-8'
-                        });
-                        const vOnNpm = vCheck.status === 0 && vCheck.stdout?.trim() === pkgVersion;
-                        if (vOnNpm) {
-                            console.log(`Installing ${pkgName}@${pkgVersion} globally from registry...`);
-                            const registryInstallResult = installGlobalWithRetry(`${pkgName}@${pkgVersion}`, cwd);
-                            if (registryInstallResult.success) {
+                        // Workspace packages must install from local — npm install -g from
+                        // registry doesn't process workspaces, so sub-packages can't resolve
+                        // sibling imports. Local install handles workspace linking correctly.
+                        if (pkg.workspaces) {
+                            console.log(`Installing ${pkgName}@${pkgVersion} globally from local (workspace)...`);
+                            const localResult = runCommand('npm', ['install', '-g', '.'], { cwd, silent: false, showCommand: true });
+                            if (localResult.success) {
                                 console.log(colors.green(`✓ Installed globally: ${pkgName}@${pkgVersion}`));
                             }
                             else {
                                 console.error(colors.red(`✗ Global install failed`));
-                                console.error(colors.yellow(`  Try running manually: npm install -g ${pkgName}@${pkgVersion}`));
+                                console.error(colors.yellow('  Try running manually: npm install -g .'));
                             }
                         }
                         else {
-                            console.log(colors.yellow(`${pkgName}@${pkgVersion} not found on npm — installing from local directory.`));
-                            console.log(colors.dim('  Use -m "message" to publish this version to npm.'));
-                            const localResult = runCommand('npm', ['install', '-g', '.'], { cwd, silent: false, showCommand: true });
-                            if (localResult.success) {
-                                console.log(colors.green(`✓ Installed globally from local: ${pkgName}@${pkgVersion}`));
+                            // Quick check: does this version actually exist on npm?
+                            const vCheck = spawnSafe('npm', ['view', `${pkgName}@${pkgVersion}`, 'version'], {
+                                shell: process.platform === 'win32',
+                                stdio: ['pipe', 'pipe', 'pipe'],
+                                encoding: 'utf-8'
+                            });
+                            const vOnNpm = vCheck.status === 0 && vCheck.stdout?.trim() === pkgVersion;
+                            if (vOnNpm) {
+                                console.log(`Installing ${pkgName}@${pkgVersion} globally from registry...`);
+                                const registryInstallResult = installGlobalWithRetry(`${pkgName}@${pkgVersion}`, cwd);
+                                if (registryInstallResult.success) {
+                                    console.log(colors.green(`✓ Installed globally: ${pkgName}@${pkgVersion}`));
+                                }
+                                else {
+                                    console.error(colors.red(`✗ Global install failed`));
+                                    console.error(colors.yellow(`  Try running manually: npm install -g ${pkgName}@${pkgVersion}`));
+                                }
                             }
                             else {
-                                console.error(colors.red(`✗ Local install failed`));
-                                console.error(colors.yellow('  Try running manually: npm install -g .'));
+                                console.log(colors.yellow(`${pkgName}@${pkgVersion} not found on npm — installing from local directory.`));
+                                console.log(colors.dim('  Use -m "message" to publish this version to npm.'));
+                                const localResult = runCommand('npm', ['install', '-g', '.'], { cwd, silent: false, showCommand: true });
+                                if (localResult.success) {
+                                    console.log(colors.green(`✓ Installed globally from local: ${pkgName}@${pkgVersion}`));
+                                }
+                                else {
+                                    console.error(colors.red(`✗ Local install failed`));
+                                    console.error(colors.yellow('  Try running manually: npm install -g .'));
+                                }
                             }
                         }
                     }
                     if (wsl) {
-                        // Check if version is on npm for registry-based WSL install
-                        const useLocal = link || (() => {
+                        // Workspace packages must install from local (see above)
+                        const useLocal = link || !!pkg.workspaces || (() => {
                             const vc = spawnSafe('npm', ['view', `${pkgName}@${pkgVersion}`, 'version'], {
                                 shell: process.platform === 'win32',
                                 stdio: ['pipe', 'pipe', 'pipe'],
@@ -3837,28 +3856,49 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
             }
         }
         else if (install) {
-            console.log(`Installing globally from registry: ${pkgName}@${pkgVersion}...`);
-            if (!dryRun) {
-                waitForNpmVersion(pkgName, pkgVersion);
-                const installResult = installGlobalWithRetry(`${pkgName}@${pkgVersion}`, cwd);
-                if (installResult.success) {
-                    globalInstallOk = true;
-                    console.log(colors.green(`✓ Installed globally: ${pkgName}@${pkgVersion}`));
+            if (updatedPkg.workspaces) {
+                // Workspace packages: install from local for proper workspace linking
+                console.log(`Installing ${pkgName}@${pkgVersion} globally from local (workspace)...`);
+                if (!dryRun) {
+                    const installResult = runCommand('npm', ['install', '-g', '.'], { cwd, silent: false, showCommand: true });
+                    if (installResult.success) {
+                        globalInstallOk = true;
+                        console.log(colors.green(`✓ Installed globally: ${pkgName}@${pkgVersion}`));
+                    }
+                    else {
+                        console.error(colors.red(`✗ Global install failed`));
+                        console.error(colors.yellow('  Try running manually: npm install -g .'));
+                    }
                 }
                 else {
-                    console.error(colors.red(`✗ Global install failed`));
-                    console.error(colors.yellow(`  Try running manually: npm install -g ${pkgName}@${pkgVersion}`));
+                    console.log(`  [dry-run] Would run: npm install -g .`);
                 }
             }
             else {
-                console.log(`  [dry-run] Would run: npm install -g ${pkgName}@${pkgVersion}`);
+                console.log(`Installing globally from registry: ${pkgName}@${pkgVersion}...`);
+                if (!dryRun) {
+                    waitForNpmVersion(pkgName, pkgVersion);
+                    const installResult = installGlobalWithRetry(`${pkgName}@${pkgVersion}`, cwd);
+                    if (installResult.success) {
+                        globalInstallOk = true;
+                        console.log(colors.green(`✓ Installed globally: ${pkgName}@${pkgVersion}`));
+                    }
+                    else {
+                        console.error(colors.red(`✗ Global install failed`));
+                        console.error(colors.yellow(`  Try running manually: npm install -g ${pkgName}@${pkgVersion}`));
+                    }
+                }
+                else {
+                    console.log(`  [dry-run] Would run: npm install -g ${pkgName}@${pkgVersion}`);
+                }
             }
         }
         if (wsl) {
-            const wslArgs = link ? ['npm', 'install', '-g', '.'] : ['npm', 'install', '-g', `${pkgName}@${pkgVersion}`];
-            if (!link && !install)
+            const useLocalWsl = link || !!updatedPkg.workspaces;
+            const wslArgs = useLocalWsl ? ['npm', 'install', '-g', '.'] : ['npm', 'install', '-g', `${pkgName}@${pkgVersion}`];
+            if (!useLocalWsl)
                 waitForNpmVersion(pkgName, pkgVersion);
-            console.log(`Installing in WSL${link ? ' (link)' : ' from registry'}: ${pkgName}@${pkgVersion}...`);
+            console.log(`Installing in WSL${useLocalWsl ? ' (local)' : ' from registry'}: ${pkgName}@${pkgVersion}...`);
             if (!dryRun) {
                 const wslResult = runCommand('wsl', wslArgs, { cwd, silent: false, showCommand: true });
                 if (wslResult.success) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.121",
+  "version": "1.0.123",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",