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

package/dist/lib/source-publish.js

@@ -0,0 +1,306 @@
+/**
+ * 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, runNocoBaseCommand } 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 buildSourceSnapshot(params) {
+    const args = ['build'];
+    if (!params.buildDts) {
+        args.push('--no-dts');
+    }
+    await runNocoBaseCommand(args, {
+        cwd: params.cwd,
+        stdio: params.stdio,
+    });
+}
+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';
+    const shouldBuild = params.build !== false;
+    const shouldBuildDts = params.buildDts !== false;
+    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',
+            });
+        }
+        if (shouldBuild) {
+            await buildSourceSnapshot({
+                cwd: projectRoot,
+                buildDts: shouldBuildDts,
+                stdio,
+            });
+        }
+        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 { resolveCliHomeDir } 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(resolveCliHomeDir(), '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.36",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -67,6 +67,9 @@
       "self": {
         "description": "Inspect or update the NocoBase CLI itself."
       },
+      "backup": {
+        "description": "Create and restore NocoBase backups."
+      },
       "skills": {
         "description": "Inspect or synchronize NocoBase AI coding skills for the current workspace."
       },
@@ -93,7 +96,7 @@
     "ora": "^8.2.0",
     "pg": "^8.14.1",
     "picocolors": "^1.1.1",
-    "tar": "^7.4.3"
+    "tar": "^7.5.15"
   },
   "devDependencies": {
     "@types/node": "^18.19.130",
@@ -105,5 +108,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "ca804833299c547f8d49f8d58f73273a4bfcd03c"
+  "gitHead": "397d45c744f6eb48b3a0cd785c87cbf1257c3513"
 }