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

package/dist/lib/app-health.js

@@ -0,0 +1,126 @@
+/**
+ * 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 { printInfo, startTask, stopTask, updateTask } from './ui.js';
+const APP_HEALTH_CHECK_INTERVAL_MS = 2_000;
+const APP_HEALTH_CHECK_TIMEOUT_MS = 600_000;
+const APP_HEALTH_CHECK_REQUEST_TIMEOUT_MS = 5_000;
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function buildHealthCheckUrl(apiBaseUrl) {
+    return `${apiBaseUrl.replace(/\/+$/, '')}/__health_check`;
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function requestAppHealthCheck(params) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, params.requestTimeoutMs ?? APP_HEALTH_CHECK_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await (params.fetchImpl ?? fetch)(params.healthCheckUrl, {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        const text = await response.text().catch(() => '');
+        const body = text.replace(/\s+/g, ' ').trim() || 'No response yet';
+        return {
+            ok: response.ok && text.trim().toLowerCase() === 'ok',
+            message: `HTTP ${response.status}: ${body}`,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            return {
+                ok: false,
+                message: `No response within ${Math.ceil((params.requestTimeoutMs ?? APP_HEALTH_CHECK_REQUEST_TIMEOUT_MS) / 1000)}s`,
+            };
+        }
+        return {
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export class AppHealthCheckError extends Error {
+}
+export function formatAppUrl(port) {
+    const value = trimValue(port);
+    return value ? `http://127.0.0.1:${value}` : undefined;
+}
+export function resolveManagedAppApiBaseUrl(runtime, options) {
+    const override = trimValue(options?.portOverride);
+    if (override) {
+        return `http://127.0.0.1:${override}/api`;
+    }
+    const baseUrl = trimValue(runtime.env.baseUrl);
+    if (baseUrl) {
+        return baseUrl.replace(/\/+$/, '');
+    }
+    const appPort = runtime.env.appPort === undefined || runtime.env.appPort === null
+        ? ''
+        : trimValue(runtime.env.appPort);
+    return appPort ? `http://127.0.0.1:${appPort}/api` : undefined;
+}
+export async function isAppReady(apiBaseUrl, options) {
+    const baseUrl = trimValue(apiBaseUrl);
+    if (!baseUrl) {
+        return false;
+    }
+    const result = await requestAppHealthCheck({
+        healthCheckUrl: buildHealthCheckUrl(baseUrl),
+        fetchImpl: options?.fetchImpl,
+        requestTimeoutMs: options?.requestTimeoutMs,
+    });
+    return result.ok;
+}
+export async function waitForAppReady(params) {
+    const apiBaseUrl = trimValue(params.apiBaseUrl);
+    if (!apiBaseUrl) {
+        printInfo(`Skipping health check for "${params.envName}" because no local API URL is saved for this env.`);
+        return;
+    }
+    const healthCheckUrl = buildHealthCheckUrl(apiBaseUrl);
+    const startedAt = Date.now();
+    let lastMessage = 'No response yet';
+    let spinnerActive = true;
+    startTask(`Waiting for NocoBase to become ready for "${params.envName}"...`);
+    try {
+        while (Date.now() - startedAt < APP_HEALTH_CHECK_TIMEOUT_MS) {
+            const result = await requestAppHealthCheck({
+                healthCheckUrl,
+                fetchImpl: params.fetchImpl,
+            });
+            if (result.ok) {
+                stopTask();
+                spinnerActive = false;
+                return;
+            }
+            lastMessage = result.message;
+            const elapsedSeconds = Math.max(1, Math.floor((Date.now() - startedAt) / 1000));
+            updateTask(`Waiting for NocoBase to become ready for "${params.envName}"... (${elapsedSeconds}s elapsed, last status: ${lastMessage})`);
+            await sleep(APP_HEALTH_CHECK_INTERVAL_MS);
+        }
+    }
+    finally {
+        if (spinnerActive) {
+            stopTask();
+        }
+    }
+    const hints = [
+        params.logHint,
+        params.containerName ? `docker logs ${params.containerName}` : undefined,
+    ].filter(Boolean);
+    const hintText = hints.length > 0 ? ` ${hints.join(' ')}` : '';
+    throw new AppHealthCheckError(`NocoBase did not become ready in time for "${params.envName}". Expected \`${healthCheckUrl}\` to respond with \`ok\`, but the last status was: ${lastMessage}.${hintText}`);
+}

package/dist/lib/app-managed-resources.js

@@ -0,0 +1,264 @@
+/**
+ * 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 { mkdir, readdir } from 'node:fs/promises';
+import { dockerContainerExists, startDockerContainer } from './app-runtime.js';
+import { resolveConfiguredEnvPath } from './cli-home.js';
+import { commandSucceeds, run } from './run-npm.js';
+import Install from '../commands/install.js';
+const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
+const DEFAULT_DOCKER_VERSION = 'alpha';
+const DOCKER_APP_STORAGE_DESTINATION = '/app/nocobase/storage';
+function commandStdio(verbose) {
+    return verbose ? 'inherit' : 'ignore';
+}
+async function ensureDockerNetwork(networkName) {
+    if (await commandSucceeds('docker', ['network', 'inspect', networkName])) {
+        return;
+    }
+    await run('docker', ['network', 'create', networkName], {
+        errorName: 'docker network create',
+    });
+}
+function localSourceLabel(source) {
+    return source === 'git' ? 'Git checkout' : 'npm app';
+}
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function normalizeDockerPlatform(value) {
+    const text = trimValue(value);
+    if (!text || text === 'auto') {
+        return undefined;
+    }
+    if (text === 'linux/amd64' || text === 'linux/arm64') {
+        return text;
+    }
+    return undefined;
+}
+function formatBuiltinDbFailure(envName, message) {
+    return [
+        `Couldn't restore the built-in database for "${envName}".`,
+        'Check the saved database settings, local storage path, and Docker runtime, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+function formatLocalSourceRestoreFailure(envName, source, message) {
+    const sourceLabel = source === 'git' ? 'the saved Git checkout' : 'the saved npm app';
+    return [
+        `Couldn't restore NocoBase files for "${envName}".`,
+        `The CLI was not able to download ${sourceLabel} before starting the app again.`,
+        'Check the saved source settings for this env, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+function formatSavedDockerSettingsIncomplete(envName, missing) {
+    return [
+        `Can't start NocoBase for "${envName}" yet.`,
+        `The saved Docker settings for this env are incomplete. Missing: ${missing.join(', ')}.`,
+        'Re-run `nb init` or `nb env add` to refresh this env config, then try again.',
+    ].join('\n');
+}
+function formatDockerAppRecreateFailure(envName, message) {
+    return [
+        `Couldn't start NocoBase for "${envName}".`,
+        'The CLI was not able to recreate the saved Docker app container successfully.',
+        'Check the saved Docker image, container settings, and database connection, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+async function localProjectHasFiles(projectRoot) {
+    try {
+        const entries = await readdir(projectRoot);
+        return entries.length > 0;
+    }
+    catch (_error) {
+        return false;
+    }
+}
+export function buildSavedDockerRunArgs(runtime) {
+    const config = runtime.env.config ?? {};
+    const configuredStoragePath = trimValue(config.storagePath);
+    const storagePath = configuredStoragePath
+        ? trimValue(resolveConfiguredEnvPath(configuredStoragePath))
+        : '';
+    const appPort = runtime.env.appPort === undefined || runtime.env.appPort === null
+        ? ''
+        : trimValue(runtime.env.appPort);
+    const appKey = trimValue(config.appKey);
+    const timeZone = trimValue(config.timezone) || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    const dbDialect = trimValue(config.dbDialect);
+    const dbHost = trimValue(config.dbHost);
+    const dbPort = trimValue(config.dbPort);
+    const dbDatabase = trimValue(config.dbDatabase);
+    const dbUser = trimValue(config.dbUser);
+    const dbPassword = trimValue(config.dbPassword);
+    const dockerRegistry = trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY;
+    const version = trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION;
+    const imageRef = `${dockerRegistry}:${version}`;
+    const missing = [];
+    if (!storagePath) {
+        missing.push('storagePath');
+    }
+    if (!appKey) {
+        missing.push('appKey');
+    }
+    if (!dbDialect) {
+        missing.push('dbDialect');
+    }
+    if (!dbHost) {
+        missing.push('dbHost');
+    }
+    if (!dbPort) {
+        missing.push('dbPort');
+    }
+    if (!dbDatabase) {
+        missing.push('dbDatabase');
+    }
+    if (!dbUser) {
+        missing.push('dbUser');
+    }
+    if (!dbPassword) {
+        missing.push('dbPassword');
+    }
+    if (missing.length > 0) {
+        throw new Error(formatSavedDockerSettingsIncomplete(runtime.envName, missing));
+    }
+    const args = [
+        'run',
+        '-d',
+        '--name',
+        runtime.containerName,
+        '--restart',
+        'always',
+        '--network',
+        runtime.workspaceName,
+    ];
+    const dockerPlatform = normalizeDockerPlatform(config.dockerPlatform);
+    if (dockerPlatform) {
+        args.push('--platform', dockerPlatform);
+    }
+    if (appPort) {
+        args.push('-p', `${appPort}:80`);
+    }
+    args.push('-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`, imageRef);
+    return {
+        appPort: appPort || undefined,
+        storagePath,
+        imageRef,
+        args,
+    };
+}
+export async function recreateSavedDockerApp(runtime, options) {
+    const plan = buildSavedDockerRunArgs(runtime);
+    try {
+        await ensureDockerNetwork(runtime.workspaceName);
+        await mkdir(plan.storagePath, { recursive: true });
+        await run('docker', plan.args, {
+            errorName: 'docker run',
+            stdio: commandStdio(options?.verbose),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes(`Can't start NocoBase for "${runtime.envName}" yet.`)
+            || message.includes(`Couldn't start NocoBase for "${runtime.envName}".`)) {
+            throw error instanceof Error ? error : new Error(message);
+        }
+        throw new Error(formatDockerAppRecreateFailure(runtime.envName, message));
+    }
+}
+export async function ensureBuiltinDbReady(runtime, options) {
+    const config = runtime.env.config ?? {};
+    if (!config.builtinDb) {
+        return;
+    }
+    const plan = Install.buildBuiltinDbPlan({
+        envName: runtime.envName,
+        workspaceName: runtime.workspaceName,
+        storagePath: config.storagePath,
+        source: runtime.source,
+        dbDialect: config.dbDialect,
+        dbHost: config.dbHost,
+        dbPort: config.dbPort,
+        dbDatabase: config.dbDatabase,
+        dbUser: config.dbUser,
+        dbPassword: config.dbPassword,
+        builtinDbImage: config.builtinDbImage,
+    });
+    options?.onStartTask?.(`Restoring the built-in ${plan.dbDialect} database for "${runtime.envName}"...`);
+    try {
+        await ensureDockerNetwork(plan.networkName);
+        if (await dockerContainerExists(plan.containerName)) {
+            const state = await startDockerContainer(plan.containerName, {
+                stdio: commandStdio(options?.verbose),
+            });
+            options?.onSucceedTask?.(state === 'already-running'
+                ? `The built-in ${plan.dbDialect} database is already running for "${runtime.envName}" at ${plan.dbHost}:${plan.dbPort}.`
+                : `The built-in ${plan.dbDialect} database is running for "${runtime.envName}" at ${plan.dbHost}:${plan.dbPort}.`);
+            return;
+        }
+        await mkdir(plan.dataDir, { recursive: true });
+        await run('docker', plan.args, {
+            errorName: 'docker run',
+            stdio: commandStdio(options?.verbose),
+        });
+        options?.onSucceedTask?.(`The built-in ${plan.dbDialect} database is running for "${runtime.envName}" at ${plan.dbHost}:${plan.dbPort}.`);
+    }
+    catch (error) {
+        options?.onFailTask?.(`Failed to restore the built-in database for "${runtime.envName}".`);
+        throw new Error(formatBuiltinDbFailure(runtime.envName, error instanceof Error ? error.message : String(error)));
+    }
+}
+export function buildSavedLocalDownloadArgv(runtime, options) {
+    const config = runtime.env.config ?? {};
+    const argv = ['-y', '--no-intro'];
+    if (options?.verbose) {
+        argv.push('--verbose');
+    }
+    argv.push('--source', runtime.source, '--replace', '--output-dir', runtime.projectRoot);
+    const version = String(config.downloadVersion ?? '').trim();
+    const gitUrl = String(config.gitUrl ?? '').trim();
+    const npmRegistry = String(config.npmRegistry ?? '').trim();
+    if (version) {
+        argv.push('--version', version);
+    }
+    if (gitUrl) {
+        argv.push('--git-url', gitUrl);
+    }
+    if (npmRegistry) {
+        argv.push('--npm-registry', npmRegistry);
+    }
+    if (config.devDependencies === true) {
+        argv.push('--dev-dependencies');
+    }
+    if (config.build === false) {
+        argv.push('--no-build');
+    }
+    if (config.buildDts === true) {
+        argv.push('--build-dts');
+    }
+    return argv;
+}
+export async function ensureSavedLocalSource(runtime, runCommand, options) {
+    if (await localProjectHasFiles(runtime.projectRoot)) {
+        return;
+    }
+    const sourceLabel = localSourceLabel(runtime.source);
+    options?.onStartTask?.(`Restoring the saved ${sourceLabel} for "${runtime.envName}"...`);
+    try {
+        await runCommand('source:download', buildSavedLocalDownloadArgv(runtime, {
+            verbose: options?.verbose,
+        }));
+        options?.onSucceedTask?.(`NocoBase files are ready for "${runtime.envName}".`);
+    }
+    catch (error) {
+        options?.onFailTask?.(`Failed to restore NocoBase files for "${runtime.envName}".`);
+        throw new Error(formatLocalSourceRestoreFailure(runtime.envName, runtime.source, error instanceof Error ? error.message : String(error)));
+    }
+}

package/dist/lib/auth-store.js

@@ -8,7 +8,7 @@
  */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveDefaultConfigScope, resolveEnvRelativePath, } from './cli-home.js';
+import { NB_CLI_ROOT_ENV, resolveCliHomeDir, resolveConfiguredEnvPath, resolveDefaultConfigScope, resolveEnvRelativePath, } from './cli-home.js';
 function normalizeStoredEnvKind(value) {
     const kind = String(value ?? '').trim();
     if (kind === 'remote') {
@@ -88,7 +88,10 @@ function hasConfiguredEnvs(config) {
 }
 function shouldFallbackToLegacyProjectScope(options = {}) {
     const requestedScope = options.scope ?? resolveDefaultConfigScope();
-    return requestedScope === 'global';
+    if (requestedScope !== 'global') {
+        return false;
+    }
+    return !process.env[NB_CLI_ROOT_ENV];
 }
 async function loadExactAuthConfig(options = {}) {
     try {

package/dist/lib/cli-home.js

@@ -11,16 +11,17 @@ import os from 'node:os';
 import path from 'node:path';
 export const CLI_HOME_DIRNAME = '.nocobase';
 export const NB_CONFIG_SCOPE_ENV = 'NB_CONFIG_SCOPE';
-export const NB_ENV_ROOT_ENV = 'NB_ENV_ROOT';
+export const NB_CLI_ROOT_ENV = 'NB_CLI_ROOT';
 export function resolveDefaultConfigScope() {
     const raw = String(process.env[NB_CONFIG_SCOPE_ENV] ?? '').trim().toLowerCase();
     return raw === 'project' ? 'project' : 'global';
 }
+function readConfiguredPath(name) {
+    const value = String(process.env[name] ?? '').trim();
+    return value || undefined;
+}
 function resolveGlobalCliHomeRoot() {
-    if (process.env.NOCOBASE_CTL_HOME) {
-        return process.env.NOCOBASE_CTL_HOME;
-    }
-    return os.homedir();
+    return readConfiguredPath(NB_CLI_ROOT_ENV) ?? os.homedir();
 }
 export function resolveCliHomeRoot(scope = resolveDefaultConfigScope()) {
     const cwdRoot = process.cwd();
@@ -40,7 +41,7 @@ export function resolveCliHomeDir(scope = resolveDefaultConfigScope()) {
     return path.join(resolveCliHomeRoot(scope), CLI_HOME_DIRNAME);
 }
 export function resolveEnvRoot(scope = resolveDefaultConfigScope()) {
-    const envRoot = String(process.env[NB_ENV_ROOT_ENV] ?? '').trim();
+    const envRoot = readConfiguredPath(NB_CLI_ROOT_ENV);
     if (envRoot) {
         return path.resolve(envRoot);
     }

package/dist/lib/cli-locale.js

@@ -7,6 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 export const SUPPORTED_CLI_LOCALES = ['en-US', 'zh-CN'];
 export const CLI_LOCALE_FLAG_OPTIONS = [...SUPPORTED_CLI_LOCALES];
 export const CLI_LOCALE_FLAG_DESCRIPTION = 'Language for CLI prompts and the local setup UI.';
@@ -30,8 +32,20 @@ function loadLocaleMessages(locale) {
     if (localeCache[locale]) {
         return localeCache[locale];
     }
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const fallbackPath = path.resolve(moduleDir, '..', 'locale', `${locale}.json`);
     const fileUrl = new URL(`../locale/${locale}.json`, import.meta.url);
-    const parsed = JSON.parse(readFileSync(fileUrl, 'utf8'));
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(fileUrl, 'utf8'));
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        parsed = JSON.parse(readFileSync(fallbackPath, 'utf8'));
+    }
     localeCache[locale] = parsed;
     return parsed;
 }

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/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/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,
+        }),
+    };
+}