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

package/dist/lib/skills-manager.js

@@ -6,8 +6,11 @@
  * 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 path from 'node:path';
+import { createGunzip } from 'node:zlib';
+import * as tar from 'tar';
 import { resolveCliHomeDir } from './cli-home.js';
 import { compareVersions } from './self-manager.js';
 import { commandOutput, commandOutputViaFile, run } from './run-npm.js';
@@ -33,6 +36,15 @@ function resolveSkillsRoot(options = {}) {
 function getSkillsCacheRoot(globalRoot) {
     return path.join(globalRoot, 'cache', 'skills');
 }
+function getCachedSkillsPackageDir(cacheRoot) {
+    return path.join(cacheRoot, 'node_modules', '@nocobase', 'skills');
+}
+function getCachedSkillsPackRoot(cacheRoot) {
+    return path.join(cacheRoot, 'pack');
+}
+function getCachedSkillsExtractRoot(cacheRoot) {
+    return path.join(cacheRoot, 'extract');
+}
 export function getManagedSkillsStateFile(workspaceRoot) {
     return path.join(workspaceRoot, 'skills.json');
 }
@@ -95,7 +107,7 @@ async function readPublishedSkillsVersion(options = {}) {
     }
 }
 async function readCachedSkillsVersion(cacheRoot) {
-    const packageJsonPath = path.join(cacheRoot, 'node_modules', '@nocobase', 'skills', 'package.json');
+    const packageJsonPath = path.join(getCachedSkillsPackageDir(cacheRoot), 'package.json');
     try {
         const content = await fsp.readFile(packageJsonPath, 'utf8');
         const parsed = JSON.parse(content);
@@ -106,9 +118,59 @@ async function readCachedSkillsVersion(cacheRoot) {
         return undefined;
     }
 }
+async function resolvePackedSkillsTarball(packRoot) {
+    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 ${NOCOBASE_SKILLS_PACKAGE_NAME}.`);
+    }
+    throw new Error(`npm pack produced multiple tarballs for ${NOCOBASE_SKILLS_PACKAGE_NAME}.`);
+}
+async function extractPackedSkillsTarball(tarballPath, cacheRoot, targetVersion) {
+    const packageDir = getCachedSkillsPackageDir(cacheRoot);
+    const extractRoot = getCachedSkillsExtractRoot(cacheRoot);
+    await fsp.rm(extractRoot, { recursive: true, force: true });
+    await fsp.mkdir(extractRoot, { recursive: true });
+    try {
+        await new Promise((resolve, reject) => {
+            fs.createReadStream(tarballPath)
+                .pipe(createGunzip())
+                .pipe(tar.extract({ cwd: extractRoot, strip: 1 }))
+                .on('finish', () => resolve())
+                .on('error', reject);
+        });
+        const packageJsonPath = path.join(extractRoot, 'package.json');
+        const packageJsonRaw = await fsp.readFile(packageJsonPath, 'utf8');
+        const manifest = JSON.parse(packageJsonRaw);
+        const packageName = String(manifest.name ?? '').trim();
+        const packageVersion = String(manifest.version ?? '').trim();
+        if (packageName !== NOCOBASE_SKILLS_PACKAGE_NAME) {
+            throw new Error(`packed tarball resolved to ${packageName || '(missing package name)'} instead of ${NOCOBASE_SKILLS_PACKAGE_NAME}.`);
+        }
+        if (targetVersion && packageVersion !== targetVersion) {
+            throw new Error(`packed tarball resolved to version ${packageVersion || '(missing version)'} instead of ${targetVersion}.`);
+        }
+        await fsp.rm(packageDir, { recursive: true, force: true });
+        await fsp.mkdir(path.dirname(packageDir), { recursive: true });
+        await fsp.rename(extractRoot, packageDir);
+        return packageDir;
+    }
+    catch (error) {
+        await fsp.rm(extractRoot, { recursive: true, force: true });
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`failed to extract ${NOCOBASE_SKILLS_PACKAGE_NAME} tarball: ${message}`);
+    }
+}
 async function prepareLocalSkillsPackage(globalRoot, options = {}, targetVersion) {
     const cacheRoot = getSkillsCacheRoot(globalRoot);
-    const packageDir = path.join(cacheRoot, 'node_modules', '@nocobase', 'skills');
+    const packageDir = getCachedSkillsPackageDir(cacheRoot);
+    const packRoot = getCachedSkillsPackRoot(cacheRoot);
     const packageSpec = targetVersion ? `${NOCOBASE_SKILLS_PACKAGE_NAME}@${targetVersion}` : NOCOBASE_SKILLS_PACKAGE_NAME;
     const cachedVersion = await readCachedSkillsVersion(cacheRoot);
     await fsp.mkdir(cacheRoot, { recursive: true });
@@ -118,17 +180,19 @@ async function prepareLocalSkillsPackage(globalRoot, options = {}, targetVersion
             cleanup: async () => undefined,
         };
     }
-    await fsp.rm(path.join(cacheRoot, 'node_modules'), { recursive: true, force: true });
-    await (options.runFn ?? run)('npm', ['install', '--no-save', '--ignore-scripts', '--no-package-lock', packageSpec], {
-        cwd: cacheRoot,
-        stdio: options.verbose ? 'inherit' : 'ignore',
-        errorName: 'npm install',
-    });
+    await fsp.rm(packRoot, { recursive: true, force: true });
+    await fsp.mkdir(packRoot, { recursive: true });
     try {
-        await fsp.access(packageDir);
+        await (options.runFn ?? run)('npm', ['pack', '--silent', packageSpec], {
+            cwd: packRoot,
+            stdio: options.verbose ? 'inherit' : 'ignore',
+            errorName: 'npm pack',
+        });
+        const tarballPath = await resolvePackedSkillsTarball(packRoot);
+        await extractPackedSkillsTarball(tarballPath, cacheRoot, targetVersion);
     }
-    catch {
-        throw new Error(`npm install did not produce a local ${NOCOBASE_SKILLS_PACKAGE_NAME} package.`);
+    finally {
+        await fsp.rm(packRoot, { recursive: true, force: true });
     }
     return {
         packageDir,

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/dist/lib/startup-update.js

@@ -9,7 +9,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import * as p from '@clack/prompts';
+import { confirm } from "./inquirer.js";
 import { inspectSelfInstall, inspectSelfStatus, } from './self-manager.js';
 import { inspectSkillsStatus } from './skills-manager.js';
 import { resolveCliHomeDir } from './cli-home.js';
@@ -264,13 +264,17 @@ export async function maybeRunStartupUpdatePrompt(argv) {
         await markChecked();
         return { kind: 'warned' };
     }
-    const answer = await p.confirm({
-        message: buildPromptMessage(selfStatus, skillsStatus),
-        active: 'Yes',
-        inactive: 'No',
-        initialValue: true,
-    });
-    if (p.isCancel(answer) || !answer) {
+    let answer = false;
+    try {
+        answer = await confirm({
+            message: buildPromptMessage(selfStatus, skillsStatus),
+            default: true,
+        });
+    }
+    catch {
+        answer = false;
+    }
+    if (!answer) {
         printWarning(buildDeclinedWarning(selfStatus, skillsStatus));
         await markChecked();
         return { kind: 'declined' };