@nocobase/cli 2.2.0-beta.1 → 2.2.0-beta.11

package/dist/commands/license/shared.js

@@ -10,8 +10,8 @@ import { Flags } from '@oclif/core';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { getEnvAsync, getInstanceIdAsync, keyDecrypt } from '@nocobase/license-kit';
-import { checkExternalDbConnection, readExternalDbConnectionConfig, } from "../../lib/db-connection-check.js";
-import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_VERSION, resolveDockerImageRef, } from "../../lib/docker-image.js";
+import { checkExternalDbConnection, readExternalDbConnectionConfig } from "../../lib/db-connection-check.js";
+import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_VERSION, resolveDockerImageRef } from "../../lib/docker-image.js";
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
 import { buildRuntimeEnvVars } from '../../lib/runtime-env-vars.js';
 import { resolveLicensePkgUrlFromConfig } from '../../lib/cli-config.js';
@@ -102,12 +102,7 @@ function buildDockerLicenseDbFlagArgs(envVars) {
     ];
 }
 async function runDockerLicenseJsonCommand(runtime, commandArgs) {
-    const args = [
-        'run',
-        '--rm',
-        '--network',
-        runtime.dockerNetworkName || runtime.workspaceName,
-    ];
+    const args = ['run', '--rm', '--network', runtime.dockerNetworkName || runtime.workspaceName];
     const dockerPlatform = normalizeDockerPlatform(runtime.env.config?.dockerPlatform);
     if (dockerPlatform) {
         args.push('--platform', dockerPlatform);
@@ -193,11 +188,11 @@ export async function generateValidatedInstanceIdFromEnvVars(envVars) {
 }
 async function generateInstanceIdForDockerRuntime(runtime) {
     const envVars = await buildRuntimeEnvVars(runtime);
-    const payload = await runDockerLicenseJsonCommand(runtime, [
+    const payload = (await runDockerLicenseJsonCommand(runtime, [
         'license',
         'generate-id',
         ...buildDockerLicenseDbFlagArgs(envVars),
-    ]);
+    ]));
     const instanceId = trimValue(payload.instanceId);
     if (!instanceId) {
         throw new Error('Docker instance ID generation did not return an instance ID.');
@@ -337,7 +332,7 @@ export async function getLicenseStatus(keyData) {
             }),
             signal: controller.signal,
         });
-        const payload = await response.json();
+        const payload = (await response.json());
         return payload?.data?.status === 'active' ? 'active' : 'invalid';
     }
     catch {
@@ -356,6 +351,22 @@ export async function validateLicenseKey(runtime, key) {
     catch {
         keyStatus = 'invalid';
     }
+    if (keyStatus) {
+        const currentDomain = appUrl(runtime);
+        return {
+            current: {
+                env: undefined,
+                domain: currentDomain ? new URL(currentDomain).host : '',
+            },
+            keyData,
+            keyStatus,
+            dbMatch: false,
+            sysMatch: false,
+            envMatch: false,
+            domainMatch: false,
+            licenseStatus: 'invalid',
+        };
+    }
     const currentEnv = await getCurrentLicenseEnv(runtime);
     const currentDomain = appUrl(runtime);
     const dbMatch = isDbMatch(currentEnv, keyData);
@@ -391,7 +402,7 @@ export async function resolveLicenseServiceUrl(value) {
     return (await resolveLicensePkgUrl(value)).replace(/\/+$/, '');
 }
 export async function resolveLicensePkgUrl(value) {
-    const normalized = String(value ?? '').trim() || await resolveLicensePkgUrlFromConfig();
+    const normalized = String(value ?? '').trim() || (await resolveLicensePkgUrlFromConfig());
     return normalized.replace(/\/+$/, '') + '/';
 }
 function shouldRedactOutputKey(key) {
@@ -414,9 +425,7 @@ export function sanitizeLicenseOutput(value) {
     if (value && typeof value === 'object') {
         return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
             key,
-            shouldRedactOutputKey(key)
-                ? redactOutputValue(String(nestedValue ?? ''))
-                : sanitizeLicenseOutput(nestedValue),
+            shouldRedactOutputKey(key) ? redactOutputValue(String(nestedValue ?? '')) : sanitizeLicenseOutput(nestedValue),
         ]));
     }
     return value;

package/dist/commands/proxy/caddy/generate.js

@@ -8,20 +8,51 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
-import { getCaddyProxyDriver, writeCaddyProxyBundle, resolveCaddyProxyRuntimeContext, } from '../../../lib/proxy-caddy.js';
+import { resolveEnvProxyEntry, setEnvProxyEntry } from '../../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../../lib/cli-home.js';
+import { getCaddyProxyDriver, writeManualCaddyProxyBundle, writeCaddyProxyBundle, resolveCaddyProxyRuntimeContext, } from '../../../lib/proxy-caddy.js';
 import { normalizeProxyListenPort } from '../../../lib/proxy-nginx.js';
 import { announceTargetEnv, failTask, startTask, succeedTask } from '../../../lib/ui.js';
 export default class ProxyCaddyGenerate extends Command {
     static summary = 'Generate caddy proxy files for one managed env';
     static examples = [
+        '<%= config.bin %> proxy caddy generate --host app1.example.com',
         '<%= config.bin %> proxy caddy generate --env app1 --host app1.example.com',
         '<%= config.bin %> proxy caddy generate --env app1 --host app1.example.com --port 8080',
+        '<%= config.bin %> proxy caddy generate --manual --name default --storage-path /path/to/storage --dist-root-path /path/to/dist-client --runtime-version 2.1.0 --upstream-port 13000',
     ];
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name to generate proxy files for',
-            required: true,
+            description: 'CLI env name to generate proxy files for. Defaults to the current env when omitted',
+        }),
+        manual: Flags.boolean({
+            description: 'Generate proxy files from explicit runtime flags instead of a saved env',
+            default: false,
+        }),
+        name: Flags.string({
+            description: 'Output bundle name used under .nocobase/proxy/caddy in manual mode',
+        }),
+        'storage-path': Flags.string({
+            description: 'Path to the NocoBase storage directory in manual mode',
+        }),
+        'dist-root-path': Flags.string({
+            description: 'Path to the dist-client root directory used to generate index-v1.html and index-v2.html in manual mode',
+        }),
+        'runtime-version': Flags.string({
+            description: 'Frontend runtime version under dist-root-path in manual mode',
+        }),
+        'app-public-path': Flags.string({
+            description: 'Public base path served by the proxied app in manual mode. Defaults to /',
+        }),
+        'upstream-host': Flags.string({
+            description: 'Upstream host used by caddy reverse_proxy in manual mode',
+        }),
+        'upstream-port': Flags.string({
+            description: 'Upstream port used by caddy reverse_proxy in manual mode',
+        }),
+        'cdn-base-url': Flags.string({
+            description: 'Client asset CDN base URL used when generating runtime HTML',
         }),
         host: Flags.string({
             description: 'Host exposed by the caddy site block, such as example.com or localhost',
@@ -35,9 +66,56 @@ export default class ProxyCaddyGenerate extends Command {
         const requestedEnv = flags.env?.trim() || undefined;
         const requestedPort = flags.port?.trim() || undefined;
         const normalizedPort = normalizeProxyListenPort(requestedPort);
+        const manual = Boolean(flags.manual);
         if (requestedPort && !normalizedPort) {
             this.error(`Invalid proxy entry port "${requestedPort}". Use an integer between 1 and 65535.`);
         }
+        if (manual && requestedEnv) {
+            this.error('`--manual` cannot be combined with `--env`.');
+        }
+        if (manual) {
+            const name = flags.name?.trim() || undefined;
+            const requestedUpstreamPort = flags['upstream-port']?.trim() || undefined;
+            const upstreamPort = normalizeProxyListenPort(requestedUpstreamPort);
+            const storagePath = flags['storage-path']?.trim() || undefined;
+            const distRootPath = flags['dist-root-path']?.trim() || undefined;
+            const runtimeVersion = flags['runtime-version']?.trim() || undefined;
+            if (requestedUpstreamPort && !upstreamPort) {
+                this.error(`Invalid manual upstream port "${requestedUpstreamPort}". Use an integer between 1 and 65535.`);
+            }
+            if (!name || !upstreamPort || !storagePath || !distRootPath || !runtimeVersion) {
+                this.error('Manual mode requires `--name`, `--upstream-port`, `--storage-path`, `--dist-root-path`, and `--runtime-version`.');
+            }
+            const driver = await getCaddyProxyDriver();
+            const runtimeContext = await resolveCaddyProxyRuntimeContext();
+            announceTargetEnv(name);
+            startTask(`Generating caddy proxy config for env "${name}" with the ${driver} driver...`);
+            try {
+                const { bundle, status } = await writeManualCaddyProxyBundle({
+                    name,
+                    storagePath,
+                    distRootPath,
+                    runtimeVersion,
+                    appPublicPath: flags['app-public-path']?.trim() || undefined,
+                    upstreamHost: flags['upstream-host']?.trim() || undefined,
+                    upstreamPort,
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                }, {
+                    host: flags.host?.trim() || undefined,
+                    port: normalizedPort,
+                }, runtimeContext, {
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                });
+                succeedTask(status === 'created'
+                    ? `Saved caddy proxy files for env "${name}" under ${bundle.entryDir}, and created app.caddy at ${bundle.appConfigPath}.`
+                    : `Saved caddy proxy files for env "${name}" under ${bundle.entryDir}, and refreshed app.caddy at ${bundle.appConfigPath}.`);
+            }
+            catch (error) {
+                failTask(`Failed to generate caddy proxy config for env "${name}".`);
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
@@ -53,10 +131,18 @@ export default class ProxyCaddyGenerate extends Command {
         announceTargetEnv(runtime.envName);
         startTask(`Generating caddy proxy config for env "${runtime.envName}" with the ${driver} driver...`);
         try {
-            const { bundle, status } = await writeCaddyProxyBundle(runtime, {
-                host: flags.host?.trim() || undefined,
-                port: normalizedPort,
-            }, runtimeContext);
+            const savedAppEntryOptions = resolveEnvProxyEntry(runtime.env.config, 'caddy');
+            const appEntryOptions = {
+                host: flags.host?.trim() || savedAppEntryOptions?.host,
+                port: normalizedPort ?? (savedAppEntryOptions?.port !== undefined ? String(savedAppEntryOptions.port) : undefined),
+            };
+            const { bundle, status } = await writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext, {
+                cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+            });
+            await setEnvProxyEntry(runtime.envName, 'caddy', {
+                host: appEntryOptions.host,
+                port: appEntryOptions.port ? Number(appEntryOptions.port) : undefined,
+            }, { scope: resolveDefaultConfigScope() });
             succeedTask(status === 'created'
                 ? `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created app.caddy at ${bundle.appConfigPath}.`
                 : `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed app.caddy at ${bundle.appConfigPath}.`);

package/dist/commands/proxy/nginx/generate.js

@@ -8,19 +8,54 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
-import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.js';
+import { resolveDefaultConfigScope } from '../../../lib/cli-home.js';
+import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeManualNginxProxyBundle, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.js';
+import { resolveEnvProxyEntry, setEnvProxyEntry } from '../../../lib/auth-store.js';
 import { announceTargetEnv, failTask, startTask, succeedTask } from '../../../lib/ui.js';
 export default class ProxyNginxGenerate extends Command {
     static summary = 'Generate nginx proxy files for one managed env';
     static examples = [
+        '<%= config.bin %> proxy nginx generate --host app1.example.com',
         '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com',
         '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com --port 8080',
+        '<%= config.bin %> proxy nginx generate --manual --name default --storage-path /path/to/storage --dist-root-path /path/to/dist-client --runtime-version 2.1.0 --upstream-port 13000',
     ];
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name to generate proxy files for',
-            required: true,
+            description: 'CLI env name to generate proxy files for. Defaults to the current env when omitted',
+        }),
+        manual: Flags.boolean({
+            description: 'Generate proxy files from explicit runtime flags instead of a saved env',
+            default: false,
+        }),
+        name: Flags.string({
+            description: 'Output bundle name used under .nocobase/proxy/nginx in manual mode',
+        }),
+        'storage-path': Flags.string({
+            description: 'Path to the NocoBase storage directory in manual mode',
+        }),
+        'dist-root-path': Flags.string({
+            description: 'Path to the dist-client root directory used to generate index-v1.html and index-v2.html in manual mode',
+        }),
+        'runtime-version': Flags.string({
+            description: 'Frontend runtime version under dist-root-path in manual mode',
+        }),
+        'app-public-path': Flags.string({
+            description: 'Public base path served by the proxied app in manual mode. Defaults to /',
+        }),
+        'upstream-host': Flags.string({
+            description: 'Upstream host used by nginx proxy_pass in manual mode',
+        }),
+        'upstream-port': Flags.string({
+            description: 'Upstream port used by nginx proxy_pass in manual mode',
+        }),
+        'cdn-base-url': Flags.string({
+            description: 'Client asset CDN base URL used when generating runtime HTML',
+        }),
+        force: Flags.boolean({
+            description: 'Overwrite existing app.conf even when the managed block is missing',
+            default: false,
         }),
         host: Flags.string({
             description: 'Host exposed by the nginx entry config, such as example.com or localhost',
@@ -34,9 +69,56 @@ export default class ProxyNginxGenerate extends Command {
         const requestedEnv = flags.env?.trim() || undefined;
         const requestedPort = flags.port?.trim() || undefined;
         const normalizedPort = normalizeProxyListenPort(requestedPort);
+        const manual = Boolean(flags.manual);
         if (requestedPort && !normalizedPort) {
             this.error(`Invalid proxy entry port "${requestedPort}". Use an integer between 1 and 65535.`);
         }
+        if (manual && requestedEnv) {
+            this.error('`--manual` cannot be combined with `--env`.');
+        }
+        if (manual) {
+            const name = flags.name?.trim() || undefined;
+            const requestedUpstreamPort = flags['upstream-port']?.trim() || undefined;
+            const upstreamPort = normalizeProxyListenPort(requestedUpstreamPort);
+            const storagePath = flags['storage-path']?.trim() || undefined;
+            const distRootPath = flags['dist-root-path']?.trim() || undefined;
+            const runtimeVersion = flags['runtime-version']?.trim() || undefined;
+            if (requestedUpstreamPort && !upstreamPort) {
+                this.error(`Invalid manual upstream port "${requestedUpstreamPort}". Use an integer between 1 and 65535.`);
+            }
+            if (!name || !upstreamPort || !storagePath || !distRootPath || !runtimeVersion) {
+                this.error('Manual mode requires `--name`, `--upstream-port`, `--storage-path`, `--dist-root-path`, and `--runtime-version`.');
+            }
+            const driver = await getNginxProxyDriver();
+            const runtimeContext = await resolveNginxProxyRuntimeContext();
+            announceTargetEnv(name);
+            startTask(`Generating nginx proxy config for env "${name}" with the ${driver} driver...`);
+            try {
+                const { bundle, status } = await writeManualNginxProxyBundle({
+                    name,
+                    storagePath,
+                    distRootPath,
+                    runtimeVersion,
+                    appPublicPath: flags['app-public-path']?.trim() || undefined,
+                    upstreamHost: flags['upstream-host']?.trim() || undefined,
+                    upstreamPort,
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                }, {
+                    host: flags.host?.trim() || undefined,
+                    port: normalizedPort,
+                }, runtimeContext, {
+                    force: flags.force,
+                });
+                succeedTask(status === 'created'
+                    ? `Saved nginx proxy files for env "${name}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
+                    : `Saved nginx proxy files for env "${name}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`);
+            }
+            catch (error) {
+                failTask(`Failed to generate nginx proxy config for env "${name}".`);
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
@@ -52,10 +134,19 @@ export default class ProxyNginxGenerate extends Command {
         announceTargetEnv(runtime.envName);
         startTask(`Generating nginx proxy config for env "${runtime.envName}" with the ${driver} driver...`);
         try {
-            const { bundle, status } = await writeNginxProxyBundle(runtime, {
-                host: flags.host?.trim() || undefined,
-                port: normalizedPort,
-            }, runtimeContext);
+            const savedAppEntryOptions = resolveEnvProxyEntry(runtime.env.config, 'nginx');
+            const appEntryOptions = {
+                host: flags.host?.trim() || savedAppEntryOptions?.host,
+                port: normalizedPort ?? (savedAppEntryOptions?.port !== undefined ? String(savedAppEntryOptions.port) : undefined),
+            };
+            const { bundle, status } = await writeNginxProxyBundle(runtime, appEntryOptions, runtimeContext, {
+                cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                force: flags.force,
+            });
+            await setEnvProxyEntry(runtime.envName, 'nginx', {
+                host: appEntryOptions.host,
+                port: appEntryOptions.port ? Number(appEntryOptions.port) : undefined,
+            }, { scope: resolveDefaultConfigScope() });
             succeedTask(status === 'created'
                 ? `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
                 : `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`);

package/dist/commands/revision/create.js

@@ -100,7 +100,7 @@ export default class RevisionCreate extends Command {
             path: '/app:publishEvent',
             body: {
                 plugin: 'plugin-version-control',
-                command: 'revision:create',
+                command: 'revision.create',
                 payload: {
                     description,
                 },

package/dist/commands/self/check.js

@@ -20,7 +20,7 @@ export default class SelfCheck extends Command {
     static flags = {
         channel: Flags.string({
             description: 'Release channel to compare against. Defaults to the current CLI channel.',
-            options: ['auto', 'latest', 'beta', 'alpha'],
+            options: ['auto', 'latest', 'test', 'beta', 'alpha'],
             default: 'auto',
         }),
         json: Flags.boolean({

package/dist/commands/self/update.js

@@ -26,17 +26,17 @@ function formatSkillsUpdateMessage(result, verbose) {
 }
 export default class SelfUpdate extends Command {
     static summary = 'Update the globally installed NocoBase CLI';
-    static description = 'Update the current NocoBase CLI install when it is managed by a standard global npm install.';
+    static description = 'Update the current NocoBase CLI install when it is managed by a standard global npm, pnpm, or yarn install.';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --yes',
         '<%= config.bin %> <%= command.id %> --skills',
-        '<%= config.bin %> <%= command.id %> --channel alpha --json',
+        '<%= config.bin %> <%= command.id %> --channel test --json',
     ];
     static flags = {
         channel: Flags.string({
             description: 'Release channel to update to. Defaults to the current CLI channel.',
-            options: ['auto', 'latest', 'beta', 'alpha'],
+            options: ['auto', 'latest', 'test', 'beta', 'alpha'],
             default: 'auto',
         }),
         yes: Flags.boolean({
@@ -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/commands/skills/check.js

@@ -12,10 +12,7 @@ import { printInfo, renderTable } from '../../lib/ui.js';
 export default class SkillsCheck extends Command {
     static summary = 'Check the globally installed NocoBase AI coding skills';
     static description = 'Inspect the global NocoBase AI coding skills and report whether they are managed by the CLI and whether an update is available.';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --json',
-    ];
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --json'];
     static flags = {
         json: Flags.boolean({
             description: 'Output the result as JSON',
@@ -25,6 +22,7 @@ export default class SkillsCheck extends Command {
     async run() {
         const { flags } = await this.parse(SkillsCheck);
         const status = await inspectSkillsStatus();
+        const displaySkillNames = status.packageSkillNames.length ? status.packageSkillNames : status.installedSkillNames;
         if (flags.json) {
             this.log(JSON.stringify({
                 ok: true,
@@ -35,6 +33,7 @@ export default class SkillsCheck extends Command {
                 managedByNb: status.managedByNb,
                 sourcePackage: status.sourcePackage,
                 npmPackageName: status.npmPackageName,
+                packageSkillNames: status.packageSkillNames,
                 installedSkillNames: status.installedSkillNames,
                 installedVersion: status.installedVersion,
                 latestVersion: status.latestVersion,
@@ -50,7 +49,7 @@ export default class SkillsCheck extends Command {
             ['Skills home', status.globalRoot],
             ['Installed', status.installed ? 'yes' : 'no'],
             ['Managed by nb', status.managedByNb ? 'yes' : 'no'],
-            ['Installed skills', status.installedSkillNames.length ? status.installedSkillNames.join(', ') : '(none)'],
+            ['Installed skills', displaySkillNames.length ? displaySkillNames.join(', ') : '(none)'],
             ['Installed version', status.installedVersion ?? '(unknown)'],
             ['Latest version', status.latestVersion ?? '(unknown)'],
             ['Update available', status.updateAvailable === null ? 'unknown' : status.updateAvailable ? 'yes' : 'no'],

package/dist/commands/skills/install.js

@@ -8,7 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { confirm } from "../../lib/inquirer.js";
-import { setVerboseMode } from '../../lib/ui.js';
+import { setVerboseMode, startTask, stopTask, updateTask } from '../../lib/ui.js';
 import { installNocoBaseSkills } from '../../lib/skills-manager.js';
 export default class SkillsInstall extends Command {
     static summary = 'Install the NocoBase AI coding skills globally';
@@ -16,6 +16,8 @@ export default class SkillsInstall extends Command {
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --version 1.0.4',
+        '<%= config.bin %> <%= command.id %> --verbose',
         '<%= config.bin %> <%= command.id %> --json',
     ];
     static flags = {
@@ -32,6 +34,9 @@ export default class SkillsInstall extends Command {
             description: 'Show detailed install output',
             default: false,
         }),
+        version: Flags.string({
+            description: 'Install a specific @nocobase/skills version',
+        }),
     };
     async run() {
         const { flags } = await this.parse(SkillsInstall);
@@ -51,8 +56,20 @@ export default class SkillsInstall extends Command {
                 return;
             }
         }
+        const shouldShowLoading = !flags.json && !flags.verbose;
+        if (shouldShowLoading) {
+            startTask(flags.version
+                ? `Installing NocoBase AI coding skills ${flags.version}...`
+                : 'Installing NocoBase AI coding skills...');
+        }
         const result = await installNocoBaseSkills({
+            targetVersion: flags.version,
             verbose: flags.verbose,
+            onProgress: shouldShowLoading ? updateTask : undefined,
+        }).finally(() => {
+            if (shouldShowLoading) {
+                stopTask();
+            }
         });
         if (flags.json) {
             this.log(JSON.stringify({

package/dist/commands/skills/update.js

@@ -8,7 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { confirm } from "../../lib/inquirer.js";
-import { setVerboseMode } from '../../lib/ui.js';
+import { setVerboseMode, startTask, stopTask, updateTask } from '../../lib/ui.js';
 import { updateNocoBaseSkills } from '../../lib/skills-manager.js';
 export default class SkillsUpdate extends Command {
     static summary = 'Update the globally installed NocoBase AI coding skills';
@@ -16,6 +16,8 @@ export default class SkillsUpdate extends Command {
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --version 1.0.4',
+        '<%= config.bin %> <%= command.id %> --verbose',
         '<%= config.bin %> <%= command.id %> --json',
     ];
     static flags = {
@@ -32,6 +34,9 @@ export default class SkillsUpdate extends Command {
             description: 'Show detailed update output',
             default: false,
         }),
+        version: Flags.string({
+            description: 'Sync to a specific @nocobase/skills version',
+        }),
     };
     async run() {
         const { flags } = await this.parse(SkillsUpdate);
@@ -51,8 +56,20 @@ export default class SkillsUpdate extends Command {
                 return;
             }
         }
+        const shouldShowLoading = !flags.json && !flags.verbose;
+        if (shouldShowLoading) {
+            startTask(flags.version
+                ? `Syncing NocoBase AI coding skills to ${flags.version}...`
+                : 'Updating NocoBase AI coding skills...');
+        }
         const result = await updateNocoBaseSkills({
+            targetVersion: flags.version,
             verbose: flags.verbose,
+            onProgress: shouldShowLoading ? updateTask : undefined,
+        }).finally(() => {
+            if (shouldShowLoading) {
+                stopTask();
+            }
         });
         if (flags.json) {
             this.log(JSON.stringify({
@@ -80,8 +97,6 @@ export default class SkillsUpdate extends Command {
                 : 'NocoBase AI coding skills are up to date.');
             return;
         }
-        this.log(flags.verbose
-            ? 'Updated the global NocoBase AI coding skills.'
-            : 'Updated NocoBase AI coding skills globally.');
+        this.log(flags.verbose ? 'Updated the global NocoBase AI coding skills.' : 'Updated NocoBase AI coding skills globally.');
     }
 }

package/dist/commands/source/dev.js

@@ -8,8 +8,9 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
-import { ensureLocalPostinstall } from '../../lib/app-managed-resources.js';
+import { ensureLocalPostinstall, ensureNpmSourceDevDependencies } from '../../lib/app-managed-resources.js';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { findAvailableTcpPort } from '../../lib/prompt-validators.js';
 import { announceTargetEnv, failTask, printInfo, startTask, succeedTask } from '../../lib/ui.js';
 function formatUnsupportedRuntimeMessage(kind, envName) {
     if (kind === 'docker') {
@@ -129,10 +130,7 @@ export default class SourceDev extends Command {
             this.error(formatUnsupportedRuntimeMessage(runtime.kind, runtime.envName));
         }
         announceTargetEnv(runtime.envName);
-        const devPort = flags.port ||
-            (runtime.env.appPort !== undefined && runtime.env.appPort !== null
-                ? String(runtime.env.appPort).trim()
-                : undefined);
+        const devPort = flags.port?.trim() || (await findAvailableTcpPort());
         const appUrl = appUrlForPort(devPort);
         if (await isAppAlreadyRunning(appUrl)) {
             this.error([
@@ -160,6 +158,12 @@ export default class SourceDev extends Command {
         }
         printInfo(`Starting NocoBase dev mode for "${runtime.envName}" from ${runtime.projectRoot}. Press Ctrl+C to stop.`);
         try {
+            await ensureNpmSourceDevDependencies(runtime, {
+                onStartTask: startTask,
+                onSucceedTask: succeedTask,
+                onFailTask: failTask,
+                verbose: true,
+            });
             await ensureLocalPostinstall(runtime, {
                 onStartTask: startTask,
                 onSucceedTask: succeedTask,