@nocobase/cli 2.1.0-alpha.25 → 2.1.0-alpha.27

package/dist/lib/env-config.js

@@ -0,0 +1,80 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+const STRING_ENV_CONFIG_KEYS = [
+    'source',
+    'downloadVersion',
+    'dockerRegistry',
+    'dockerPlatform',
+    'gitUrl',
+    'npmRegistry',
+    'appRootPath',
+    'storagePath',
+    'appPort',
+    'appKey',
+    'timezone',
+    'dbDialect',
+    'builtinDbImage',
+    'dbHost',
+    'dbPort',
+    'dbDatabase',
+    'dbUser',
+    'dbPassword',
+    'rootUsername',
+    'rootEmail',
+    'rootPassword',
+    'rootNickname',
+];
+const BOOLEAN_ENV_CONFIG_KEYS = [
+    'builtinDb',
+    'devDependencies',
+    'build',
+    'buildDts',
+];
+function trimConfigValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function resolveEnvKind(input) {
+    const source = trimConfigValue(input.source);
+    const appRootPath = trimConfigValue(input.appRootPath);
+    if (source === 'docker') {
+        return 'docker';
+    }
+    if (source === 'npm' || source === 'git' || source === 'local' || appRootPath) {
+        return 'local';
+    }
+    return 'http';
+}
+export function buildStoredEnvConfig(input) {
+    const envConfig = {
+        kind: resolveEnvKind(input),
+        apiBaseUrl: trimConfigValue(input.apiBaseUrl) ?? '',
+    };
+    for (const key of STRING_ENV_CONFIG_KEYS) {
+        const value = trimConfigValue(input[key]);
+        if (value) {
+            envConfig[key] = value;
+        }
+    }
+    for (const key of BOOLEAN_ENV_CONFIG_KEYS) {
+        const value = input[key];
+        if (typeof value === 'boolean') {
+            envConfig[key] = value;
+        }
+    }
+    if (input.builtinDb === false) {
+        envConfig.builtinDbImage = undefined;
+    }
+    const authType = trimConfigValue(input.authType);
+    const accessToken = trimConfigValue(input.accessToken);
+    if (authType === 'token' && accessToken) {
+        envConfig.accessToken = accessToken;
+    }
+    return envConfig;
+}

package/dist/lib/generated-command.js

@@ -1,3 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
 /**
  * This file is part of the NocoBase (R) project.
  * Copyright (c) 2020-2024 NocoBase Co., Ltd.
@@ -12,7 +20,10 @@ import { applyPostProcessor } from './post-processors.js';
 import { registerPostProcessors } from '../post-processors/index.js';
 function buildParameterFlag(parameter, options) {
     const hints = [parameter.in];
-    if (parameter.type === 'object' || parameter.type === 'array' || parameter.jsonEncoded) {
+    if (parameter.isFile) {
+        hints.push('file path');
+    }
+    else if (parameter.type === 'object' || parameter.type === 'array' || parameter.jsonEncoded) {
         hints.push('JSON');
     }
     else if (parameter.isArray) {
@@ -67,10 +78,10 @@ export function createGeneratedFlags(operation) {
             // Body flags are an alternative authoring path to --body/--body-file.
             // Enforce required body semantics later in parseBody(), after we know
             // which input mode the user chose.
-            required: parameter.in === 'body' ? false : parameter.required,
+            required: parameter.in === 'body' && !parameter.isFile ? false : parameter.required,
         });
     }
-    if (operation.hasBody) {
+    if (operation.hasBody && operation.requestContentType !== 'multipart/form-data') {
         flags.body = Flags.string({
             description: 'Full JSON request body string. Do not combine with body field flags.',
             helpGroup: 'Raw JSON Body',
@@ -82,6 +93,13 @@ export function createGeneratedFlags(operation) {
             exclusive: ['body'],
         });
     }
+    if (operation.responseType === 'binary') {
+        flags.output = Flags.string({
+            description: 'Path where the downloaded response should be written.',
+            helpGroup: 'Output',
+            required: true,
+        });
+    }
     flags['api-base-url'] = Flags.string({
         description: 'NocoBase API base URL, for example http://localhost:13000/api',
         helpGroup: 'Global',
@@ -132,6 +150,8 @@ export class GeneratedApiCommand extends Command {
                 parameters: ctor.operation.parameters,
                 hasBody: ctor.operation.hasBody,
                 bodyRequired: ctor.operation.bodyRequired,
+                requestContentType: ctor.operation.requestContentType,
+                responseType: ctor.operation.responseType,
             },
         });
         if (!response.ok) {

package/dist/lib/plugin-storage.js

@@ -0,0 +1,127 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import path from 'node:path';
+import { access, lstat, mkdir, readdir, readlink, realpath, rm, stat, symlink } from 'node:fs/promises';
+async function pathExists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolvePluginStoragePath(storagePath) {
+    const root = String(storagePath ?? process.env.STORAGE_PATH ?? '').trim();
+    if (root) {
+        return path.join(path.isAbsolute(root) ? root : path.resolve(process.cwd(), root), 'plugins');
+    }
+    const configured = String(process.env.PLUGIN_STORAGE_PATH ?? '').trim();
+    if (configured) {
+        return path.isAbsolute(configured) ? configured : path.resolve(process.cwd(), configured);
+    }
+    return path.resolve(process.cwd(), 'storage', 'plugins');
+}
+async function getStoragePluginNames(target) {
+    const plugins = [];
+    const items = await readdir(target);
+    for (const item of items) {
+        const itemPath = path.resolve(target, item);
+        if (item.startsWith('@')) {
+            const statResult = await stat(itemPath);
+            if (!statResult.isDirectory()) {
+                continue;
+            }
+            const children = await getStoragePluginNames(itemPath);
+            plugins.push(...children.map((child) => `${item}/${child}`));
+            continue;
+        }
+        if (await pathExists(path.resolve(itemPath, 'package.json'))) {
+            plugins.push(item);
+        }
+    }
+    return plugins;
+}
+async function ensureOrgDirectory(nodeModulesPath, pluginName) {
+    if (!pluginName.startsWith('@')) {
+        return;
+    }
+    const [orgName] = pluginName.split('/');
+    await mkdir(path.resolve(nodeModulesPath, orgName), { recursive: true });
+}
+async function isSymlinkValid(linkPath, targetPath) {
+    try {
+        if (await pathExists(linkPath)) {
+            const realPath = await realpath(linkPath);
+            return realPath === targetPath;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+async function createStoragePluginSymlink(storagePluginsPath, nodeModulesPath, pluginName) {
+    const targetPath = path.resolve(storagePluginsPath, pluginName);
+    if (!(await pathExists(targetPath))) {
+        return;
+    }
+    await ensureOrgDirectory(nodeModulesPath, pluginName);
+    const linkPath = path.resolve(nodeModulesPath, pluginName);
+    if (await isSymlinkValid(linkPath, targetPath)) {
+        return;
+    }
+    await rm(linkPath, { recursive: true, force: true });
+    await symlink(targetPath, linkPath, 'dir');
+}
+export async function createStoragePluginsSymlink(storagePath, nodeModulesPath = String(process.env.NODE_MODULES_PATH ?? '').trim()) {
+    if (!nodeModulesPath) {
+        return;
+    }
+    const storagePluginsPath = resolvePluginStoragePath(storagePath);
+    if (!(await pathExists(storagePluginsPath))) {
+        return;
+    }
+    const pluginNames = await getStoragePluginNames(storagePluginsPath);
+    await Promise.all(pluginNames.map(async (pluginName) => await createStoragePluginSymlink(storagePluginsPath, nodeModulesPath, pluginName)));
+}
+export async function removeStoragePluginSymlink(pluginName, storagePath, nodeModulesPath = String(process.env.NODE_MODULES_PATH ?? '').trim()) {
+    if (!nodeModulesPath) {
+        return false;
+    }
+    const storagePluginsPath = resolvePluginStoragePath(storagePath);
+    const targetPath = path.resolve(storagePluginsPath, pluginName);
+    const linkPath = path.resolve(nodeModulesPath, pluginName);
+    if (!(await pathExists(linkPath))) {
+        return false;
+    }
+    let statResult;
+    try {
+        statResult = await lstat(linkPath);
+    }
+    catch {
+        return false;
+    }
+    if (!statResult.isSymbolicLink()) {
+        return false;
+    }
+    let resolvedLinkTarget = '';
+    try {
+        const linkTarget = await readlink(linkPath);
+        resolvedLinkTarget = path.resolve(path.dirname(linkPath), linkTarget);
+    }
+    catch {
+        return false;
+    }
+    if (resolvedLinkTarget !== targetPath) {
+        return false;
+    }
+    await rm(linkPath, { recursive: true, force: true });
+    return true;
+}

package/dist/lib/prompt-validators.js

@@ -173,13 +173,13 @@ export async function validateAvailableTcpPort(value) {
         return formatError;
     }
     const port = parseTcpPort(raw);
-    const available = await canListenOnTcpPort(port);
-    if (!available) {
-        return translateCli('validators.tcpPort.alreadyInUse', { port });
-    }
     const dockerPorts = await getDockerPublishedTcpPorts();
     if (dockerPorts.has(port)) {
         return translateCli('validators.tcpPort.alreadyInUseByDocker', { port });
     }
+    const available = await canListenOnTcpPort(port);
+    if (!available) {
+        return translateCli('validators.tcpPort.alreadyInUse', { port });
+    }
     return undefined;
 }

package/dist/lib/prompt-web-ui.js

@@ -559,17 +559,23 @@ function readFormFromClientStrippingPwcMeta(o) {
     const { [PWC_FORM_META_STEP]: _meta, ...rest } = o;
     return rest;
 }
-function openUrlInDefaultBrowser(url) {
+function openUrlInDefaultBrowser(url, onError) {
+    const reportError = (error) => {
+        onError?.(url, error);
+    };
     const platform = process.platform;
+    let child;
     if (platform === 'darwin') {
-        spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
+        child = spawn('open', [url], { stdio: 'ignore', detached: true });
     }
     else if (platform === 'win32') {
-        spawn('cmd', ['/c', 'start', '', url], { stdio: 'ignore', detached: true, windowsHide: true }).unref();
+        child = spawn('cmd', ['/c', 'start', '', url], { stdio: 'ignore', detached: true, windowsHide: true });
     }
     else {
-        spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+        child = spawn('xdg-open', [url], { stdio: 'ignore', detached: true });
     }
+    child.once('error', reportError);
+    child.unref();
 }
 function closePromptWebUiServer(server, done) {
     server.close(done);
@@ -2084,11 +2090,12 @@ function runPromptCatalogWebUIImpl(options) {
             const port = addr.port;
             const startUrl = `http://${host}:${port}/`;
             options.onServerStart?.({ host, port, url: startUrl });
+            const onOpenBrowserError = options.onOpenBrowserError ?? ((u, err) => console.warn(String(err), u));
             try {
-                openUrlInDefaultBrowser(startUrl);
+                openUrlInDefaultBrowser(startUrl, onOpenBrowserError);
             }
             catch (e) {
-                (options.onOpenBrowserError ?? ((u, err) => console.warn(String(err), u)))(startUrl, e);
+                onOpenBrowserError(startUrl, e);
             }
             timeoutId = setTimeout(() => rejectAndClose(new Error('Local UI timeout — close the tab and try again, or resubmit within the time limit.')), timeoutMs);
         });

package/dist/lib/runtime-generator.js

@@ -1,3 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
 /**
  * This file is part of the NocoBase (R) project.
  * Copyright (c) 2020-2024 NocoBase Co., Ltd.
@@ -60,12 +68,59 @@ function toGeneratedParameter(parameter, usedFlagNames) {
         required: parameter.required,
         description: parameter.description,
         type: inferParameterType(parameter.schema),
+        format: parameter.schema?.format,
         isArray: parameter.schema?.type === 'array',
+        isFile: parameter.schema?.type === 'string' && parameter.schema?.format === 'binary',
     };
 }
 function getJsonRequestSchema(requestBody) {
     return requestBody?.content?.['application/json']?.schema;
 }
+function getMultipartRequestSchema(requestBody) {
+    return requestBody?.content?.['multipart/form-data']?.schema;
+}
+function getRequestContentType(requestBody) {
+    if (!requestBody || '$ref' in requestBody) {
+        return undefined;
+    }
+    if (requestBody.content?.['multipart/form-data']) {
+        return 'multipart/form-data';
+    }
+    if (requestBody.content?.['application/json']) {
+        return 'application/json';
+    }
+    return undefined;
+}
+function getRequestSchema(requestBody) {
+    return getMultipartRequestSchema(requestBody) ?? getJsonRequestSchema(requestBody);
+}
+function isBinarySchema(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return false;
+    }
+    if (schema.type === 'string' && schema.format === 'binary') {
+        return true;
+    }
+    return [...(schema.oneOf ?? []), ...(schema.anyOf ?? []), ...(schema.allOf ?? [])].some(isBinarySchema);
+}
+function getResponseType(operation) {
+    for (const response of Object.values(operation.responses ?? {})) {
+        const content = response?.content ?? {};
+        const mediaTypes = Object.keys(content);
+        const hasJson = mediaTypes.some((mediaType) => mediaType.includes('json'));
+        if (hasJson) {
+            return 'json';
+        }
+        const hasBinary = mediaTypes.some((mediaType) => {
+            const schema = content[mediaType]?.schema;
+            return mediaType === 'application/octet-stream' || mediaType.includes('zip') || isBinarySchema(schema);
+        });
+        if (hasBinary) {
+            return 'binary';
+        }
+    }
+    return undefined;
+}
 function normalizeCompositeSchema(schema) {
     if (!schema || typeof schema !== 'object') {
         return schema;
@@ -139,7 +194,7 @@ function describeSchemaShape(schema, options = {}) {
     return type;
 }
 function extractBodyParameters(requestBody, usedFlagNames) {
-    const schema = getJsonRequestSchema(requestBody);
+    const schema = getRequestSchema(requestBody);
     const properties = normalizeCompositeSchema(schema)?.properties;
     const required = new Set(normalizeCompositeSchema(schema)?.required ?? []);
     return Object.entries(properties ?? {}).map(([name, propertySchema]) => ({
@@ -149,7 +204,9 @@ function extractBodyParameters(requestBody, usedFlagNames) {
         required: required.has(name),
         description: propertySchema.description,
         type: inferParameterType(propertySchema),
+        format: propertySchema.format,
         isArray: propertySchema.type === 'array',
+        isFile: propertySchema.type === 'string' && propertySchema.format === 'binary',
         jsonEncoded: propertySchema.type === 'object' || propertySchema.type === 'array',
         jsonShape: describeSchemaShape(propertySchema),
     }));
@@ -179,6 +236,9 @@ function formatFlagExample(parameter) {
     if (parameter.type === 'boolean') {
         return `--${parameter.flagName}`;
     }
+    if (parameter.isFile) {
+        return `--${parameter.flagName} <path>`;
+    }
     if (parameter.type === 'object' || parameter.jsonEncoded) {
         if (parameter.type === 'array' || parameter.isArray) {
             return `--${parameter.flagName} '[]'`;
@@ -216,12 +276,13 @@ export function buildExamples(commandId, operation) {
     const requiredParameters = operation.parameters.filter((parameter) => parameter.required);
     const requiredFlags = requiredParameters.map(formatFlagExample);
     const requiredNonBodyFlags = requiredParameters.filter((parameter) => parameter.in !== 'body').map(formatFlagExample);
-    const examples = [`nb api ${commandId}${requiredFlags.length ? ` ${requiredFlags.join(' ')}` : ''}`];
+    const outputFlag = operation.responseType === 'binary' ? ' --output <path>' : '';
+    const examples = [`nb api ${commandId}${requiredFlags.length ? ` ${requiredFlags.join(' ')}` : ''}${outputFlag}`];
     const firstOptional = operation.parameters.find((parameter) => !parameter.required);
     if (firstOptional) {
-        examples.push(`${examples[0]} ${formatFlagExample(firstOptional)}`);
+        examples.push(`${examples[0]} ${formatFlagExample(firstOptional)}`.trim());
     }
-    if (operation.hasBody) {
+    if (operation.hasBody && operation.requestContentType !== 'multipart/form-data') {
         const prefix = `nb api ${commandId}${requiredNonBodyFlags.length ? ` ${requiredNonBodyFlags.join(' ')}` : ''}`;
         examples.push(`${prefix} --body '${buildSampleBody(operation.parameters)}'`);
     }
@@ -248,9 +309,17 @@ function buildDescription(operation) {
     }
     if (operation.hasBody) {
         const bodyFlags = operation.parameters.filter((parameter) => parameter.in === 'body').map((parameter) => `--${parameter.flagName}`);
-        sections.push(bodyFlags.length
-            ? `Request body: use body field flags (${bodyFlags.join(', ')}) or pass raw JSON via \`--body\` / \`--body-file\`.`
-            : 'Request body: JSON via `--body` or `--body-file`.');
+        if (operation.requestContentType === 'multipart/form-data') {
+            sections.push(bodyFlags.length ? `Request body: multipart form fields (${bodyFlags.join(', ')}).` : 'Request body: multipart form data.');
+        }
+        else {
+            sections.push(bodyFlags.length
+                ? `Request body: use body field flags (${bodyFlags.join(', ')}) or pass raw JSON via \`--body\` / \`--body-file\`.`
+                : 'Request body: JSON via `--body` or `--body-file`.');
+        }
+    }
+    if (operation.responseType === 'binary') {
+        sections.push('Response body: binary download written to `--output`.');
     }
     return sections.join('\n\n');
 }
@@ -357,6 +426,8 @@ export async function generateRuntime(document, configFile, baseUrl) {
         const bodyParameters = extractBodyParameters(operation.requestBody, usedFlagNames);
         const allParameters = [...parameters, ...bodyParameters];
         const hasBody = Boolean(operation.requestBody && !('$ref' in operation.requestBody));
+        const requestContentType = getRequestContentType(operation.requestBody);
+        const responseType = getResponseType(operation);
         const moduleDisplayName = moduleConfig.name ?? moduleKey;
         const moduleDescription = moduleConfig.description;
         const resourceDisplayName = resourceConfig?.name ?? resourceKey;
@@ -366,9 +437,11 @@ export async function generateRuntime(document, configFile, baseUrl) {
             description: operation.description,
         });
         const resourceSegments = toResourceSegments(pathTemplate);
-        const mappedResourceSegments = resourceSegments.length && resourceConfig?.name
-            ? [toKebabCase(resourceConfig.name), ...resourceSegments.slice(1)]
-            : resourceSegments;
+        const mappedResourceSegments = resourceSegments.length && resourceConfig?.segments?.length
+            ? [...resourceConfig.segments.map(toKebabCase), ...resourceSegments.slice(1)]
+            : resourceSegments.length && resourceConfig?.name
+                ? [toKebabCase(resourceConfig.name), ...resourceSegments.slice(1)]
+                : resourceSegments;
         const segments = [
             ...(resourceConfig?.topLevel ? [] : [toKebabCase(moduleDisplayName)]),
             ...mappedResourceSegments,
@@ -397,15 +470,21 @@ export async function generateRuntime(document, configFile, baseUrl) {
                 tags: operation.tags,
                 description: operationText.description,
                 hasBody,
+                requestContentType,
+                responseType,
                 parameters: allParameters,
             }),
             examples: buildExamples(segments.join(' '), {
                 parameters: allParameters,
                 hasBody,
+                requestContentType,
+                responseType,
             }),
             parameters: allParameters,
             hasBody,
             bodyRequired: operation.requestBody && !('$ref' in operation.requestBody) ? operation.requestBody.required : undefined,
+            requestContentType,
+            responseType,
         });
     }
     const schemaHash = createHash('sha1').update(JSON.stringify(document)).digest('hex').slice(0, 8);

package/dist/lib/self-manager.js

@@ -7,11 +7,14 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import fs from 'node:fs';
+import fsp from 'node:fs/promises';
 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);
 }
@@ -115,6 +118,38 @@ function detectInstallMethod(packageRoot, globalPrefix) {
     }
     return 'unknown';
 }
+function getInstallMethodCacheFile() {
+    return path.join(resolveCliHomeDir('global'), INSTALL_METHOD_CACHE_FILE);
+}
+function getInstallMethodCacheKey(packageRoot) {
+    return normalizePath(path.join(packageRoot, 'bin', 'run.js'));
+}
+async function readInstallMethodCache() {
+    try {
+        const raw = await fsp.readFile(getInstallMethodCacheFile(), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function writeInstallMethodCache(state) {
+    const filePath = getInstallMethodCacheFile();
+    await fsp.mkdir(path.dirname(filePath), { recursive: true });
+    await fsp.writeFile(filePath, JSON.stringify(state, null, 2));
+}
+async function readCachedInstallMethod(packageRoot) {
+    const state = await readInstallMethodCache();
+    return state.entries?.[getInstallMethodCacheKey(packageRoot)];
+}
+async function writeCachedInstallMethod(packageRoot, entry) {
+    const state = await readInstallMethodCache();
+    const entries = {
+        ...(state.entries ?? {}),
+        [getInstallMethodCacheKey(packageRoot)]: entry,
+    };
+    await writeInstallMethodCache({ entries });
+}
 async function readGlobalPrefix(commandOutputFn) {
     try {
         return (await commandOutputFn('npm', ['prefix', '-g'], {
@@ -177,14 +212,34 @@ export function formatSelfUpdateUnavailableMessage(status) {
 export function getSelfUpdatePackageSpec(status) {
     return `${status.packageName}@${status.channel}`;
 }
+export async function inspectSelfInstall(options = {}) {
+    const packageRoot = options.packageRoot ? normalizePath(options.packageRoot) : PACKAGE_ROOT;
+    const commandOutputFn = options.commandOutputFn ?? commandOutput;
+    const cachedInstallMethod = await readCachedInstallMethod(packageRoot);
+    const globalPrefix = cachedInstallMethod?.globalPrefix ?? await readGlobalPrefix(commandOutputFn);
+    const installMethod = cachedInstallMethod?.installMethod ?? detectInstallMethod(packageRoot, globalPrefix);
+    if (!cachedInstallMethod) {
+        await writeCachedInstallMethod(packageRoot, {
+            installMethod,
+            globalPrefix,
+        });
+    }
+    return {
+        packageRoot,
+        installMethod,
+        globalPrefix,
+    };
+}
 export async function inspectSelfStatus(options = {}) {
     const packageRoot = options.packageRoot ? normalizePath(options.packageRoot) : PACKAGE_ROOT;
     const packageName = options.packageName ?? DEFAULT_PACKAGE_NAME;
     const currentVersion = options.currentVersion ?? readCurrentVersion(packageRoot);
     const channel = options.channel && options.channel !== 'auto' ? options.channel : detectChannel(currentVersion);
     const commandOutputFn = options.commandOutputFn ?? commandOutput;
-    const globalPrefix = await readGlobalPrefix(commandOutputFn);
-    const installMethod = detectInstallMethod(packageRoot, globalPrefix);
+    const { installMethod, globalPrefix } = await inspectSelfInstall({
+        packageRoot,
+        commandOutputFn,
+    });
     let latestVersion;
     let registryError;
     try {

package/dist/lib/skills-manager.js

@@ -180,12 +180,6 @@ export async function inspectSkillsStatus(options = {}) {
         registryError,
     };
 }
-function formatSkillsNotInstalledMessage() {
-    return [
-        'NocoBase AI coding skills are not installed globally.',
-        'Run `nb skills install` first.',
-    ].join('\n');
-}
 async function persistManagedSkillsState(globalRoot, options = {}) {
     const installedSkills = await listGlobalSkills({
         globalRoot,
@@ -250,7 +244,11 @@ export async function updateNocoBaseSkills(options = {}) {
         commandOutputFn: options.commandOutputFn,
     });
     if (!status.installed) {
-        throw new Error(formatSkillsNotInstalledMessage());
+        return {
+            action: 'noop',
+            reason: 'not-installed',
+            status,
+        };
     }
     if (status.managedByNb
         && status.latestVersion
@@ -258,6 +256,7 @@ export async function updateNocoBaseSkills(options = {}) {
         && compareVersions(status.latestVersion, status.installedVersion) <= 0) {
         return {
             action: 'noop',
+            reason: 'up-to-date',
             status,
         };
     }
@@ -267,3 +266,31 @@ export async function updateNocoBaseSkills(options = {}) {
         status: await persistManagedSkillsState(globalRoot, options),
     };
 }
+export async function removeNocoBaseSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const status = await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (!status.installed || status.installedSkillNames.length === 0) {
+        return {
+            action: 'noop',
+            status,
+        };
+    }
+    for (const skillName of status.installedSkillNames) {
+        await (options.runFn ?? run)('npx', ['-y', 'skills', 'remove', skillName, '-g', '-y'], {
+            cwd: globalRoot,
+            stdio: options.verbose ? 'inherit' : 'ignore',
+            errorName: 'skills remove',
+        });
+    }
+    await fsp.rm(getManagedSkillsStateFile(globalRoot), { force: true });
+    return {
+        action: 'removed',
+        status: await inspectSkillsStatus({
+            globalRoot,
+            commandOutputFn: options.commandOutputFn,
+        }),
+    };
+}