@nocobase/cli 2.1.0-alpha.45 → 2.1.0-alpha.47

package/dist/lib/inquirer.js

@@ -103,7 +103,7 @@ export const input = createPrompt((config, done) => {
             rl.write(config.default);
             setValue(config.default);
         }
-    }, []);
+    }, [config.default]);
     useKeypress(async (key, rl) => {
         if (status !== 'idle')
             return;
@@ -232,11 +232,10 @@ export const password = createPrompt((config, done) => {
     });
     const message = theme.style.message(config.message, status);
     const maskChar = resolveMaskChar(config.mask);
+    const transformedValue = value ? config.transformer?.(value) : undefined;
     const displayValue = status === 'done'
-        ? theme.style.answer(maskChar.repeat(value.length))
-        : maskChar
-            ? maskChar.repeat(value.length)
-            : '';
+        ? theme.style.answer(transformedValue ?? maskChar.repeat(value.length))
+        : transformedValue ?? (maskChar ? maskChar.repeat(value.length) : '');
     const headerLine = [prefix, message].filter(Boolean).join(' ');
     const inputLine = buildInputLine(displayValue);
     const prompt = headerLine.endsWith('\n') ? `${headerLine}${inputLine}` : `${headerLine}\n${inputLine}`;

package/dist/lib/managed-env-file.js

@@ -0,0 +1,98 @@
+/**
+ * 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 { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { resolveConfiguredEnvPath } from './cli-home.js';
+import { resolveDockerEnvFileArg } from "./docker-env-file.js";
+import { resolveConfiguredAppPath } from './env-paths.js';
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function stripWrappingQuotes(value) {
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+        return value
+            .slice(1, -1)
+            .replace(/\\n/g, '\n')
+            .replace(/\\r/g, '\r')
+            .replace(/\\t/g, '\t')
+            .replace(/\\"/g, '"')
+            .replace(/\\\\/g, '\\');
+    }
+    if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+export function parseSimpleEnvFile(content) {
+    const values = {};
+    for (const rawLine of content.split(/\r?\n/)) {
+        const trimmed = rawLine.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const line = trimmed.startsWith('export ') ? trimmed.slice('export '.length).trim() : trimmed;
+        const separatorIndex = line.indexOf('=');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        if (!key) {
+            continue;
+        }
+        values[key] = stripWrappingQuotes(line.slice(separatorIndex + 1).trim());
+    }
+    return values;
+}
+export function resolveManagedLocalEnvFilePath(runtime) {
+    const config = runtime.env.config ?? {};
+    const explicitEnvFile = trimValue(config.envFile);
+    if (explicitEnvFile) {
+        return resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile;
+    }
+    const configuredAppPath = resolveConfiguredAppPath(config);
+    if (configuredAppPath) {
+        return path.join(configuredAppPath, '.env');
+    }
+    if (path.basename(runtime.projectRoot) === 'source') {
+        return path.resolve(runtime.projectRoot, '..', '.env');
+    }
+    return path.join(runtime.projectRoot, '.env');
+}
+export async function resolveManagedRuntimeEnvFilePath(runtime) {
+    if (runtime.kind === 'local') {
+        return resolveManagedLocalEnvFilePath(runtime);
+    }
+    return await resolveDockerEnvFileArg(runtime.envName, runtime.env.config ?? {});
+}
+export async function readManagedRuntimeEnvValues(runtime) {
+    const envFilePath = await resolveManagedRuntimeEnvFilePath(runtime);
+    if (!envFilePath) {
+        return {
+            envFilePath: undefined,
+            envValues: {},
+        };
+    }
+    try {
+        return {
+            envFilePath,
+            envValues: parseSimpleEnvFile(await readFile(envFilePath, 'utf8')),
+        };
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+        if (code === 'ENOENT') {
+            return {
+                envFilePath,
+                envValues: {},
+            };
+        }
+        throw error;
+    }
+}

package/dist/lib/plugin-import.js

@@ -0,0 +1,279 @@
+/**
+ * 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 fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createGunzip } from 'node:zlib';
+import * as tar from 'tar';
+import { fetchWithPreservedAuthRedirect } from './http-request.js';
+import { resolvePluginStoragePath } from './plugin-storage.js';
+import { run } from './run-npm.js';
+const NPM_PACK_TIMEOUT_MS = 30_000;
+const NPM_AUTH_ERROR_PATTERNS = [
+    'e401',
+    'e403',
+    'unauthorized',
+    'authorization',
+    'forbidden',
+    'need auth',
+    'requires authentication',
+    'unable to authenticate',
+    'authentication token',
+];
+const NPM_NOT_FOUND_ERROR_PATTERNS = [
+    'e404',
+    'etarget',
+    'not found',
+    'not in this registry',
+    'no matching version found',
+    'no match found',
+];
+const NPM_NETWORK_ERROR_PATTERNS = [
+    'enotfound',
+    'eai_again',
+    'etimedout',
+    'esockettimedout',
+    'econnreset',
+    'econnrefused',
+    'enetunreach',
+    'ehostunreach',
+    'fetch failed',
+    'getaddrinfo',
+    'timed out',
+];
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+async function pathExists(target) {
+    try {
+        await fsp.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isHttpArchiveSource(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+function responseBodyToNodeReadable(body) {
+    return Readable.fromWeb(body);
+}
+function looksLikeLocalArchivePath(value) {
+    return (path.isAbsolute(value) ||
+        value.startsWith('./') ||
+        value.startsWith('../') ||
+        value.endsWith('.tgz') ||
+        value.endsWith('.tar.gz'));
+}
+function resolvePluginOutputDir(storagePluginsPath, packageName) {
+    const outputDir = path.resolve(storagePluginsPath, packageName);
+    const relative = path.relative(storagePluginsPath, outputDir);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`Imported archive package name "${packageName}" resolves outside plugin storage.`);
+    }
+    return outputDir;
+}
+function normalizeNpmRegistry(value) {
+    const text = trimValue(value);
+    return text ? text.replace(/\/+$/, '') : undefined;
+}
+function formatNpmPackFailureMessage(source, registry, details) {
+    const normalizedDetails = details.toLowerCase();
+    const lines = [
+        `Failed to import npm package "${source}" with \`npm pack\`.`,
+        details,
+    ];
+    const loginCommand = registry ? `npm login --registry=${registry}` : 'npm login';
+    if (NPM_AUTH_ERROR_PATTERNS.some((pattern) => normalizedDetails.includes(pattern))) {
+        lines.push(`Hint: If this is a private registry, run \`${loginCommand}\` first and retry.`);
+        return lines.join('\n');
+    }
+    if (NPM_NOT_FOUND_ERROR_PATTERNS.some((pattern) => normalizedDetails.includes(pattern))) {
+        lines.push(registry
+            ? `Hint: Check that "${source}" exists in ${registry} and that the package name or tag is correct.`
+            : `Hint: Check that "${source}" exists and that the package name or tag is correct.`);
+        return lines.join('\n');
+    }
+    if (NPM_NETWORK_ERROR_PATTERNS.some((pattern) => normalizedDetails.includes(pattern))) {
+        lines.push(registry
+            ? `Hint: Check that the npm registry ${registry} is reachable from this machine.`
+            : 'Hint: Check that the npm registry is reachable from this machine.');
+        return lines.join('\n');
+    }
+    if (registry) {
+        lines.push(`Hint: If this is a private registry, make sure \`${loginCommand}\` has completed successfully.`);
+    }
+    return lines.join('\n');
+}
+async function resolvePackedPluginTarball(packRoot, sourceLabel) {
+    const entries = await fsp.readdir(packRoot, { withFileTypes: true });
+    const tarballs = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.tgz'))
+        .map((entry) => path.join(packRoot, entry.name))
+        .sort();
+    if (tarballs.length === 1) {
+        return tarballs[0];
+    }
+    if (tarballs.length === 0) {
+        throw new Error(`npm pack did not produce a local tarball for ${sourceLabel}.`);
+    }
+    throw new Error(`npm pack produced multiple tarballs for ${sourceLabel}.`);
+}
+async function packNpmPluginSource(source, npmRegistry, runFn = run) {
+    const packRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-plugin-pack-'));
+    const args = ['pack', '--silent'];
+    const registry = normalizeNpmRegistry(npmRegistry);
+    if (registry) {
+        args.push(`--registry=${registry}`);
+    }
+    args.push(source);
+    let stdout = '';
+    let stderr = '';
+    try {
+        await runFn('npm', args, {
+            cwd: packRoot,
+            stdio: 'pipe',
+            errorName: 'npm pack',
+            timeoutMs: NPM_PACK_TIMEOUT_MS,
+            onStdout: (chunk) => {
+                stdout += chunk;
+            },
+            onStderr: (chunk) => {
+                stderr += chunk;
+            },
+        });
+        const tarballPath = await resolvePackedPluginTarball(packRoot, source);
+        return {
+            stream: fs.createReadStream(tarballPath),
+            source,
+            sourceType: 'npm',
+            cleanup: async () => {
+                await fsp.rm(packRoot, { recursive: true, force: true });
+            },
+        };
+    }
+    catch (error) {
+        await fsp.rm(packRoot, { recursive: true, force: true });
+        const originalMessage = error instanceof Error ? error.message : String(error);
+        const details = trimValue(stderr) || trimValue(stdout) || trimValue(originalMessage) || 'npm pack failed.';
+        throw new Error(formatNpmPackFailureMessage(source, registry, details));
+    }
+}
+async function openPluginSource(source, npmRegistry, runFn = run) {
+    if (isHttpArchiveSource(source)) {
+        const response = await fetchWithPreservedAuthRedirect(source);
+        if (!response.ok) {
+            const statusText = trimValue(response.statusText);
+            throw new Error(`Failed to download plugin archive from ${source}: ${response.status}${statusText ? ` ${statusText}` : ''}.`);
+        }
+        if (!response.body) {
+            throw new Error(`Downloaded plugin archive from ${source} does not include a response body.`);
+        }
+        return {
+            stream: responseBodyToNodeReadable(response.body),
+            source,
+            sourceType: 'url',
+            cleanup: async () => undefined,
+        };
+    }
+    const resolvedPath = path.resolve(process.cwd(), source);
+    if (await pathExists(resolvedPath)) {
+        return {
+            stream: fs.createReadStream(resolvedPath),
+            source: resolvedPath,
+            sourceType: 'file',
+            cleanup: async () => undefined,
+        };
+    }
+    if (looksLikeLocalArchivePath(source)) {
+        throw new Error(`Plugin archive file does not exist: ${resolvedPath}`);
+    }
+    return await packNpmPluginSource(source, npmRegistry, runFn);
+}
+async function readPluginMetadata(extractRoot, sourceLabel) {
+    const packageJsonPath = path.join(extractRoot, 'package.json');
+    let content;
+    try {
+        content = await fsp.readFile(packageJsonPath, 'utf8');
+    }
+    catch {
+        throw new Error(`Imported archive from ${sourceLabel} does not contain a package.json at the package root.`);
+    }
+    let metadata;
+    try {
+        metadata = JSON.parse(content);
+    }
+    catch {
+        throw new Error(`Imported archive from ${sourceLabel} contains an invalid package.json.`);
+    }
+    const packageName = trimValue(metadata.name);
+    if (!packageName) {
+        throw new Error(`Imported archive from ${sourceLabel} is missing "package.json.name".`);
+    }
+    return {
+        packageName,
+        packageVersion: trimValue(metadata.version),
+    };
+}
+export async function importPluginSource(source, options = {}) {
+    const normalizedSource = trimValue(source);
+    if (!normalizedSource) {
+        throw new Error('Pass a plugin archive path, URL, or npm package spec.');
+    }
+    const storagePluginsPath = resolvePluginStoragePath(options.storagePath);
+    await fsp.mkdir(storagePluginsPath, { recursive: true });
+    const archive = await openPluginSource(normalizedSource, options.npmRegistry, options.runFn);
+    const stageDir = await fsp.mkdtemp(path.join(storagePluginsPath, '.nb-plugin-import-'));
+    let stageMoved = false;
+    try {
+        try {
+            await pipeline(archive.stream, createGunzip(), tar.extract({ cwd: stageDir, strip: 1 }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to extract plugin archive from ${archive.source}: ${message}`);
+        }
+        const { packageName, packageVersion } = await readPluginMetadata(stageDir, archive.source);
+        const outputDir = resolvePluginOutputDir(storagePluginsPath, packageName);
+        const action = (await pathExists(outputDir)) ? 'updated' : 'installed';
+        await fsp.mkdir(path.dirname(outputDir), { recursive: true });
+        await fsp.rm(outputDir, { recursive: true, force: true });
+        await fsp.rename(stageDir, outputDir);
+        stageMoved = true;
+        return {
+            action,
+            packageName,
+            packageVersion,
+            outputDir,
+            source: archive.source,
+            sourceType: archive.sourceType,
+            storagePluginsPath,
+        };
+    }
+    finally {
+        if (!stageMoved) {
+            await fsp.rm(stageDir, { recursive: true, force: true });
+        }
+        await archive.cleanup();
+    }
+}
+export async function importPluginArchive(source, storagePath) {
+    return await importPluginSource(source, { storagePath });
+}

package/dist/lib/prompt-catalog-core.js

@@ -88,14 +88,15 @@ export function mergedInteger(key, def, iv, useYesInitial) {
     }
     return def.initialValue;
 }
-export function mergedPassword(key, def, iv, useYesInitial) {
+export function mergedPassword(key, def, iv, useYesInitial, valuesSoFar = {}) {
     if (hasIvKey(iv, key)) {
         return String(iv[key] ?? '');
     }
     if (useYesInitial && def.yesInitialValue !== undefined) {
         return def.yesInitialValue;
     }
-    return def.initialValue;
+    const initialValue = def.initialValue;
+    return typeof initialValue === 'function' ? initialValue(valuesSoFar) : initialValue;
 }
 export function isBlankText(value) {
     return value.trim() === '';

package/dist/lib/prompt-validators.js

@@ -11,6 +11,7 @@ import net from 'node:net';
 import { translateCli } from "./cli-locale.js";
 const API_BASE_URL_EXAMPLE = 'http://localhost:13000/api';
 const ENV_KEY_PATTERN = /^[A-Za-z0-9]+$/;
+const APP_PUBLIC_PATH_PATTERN = /^\/(?:[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*)?\/?$/;
 const TCP_PORT_EXAMPLE = '13000';
 const API_BASE_URL_REQUEST_TIMEOUT_MS = 5_000;
 const TCP_PORT_PROBE_HOSTS = ['127.0.0.1', '0.0.0.0', '::1'];
@@ -95,6 +96,19 @@ export function validateEnvKey(value) {
     }
     return undefined;
 }
+export function validateAppPublicPath(value) {
+    const raw = String(value ?? '').trim();
+    if (raw === '') {
+        return undefined;
+    }
+    if (!raw.startsWith('/')) {
+        return translateCli('validators.appPublicPath.invalid');
+    }
+    if (!APP_PUBLIC_PATH_PATTERN.test(raw)) {
+        return translateCli('validators.appPublicPath.invalid');
+    }
+    return undefined;
+}
 function parseTcpPort(value) {
     const raw = String(value ?? '').trim();
     if (raw === '') {

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

@@ -33,6 +33,13 @@ function resolveTextDefault(def, out) {
     }
     return String(iv ?? '');
 }
+function resolvePasswordDefault(def, out) {
+    const iv = def.initialValue;
+    if (typeof iv === 'function') {
+        return String(iv(out) ?? '');
+    }
+    return String(iv ?? '');
+}
 function isInputBlock(def) {
     return (def.type === 'text' ||
         def.type === 'boolean' ||
@@ -89,7 +96,7 @@ function defaultValueForInput(key, def, out) {
             return firstValue ?? '';
         }
         case 'password':
-            return def.initialValue ?? '';
+            return resolvePasswordDefault(def, out);
         case 'integer':
             return def.initialValue !== undefined && Number.isFinite(def.initialValue) ? def.initialValue : 0;
         default:

package/dist/lib/run-npm.js

@@ -28,18 +28,35 @@ const MISSING_COMMAND_SPECS = {
         displayName: 'Docker',
         configKey: 'bin.docker',
     },
+    caddy: {
+        displayName: 'Caddy',
+        configKey: 'bin.caddy',
+    },
     git: {
         displayName: 'Git',
         configKey: 'bin.git',
     },
+    nginx: {
+        displayName: 'Nginx',
+        configKey: 'bin.nginx',
+    },
     yarn: {
         displayName: 'Yarn',
         configKey: 'bin.yarn',
     },
 };
+const DOCKER_DAEMON_UNAVAILABLE_PATTERNS = [
+    /cannot connect to the docker daemon/i,
+    /is the docker daemon running\?/i,
+    /error during connect/i,
+    /docker daemon is not running/i,
+];
 async function resolveCommandName(name) {
     return await resolveConfiguredCommandName(name);
 }
+function shouldTeeInheritedOutput(options) {
+    return options?.stdio === 'inherit' && Boolean(String(process.env.NB_CLI_ACTIVE_LOG_FILE ?? '').trim());
+}
 function createMissingCommandError(name, label, error) {
     const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : undefined;
     if (code !== 'ENOENT') {
@@ -53,6 +70,17 @@ function createMissingCommandError(name, label, error) {
         fallback: `Couldn't run \`${label}\` because the ${spec.displayName} executable could not be found. Install ${spec.displayName} or update \`nb config set ${spec.configKey} <path>\` and try again.`,
     }));
 }
+function isDockerDaemonUnavailableError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return DOCKER_DAEMON_UNAVAILABLE_PATTERNS.some((pattern) => pattern.test(message));
+}
+function createDockerDaemonUnavailableError(action, error) {
+    const details = error instanceof Error ? error.message : String(error);
+    return new Error(translateCli('commands.shared.dockerDaemonUnavailable', { action, details }, {
+        fallback: `Couldn't run \`${action}\` because Docker is installed but the Docker daemon is not running.` +
+            ` Start Docker Desktop or the Docker daemon service, then try again. Details: ${details}`,
+    }));
+}
 function pathExists(candidate) {
     try {
         return Boolean(candidate) && fs.statSync(candidate) !== undefined;
@@ -107,9 +135,12 @@ export async function run(name, args, options) {
     const cwd = resolveCwd(options?.cwd);
     const label = options?.errorName ?? name;
     const command = await resolveCommandName(name);
+    const stdio = shouldTeeInheritedOutput(options)
+        ? ['inherit', 'pipe', 'pipe']
+        : (options?.stdio ?? 'inherit');
     return await new Promise((resolve, reject) => {
         const child = spawn(command, [...args], {
-            stdio: options?.stdio ?? 'inherit',
+            stdio,
             cwd,
             env: {
                 ...process.env,
@@ -117,19 +148,21 @@ export async function run(name, args, options) {
             },
             windowsHide: process.platform === 'win32',
         });
-        if (options?.stdio === 'pipe') {
+        if (options?.stdio === 'pipe' || shouldTeeInheritedOutput(options)) {
             child.stdout?.setEncoding('utf8');
             child.stderr?.setEncoding('utf8');
-            if (options.onStdout) {
-                child.stdout?.on('data', (chunk) => {
-                    options.onStdout?.(String(chunk));
-                });
-            }
-            if (options.onStderr) {
-                child.stderr?.on('data', (chunk) => {
-                    options.onStderr?.(String(chunk));
-                });
-            }
+            child.stdout?.on('data', (chunk) => {
+                if (shouldTeeInheritedOutput(options)) {
+                    process.stdout.write(chunk);
+                }
+                options.onStdout?.(String(chunk));
+            });
+            child.stderr?.on('data', (chunk) => {
+                if (shouldTeeInheritedOutput(options)) {
+                    process.stderr.write(chunk);
+                }
+                options.onStderr?.(String(chunk));
+            });
         }
         const cleanupSignalForwarding = forwardSignalsToChild(child);
         const timeoutController = attachProcessTimeout(child, options?.timeoutMs);
@@ -370,6 +403,17 @@ export async function commandOutputViaFile(name, args, options) {
 export function runNpm(args, options) {
     return run('yarn', [...args], { ...options, errorName: 'npm' });
 }
+export async function ensureDockerDaemonRunning(action = 'use Docker') {
+    try {
+        await commandOutput('docker', ['info'], { errorName: 'docker info', timeoutMs: 5000 });
+    }
+    catch (error) {
+        if (isDockerDaemonUnavailableError(error)) {
+            throw createDockerDaemonUnavailableError(action, error);
+        }
+        throw error;
+    }
+}
 export function runNocoBaseCommand(args, options) {
     const cwd = resolveProjectCwd(options?.cwd);
     const localBin = path.join(cwd, 'node_modules', '.bin');

package/dist/lib/skills-manager.js

@@ -17,7 +17,9 @@ import { commandOutput, commandOutputViaFile, run } from './run-npm.js';
 export const NOCOBASE_SKILLS_SOURCE = 'nocobase/skills';
 export const NOCOBASE_SKILLS_PACKAGE_NAME = '@nocobase/skills';
 const NOCOBASE_SKILLS_NAME_PREFIX = 'nocobase-';
-const SKILLS_LIST_TIMEOUT_MS = 5000;
+// `npx skills list` may take several seconds on cold starts while `npx`
+// resolves and boots the package, even when the local skills installation is healthy.
+const SKILLS_LIST_TIMEOUT_MS = 15000;
 const SKILLS_NPM_VIEW_TIMEOUT_MS = 3000;
 const SKILLS_PACK_TIMEOUT_MS = 30000;
 const SKILLS_ADD_TIMEOUT_MS = 20000;

package/dist/lib/source-publish.js

@@ -15,6 +15,9 @@ function trimValue(value) {
 function sanitizeEnvSegment(value) {
     return trimValue(value).replace(/[^A-Za-z0-9]+/g, '').slice(0, 16);
 }
+function normalizeSnapshotBaseVersion(baseVersion) {
+    return trimValue(baseVersion).replace(/(?:-snapshot\.\d{8}\.[A-Za-z0-9]+)+$/, '');
+}
 export async function resolveSourcePublishRegistry(explicitRegistry) {
     const normalized = trimValue(explicitRegistry);
     if (normalized) {
@@ -50,7 +53,7 @@ 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}`;
+    return `${normalizeSnapshotBaseVersion(baseVersion)}-snapshot.${yyyy}${mm}${dd}.${gitSha}`;
 }
 export async function resolveGitBranch(cwd) {
     const branch = trimValue(await commandOutput('git', ['branch', '--show-current'], {
@@ -60,6 +63,20 @@ export async function resolveGitBranch(cwd) {
     if (!branch) {
         throw new Error('`nb source publish --snapshot` requires a named Git branch. Detached HEAD is not supported.');
     }
+    const branchRef = `refs/heads/${branch}`;
+    try {
+        await commandOutput('git', ['rev-parse', '--verify', branchRef], {
+            cwd,
+            errorName: `git rev-parse --verify ${branchRef}`,
+        });
+    }
+    catch (error) {
+        throw new Error([
+            `The current Git branch reference is invalid: ${branch}.`,
+            'This usually means a previous source publish cleanup left HEAD pointing at a missing temporary branch.',
+            'Switch to a real local branch, then run `nb source publish --snapshot` again.',
+        ].join('\n'), { cause: error });
+    }
     return branch;
 }
 export async function hasLocalGitChanges(cwd) {
@@ -292,6 +309,9 @@ export async function publishSourceSnapshot(params) {
     if (publishError) {
         throw publishError;
     }
+    if (!result) {
+        throw new Error('Source snapshot publishing finished without a result.');
+    }
     return result;
 }
 export function buildSuggestedInitCommand(result) {
@@ -299,7 +319,7 @@ export function buildSuggestedInitCommand(result) {
     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`,
+        `nb init --ui --env ${suggestedEnv} --yes --source npm`,
         `--version ${result.version}`,
         `--npm-registry=${normalizedRegistry}`,
     ].join(' ');