@nocobase/cli 2.1.0-beta.20 → 2.1.0-beta.22

package/dist/lib/http-request.js

@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+function normalizeLocationUrl(location, currentUrl) {
+    try {
+        return new URL(location, currentUrl).toString();
+    }
+    catch (_error) {
+        return undefined;
+    }
+}
+function shouldPreserveAuthorizationRedirect(fromUrl, toUrl) {
+    try {
+        const from = new URL(fromUrl);
+        const to = new URL(toUrl);
+        return (from.hostname === to.hostname &&
+            from.port === to.port &&
+            from.pathname === to.pathname &&
+            from.search === to.search &&
+            from.protocol === 'http:' &&
+            to.protocol === 'https:');
+    }
+    catch (_error) {
+        return false;
+    }
+}
+export async function fetchWithPreservedAuthRedirect(url, init = {}) {
+    const response = await fetch(url, {
+        ...init,
+        redirect: 'manual',
+    });
+    const location = response.headers.get('location');
+    if (!location || ![301, 302, 307, 308].includes(response.status)) {
+        return response;
+    }
+    const nextUrl = normalizeLocationUrl(location, url);
+    if (!nextUrl || !shouldPreserveAuthorizationRedirect(url, nextUrl)) {
+        return response;
+    }
+    return fetch(nextUrl, {
+        ...init,
+        redirect: 'manual',
+    });
+}

package/dist/lib/resource-command.js

@@ -1,3 +1,11 @@
+/**
+ * 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 { Flags } from '@oclif/core';
 import { executeResourceRequest } from './resource-request.js';
 import { setVerboseMode } from './ui.js';
@@ -80,7 +88,7 @@ function printResponse(command, response, jsonOutput) {
     command.log(`HTTP ${response.status}`);
 }
 export const resourceBaseFlags = {
-    'base-url': Flags.string({
+    'api-base-url': Flags.string({
         description: 'NocoBase API base URL, for example http://localhost:13000/api',
     }),
     verbose: Flags.boolean({
@@ -325,7 +333,7 @@ export async function runResourceCommand(command, action, flags, args) {
     setVerboseMode(Boolean(flags.verbose));
     const response = await executeResourceRequest({
         envName: flags.env,
-        baseUrl: flags['base-url'],
+        baseUrl: flags['api-base-url'],
         role: flags.role,
         token: flags.token,
         action,

package/dist/lib/runtime-generator.js

@@ -10,7 +10,7 @@ import { createHash } from 'node:crypto';
 import { loadBuildConfig } from './build-config.js';
 import { toKebabCase, toLogicalActionName, toLogicalResourceName, toResourceSegments } from './naming.js';
 import { collectOperations } from './openapi.js';
-const RESERVED_FLAG_NAMES = new Set(['base-url', 'env', 'token', 'json-output', 'body', 'body-file']);
+const RESERVED_FLAG_NAMES = new Set(['api-base-url', 'base-url', 'env', 'token', 'json-output', 'body', 'body-file']);
 function matchesPattern(value, pattern) {
     if (!value) {
         return false;

package/dist/lib/self-manager.js

@@ -234,7 +234,7 @@ export async function updateSelf(options = {}) {
     }
     const packageSpec = getSelfUpdatePackageSpec(status);
     await (options.runFn ?? run)('npm', ['install', '-g', packageSpec], {
-        stdio: 'inherit',
+        stdio: options.verbose ? 'inherit' : 'ignore',
         errorName: 'npm install',
     });
     return {

package/dist/lib/skills-manager.js

@@ -6,31 +6,38 @@
  * 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 { resolveCliHomeDir } from './cli-home.js';
+import { compareVersions } from './self-manager.js';
 import { commandOutput, run } from './run-npm.js';
-export const NOCOBASE_SKILLS_PACKAGE = 'nocobase/skills';
-export const NOCOBASE_SKILLS_REPO_URL = 'https://github.com/nocobase/skills.git';
+export const NOCOBASE_SKILLS_SOURCE = 'nocobase/skills';
+export const NOCOBASE_SKILLS_PACKAGE_NAME = '@nocobase/skills';
 const NOCOBASE_SKILLS_NAME_PREFIX = 'nocobase-';
 function normalizePath(value) {
     return path.resolve(value);
 }
+export function resolveGlobalSkillsRoot(_startCwd = process.cwd()) {
+    return normalizePath(resolveCliHomeDir('global'));
+}
 export function resolveSkillsWorkspaceRoot(startCwd = process.cwd()) {
-    let current = normalizePath(startCwd);
-    while (true) {
-        if (fs.existsSync(path.join(current, '.nocobase')) || fs.existsSync(path.join(current, '.agents'))) {
-            return current;
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return normalizePath(startCwd);
-        }
-        current = parent;
-    }
+    return resolveGlobalSkillsRoot(startCwd);
+}
+function resolveSkillsRoot(options = {}) {
+    return options.globalRoot
+        ? normalizePath(options.globalRoot)
+        : options.workspaceRoot
+            ? normalizePath(options.workspaceRoot)
+            : resolveGlobalSkillsRoot();
+}
+function getSkillsCacheRoot(globalRoot) {
+    return path.join(globalRoot, 'cache', 'skills');
 }
 export function getManagedSkillsStateFile(workspaceRoot) {
-    return path.join(workspaceRoot, '.nocobase', 'skills.json');
+    return path.join(workspaceRoot, 'skills.json');
+}
+async function ensureSkillsWorkspaceRoot(workspaceRoot) {
+    await fsp.mkdir(workspaceRoot, { recursive: true });
 }
 async function readManagedSkillsState(workspaceRoot) {
     const filePath = getManagedSkillsStateFile(workspaceRoot);
@@ -47,15 +54,19 @@ async function writeManagedSkillsState(workspaceRoot, state) {
     await fsp.mkdir(path.dirname(filePath), { recursive: true });
     await fsp.writeFile(filePath, JSON.stringify(state, null, 2));
 }
-export async function listProjectSkills(options = {}) {
-    const workspaceRoot = options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot();
-    const output = await (options.commandOutputFn ?? commandOutput)('npx', ['-y', 'skills', 'list', '--json'], {
-        cwd: workspaceRoot,
+export async function listGlobalSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    await ensureSkillsWorkspaceRoot(globalRoot);
+    const output = await (options.commandOutputFn ?? commandOutput)('npx', ['-y', 'skills', 'list', '-g', '--json'], {
+        cwd: globalRoot,
         errorName: 'skills list',
     });
     const parsed = JSON.parse(output);
     return Array.isArray(parsed) ? parsed : [];
 }
+export async function listProjectSkills(options = {}) {
+    return await listGlobalSkills(options);
+}
 function pickInstalledNocoBaseSkillNames(installedSkills, state) {
     const installedNames = new Set(installedSkills.map((skill) => String(skill.name ?? '').trim()).filter(Boolean));
     if (state?.skillNames?.length) {
@@ -65,14 +76,17 @@ function pickInstalledNocoBaseSkillNames(installedSkills, state) {
         .filter((name) => name.startsWith(NOCOBASE_SKILLS_NAME_PREFIX))
         .sort();
 }
-export async function readNocoBaseSkillsHeadRef(options = {}) {
+async function readPublishedSkillsVersion(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    await ensureSkillsWorkspaceRoot(globalRoot);
     try {
-        const output = await (options.commandOutputFn ?? commandOutput)('git', ['ls-remote', NOCOBASE_SKILLS_REPO_URL, 'HEAD'], {
-            cwd: options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot(),
-            errorName: 'git ls-remote',
+        const output = await (options.commandOutputFn ?? commandOutput)('npm', ['view', NOCOBASE_SKILLS_PACKAGE_NAME, 'version', '--json'], {
+            cwd: globalRoot,
+            errorName: 'npm view',
         });
-        const ref = output.trim().split(/\s+/)[0];
-        return { ref: ref || undefined };
+        const parsed = JSON.parse(output);
+        const version = String(parsed ?? '').trim();
+        return { version: version || undefined };
     }
     catch (error) {
         return {
@@ -80,80 +94,134 @@ export async function readNocoBaseSkillsHeadRef(options = {}) {
         };
     }
 }
+async function readCachedSkillsVersion(cacheRoot) {
+    const packageJsonPath = path.join(cacheRoot, 'node_modules', '@nocobase', 'skills', 'package.json');
+    try {
+        const content = await fsp.readFile(packageJsonPath, 'utf8');
+        const parsed = JSON.parse(content);
+        const version = String(parsed.version ?? '').trim();
+        return version || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function prepareLocalSkillsPackage(globalRoot, options = {}, targetVersion) {
+    const cacheRoot = getSkillsCacheRoot(globalRoot);
+    const packageDir = path.join(cacheRoot, 'node_modules', '@nocobase', 'skills');
+    const packageSpec = targetVersion ? `${NOCOBASE_SKILLS_PACKAGE_NAME}@${targetVersion}` : NOCOBASE_SKILLS_PACKAGE_NAME;
+    const cachedVersion = await readCachedSkillsVersion(cacheRoot);
+    await fsp.mkdir(cacheRoot, { recursive: true });
+    if (targetVersion && cachedVersion && compareVersions(cachedVersion, targetVersion) === 0) {
+        return {
+            packageDir,
+            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',
+    });
+    try {
+        await fsp.access(packageDir);
+    }
+    catch {
+        throw new Error(`npm install did not produce a local ${NOCOBASE_SKILLS_PACKAGE_NAME} package.`);
+    }
+    return {
+        packageDir,
+        cleanup: async () => undefined,
+    };
+}
 export async function inspectSkillsStatus(options = {}) {
-    const workspaceRoot = options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot();
-    const stateFile = getManagedSkillsStateFile(workspaceRoot);
+    const globalRoot = resolveSkillsRoot(options);
+    const stateFile = getManagedSkillsStateFile(globalRoot);
     const [installedSkills, managedState] = await Promise.all([
-        listProjectSkills({
-            workspaceRoot,
+        listGlobalSkills({
+            globalRoot,
             commandOutputFn: options.commandOutputFn,
         }),
-        readManagedSkillsState(workspaceRoot),
+        readManagedSkillsState(globalRoot),
     ]);
     const installedSkillNames = pickInstalledNocoBaseSkillNames(installedSkills, managedState);
-    const managedByNb = managedState?.packageName === NOCOBASE_SKILLS_PACKAGE;
-    let latestRef;
+    const managedByNb = managedState?.packageName === NOCOBASE_SKILLS_PACKAGE_NAME;
+    let latestVersion;
     let registryError;
     let updateAvailable = installedSkillNames.length > 0 ? null : false;
     if (installedSkillNames.length > 0 || managedByNb) {
-        const remote = await readNocoBaseSkillsHeadRef({
-            workspaceRoot,
+        const published = await readPublishedSkillsVersion({
+            globalRoot,
             commandOutputFn: options.commandOutputFn,
         });
-        latestRef = remote.ref;
-        registryError = remote.error;
-        if (managedState?.installedRef && latestRef) {
-            updateAvailable = latestRef !== managedState.installedRef;
+        latestVersion = published.version;
+        registryError = published.error;
+        const installedVersion = managedState?.installedVersion ?? managedState?.installedRef;
+        if (installedVersion && latestVersion) {
+            updateAvailable = compareVersions(latestVersion, installedVersion) > 0;
         }
     }
+    const installedVersion = managedState?.installedVersion ?? managedState?.installedRef;
     return {
-        workspaceRoot,
+        globalRoot,
+        workspaceRoot: globalRoot,
         stateFile,
         installed: installedSkillNames.length > 0,
         managedByNb,
-        sourcePackage: NOCOBASE_SKILLS_PACKAGE,
+        sourcePackage: managedState?.sourcePackage ?? NOCOBASE_SKILLS_SOURCE,
+        npmPackageName: managedState?.packageName ?? NOCOBASE_SKILLS_PACKAGE_NAME,
         installedSkillNames,
-        latestRef,
-        installedRef: managedState?.installedRef,
+        latestVersion,
+        installedVersion,
+        latestRef: latestVersion,
+        installedRef: installedVersion,
         updateAvailable,
         registryError,
     };
 }
-function formatSkillsNotInstalledMessage() {
-    return [
-        'NocoBase AI coding skills are not installed for this workspace.',
-        'Run `nb skills install` first.',
-    ].join('\n');
-}
-async function persistManagedSkillsState(workspaceRoot, options = {}) {
-    const installedSkills = await listProjectSkills({
-        workspaceRoot,
+async function persistManagedSkillsState(globalRoot, options = {}) {
+    const installedSkills = await listGlobalSkills({
+        globalRoot,
         commandOutputFn: options.commandOutputFn,
     });
-    const managedState = await readManagedSkillsState(workspaceRoot);
+    const managedState = await readManagedSkillsState(globalRoot);
     const installedSkillNames = pickInstalledNocoBaseSkillNames(installedSkills, managedState);
-    const remote = await readNocoBaseSkillsHeadRef({
-        workspaceRoot,
+    const published = await readPublishedSkillsVersion({
+        globalRoot,
         commandOutputFn: options.commandOutputFn,
     });
     const now = new Date().toISOString();
-    await writeManagedSkillsState(workspaceRoot, {
-        packageName: NOCOBASE_SKILLS_PACKAGE,
-        repoUrl: NOCOBASE_SKILLS_REPO_URL,
+    await writeManagedSkillsState(globalRoot, {
+        packageName: NOCOBASE_SKILLS_PACKAGE_NAME,
+        sourcePackage: NOCOBASE_SKILLS_SOURCE,
         installedAt: managedState?.installedAt ?? now,
         updatedAt: now,
-        installedRef: remote.ref,
+        installedVersion: published.version,
         skillNames: installedSkillNames,
     });
     return await inspectSkillsStatus({
-        workspaceRoot,
+        globalRoot,
         commandOutputFn: options.commandOutputFn,
     });
 }
+async function reinstallManagedSkills(globalRoot, options = {}, targetVersion) {
+    const prepared = await prepareLocalSkillsPackage(globalRoot, options, targetVersion);
+    try {
+        await (options.runFn ?? run)('npx', ['-y', 'skills', 'add', prepared.packageDir, '-g', '-y'], {
+            cwd: globalRoot,
+            stdio: options.verbose ? 'inherit' : 'ignore',
+            errorName: 'skills add',
+        });
+    }
+    finally {
+        await prepared.cleanup();
+    }
+}
 export async function installNocoBaseSkills(options = {}) {
-    const workspaceRoot = options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot();
+    const globalRoot = resolveSkillsRoot(options);
     const status = await inspectSkillsStatus({
-        workspaceRoot,
+        globalRoot,
         commandOutputFn: options.commandOutputFn,
     });
     if (status.installed) {
@@ -162,41 +230,67 @@ export async function installNocoBaseSkills(options = {}) {
             status,
         };
     }
-    await (options.runFn ?? run)('npx', ['-y', 'skills', 'add', NOCOBASE_SKILLS_PACKAGE, '-y'], {
-        cwd: workspaceRoot,
-        stdio: 'inherit',
-        errorName: 'skills add',
-    });
+    await ensureSkillsWorkspaceRoot(globalRoot);
+    await reinstallManagedSkills(globalRoot, options, status.latestVersion);
     return {
         action: 'installed',
-        status: await persistManagedSkillsState(workspaceRoot, options),
+        status: await persistManagedSkillsState(globalRoot, options),
     };
 }
 export async function updateNocoBaseSkills(options = {}) {
-    const workspaceRoot = options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot();
+    const globalRoot = resolveSkillsRoot(options);
     const status = await inspectSkillsStatus({
-        workspaceRoot,
+        globalRoot,
         commandOutputFn: options.commandOutputFn,
     });
     if (!status.installed) {
-        throw new Error(formatSkillsNotInstalledMessage());
+        return {
+            action: 'noop',
+            reason: 'not-installed',
+            status,
+        };
     }
     if (status.managedByNb
-        && status.latestRef
-        && status.installedRef
-        && status.latestRef === status.installedRef) {
+        && status.latestVersion
+        && status.installedVersion
+        && compareVersions(status.latestVersion, status.installedVersion) <= 0) {
         return {
             action: 'noop',
+            reason: 'up-to-date',
             status,
         };
     }
-    await (options.runFn ?? run)('npx', ['-y', 'skills', 'update', '-p', '-y', ...status.installedSkillNames], {
-        cwd: workspaceRoot,
-        stdio: 'inherit',
-        errorName: 'skills update',
-    });
+    await reinstallManagedSkills(globalRoot, options, status.latestVersion);
     return {
         action: 'updated',
-        status: await persistManagedSkillsState(workspaceRoot, options),
+        status: await persistManagedSkillsState(globalRoot, options),
+    };
+}
+export async function removeNocoBaseSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const status = await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (!status.installed || status.installedSkillNames.length === 0) {
+        return {
+            action: 'noop',
+            status,
+        };
+    }
+    for (const skillName of status.installedSkillNames) {
+        await (options.runFn ?? run)('npx', ['-y', 'skills', 'remove', skillName, '-g', '-y'], {
+            cwd: globalRoot,
+            stdio: options.verbose ? 'inherit' : 'ignore',
+            errorName: 'skills remove',
+        });
+    }
+    await fsp.rm(getManagedSkillsStateFile(globalRoot), { force: true });
+    return {
+        action: 'removed',
+        status: await inspectSkillsStatus({
+            globalRoot,
+            commandOutputFn: options.commandOutputFn,
+        }),
     };
 }

package/dist/lib/startup-update.js

@@ -0,0 +1,203 @@
+/**
+ * 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/promises';
+import path from 'node:path';
+import * as p from '@clack/prompts';
+import { inspectSelfStatus, } from './self-manager.js';
+import { inspectSkillsStatus } from './skills-manager.js';
+import { resolveCliHomeDir } from './cli-home.js';
+import { isInteractiveTerminal, printWarning } from './ui.js';
+import { run } from './run-npm.js';
+const STARTUP_UPDATE_STATE_FILE = 'startup-update.json';
+const NB_SKIP_STARTUP_UPDATE_ENV = 'NB_SKIP_STARTUP_UPDATE';
+function getStateFile() {
+    return path.join(resolveCliHomeDir('global'), STARTUP_UPDATE_STATE_FILE);
+}
+function todayStamp(now = new Date()) {
+    return now.toISOString().slice(0, 10);
+}
+function shouldSkipByArgv(argv) {
+    const tokens = argv.filter((token) => token && !token.startsWith('-'));
+    if (tokens.length === 0) {
+        return false;
+    }
+    if (tokens[0] === 'self' || tokens[0] === 'skills') {
+        return true;
+    }
+    return false;
+}
+async function readState() {
+    try {
+        const raw = await fs.readFile(getStateFile(), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function writeState(state) {
+    const filePath = getStateFile();
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(state, null, 2));
+}
+async function markChecked(now = new Date()) {
+    await writeState({ lastCheckedDate: todayStamp(now) });
+}
+export async function shouldRunStartupUpdateCheck(argv, now = new Date()) {
+    if (process.env[NB_SKIP_STARTUP_UPDATE_ENV] === '1') {
+        return false;
+    }
+    if (shouldSkipByArgv(argv)) {
+        return false;
+    }
+    const state = await readState();
+    return state.lastCheckedDate !== todayStamp(now);
+}
+export function shouldEnableStartupUpdateForInstallMethod(installMethod) {
+    return installMethod === 'npm-global';
+}
+function hasPendingUpdates(selfStatus, skillsStatus) {
+    return Boolean(selfStatus.updateAvailable || skillsStatus.updateAvailable === true);
+}
+function describeCliUpdate(selfStatus) {
+    return selfStatus.latestVersion
+        ? `NocoBase CLI: ${selfStatus.currentVersion} -> ${selfStatus.latestVersion}`
+        : `NocoBase CLI: update available from ${selfStatus.currentVersion}`;
+}
+function describeSkillsUpdate() {
+    return 'NocoBase AI skills: update available';
+}
+function describeSkillsUpdateWithVersion(skillsStatus) {
+    if (skillsStatus.installedVersion && skillsStatus.latestVersion) {
+        return `NocoBase AI skills: ${skillsStatus.installedVersion} -> ${skillsStatus.latestVersion}`;
+    }
+    if (skillsStatus.latestVersion) {
+        return `NocoBase AI skills: latest ${skillsStatus.latestVersion} available`;
+    }
+    return describeSkillsUpdate();
+}
+function buildPromptMessage(selfStatus, skillsStatus) {
+    const lines = [];
+    const hasCliUpdate = selfStatus.updateAvailable;
+    const hasSkillsUpdate = skillsStatus.updateAvailable === true;
+    if (hasCliUpdate && hasSkillsUpdate) {
+        lines.push('Updates are available for your NocoBase CLI and AI skills.');
+    }
+    else if (hasCliUpdate) {
+        lines.push('An update is available for your NocoBase CLI.');
+    }
+    else if (hasSkillsUpdate) {
+        lines.push('An update is available for your NocoBase AI skills.');
+    }
+    else {
+        lines.push('A NocoBase CLI or skills update is available.');
+    }
+    if (hasCliUpdate) {
+        lines.push(`- ${describeCliUpdate(selfStatus)}`);
+    }
+    if (hasSkillsUpdate) {
+        lines.push(`- ${describeSkillsUpdateWithVersion(skillsStatus)}`);
+    }
+    lines.push('Update now?');
+    return lines.join('\n');
+}
+function buildUpdateCommands(selfStatus, skillsStatus) {
+    const commands = [];
+    if (selfStatus.updateAvailable && selfStatus.updatable) {
+        commands.push('nb self update --yes');
+    }
+    if (skillsStatus.updateAvailable === true) {
+        commands.push('nb skills update --yes');
+    }
+    return commands;
+}
+function buildNonInteractiveWarning(selfStatus, skillsStatus) {
+    const commands = buildUpdateCommands(selfStatus, skillsStatus);
+    const details = [];
+    if (selfStatus.updateAvailable) {
+        details.push(describeCliUpdate(selfStatus));
+    }
+    if (skillsStatus.updateAvailable === true) {
+        details.push(describeSkillsUpdateWithVersion(skillsStatus));
+    }
+    return [
+        `Updates available${details.length ? `: ${details.join(', ')}` : '.'}`,
+        'Non-interactive session, skipped auto-update.',
+        commands.length
+            ? `Run: ${commands.join(' && ')}`
+            : 'Check with: `nb self check` and `nb skills check`.',
+        'You may run into compatibility issues until you update.',
+    ].join(' ');
+}
+function buildDeclinedWarning(selfStatus, skillsStatus) {
+    const commands = buildUpdateCommands(selfStatus, skillsStatus);
+    const details = [];
+    if (selfStatus.updateAvailable) {
+        details.push(describeCliUpdate(selfStatus));
+    }
+    if (skillsStatus.updateAvailable === true) {
+        details.push(describeSkillsUpdateWithVersion(skillsStatus));
+    }
+    return [
+        `Skipped updates${details.length ? `: ${details.join(', ')}` : '.'}`,
+        commands.length
+            ? `Run: ${commands.join(' && ')}`
+            : 'Check with: `nb self check` and `nb skills check`.',
+        'You may run into compatibility issues until you update.',
+    ].join(' ');
+}
+async function runStartupUpdates() {
+    await run('nb', ['self', 'update', '--yes'], {
+        stdio: 'inherit',
+        env: {
+            [NB_SKIP_STARTUP_UPDATE_ENV]: '1',
+        },
+        errorName: 'nb self update',
+    });
+    await run('nb', ['skills', 'update', '--yes'], {
+        stdio: 'inherit',
+        env: {
+            [NB_SKIP_STARTUP_UPDATE_ENV]: '1',
+        },
+        errorName: 'nb skills update',
+    });
+}
+export async function maybeRunStartupUpdatePrompt(argv) {
+    if (!(await shouldRunStartupUpdateCheck(argv))) {
+        return { kind: 'skipped' };
+    }
+    const selfStatus = await inspectSelfStatus();
+    if (!shouldEnableStartupUpdateForInstallMethod(selfStatus.installMethod)) {
+        return { kind: 'skipped' };
+    }
+    const skillsStatus = await inspectSkillsStatus();
+    if (!hasPendingUpdates(selfStatus, skillsStatus)) {
+        await markChecked();
+        return { kind: 'no-update' };
+    }
+    if (!isInteractiveTerminal()) {
+        printWarning(buildNonInteractiveWarning(selfStatus, skillsStatus));
+        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) {
+        printWarning(buildDeclinedWarning(selfStatus, skillsStatus));
+        await markChecked();
+        return { kind: 'declined' };
+    }
+    await runStartupUpdates();
+    await markChecked();
+    return { kind: 'updated' };
+}