@nocobase/cli 2.1.11-test.1 → 2.1.11-test.11

package/dist/commands/self/update.js

@@ -77,7 +77,7 @@ export default class SelfUpdate extends Command {
                     message: flags.skills
                         ? `Update ${status.packageName} from ${status.currentVersion} to ${status.latestVersion} and refresh the globally installed NocoBase AI coding skills?`
                         : `Update ${status.packageName} from ${status.currentVersion} to ${status.latestVersion}?`,
-                    default: false,
+                    default: true,
                 });
             }
             catch {

package/dist/lib/self-manager.js

@@ -7,14 +7,12 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import fs from 'node:fs';
-import fsp from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { resolveCliHomeDir } from './cli-home.js';
 import { commandOutput, run } from './run-npm.js';
 const DEFAULT_PACKAGE_NAME = '@nocobase/cli';
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const INSTALL_METHOD_CACHE_FILE = 'self-install-methods.json';
 function normalizePath(value) {
     return path.resolve(value);
 }
@@ -119,6 +117,14 @@ function detectInstallMethod(packageRoot, options = {}) {
     if (options.yarnGlobalDir && isSubPath(options.yarnGlobalDir, packageRoot)) {
         return 'yarn-global';
     }
+    if (isPnpmGlobalInstallPath({
+        packageName: options.packageName ?? DEFAULT_PACKAGE_NAME,
+        packageRoot,
+        pnpmGlobalBin: options.pnpmGlobalBin,
+        pnpmGlobalRoot: options.pnpmGlobalRoot,
+    })) {
+        return 'pnpm-global';
+    }
     if (isPnpmGlobalPath(packageRoot)) {
         return 'pnpm-global';
     }
@@ -136,43 +142,157 @@ function isPnpmGlobalPath(packageRoot) {
     }
     return segments.slice(globalIndex + 2).includes('node_modules');
 }
-function getInstallMethodCacheFile() {
-    return path.join(resolveCliHomeDir('global'), INSTALL_METHOD_CACHE_FILE);
+function normalizePnpmGlobalNodeModulesRoot(pnpmGlobalRoot) {
+    const normalizedGlobalRoot = normalizePath(pnpmGlobalRoot);
+    return path.basename(normalizedGlobalRoot) === 'node_modules'
+        ? normalizedGlobalRoot
+        : path.join(normalizedGlobalRoot, 'node_modules');
+}
+function readSiblingPnpmGlobalNodeModulesRoots(pnpmGlobalRoot) {
+    const globalNodeModulesDir = normalizePnpmGlobalNodeModulesRoot(pnpmGlobalRoot);
+    const globalProjectDir = path.dirname(globalNodeModulesDir);
+    let entries;
+    try {
+        entries = fs.readdirSync(globalProjectDir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => {
+        if (entry === path.basename(globalNodeModulesDir)) {
+            return false;
+        }
+        try {
+            return fs.statSync(path.join(globalProjectDir, entry)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })
+        .map((entry) => path.join(globalProjectDir, entry, 'node_modules'));
+}
+function readPnpmGlobalNodeModulesRoots(pnpmGlobalRoot) {
+    return [normalizePnpmGlobalNodeModulesRoot(pnpmGlobalRoot), ...readSiblingPnpmGlobalNodeModulesRoots(pnpmGlobalRoot)];
+}
+function packageNameToPath(packageName) {
+    return packageName.split('/').filter(Boolean);
+}
+function isSameRealPath(left, right) {
+    try {
+        return normalizePath(fs.realpathSync(left)) === normalizePath(fs.realpathSync(right));
+    }
+    catch {
+        return false;
+    }
+}
+function isPnpmGlobalRootPath(pnpmGlobalRoot, packageRoot) {
+    if (isSubPath(pnpmGlobalRoot, packageRoot)) {
+        return true;
+    }
+    const globalNodeModulesDir = normalizePnpmGlobalNodeModulesRoot(pnpmGlobalRoot);
+    const globalProjectDir = path.dirname(globalNodeModulesDir);
+    if (!isSubPath(globalProjectDir, packageRoot)) {
+        return false;
+    }
+    const segments = normalizePath(packageRoot).split(path.sep).filter(Boolean);
+    const pnpmStoreIndex = segments.indexOf('.pnpm');
+    if (pnpmStoreIndex === -1) {
+        return false;
+    }
+    return segments.slice(pnpmStoreIndex + 1).includes('node_modules');
 }
-function getInstallMethodCacheKey(packageRoot) {
-    return normalizePath(path.join(packageRoot, 'bin', 'run.js'));
+function isPnpmGlobalPackagePath(pnpmGlobalRoot, packageRoot, packageName) {
+    return readPnpmGlobalNodeModulesRoots(pnpmGlobalRoot).some((pnpmGlobalNodeModulesRoot) => isSameRealPath(path.join(pnpmGlobalNodeModulesRoot, ...packageNameToPath(packageName)), packageRoot));
 }
-async function readInstallMethodCache() {
+function isPnpmGlobalBinProjectPath(pnpmGlobalBin, packageRoot, packageName) {
+    const pnpmHome = path.dirname(normalizePath(pnpmGlobalBin));
+    const globalDir = path.join(pnpmHome, 'global');
+    if (isSubPath(globalDir, packageRoot)) {
+        return true;
+    }
+    let entries;
     try {
-        const raw = await fsp.readFile(getInstallMethodCacheFile(), 'utf8');
-        return JSON.parse(raw);
+        entries = fs.readdirSync(globalDir);
     }
     catch {
-        return {};
+        return false;
     }
+    return entries.some((entry) => {
+        const pnpmGlobalRoot = path.join(globalDir, entry);
+        return (isPnpmGlobalRootPath(pnpmGlobalRoot, packageRoot)
+            || isPnpmGlobalPackagePath(pnpmGlobalRoot, packageRoot, packageName));
+    });
 }
-async function writeInstallMethodCache(state) {
-    const filePath = getInstallMethodCacheFile();
-    await fsp.mkdir(path.dirname(filePath), { recursive: true });
-    await fsp.writeFile(filePath, JSON.stringify(state, null, 2));
+function isPnpmGlobalInstallPath(options) {
+    if (options.pnpmGlobalRoot) {
+        const matchedRoot = isPnpmGlobalRootPath(options.pnpmGlobalRoot, options.packageRoot)
+            || isPnpmGlobalPackagePath(options.pnpmGlobalRoot, options.packageRoot, options.packageName);
+        if (matchedRoot) {
+            return true;
+        }
+    }
+    if (options.pnpmGlobalBin) {
+        return isPnpmGlobalBinProjectPath(options.pnpmGlobalBin, options.packageRoot, options.packageName);
+    }
+    return false;
 }
-async function readCachedInstallMethod(packageRoot) {
-    const state = await readInstallMethodCache();
-    return state.entries?.[getInstallMethodCacheKey(packageRoot)];
+function readCurrentBinPath(currentBinPath) {
+    const candidate = String(currentBinPath ?? process.argv[1] ?? '').trim();
+    if (!candidate) {
+        return undefined;
+    }
+    return normalizePath(candidate);
 }
-async function writeCachedInstallMethod(packageRoot, entry) {
-    const state = await readInstallMethodCache();
-    const entries = {
-        ...(state.entries ?? {}),
-        [getInstallMethodCacheKey(packageRoot)]: entry,
-    };
-    await writeInstallMethodCache({ entries });
+function cleanCommandPath(value) {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function resolvePackageManagerProbeCwd() {
+    const candidates = [os.homedir(), os.tmpdir(), path.parse(process.cwd()).root];
+    for (const candidate of candidates) {
+        if (!candidate) {
+            continue;
+        }
+        try {
+            if (fs.statSync(candidate).isDirectory()) {
+                return candidate;
+            }
+        }
+        catch {
+            // Ignore invalid probe cwd candidates and continue to the next one.
+        }
+    }
+    return undefined;
 }
 async function readGlobalPrefix(commandOutputFn) {
     try {
-        return (await commandOutputFn('npm', ['prefix', '-g'], {
+        return cleanCommandPath(await commandOutputFn('npm', ['prefix', '-g'], {
+            cwd: resolvePackageManagerProbeCwd(),
             errorName: 'npm prefix',
-        })).trim();
+        }));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readPnpmGlobalBin(commandOutputFn) {
+    try {
+        return cleanCommandPath(await commandOutputFn('pnpm', ['bin', '-g'], {
+            cwd: resolvePackageManagerProbeCwd(),
+            errorName: 'pnpm bin',
+        }));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readPnpmGlobalRoot(commandOutputFn) {
+    try {
+        return cleanCommandPath(await commandOutputFn('pnpm', ['root', '-g'], {
+            cwd: resolvePackageManagerProbeCwd(),
+            errorName: 'pnpm root',
+        }));
     }
     catch {
         return undefined;
@@ -180,9 +300,21 @@ async function readGlobalPrefix(commandOutputFn) {
 }
 async function readYarnGlobalDir(commandOutputFn) {
     try {
-        return (await commandOutputFn('yarn', ['global', 'dir'], {
+        return cleanCommandPath(await commandOutputFn('yarn', ['global', 'dir'], {
+            cwd: resolvePackageManagerProbeCwd(),
             errorName: 'yarn global dir',
-        })).trim();
+        }));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readYarnGlobalBin(commandOutputFn) {
+    try {
+        return cleanCommandPath(await commandOutputFn('yarn', ['global', 'bin'], {
+            cwd: resolvePackageManagerProbeCwd(),
+            errorName: 'yarn global bin',
+        }));
     }
     catch {
         return undefined;
@@ -242,28 +374,45 @@ export function getSelfUpdatePackageSpec(status) {
 }
 export async function inspectSelfInstall(options = {}) {
     const packageRoot = options.packageRoot ? normalizePath(options.packageRoot) : PACKAGE_ROOT;
+    const packageName = options.packageName ?? DEFAULT_PACKAGE_NAME;
     const commandOutputFn = options.commandOutputFn ?? commandOutput;
-    const cachedInstallMethod = await readCachedInstallMethod(packageRoot);
-    const globalPrefix = cachedInstallMethod?.globalPrefix ?? await readGlobalPrefix(commandOutputFn);
-    const yarnGlobalDir = cachedInstallMethod?.yarnGlobalDir ?? await readYarnGlobalDir(commandOutputFn);
-    const installMethod = cachedInstallMethod?.installMethod
-        ?? detectInstallMethod(packageRoot, {
-            globalPrefix,
-            yarnGlobalDir,
-        });
-    if (!cachedInstallMethod) {
-        await writeCachedInstallMethod(packageRoot, {
-            installMethod,
-            globalPrefix,
-            yarnGlobalDir,
-        });
-    }
+    const currentBinPath = readCurrentBinPath(options.currentBinPath);
+    const globalPrefix = await readGlobalPrefix(commandOutputFn);
+    const pnpmGlobalBin = await readPnpmGlobalBin(commandOutputFn);
+    const pnpmGlobalRoot = await readPnpmGlobalRoot(commandOutputFn);
+    const yarnGlobalDir = await readYarnGlobalDir(commandOutputFn);
+    const yarnGlobalBin = await readYarnGlobalBin(commandOutputFn);
+    const installMethod = detectInstallMethodFromSignals({
+        packageRoot,
+        currentBinPath,
+        globalPrefix,
+        packageName,
+        pnpmGlobalBin,
+        pnpmGlobalRoot,
+        yarnGlobalBin,
+        yarnGlobalDir,
+    });
     return {
         packageRoot,
         installMethod,
         globalPrefix,
     };
 }
+function detectInstallMethodFromSignals(options) {
+    if (options.currentBinPath && options.yarnGlobalBin && isSubPath(options.yarnGlobalBin, options.currentBinPath)) {
+        return 'yarn-global';
+    }
+    if (options.currentBinPath && options.pnpmGlobalBin && isSubPath(options.pnpmGlobalBin, options.currentBinPath)) {
+        return 'pnpm-global';
+    }
+    return detectInstallMethod(options.packageRoot, {
+        globalPrefix: options.globalPrefix,
+        packageName: options.packageName,
+        pnpmGlobalBin: options.pnpmGlobalBin,
+        pnpmGlobalRoot: options.pnpmGlobalRoot,
+        yarnGlobalDir: options.yarnGlobalDir,
+    });
+}
 export async function inspectSelfStatus(options = {}) {
     const packageRoot = options.packageRoot ? normalizePath(options.packageRoot) : PACKAGE_ROOT;
     const packageName = options.packageName ?? DEFAULT_PACKAGE_NAME;
@@ -271,6 +420,8 @@ export async function inspectSelfStatus(options = {}) {
     const channel = options.channel && options.channel !== 'auto' ? options.channel : detectChannel(currentVersion);
     const commandOutputFn = options.commandOutputFn ?? commandOutput;
     const { installMethod, globalPrefix } = await inspectSelfInstall({
+        currentBinPath: options.currentBinPath,
+        packageName,
         packageRoot,
         commandOutputFn,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.1.11-test.1",
+  "version": "2.1.11-test.11",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",