@nocobase/cli 2.1.0-beta.44.test.4 → 2.1.0-beta.45

package/dist/lib/startup-update.js

@@ -0,0 +1,309 @@
+/**
+ * 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 { fileURLToPath } from 'node:url';
+import { confirm } from "./inquirer.js";
+import { DEFAULT_UPDATE_POLICY, getExplicitCliConfigValue, loadCliConfig, } from './cli-config.js';
+import { inspectSelfInstall, 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 getCurrentInstallBinPath() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'bin', 'run.js');
+}
+function getCurrentInstallEntry(state) {
+    return state.entries?.[getCurrentInstallBinPath()];
+}
+function todayStamp(now = new Date()) {
+    const timeZone = String(process.env.TZ ?? '').trim();
+    if (timeZone) {
+        try {
+            const parts = new Intl.DateTimeFormat('en-CA', {
+                timeZone,
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+            }).formatToParts(now);
+            const year = parts.find((part) => part.type === 'year')?.value;
+            const month = parts.find((part) => part.type === 'month')?.value;
+            const day = parts.find((part) => part.type === 'day')?.value;
+            if (year && month && day) {
+                return `${year}-${month}-${day}`;
+            }
+        }
+        catch {
+            // Fall back to the host local timezone.
+        }
+    }
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+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));
+}
+function readCurrentInstallLastCheckedDate(state) {
+    return getCurrentInstallEntry(state)?.lastCheckedDate ?? state.lastCheckedDate;
+}
+async function writeCurrentInstallEntry(updater) {
+    const state = await readState();
+    const installBinPath = getCurrentInstallBinPath();
+    const nextEntry = updater(getCurrentInstallEntry(state), state);
+    const entries = {
+        ...(state.entries ?? {}),
+    };
+    if (nextEntry?.policy || nextEntry?.lastCheckedDate) {
+        entries[installBinPath] = nextEntry;
+    }
+    else {
+        delete entries[installBinPath];
+    }
+    await writeState({
+        ...state,
+        entries: Object.keys(entries).length ? entries : undefined,
+    });
+}
+async function markChecked(now = new Date()) {
+    await writeCurrentInstallEntry((current) => {
+        return {
+            ...current,
+            lastCheckedDate: todayStamp(now),
+        };
+    });
+}
+function resolveLegacyStartupUpdatePolicy(state) {
+    const policy = getCurrentInstallEntry(state)?.policy;
+    if (policy === 'disabled') {
+        return 'off';
+    }
+    if (policy === 'daily') {
+        return 'prompt';
+    }
+    return undefined;
+}
+async function resolveStartupUpdatePolicy(state) {
+    const config = await loadCliConfig({ scope: 'global' });
+    const explicit = getExplicitCliConfigValue(config, 'update.policy');
+    return explicit ?? resolveLegacyStartupUpdatePolicy(state) ?? DEFAULT_UPDATE_POLICY;
+}
+export async function clearLegacyStartupUpdatePolicyForCurrentInstall() {
+    const state = await readState();
+    const current = getCurrentInstallEntry(state);
+    if (!current?.policy) {
+        return false;
+    }
+    await writeCurrentInstallEntry(() => ({
+        lastCheckedDate: current.lastCheckedDate,
+    }));
+    return true;
+}
+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();
+    const policy = await resolveStartupUpdatePolicy(state);
+    if (policy === 'off') {
+        return false;
+    }
+    const selfInstall = await inspectSelfInstall();
+    if (!shouldEnableStartupUpdateForInstallMethod(selfInstall.installMethod)) {
+        return false;
+    }
+    return readCurrentInstallLastCheckedDate(state) !== 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) {
+    if (selfStatus.updateAvailable && selfStatus.updatable) {
+        return [skillsStatus.updateAvailable === true ? 'nb self update --yes --skills' : 'nb self update --yes'];
+    }
+    if (skillsStatus.updateAvailable === true) {
+        return ['nb skills update --yes'];
+    }
+    return [];
+}
+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(selfStatus, skillsStatus) {
+    if (selfStatus.updateAvailable && selfStatus.updatable) {
+        const args = ['self', 'update', '--yes'];
+        if (skillsStatus.updateAvailable === true) {
+            args.push('--skills');
+        }
+        await run('nb', args, {
+            stdio: 'inherit',
+            env: {
+                [NB_SKIP_STARTUP_UPDATE_ENV]: '1',
+            },
+            errorName: 'nb self update',
+        });
+        return;
+    }
+    if (skillsStatus.updateAvailable === true) {
+        await run('nb', ['skills', 'update', '--yes'], {
+            stdio: 'inherit',
+            env: {
+                [NB_SKIP_STARTUP_UPDATE_ENV]: '1',
+            },
+            errorName: 'nb skills update',
+        });
+    }
+}
+export async function maybeRunStartupUpdate(argv) {
+    if (!(await shouldRunStartupUpdateCheck(argv))) {
+        return { kind: 'skipped' };
+    }
+    const policy = await resolveStartupUpdatePolicy(await readState());
+    const selfStatus = await inspectSelfStatus();
+    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' };
+    }
+    if (policy === 'auto') {
+        await runStartupUpdates(selfStatus, skillsStatus);
+        await markChecked();
+        return { kind: 'updated' };
+    }
+    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' };
+    }
+    await runStartupUpdates(selfStatus, skillsStatus);
+    await markChecked();
+    return { kind: 'updated' };
+}

package/dist/lib/ui.js

@@ -0,0 +1,159 @@
+/**
+ * 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 { stdin as input, stdout as output } from 'node:process';
+import ora from 'ora';
+import pc from 'picocolors';
+import { translateCli } from './cli-locale.js';
+let activeSpinner;
+let verboseMode = false;
+let lastStaticTaskMessage;
+let lastStaticTaskAt = 0;
+const STATIC_TASK_UPDATE_THROTTLE_MS = 3_000;
+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);
+}
+function supportsDynamicTaskUpdates() {
+    return isInteractiveTerminal() && process.env.TERM !== 'dumb';
+}
+export function setVerboseMode(value) {
+    verboseMode = value;
+}
+export function isVerboseMode() {
+    return verboseMode;
+}
+export function printSection(title) {
+    console.log(title);
+}
+export function printStage(title) {
+    clearActiveSpinner();
+    console.log(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 announceTargetEnv(envName) {
+    if (process.env.NB_SKIP_TARGET_ENV_LOG === '1') {
+        return;
+    }
+    printInfo(translateCli('commands.shared.targetEnv', { envName }));
+}
+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();
+    }
+    lastStaticTaskMessage = message;
+    lastStaticTaskAt = Date.now();
+    if (!supportsDynamicTaskUpdates()) {
+        activeSpinner = undefined;
+        console.log(pc.cyan(message));
+        return;
+    }
+    activeSpinner = ora({
+        text: pc.cyan(message),
+        isSilent: false,
+    }).start();
+}
+export function updateTask(message) {
+    if (!activeSpinner) {
+        const now = Date.now();
+        if (message !== lastStaticTaskMessage
+            && now - lastStaticTaskAt >= STATIC_TASK_UPDATE_THROTTLE_MS) {
+            console.log(pc.cyan(message));
+            lastStaticTaskMessage = message;
+            lastStaticTaskAt = now;
+        }
+        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() {
+    lastStaticTaskMessage = undefined;
+    lastStaticTaskAt = 0;
+    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');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.1.0-beta.44.test.4",
+  "version": "2.1.0-beta.45",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -137,5 +137,6 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
-  }
+  },
+  "gitHead": "42587115fc34c3eb01ef2b2549f1c998e5708318"
 }