@nocobase/cli 2.1.0-beta.34 → 2.1.0-beta.35

package/bin/run.js

@@ -5,7 +5,7 @@ import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { normalizeSessionEnv } from './session-env.js';
+import { normalizeNodeOptions, normalizeSessionEnv } from './session-env.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const requireFromCli = createRequire(import.meta.url);
@@ -18,6 +18,7 @@ if (process.env.NB_CLI_USE_DIST === '1') {
 }
 
 normalizeSessionEnv();
+normalizeNodeOptions();
 
 /**
  * In the monorepo, plain `node` cannot load `.ts`. Re-exec once with `--import <tsx>`

package/bin/session-env.js

@@ -4,6 +4,7 @@ const SESSION_ENV_SOURCES = [
   'COPILOT_AGENT_SESSION_ID',
   'CLAUDE_CODE_SESSION_ID',
 ];
+const PRESERVE_SYMLINKS_FLAG = '--preserve-symlinks';
 
 export function resolveNormalizedSessionId(env = process.env) {
   for (const key of SESSION_ENV_SOURCES) {
@@ -25,3 +26,14 @@ export function normalizeSessionEnv(env = process.env) {
   env.NB_SESSION_ID = sessionId;
   return sessionId;
 }
+
+export function normalizeNodeOptions(env = process.env) {
+  const currentNodeOptions = String(env.NODE_OPTIONS ?? '').trim();
+  const flags = currentNodeOptions ? currentNodeOptions.split(/\s+/) : [];
+
+  if (!flags.includes(PRESERVE_SYMLINKS_FLAG)) {
+    env.NODE_OPTIONS = [...flags, PRESERVE_SYMLINKS_FLAG].join(' ');
+  }
+
+  return env.NODE_OPTIONS;
+}

package/dist/commands/app/start.js

@@ -10,7 +10,7 @@ import { Command, Flags } from '@oclif/core';
 import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, startDockerContainer, } from '../../lib/app-runtime.js';
 import { AppHealthCheckError, formatAppUrl, isAppReady, resolveManagedAppApiBaseUrl, waitForAppReady, } from '../../lib/app-health.js';
-import { ensureBuiltinDbReady, ensureSavedLocalSource, recreateSavedDockerApp, } from '../../lib/app-managed-resources.js';
+import { ensureBuiltinDbReady, ensureLocalPostinstall, ensureSavedLocalSource, recreateSavedDockerApp, } from '../../lib/app-managed-resources.js';
 import { run } from '../../lib/run-npm.js';
 import { announceTargetEnv, failTask, printInfo, startTask, succeedTask } from '../../lib/ui.js';
 function argvHasToken(argv, tokens) {
@@ -258,6 +258,17 @@ export default class AppStart extends Command {
             }
             return;
         }
+        try {
+            await ensureLocalPostinstall(runtime, {
+                verbose: flags.verbose,
+                onStartTask: startTask,
+                onSucceedTask: succeedTask,
+                onFailTask: failTask,
+            });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
         if (flags.daemon === false) {
             printInfo(`Starting NocoBase for "${runtime.envName}" in the foreground${appUrl ? ` at ${appUrl}` : ''}. Press Ctrl+C to stop.`);
         }

package/dist/commands/app/upgrade.js

@@ -8,6 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { upsertEnv } from '../../lib/auth-store.js';
+import { ensureLocalPostinstall } from '../../lib/app-managed-resources.js';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, startDockerContainer, stopDockerContainer, } from '../../lib/app-runtime.js';
 import { resolveConfiguredEnvPath } from '../../lib/cli-home.js';
 import { deriveBuiltinDbConnection } from '../../lib/builtin-db.js';
@@ -436,6 +437,12 @@ export default class AppUpgrade extends Command {
         else {
             printInfo(`Skipping code download for "${runtime.envName}" because this env is managed from an existing local app path.`);
         }
+        await ensureLocalPostinstall(runtime, {
+            verbose: flags.verbose,
+            onStartTask: startTask,
+            onSucceedTask: succeedTask,
+            onFailTask: failTask,
+        });
         startTask(`Starting upgraded NocoBase for "${runtime.envName}"...`);
         try {
             await runLocalNocoBaseCommand(runtime, AppUpgrade.buildLocalStartArgv(runtime), {

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 { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
-import { announceTargetEnv, printInfo } from '../../lib/ui.js';
+import { announceTargetEnv, failTask, printInfo, startTask, succeedTask } from '../../lib/ui.js';
 function formatUnsupportedRuntimeMessage(kind, envName) {
     if (kind === 'docker') {
         return [
@@ -159,6 +160,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 ensureLocalPostinstall(runtime, {
+                onStartTask: startTask,
+                onSucceedTask: succeedTask,
+                onFailTask: failTask,
+                verbose: true,
+            });
             await runLocalNocoBaseCommand(runtime, npmArgs, {
                 stdio: 'inherit',
             });

package/dist/commands/source/publish.js

@@ -0,0 +1,92 @@
+/**
+ * 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 { Command, Flags } from '@oclif/core';
+import { buildSuggestedInitCommand, publishSourceSnapshot } from '../../lib/source-publish.js';
+import { failTask, printInfo, startTask, succeedTask } from '../../lib/ui.js';
+function formatPublishFailure(message) {
+    return [
+        'Couldn\'t publish a source snapshot.',
+        'Check that Docker is running, the target npm registry is reachable, and the current directory is a NocoBase source repo.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+export default class SourcePublish extends Command {
+    static description = 'Publish the current NocoBase source repo as a snapshot version to an npm registry for install testing.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --snapshot',
+        '<%= config.bin %> <%= command.id %> --snapshot --cwd /path/to/nocobase/source',
+        '<%= config.bin %> <%= command.id %> --snapshot --npm-registry=http://127.0.0.1:4873',
+        '<%= config.bin %> <%= command.id %> --snapshot --json',
+    ];
+    static flags = {
+        snapshot: Flags.boolean({
+            description: 'Publish the current source repo as a unique snapshot version',
+            required: true,
+            default: false,
+        }),
+        'npm-registry': Flags.string({
+            description: 'npm registry URL to publish to. Defaults to the running local source registry when available',
+            required: false,
+        }),
+        cwd: Flags.string({
+            description: 'Source repository path. Defaults to the nearest detected NocoBase source root from the current working directory',
+            required: false,
+        }),
+        json: Flags.boolean({
+            description: 'Print the publish result as JSON',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show detailed command output while versioning and publishing the snapshot',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SourcePublish);
+        if (!flags.snapshot) {
+            this.error('`nb source publish` currently requires `--snapshot`.');
+        }
+        if (!flags.json) {
+            startTask('Publishing a source snapshot...');
+        }
+        try {
+            const result = await publishSourceSnapshot({
+                cwd: flags.cwd,
+                npmRegistry: flags['npm-registry'],
+                verbose: flags.verbose,
+            });
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    version: result.version,
+                    npmRegistry: result.npmRegistry,
+                    gitSha: result.gitSha,
+                    projectRoot: result.projectRoot,
+                    suggestedInitCommand: buildSuggestedInitCommand(result),
+                }, null, 2));
+                return;
+            }
+            succeedTask(`Published source snapshot ${result.version} to ${result.npmRegistry}.`);
+            printInfo(`Source root: ${result.projectRoot}`);
+            printInfo(`Snapshot version: ${result.version}`);
+            printInfo(`npm registry: ${result.npmRegistry}`);
+            printInfo(`Next: ${buildSuggestedInitCommand(result)}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (flags.json) {
+                this.logToStderr(JSON.stringify({
+                    error: formatPublishFailure(message),
+                }, null, 2));
+                this.exit(1);
+            }
+            failTask('Failed to publish the source snapshot.');
+            this.error(formatPublishFailure(message));
+        }
+    }
+}

package/dist/commands/source/registry/logs.js

@@ -0,0 +1,70 @@
+/**
+ * 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 { Command, Flags } from '@oclif/core';
+import { run } from '../../../lib/run-npm.js';
+import { printInfo } from '../../../lib/ui.js';
+import { getSourceRegistryInfo } from '../../../lib/source-registry.js';
+function formatLogsFailure(message) {
+    if (/does not exist/i.test(message)) {
+        return [
+            'Can\'t show source registry logs yet.',
+            'The saved source registry container could not be found on this machine.',
+            'Start the registry first with `nb source registry start`.',
+            `Details: ${message}`,
+        ].join('\n');
+    }
+    return [
+        'Couldn\'t show source registry logs.',
+        'Check that Docker is installed and the source registry container still exists, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+export default class SourceRegistryLogs extends Command {
+    static description = 'Show logs for the local Docker-based npm registry used for source tests.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --tail 200',
+        '<%= config.bin %> <%= command.id %> --follow',
+    ];
+    static flags = {
+        tail: Flags.integer({
+            description: 'Number of recent log lines to show before following',
+            default: 100,
+            min: 0,
+        }),
+        follow: Flags.boolean({
+            char: 'f',
+            description: 'Keep streaming new log lines',
+            default: false,
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SourceRegistryLogs);
+        const info = getSourceRegistryInfo();
+        printInfo(flags.follow
+            ? `Showing source registry logs from "${info.containerName}" (press Ctrl+C to stop).`
+            : `Showing recent source registry logs from "${info.containerName}".`);
+        const dockerArgs = ['logs', '--tail', String(flags.tail ?? 100)];
+        if (flags.follow) {
+            dockerArgs.push('--follow');
+        }
+        dockerArgs.push(info.containerName);
+        try {
+            await run('docker', dockerArgs, {
+                errorName: 'docker logs',
+                stdio: 'inherit',
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(formatLogsFailure(message));
+        }
+    }
+}

package/dist/commands/source/registry/start.js

@@ -0,0 +1,57 @@
+/**
+ * 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 { Command, Flags } from '@oclif/core';
+import { failTask, startTask, succeedTask } from '../../../lib/ui.js';
+import { getSourceRegistryInfo, startSourceRegistry } from '../../../lib/source-registry.js';
+function formatStartFailure(message) {
+    if (/port is already allocated|address already in use/i.test(message)) {
+        return [
+            'Can\'t start the source registry.',
+            'Port 4873 is already in use on this machine.',
+            'Stop the conflicting process, or free the port before trying again.',
+            `Details: ${message}`,
+        ].join('\n');
+    }
+    return [
+        'Couldn\'t start the source registry.',
+        'Check that Docker is installed and running, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+export default class SourceRegistryStart extends Command {
+    static description = 'Start the local Docker-based npm registry used for source snapshot publish and install tests.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --verbose',
+    ];
+    static flags = {
+        verbose: Flags.boolean({
+            description: 'Show raw Docker output while starting the registry container',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SourceRegistryStart);
+        const info = getSourceRegistryInfo();
+        startTask(`Starting the source registry at ${info.url}...`);
+        try {
+            const state = await startSourceRegistry({
+                stdio: flags.verbose ? 'inherit' : 'ignore',
+            });
+            succeedTask(state === 'already-running'
+                ? `The source registry is already running at ${info.url}.`
+                : `The source registry is running at ${info.url}.`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failTask('Failed to start the source registry.');
+            this.error(formatStartFailure(message));
+        }
+    }
+}

package/dist/commands/source/registry/status.js

@@ -0,0 +1,33 @@
+/**
+ * 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 { Command, Flags } from '@oclif/core';
+import { renderTable } from '../../../lib/ui.js';
+import { resolveSourceRegistryInfo } from '../../../lib/source-registry.js';
+export default class SourceRegistryStatus extends Command {
+    static description = 'Show the status of the local Docker-based npm registry used for source tests.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'Print the source registry status as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SourceRegistryStatus);
+        const info = await resolveSourceRegistryInfo();
+        if (flags.json) {
+            this.log(JSON.stringify(info, null, 2));
+            return;
+        }
+        this.log(renderTable(['Container', 'Status', 'URL', 'Storage'], [[info.containerName, info.status, info.url, info.storageDir]]));
+    }
+}

package/dist/commands/source/registry/stop.js

@@ -0,0 +1,48 @@
+/**
+ * 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 { Command, Flags } from '@oclif/core';
+import { failTask, startTask, succeedTask } from '../../../lib/ui.js';
+import { stopSourceRegistry } from '../../../lib/source-registry.js';
+function formatStopFailure(message) {
+    return [
+        'Couldn\'t stop the source registry.',
+        'Check that Docker is installed and the saved registry container still exists, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+export default class SourceRegistryStop extends Command {
+    static description = 'Stop the local Docker-based npm registry used for source snapshot tests.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --verbose',
+    ];
+    static flags = {
+        verbose: Flags.boolean({
+            description: 'Show raw Docker output while stopping the registry container',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SourceRegistryStop);
+        startTask('Stopping the source registry...');
+        try {
+            const state = await stopSourceRegistry({
+                stdio: flags.verbose ? 'inherit' : 'ignore',
+            });
+            succeedTask(state === 'already-stopped'
+                ? 'The source registry is already stopped.'
+                : 'The source registry has stopped.');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failTask('Failed to stop the source registry.');
+            this.error(formatStopFailure(message));
+        }
+    }
+}

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

@@ -7,7 +7,7 @@
  * 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 { dockerContainerExists, runLocalNocoBaseCommand, startDockerContainer } from './app-runtime.js';
 import { deriveBuiltinDbConnection, resolveBuiltinDbConnection } from './builtin-db.js';
 import { resolveConfiguredEnvPath } from './cli-home.js';
 import { resolveDockerEnvFileArg } from "./docker-env-file.js";
@@ -58,6 +58,14 @@ function formatLocalSourceRestoreFailure(envName, source, message) {
         `Details: ${message}`,
     ].join('\n');
 }
+function formatLocalPostinstallFailure(envName, message) {
+    return [
+        `Couldn't prepare NocoBase for "${envName}".`,
+        'The CLI was not able to run `nocobase-v1 postinstall` before starting the local app.',
+        'Check the local dependencies, storage path, and saved env settings, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
 function formatSavedDockerSettingsIncomplete(envName, missing) {
     return [
         `Can't start NocoBase for "${envName}" yet.`,
@@ -274,3 +282,16 @@ export async function ensureSavedLocalSource(runtime, runCommand, options) {
         throw new Error(formatLocalSourceRestoreFailure(runtime.envName, runtime.source, error instanceof Error ? error.message : String(error)));
     }
 }
+export async function ensureLocalPostinstall(runtime, options) {
+    options?.onStartTask?.(`Running local postinstall for "${runtime.envName}"...`);
+    try {
+        await runLocalNocoBaseCommand(runtime, ['postinstall'], {
+            stdio: commandStdio(options?.verbose),
+        });
+        options?.onSucceedTask?.(`Local postinstall finished for "${runtime.envName}".`);
+    }
+    catch (error) {
+        options?.onFailTask?.(`Failed to run local postinstall for "${runtime.envName}".`);
+        throw new Error(formatLocalPostinstallFailure(runtime.envName, error instanceof Error ? error.message : String(error)));
+    }
+}

package/dist/lib/run-npm.js

@@ -44,16 +44,15 @@ export function resolveCwd(cwd) {
 }
 export function resolveProjectCwd(cwd) {
     const normalizedCwd = typeof cwd === 'string' && cwd.trim() === '' ? undefined : cwd;
-    const next = normalizedCwd ?? process.cwd();
-    const resolvedNext = resolveCwd(normalizedCwd);
-    if (!normalizedCwd || path.isAbsolute(next)) {
-        return resolvedNext;
-    }
-    const baseCwd = process.cwd();
-    let current = baseCwd;
-    const fallback = resolvedNext;
+    const fallback = resolveCwd(normalizedCwd);
+    const isAbsoluteInput = typeof normalizedCwd === 'string' && path.isAbsolute(normalizedCwd);
+    let current = isAbsoluteInput ? fallback : process.cwd();
     while (true) {
-        const candidate = path.resolve(current, next);
+        const candidate = isAbsoluteInput
+            ? current
+            : normalizedCwd
+                ? path.resolve(current, normalizedCwd)
+                : current;
         if (hasLocalNocoBaseBinary(candidate)) {
             return candidate;
         }

package/dist/lib/source-publish.js

@@ -0,0 +1,287 @@
+/**
+ * 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 { commandOutput, resolveProjectCwd, run } from './run-npm.js';
+import { DEFAULT_SOURCE_REGISTRY_PORT, parseSourceRegistryUrl, resolveSourceRegistryInfo } from './source-registry.js';
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function sanitizeEnvSegment(value) {
+    return trimValue(value).replace(/[^A-Za-z0-9]+/g, '').slice(0, 16);
+}
+export async function resolveSourcePublishRegistry(explicitRegistry) {
+    const normalized = trimValue(explicitRegistry);
+    if (normalized) {
+        return normalized;
+    }
+    const info = await resolveSourceRegistryInfo();
+    if (info.status === 'running') {
+        return info.url;
+    }
+    throw new Error([
+        'No npm registry was provided for source publish.',
+        'Start the local source registry with `nb source registry start`, or pass `--npm-registry <url>` explicitly.',
+    ].join('\n'));
+}
+export async function resolveGitSha(cwd) {
+    return await commandOutput('git', ['rev-parse', '--short', 'HEAD'], {
+        cwd,
+        errorName: 'git rev-parse',
+    });
+}
+export async function readRootVersion(cwd) {
+    const root = resolveProjectCwd(cwd);
+    const { readFile } = await import('node:fs/promises');
+    const content = await readFile(path.join(root, 'lerna.json'), 'utf8');
+    const parsed = JSON.parse(content);
+    const version = trimValue(parsed.version);
+    if (!version) {
+        throw new Error(`Couldn't read a version from ${path.join(root, 'lerna.json')}.`);
+    }
+    return version;
+}
+export function buildSnapshotVersion(baseVersion, gitSha, now = new Date()) {
+    const yyyy = String(now.getFullYear()).padStart(4, '0');
+    const mm = String(now.getMonth() + 1).padStart(2, '0');
+    const dd = String(now.getDate()).padStart(2, '0');
+    return `${baseVersion}-snapshot.${yyyy}${mm}${dd}.${gitSha}`;
+}
+export async function resolveGitBranch(cwd) {
+    const branch = trimValue(await commandOutput('git', ['branch', '--show-current'], {
+        cwd,
+        errorName: 'git branch --show-current',
+    }));
+    if (!branch) {
+        throw new Error('`nb source publish --snapshot` requires a named Git branch. Detached HEAD is not supported.');
+    }
+    return branch;
+}
+export async function hasLocalGitChanges(cwd) {
+    const output = await commandOutput('git', ['status', '--short', '--untracked-files=all'], {
+        cwd,
+        errorName: 'git status',
+    });
+    return trimValue(output).length > 0;
+}
+export function buildSourcePublishBranchName(gitSha, now = new Date()) {
+    const yyyy = String(now.getFullYear()).padStart(4, '0');
+    const mm = String(now.getMonth() + 1).padStart(2, '0');
+    const dd = String(now.getDate()).padStart(2, '0');
+    const hh = String(now.getHours()).padStart(2, '0');
+    const mi = String(now.getMinutes()).padStart(2, '0');
+    const ss = String(now.getSeconds()).padStart(2, '0');
+    return `nb/source-publish-${yyyy}${mm}${dd}${hh}${mi}${ss}-${gitSha}`;
+}
+async function runGit(args, options) {
+    await run('git', args, {
+        cwd: options?.cwd,
+        stdio: options?.stdio,
+        env: options?.env,
+        errorName: options?.errorName ?? `git ${args.join(' ')}`,
+    });
+}
+async function commitSourceSnapshotVersion(params) {
+    await runGit(['add', '-A'], {
+        cwd: params.cwd,
+        stdio: params.stdio,
+        errorName: 'git add',
+    });
+    await runGit(['commit', '--no-verify', '-m', `chore(source-publish): ${params.version}`], {
+        cwd: params.cwd,
+        stdio: params.stdio,
+        errorName: 'git commit',
+    });
+}
+async function createSourcePublishStash(params) {
+    if (!(await hasLocalGitChanges(params.cwd))) {
+        return undefined;
+    }
+    await runGit(['stash', 'push', '-u', '-m', params.label], {
+        cwd: params.cwd,
+        stdio: params.stdio,
+        errorName: 'git stash push',
+    });
+    return {
+        commit: trimValue(await commandOutput('git', ['rev-parse', '--verify', 'refs/stash'], {
+            cwd: params.cwd,
+            errorName: 'git rev-parse refs/stash',
+        })),
+    };
+}
+async function resolveSourcePublishStashReference(params) {
+    const output = trimValue(await commandOutput('git', ['stash', 'list', '--format=%gd%x00%H'], {
+        cwd: params.cwd,
+        errorName: 'git stash list',
+    }));
+    for (const line of output.split('\n')) {
+        const [reference, commit] = line.split('\x00');
+        if (trimValue(commit) === params.stash.commit) {
+            return trimValue(reference);
+        }
+    }
+    throw new Error(`Couldn't locate the saved stash for source publish: ${params.stash.commit}`);
+}
+function buildSourcePublishRecoveryError(params) {
+    const originalMessage = params.originalError instanceof Error
+        ? params.originalError.message
+        : String(params.originalError);
+    const cleanupMessage = params.cleanupError instanceof Error
+        ? params.cleanupError.message
+        : String(params.cleanupError);
+    const recoveryHints = [
+        `Project root: ${params.projectRoot}`,
+        `Temporary branch: ${params.temporaryBranch}`,
+    ];
+    if (params.stash) {
+        recoveryHints.push(`Saved stash commit: ${params.stash.commit}`);
+    }
+    return new Error([
+        originalMessage,
+        '',
+        'Cleanup also failed after the publish attempt.',
+        `Cleanup error: ${cleanupMessage}`,
+        ...recoveryHints,
+    ].join('\n'));
+}
+export async function publishSourceSnapshot(params) {
+    const projectRoot = resolveProjectCwd(params.cwd);
+    const npmRegistry = await resolveSourcePublishRegistry(params.npmRegistry);
+    const originalBranch = await resolveGitBranch(projectRoot);
+    const gitSha = trimValue(await resolveGitSha(projectRoot));
+    const baseVersion = await readRootVersion(projectRoot);
+    const version = buildSnapshotVersion(baseVersion, gitSha, params.now);
+    const temporaryBranch = buildSourcePublishBranchName(gitSha, params.now);
+    const stdio = params.verbose ? 'inherit' : 'ignore';
+    let stash;
+    let onTemporaryBranch = false;
+    let branchCreated = false;
+    let publishError;
+    let result;
+    try {
+        stash = await createSourcePublishStash({
+            cwd: projectRoot,
+            label: temporaryBranch,
+            stdio,
+        });
+        await runGit(['switch', '-c', temporaryBranch], {
+            cwd: projectRoot,
+            stdio,
+            errorName: 'git switch',
+        });
+        branchCreated = true;
+        onTemporaryBranch = true;
+        if (stash) {
+            await runGit(['stash', 'apply', '--index', await resolveSourcePublishStashReference({
+                    cwd: projectRoot,
+                    stash,
+                })], {
+                cwd: projectRoot,
+                stdio,
+                errorName: 'git stash apply',
+            });
+        }
+        await run('yarn', ['lerna', 'version', version, '--force-publish=*', '--no-git-tag-version', '-y'], {
+            cwd: projectRoot,
+            errorName: 'lerna version',
+            stdio,
+        });
+        await commitSourceSnapshotVersion({
+            cwd: projectRoot,
+            version,
+            stdio,
+        });
+        await run('yarn', ['lerna', 'publish', 'from-package', '--registry', npmRegistry, '--dist-tag', 'local', '--yes', '--no-verify-access', '--git-head', gitSha], {
+            cwd: projectRoot,
+            errorName: 'lerna publish',
+            stdio,
+            env: {
+                npm_config_registry: npmRegistry,
+            },
+        });
+        result = {
+            version,
+            npmRegistry,
+            gitSha,
+            projectRoot,
+        };
+    }
+    catch (error) {
+        publishError = error;
+    }
+    try {
+        if (onTemporaryBranch) {
+            await runGit(['reset', '--hard', 'HEAD'], {
+                cwd: projectRoot,
+                stdio,
+                errorName: 'git reset --hard',
+            });
+            await runGit(['clean', '-fd'], {
+                cwd: projectRoot,
+                stdio,
+                errorName: 'git clean -fd',
+            });
+            await runGit(['switch', originalBranch], {
+                cwd: projectRoot,
+                stdio,
+                errorName: 'git switch',
+            });
+            onTemporaryBranch = false;
+        }
+        if (stash) {
+            await runGit(['stash', 'pop', '--index', await resolveSourcePublishStashReference({
+                    cwd: projectRoot,
+                    stash,
+                })], {
+                cwd: projectRoot,
+                stdio,
+                errorName: 'git stash pop',
+            });
+            stash = undefined;
+        }
+        if (branchCreated) {
+            await runGit(['branch', '-D', temporaryBranch], {
+                cwd: projectRoot,
+                stdio,
+                errorName: 'git branch -D',
+            });
+        }
+    }
+    catch (cleanupError) {
+        if (publishError) {
+            throw buildSourcePublishRecoveryError({
+                originalError: publishError,
+                cleanupError,
+                stash,
+                temporaryBranch,
+                projectRoot,
+            });
+        }
+        throw new Error([
+            'The source snapshot was published, but local Git cleanup failed afterwards.',
+            `Cleanup error: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`,
+            `Project root: ${projectRoot}`,
+            `Temporary branch: ${temporaryBranch}`,
+            ...(stash ? [`Saved stash commit: ${stash.commit}`] : []),
+        ].join('\n'));
+    }
+    if (publishError) {
+        throw publishError;
+    }
+    return result;
+}
+export function buildSuggestedInitCommand(result) {
+    const { host, port } = parseSourceRegistryUrl(result.npmRegistry);
+    const normalizedRegistry = result.npmRegistry || `http://${host}:${port || DEFAULT_SOURCE_REGISTRY_PORT}`;
+    const suggestedEnv = ['snapshot', sanitizeEnvSegment(result.gitSha)].filter(Boolean).join('');
+    return [
+        `nb init --env ${suggestedEnv} --yes --source npm`,
+        `--version ${result.version}`,
+        `--npm-registry=${normalizedRegistry}`,
+    ].join(' ');
+}

package/dist/lib/source-registry.js

@@ -0,0 +1,188 @@
+/**
+ * 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 fsp from 'node:fs/promises';
+import path from 'node:path';
+import { commandOutput, commandSucceeds, resolveCwd, resolveProjectCwd, run } from './run-npm.js';
+import { resolveCliHomeRoot } from './cli-home.js';
+export const DEFAULT_SOURCE_REGISTRY_HOST = '127.0.0.1';
+export const DEFAULT_SOURCE_REGISTRY_PORT = 4873;
+export const DEFAULT_SOURCE_REGISTRY_CONTAINER_NAME = 'nb-source-registry';
+export const DEFAULT_SOURCE_REGISTRY_IMAGE = 'verdaccio/verdaccio';
+export function parseSourceRegistryUrl(url) {
+    const parsed = new URL(url);
+    const host = trimValue(parsed.hostname) || DEFAULT_SOURCE_REGISTRY_HOST;
+    const portText = trimValue(parsed.port);
+    const port = portText ? Number(portText) : DEFAULT_SOURCE_REGISTRY_PORT;
+    return {
+        host,
+        port: Number.isFinite(port) && port > 0 ? port : DEFAULT_SOURCE_REGISTRY_PORT,
+    };
+}
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function asPosixPathForDockerMount(value) {
+    return resolveCwd(value).replace(/\\/g, '/');
+}
+export function resolveSourceRegistryRootDir() {
+    return path.join(resolveCliHomeRoot(), 'verdaccio');
+}
+export function resolveSourceRegistryConfigPath() {
+    return path.join(resolveSourceRegistryRootDir(), 'config.yaml');
+}
+export function resolveSourceRegistryStorageDir() {
+    return path.join(resolveSourceRegistryRootDir(), 'storage');
+}
+export function resolveSourceRegistryUrl(host = DEFAULT_SOURCE_REGISTRY_HOST, port = DEFAULT_SOURCE_REGISTRY_PORT) {
+    return `http://${host}:${port}`;
+}
+export function getSourceRegistryInfo() {
+    const host = DEFAULT_SOURCE_REGISTRY_HOST;
+    const port = DEFAULT_SOURCE_REGISTRY_PORT;
+    const rootDir = resolveSourceRegistryRootDir();
+    return {
+        containerName: DEFAULT_SOURCE_REGISTRY_CONTAINER_NAME,
+        image: DEFAULT_SOURCE_REGISTRY_IMAGE,
+        host,
+        port,
+        url: resolveSourceRegistryUrl(host, port),
+        rootDir,
+        configPath: resolveSourceRegistryConfigPath(),
+        storageDir: resolveSourceRegistryStorageDir(),
+        status: 'missing',
+    };
+}
+export function resolveSourceRegistryTemplatePath(cwd) {
+    return path.join(resolveProjectCwd(cwd), 'config.yaml');
+}
+function applySourceRegistryTemplateOverrides(template) {
+    return template
+        .replace(/\r\n/g, '\n')
+        .replace(/^storage:\s*.+$/m, 'storage: /verdaccio/storage')
+        .replace(/^(\s*)file:\s*\.\/*htpasswd\s*$/m, '$1file: /verdaccio/storage/htpasswd')
+        .replace(/^(\s*)publish:\s+\$authenticated\s*$/gm, '$1publish: $all')
+        .replace(/^(\s*)unpublish:\s+\$authenticated\s*$/gm, '$1unpublish: $all');
+}
+async function buildFallbackSourceRegistryConfigTemplate() {
+    return [
+        'storage: ./storage',
+        'auth:',
+        '  htpasswd:',
+        '    file: ./htpasswd',
+        'uplinks:',
+        '  npmjs:',
+        '    url: https://registry.npmmirror.com/',
+        'packages:',
+        "  '@*/*':",
+        '    access: $all',
+        '    publish: $authenticated',
+        '    unpublish: $authenticated',
+        '    proxy: npmjs',
+        "  '**':",
+        '    access: $all',
+        '    publish: $authenticated',
+        '    unpublish: $authenticated',
+        '    proxy: npmjs',
+        'server:',
+        '  keepAliveTimeout: 60',
+        '  dotfiles: ignore',
+        'max_body_size: 100mb',
+        'middlewares:',
+        '  audit:',
+        '    enabled: true',
+        '',
+    ].join('\n');
+}
+export async function buildSourceRegistryConfig(cwd) {
+    const templatePath = resolveSourceRegistryTemplatePath(cwd);
+    try {
+        const template = await fsp.readFile(templatePath, 'utf8');
+        return applySourceRegistryTemplateOverrides(template);
+    }
+    catch {
+        const fallback = await buildFallbackSourceRegistryConfigTemplate();
+        return applySourceRegistryTemplateOverrides(fallback);
+    }
+}
+export async function ensureSourceRegistryFiles(cwd) {
+    const info = getSourceRegistryInfo();
+    await fsp.mkdir(info.storageDir, { recursive: true });
+    await fsp.mkdir(info.rootDir, { recursive: true });
+    await fsp.writeFile(info.configPath, await buildSourceRegistryConfig(cwd), 'utf8');
+    return info;
+}
+export async function sourceRegistryContainerExists(containerName = DEFAULT_SOURCE_REGISTRY_CONTAINER_NAME) {
+    return await commandSucceeds('docker', ['container', 'inspect', containerName]);
+}
+export async function sourceRegistryContainerIsRunning(containerName = DEFAULT_SOURCE_REGISTRY_CONTAINER_NAME) {
+    try {
+        const output = await commandOutput('docker', ['inspect', '--format', '{{.State.Running}}', containerName], { errorName: 'docker inspect' });
+        return trimValue(output) === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveSourceRegistryInfo() {
+    const base = getSourceRegistryInfo();
+    if (!(await sourceRegistryContainerExists(base.containerName))) {
+        return base;
+    }
+    return {
+        ...base,
+        status: (await sourceRegistryContainerIsRunning(base.containerName)) ? 'running' : 'stopped',
+    };
+}
+export async function startSourceRegistry(options) {
+    const info = await ensureSourceRegistryFiles(options?.cwd);
+    const exists = await sourceRegistryContainerExists(info.containerName);
+    if (exists) {
+        if (await sourceRegistryContainerIsRunning(info.containerName)) {
+            return 'already-running';
+        }
+        await run('docker', ['start', info.containerName], {
+            errorName: 'docker start',
+            stdio: options?.stdio,
+        });
+        return 'started';
+    }
+    const configMount = `${asPosixPathForDockerMount(info.configPath)}:/verdaccio/conf/config.yaml`;
+    const storageMount = `${asPosixPathForDockerMount(info.storageDir)}:/verdaccio/storage`;
+    await run('docker', [
+        'run',
+        '-d',
+        '--name',
+        info.containerName,
+        '-p',
+        `${info.port}:4873`,
+        '-v',
+        configMount,
+        '-v',
+        storageMount,
+        info.image,
+    ], {
+        errorName: 'docker run',
+        stdio: options?.stdio,
+    });
+    return 'started';
+}
+export async function stopSourceRegistry(options) {
+    const info = getSourceRegistryInfo();
+    if (!(await sourceRegistryContainerExists(info.containerName))) {
+        return 'already-stopped';
+    }
+    if (!(await sourceRegistryContainerIsRunning(info.containerName))) {
+        return 'already-stopped';
+    }
+    await run('docker', ['stop', info.containerName], {
+        errorName: 'docker stop',
+        stdio: options?.stdio,
+    });
+    return 'stopped';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.1.0-beta.34",
+  "version": "2.1.0-beta.35",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -105,5 +105,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "ca804833299c547f8d49f8d58f73273a4bfcd03c"
+  "gitHead": "74310d8b9e9581fcde14b5a93d12b41ddb5bb325"
 }