@nocobase/cli 2.1.0-beta.2 → 2.1.0-beta.21

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' };
+}

package/dist/lib/ui.js

@@ -0,0 +1,175 @@
+/**
+ * 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 readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import ora from 'ora';
+import pc from 'picocolors';
+let activeSpinner;
+let verboseMode = false;
+function stringWidth(value) {
+    return Array.from(value).length;
+}
+function pad(value, width) {
+    const padding = Math.max(0, width - stringWidth(value));
+    return `${value}${' '.repeat(padding)}`;
+}
+export function isInteractiveTerminal() {
+    return Boolean(input.isTTY && output.isTTY);
+}
+export function setVerboseMode(value) {
+    verboseMode = value;
+}
+export function isVerboseMode() {
+    return verboseMode;
+}
+export async function promptText(message, options) {
+    if (!isInteractiveTerminal()) {
+        return options?.defaultValue ?? '';
+    }
+    const rl = readline.createInterface({
+        input,
+        output,
+        terminal: true,
+    });
+    try {
+        const suffix = options?.defaultValue ? ` (${options.defaultValue})` : '';
+        const hint = options?.secret ? ' [input visible]' : '';
+        const prompt = `${message}${suffix}${hint}: `;
+        const answer = await rl.question(prompt);
+        return answer.trim() || options?.defaultValue || '';
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function confirmAction(message, options) {
+    if (!isInteractiveTerminal()) {
+        return Boolean(options?.defaultValue);
+    }
+    stopTask();
+    const rl = readline.createInterface({
+        input,
+        output,
+        terminal: true,
+    });
+    try {
+        const suffix = options?.defaultValue ? pc.dim('[Y/n]') : pc.dim('[y/N]');
+        const prompt = `${pc.yellow('?')} ${pc.bold(message)} ${suffix} `;
+        const answer = await rl.question(prompt);
+        const normalized = answer.trim().toLowerCase();
+        if (!normalized) {
+            return Boolean(options?.defaultValue);
+        }
+        return normalized === 'y' || normalized === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}
+export function printSection(title) {
+    console.log(pc.bold(title));
+}
+export function printInfo(message) {
+    if (activeSpinner) {
+        if (!isInteractiveTerminal()) {
+            activeSpinner = undefined;
+            console.log(pc.cyan(message));
+            return;
+        }
+        activeSpinner.info(pc.cyan(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.cyan(message));
+}
+export function printVerbose(message) {
+    if (!verboseMode) {
+        return;
+    }
+    printInfo(message);
+}
+export function printSuccess(message) {
+    if (activeSpinner) {
+        if (!isInteractiveTerminal()) {
+            activeSpinner = undefined;
+            console.log(pc.green(message));
+            return;
+        }
+        activeSpinner.succeed(pc.green(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.green(message));
+}
+function clearActiveSpinner() {
+    if (activeSpinner) {
+        activeSpinner.stop();
+        activeSpinner = undefined;
+    }
+}
+export function printWarning(message) {
+    clearActiveSpinner();
+    console.log(pc.yellow(`⚠ Warning: ${message}`));
+}
+export function printWarningBlock(message) {
+    clearActiveSpinner();
+    console.log(pc.yellow(`⚠ Warning\n${message}\n`));
+}
+export function printVerboseWarning(message) {
+    if (!verboseMode) {
+        return;
+    }
+    printWarning(message);
+}
+export function startTask(message) {
+    if (activeSpinner) {
+        activeSpinner.stop();
+    }
+    activeSpinner = ora({
+        text: pc.cyan(message),
+        isSilent: !isInteractiveTerminal(),
+    }).start();
+    if (!isInteractiveTerminal()) {
+        console.log(pc.cyan(message));
+    }
+}
+export function updateTask(message) {
+    if (!activeSpinner) {
+        startTask(message);
+        return;
+    }
+    activeSpinner.text = pc.cyan(message);
+}
+export function succeedTask(message) {
+    if (activeSpinner) {
+        activeSpinner.succeed(pc.green(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.green(message));
+}
+export function failTask(message) {
+    if (activeSpinner) {
+        activeSpinner.fail(pc.red(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.error(pc.red(message));
+}
+export function stopTask() {
+    clearActiveSpinner();
+}
+export function renderTable(headers, rows) {
+    const widths = headers.map((header, index) => {
+        return rows.reduce((max, row) => Math.max(max, stringWidth(row[index] ?? '')), stringWidth(header));
+    });
+    const renderRow = (row) => row.map((cell, index) => pad(cell ?? '', widths[index])).join('  ').trimEnd();
+    const divider = widths.map((width) => '-'.repeat(width)).join('  ');
+    return [renderRow(headers), divider, ...rows.map(renderRow)].join('\n');
+}