@solarains/va-cli 0.1.3 → 0.1.5

package/dist/features/update/preflight.js

@@ -0,0 +1,488 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPLICIT_UPDATE_TARGET_VERSION_ENV = exports.EXPLICIT_UPDATE_REEXEC_ENV = exports.PREFLIGHT_GUARD_ENV = void 0;
+exports.shouldSkipManagedSync = shouldSkipManagedSync;
+exports.shouldSkipCliUpdate = shouldSkipCliUpdate;
+exports.canPromptForUpdate = canPromptForUpdate;
+exports.fetchLatestPublishedVersion = fetchLatestPublishedVersion;
+exports.performSelfUpdate = performSelfUpdate;
+exports.reexecCommand = reexecCommand;
+exports.resolveUpdateAction = resolveUpdateAction;
+exports.runExplicitUpdate = runExplicitUpdate;
+exports.runStartupPreflight = runStartupPreflight;
+const node_child_process_1 = require("node:child_process");
+const paths_1 = require("../../state/paths");
+const runtime_config_1 = require("../../config/runtime-config");
+const update_state_store_1 = require("../../state/stores/update-state-store");
+const prompt_1 = require("../init/prompt");
+const managed_pack_1 = require("../init/managed-pack");
+const package_metadata_1 = require("../runtime/package-metadata");
+const version_1 = require("./version");
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+exports.PREFLIGHT_GUARD_ENV = 'VAONE_SKIP_PREFLIGHT';
+exports.EXPLICIT_UPDATE_REEXEC_ENV = 'VAONE_EXPLICIT_UPDATE_REEXEC';
+exports.EXPLICIT_UPDATE_TARGET_VERSION_ENV = 'VAONE_EXPLICIT_UPDATE_TARGET_VERSION';
+const UPDATE_COPY = {
+    en: {
+        promptTitle(currentVersion, latestVersion) {
+            return `A newer VAOne CLI is available (${currentVersion} -> ${latestVersion}).`;
+        },
+        updateNow: 'Update now',
+        updateNowDescription: 'Run npm global install immediately',
+        skip: 'Skip this run',
+        skipDescription: 'Continue without updating',
+        defer: 'Wait for next release',
+        deferDescription: 'Hide this prompt until a newer version appears',
+        timeoutNotice(latestVersion) {
+            return `No response after 5 seconds. Updating VAOne CLI to ${latestVersion}.`;
+        },
+        updatingNotice(latestVersion) {
+            return `Updating VAOne CLI to ${latestVersion}...`;
+        },
+        restartingNotice: 'Restarting the requested command with the updated CLI.',
+    },
+    'zh-CN': {
+        promptTitle(currentVersion, latestVersion) {
+            return `检测到更高版本的 VAOne CLI（${currentVersion} -> ${latestVersion}）。`;
+        },
+        updateNow: '立即更新',
+        updateNowDescription: '马上执行 npm 全局安装',
+        skip: '本次跳过',
+        skipDescription: '继续执行当前命令，不更新',
+        defer: '下个版本再提醒',
+        deferDescription: '在出现更新版本前不再提示',
+        timeoutNotice(latestVersion) {
+            return `5 秒内未收到响应，开始将 VAOne CLI 更新到 ${latestVersion}。`;
+        },
+        updatingNotice(latestVersion) {
+            return `正在将 VAOne CLI 更新到 ${latestVersion}...`;
+        },
+        restartingNotice: '正在使用更新后的 CLI 重新执行原命令。',
+    },
+};
+function isAutomationContext(env) {
+    return env.CI === '1' || env.CI === 'true';
+}
+function shouldSkipManagedSync(commandPath) {
+    return (commandPath.length === 0 ||
+        commandPath[0] === 'init' ||
+        commandPath[0] === 'doctor' ||
+        commandPath[0] === 'uninstall' ||
+        commandPath[0] === 'update' ||
+        commandPath[0] === 'version');
+}
+function shouldSkipCliUpdate(commandPath) {
+    return (commandPath[0] === 'doctor' ||
+        commandPath[0] === 'update' ||
+        commandPath[0] === 'version');
+}
+function canPromptForUpdate(env) {
+    return (process.stdin.isTTY === true &&
+        process.stdout.isTTY === true &&
+        !isAutomationContext(env));
+}
+async function fetchLatestPublishedVersion(packageName) {
+    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`, {
+        headers: {
+            accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`npm registry returned ${response.status} while checking ${packageName}.`);
+    }
+    const payload = (await response.json());
+    if (!payload.version) {
+        throw new Error(`npm registry did not return a version for ${packageName}.`);
+    }
+    return payload.version;
+}
+function runUpdateCommand(packageName, version) {
+    const command = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    return (0, node_child_process_1.spawnSync)(command, ['install', '--global', `${packageName}@${version}`], {
+        encoding: 'utf8',
+        stdio: 'pipe',
+        env: process.env,
+    });
+}
+async function performSelfUpdate(packageName, version) {
+    const result = runUpdateCommand(packageName, version);
+    if (result.status === 0) {
+        return { success: true };
+    }
+    return {
+        success: false,
+        failureCode: result.status === null ? 'npm_update_signal' : 'npm_update_failed',
+        failureMessage: result.stderr?.trim() || result.stdout?.trim() || 'npm update failed.',
+    };
+}
+async function reexecCommand(argv, extraEnv) {
+    if (!process.argv[1]) {
+        return null;
+    }
+    const result = (0, node_child_process_1.spawnSync)(process.execPath, [process.argv[1], ...argv], {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            [exports.PREFLIGHT_GUARD_ENV]: '1',
+            ...extraEnv,
+        },
+    });
+    if (typeof result.status === 'number') {
+        return result.status;
+    }
+    return null;
+}
+async function resolveUpdateAction(input) {
+    const copy = UPDATE_COPY[input.locale];
+    const prompt = (input.promptFactory ?? prompt_1.createTerminalPrompt)();
+    const selectionPromise = prompt
+        .select({
+        message: copy.promptTitle(input.currentVersion, input.latestVersion),
+        defaultValue: 'update',
+        locale: input.locale,
+        choices: [
+            {
+                value: 'update',
+                label: copy.updateNow,
+                description: copy.updateNowDescription,
+            },
+            {
+                value: 'skip',
+                label: copy.skip,
+                description: copy.skipDescription,
+            },
+            {
+                value: 'defer',
+                label: copy.defer,
+                description: copy.deferDescription,
+            },
+        ],
+    })
+        .then((choice) => ({ kind: 'choice', choice }), (error) => ({ kind: 'error', error }));
+    const result = input.timeoutMs === null
+        ? await selectionPromise
+        : await Promise.race([
+            selectionPromise,
+            new Promise((resolve) => {
+                setTimeout(() => {
+                    void prompt.close().catch(() => undefined);
+                    resolve({ kind: 'timeout' });
+                }, input.timeoutMs ?? 5_000);
+            }),
+        ]);
+    if (result.kind === 'timeout') {
+        input.logger.info(copy.timeoutNotice(input.latestVersion));
+        return 'update';
+    }
+    if (result.kind === 'error') {
+        throw result.error;
+    }
+    return result.choice;
+}
+function createUpdateStateStore(paths) {
+    return new update_state_store_1.UpdateStateStore((0, paths_1.resolveUpdateStateFile)(paths));
+}
+function formatManagedPackRefreshSummary(refreshed) {
+    return refreshed
+        .map((entry) => `${entry.target.displayName} (${entry.scope})`)
+        .join(', ');
+}
+async function syncManagedPacksForVersion(input) {
+    const refreshed = await (input.syncManagedPacksImpl ?? managed_pack_1.syncManagedPacks)({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        currentVersion: input.currentVersion,
+    });
+    if (refreshed.length > 0) {
+        input.logger.info(`Refreshed stale managed skill packs: ${formatManagedPackRefreshSummary(refreshed)}.`);
+    }
+    return refreshed;
+}
+async function resolvePublishedUpdate(input) {
+    const updateStateStore = createUpdateStateStore(input.paths);
+    const updateState = (await updateStateStore.read()) ?? {};
+    try {
+        const latestVersion = await (input.fetchLatestVersionImpl ?? fetchLatestPublishedVersion)(input.packageName);
+        return {
+            latestVersion,
+            updateStateStore,
+            updateState,
+            nextState: {
+                ...updateState,
+                lastCheckedAt: new Date(input.now()).toISOString(),
+                lastKnownLatestVersion: latestVersion,
+            },
+        };
+    }
+    catch (error) {
+        await updateStateStore.save({
+            ...updateState,
+            lastCheckedAt: new Date(input.now()).toISOString(),
+            lastFailureCode: 'version_check_failed',
+            lastFailureMessage: error instanceof Error ? error.message : 'Version check failed.',
+        });
+        throw error;
+    }
+}
+function createExplicitRestartEnv(latestVersion) {
+    return {
+        [exports.EXPLICIT_UPDATE_REEXEC_ENV]: '1',
+        [exports.EXPLICIT_UPDATE_TARGET_VERSION_ENV]: latestVersion,
+    };
+}
+async function runExplicitUpdate(input, deps = {}) {
+    const runtimePackage = (await deps.resolvePackageInfo?.()) ?? (await (0, package_metadata_1.resolveRuntimePackageInfo)());
+    if (input.env[exports.EXPLICIT_UPDATE_REEXEC_ENV] === '1') {
+        const updatedVersion = input.env[exports.EXPLICIT_UPDATE_TARGET_VERSION_ENV] ?? runtimePackage.version;
+        input.logger.info(`VAOne CLI updated to ${updatedVersion}.`);
+        try {
+            const refreshed = await syncManagedPacksForVersion({
+                logger: input.logger,
+                cwd: input.cwd,
+                homeDir: input.homeDir,
+                currentVersion: runtimePackage.version,
+                syncManagedPacksImpl: deps.syncManagedPacks,
+            });
+            if (refreshed.length === 0) {
+                input.logger.info('No stale VA-managed skill packs were found.');
+            }
+            return 0;
+        }
+        catch (error) {
+            input.logger.error(`Managed skill-pack sync failed after CLI update: ${error instanceof Error ? error.message : 'unknown error'}`);
+            return 1;
+        }
+    }
+    if (!runtimePackage.isPackagedInstall) {
+        input.logger.error('`vaone update` only works from the packaged npm install. Local repository runs must update dependencies manually.');
+        return 1;
+    }
+    const now = deps.now ?? Date.now;
+    let publishedUpdate;
+    try {
+        publishedUpdate = await resolvePublishedUpdate({
+            now,
+            logger: input.logger,
+            paths: input.paths,
+            packageName: runtimePackage.name,
+            fetchLatestVersionImpl: deps.fetchLatestVersion,
+        });
+    }
+    catch (error) {
+        input.logger.error(`CLI update check failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+        return 1;
+    }
+    const { latestVersion, nextState, updateStateStore } = publishedUpdate;
+    if ((0, version_1.isVersionNewer)(latestVersion, runtimePackage.version)) {
+        const interactive = canPromptForUpdate(input.env);
+        const action = interactive
+            ? await resolveUpdateAction({
+                currentVersion: runtimePackage.version,
+                latestVersion,
+                locale: input.runtimeConfig.locale,
+                logger: input.logger,
+                promptFactory: deps.promptFactory,
+                timeoutMs: null,
+            })
+            : 'update';
+        if (!interactive) {
+            input.logger.info(`No interactive terminal detected. Updating VAOne CLI to ${latestVersion}.`);
+        }
+        if (action === 'defer') {
+            await (0, runtime_config_1.saveRuntimeConfig)(input.paths, {
+                updateDeferredUntilVersion: latestVersion,
+            });
+            input.runtimeConfig.updateDeferredUntilVersion = latestVersion;
+            await updateStateStore.save({
+                ...nextState,
+                lastFailureCode: undefined,
+                lastFailureMessage: undefined,
+            });
+            input.logger.info(`Deferred CLI self-update until a version newer than ${latestVersion} is published.`);
+        }
+        else if (action === 'skip') {
+            await updateStateStore.save({
+                ...nextState,
+                lastFailureCode: undefined,
+                lastFailureMessage: undefined,
+            });
+            input.logger.info('Skipped CLI self-update for this run.');
+        }
+        else {
+            const copy = UPDATE_COPY[input.runtimeConfig.locale];
+            input.logger.info(copy.updatingNotice(latestVersion));
+            const result = await (deps.performSelfUpdate ?? performSelfUpdate)(runtimePackage.name, latestVersion);
+            if (!result.success) {
+                await updateStateStore.save({
+                    ...nextState,
+                    lastAttemptedUpdateAt: new Date(now()).toISOString(),
+                    lastAttemptedTargetVersion: latestVersion,
+                    lastFailureCode: result.failureCode,
+                    lastFailureMessage: result.failureMessage,
+                });
+                input.logger.error(result.failureMessage ?? 'CLI update failed.');
+                return 1;
+            }
+            await (0, runtime_config_1.saveRuntimeConfig)(input.paths, {
+                updateDeferredUntilVersion: undefined,
+            });
+            input.runtimeConfig.updateDeferredUntilVersion = undefined;
+            await updateStateStore.save({
+                ...nextState,
+                lastAttemptedUpdateAt: new Date(now()).toISOString(),
+                lastAttemptedTargetVersion: latestVersion,
+                lastFailureCode: undefined,
+                lastFailureMessage: undefined,
+            });
+            input.logger.info(copy.restartingNotice);
+            const exitCode = await (deps.reexecCommand ?? reexecCommand)(input.argv, createExplicitRestartEnv(latestVersion));
+            if (typeof exitCode === 'number') {
+                return exitCode;
+            }
+            input.logger.error('CLI update completed, but restarting `vaone update` did not return an exit code.');
+            return 1;
+        }
+    }
+    else {
+        await updateStateStore.save({
+            ...nextState,
+            lastFailureCode: undefined,
+            lastFailureMessage: undefined,
+        });
+        input.logger.info(`VAOne CLI is already up to date (${runtimePackage.version}).`);
+    }
+    try {
+        const refreshed = await syncManagedPacksForVersion({
+            logger: input.logger,
+            cwd: input.cwd,
+            homeDir: input.homeDir,
+            currentVersion: runtimePackage.version,
+            syncManagedPacksImpl: deps.syncManagedPacks,
+        });
+        if (refreshed.length === 0) {
+            input.logger.info('No stale VA-managed skill packs were found.');
+        }
+        return 0;
+    }
+    catch (error) {
+        input.logger.error(`Managed skill-pack sync failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+        return 1;
+    }
+}
+async function runStartupPreflight(input, deps = {}) {
+    if (input.env[exports.PREFLIGHT_GUARD_ENV] === '1') {
+        return null;
+    }
+    const now = deps.now ?? Date.now;
+    const runtimePackage = (await deps.resolvePackageInfo?.()) ?? (await (0, package_metadata_1.resolveRuntimePackageInfo)());
+    if (!shouldSkipManagedSync(input.commandPath)) {
+        try {
+            await syncManagedPacksForVersion({
+                logger: input.logger,
+                cwd: input.cwd,
+                homeDir: input.homeDir,
+                currentVersion: runtimePackage.version,
+                syncManagedPacksImpl: deps.syncManagedPacks,
+            });
+        }
+        catch (error) {
+            input.logger.warn(`Managed skill-pack sync failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+    }
+    if (shouldSkipCliUpdate(input.commandPath)) {
+        return null;
+    }
+    if (!runtimePackage.isPackagedInstall || !canPromptForUpdate(input.env)) {
+        return null;
+    }
+    const updateStateStore = createUpdateStateStore(input.paths);
+    const updateState = (await updateStateStore.read()) ?? {};
+    const lastCheckedAt = updateState.lastCheckedAt
+        ? Date.parse(updateState.lastCheckedAt)
+        : NaN;
+    if (Number.isFinite(lastCheckedAt) &&
+        now() - lastCheckedAt < UPDATE_CHECK_INTERVAL_MS) {
+        return null;
+    }
+    let latestVersion;
+    try {
+        latestVersion = (await resolvePublishedUpdate({
+            now,
+            logger: input.logger,
+            paths: input.paths,
+            packageName: runtimePackage.name,
+            fetchLatestVersionImpl: deps.fetchLatestVersion,
+        })).latestVersion;
+    }
+    catch (error) {
+        input.logger.warn(`CLI update check failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+        return null;
+    }
+    const nextState = {
+        ...updateState,
+        lastCheckedAt: new Date(now()).toISOString(),
+        lastKnownLatestVersion: latestVersion,
+    };
+    if (!(0, version_1.isVersionNewer)(latestVersion, runtimePackage.version)) {
+        await updateStateStore.save({
+            ...nextState,
+            lastFailureCode: undefined,
+            lastFailureMessage: undefined,
+        });
+        return null;
+    }
+    const deferredBoundary = input.runtimeConfig.updateDeferredUntilVersion;
+    if (deferredBoundary &&
+        !(0, version_1.isVersionNewer)(latestVersion, deferredBoundary)) {
+        await updateStateStore.save(nextState);
+        return null;
+    }
+    const action = await resolveUpdateAction({
+        currentVersion: runtimePackage.version,
+        latestVersion,
+        locale: input.runtimeConfig.locale,
+        logger: input.logger,
+        promptFactory: deps.promptFactory,
+        timeoutMs: deps.promptTimeoutMs,
+    });
+    if (action === 'skip') {
+        await updateStateStore.save(nextState);
+        return null;
+    }
+    if (action === 'defer') {
+        await (0, runtime_config_1.saveRuntimeConfig)(input.paths, {
+            updateDeferredUntilVersion: latestVersion,
+        });
+        input.runtimeConfig.updateDeferredUntilVersion = latestVersion;
+        await updateStateStore.save(nextState);
+        return null;
+    }
+    const copy = UPDATE_COPY[input.runtimeConfig.locale];
+    input.logger.info(copy.updatingNotice(latestVersion));
+    const result = await (deps.performSelfUpdate ?? performSelfUpdate)(runtimePackage.name, latestVersion);
+    if (!result.success) {
+        await updateStateStore.save({
+            ...nextState,
+            lastAttemptedUpdateAt: new Date(now()).toISOString(),
+            lastAttemptedTargetVersion: latestVersion,
+            lastFailureCode: result.failureCode,
+            lastFailureMessage: result.failureMessage,
+        });
+        input.logger.warn(result.failureMessage ?? 'CLI update failed.');
+        return null;
+    }
+    await (0, runtime_config_1.saveRuntimeConfig)(input.paths, {
+        updateDeferredUntilVersion: undefined,
+    });
+    input.runtimeConfig.updateDeferredUntilVersion = undefined;
+    await updateStateStore.save({
+        ...nextState,
+        lastAttemptedUpdateAt: new Date(now()).toISOString(),
+        lastAttemptedTargetVersion: latestVersion,
+        lastFailureCode: undefined,
+        lastFailureMessage: undefined,
+    });
+    input.logger.info(copy.restartingNotice);
+    const exitCode = await (deps.reexecCommand ?? reexecCommand)(input.argv);
+    return exitCode;
+}

package/dist/features/update/version.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareVersions = compareVersions;
+exports.isVersionNewer = isVersionNewer;
+function parseVersion(raw) {
+    const trimmed = raw.trim();
+    const [core, prerelease] = trimmed.split('-', 2);
+    const segments = core.split('.').map((value) => {
+        if (!/^\d+$/.test(value)) {
+            throw new Error(`Invalid version segment "${value}" in "${raw}".`);
+        }
+        return Number(value);
+    });
+    return {
+        segments,
+        prerelease,
+    };
+}
+function compareVersions(left, right) {
+    const parsedLeft = parseVersion(left);
+    const parsedRight = parseVersion(right);
+    const maxLength = Math.max(parsedLeft.segments.length, parsedRight.segments.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftValue = parsedLeft.segments[index] ?? 0;
+        const rightValue = parsedRight.segments[index] ?? 0;
+        if (leftValue !== rightValue) {
+            return leftValue > rightValue ? 1 : -1;
+        }
+    }
+    if (parsedLeft.prerelease && !parsedRight.prerelease) {
+        return -1;
+    }
+    if (!parsedLeft.prerelease && parsedRight.prerelease) {
+        return 1;
+    }
+    if (parsedLeft.prerelease === parsedRight.prerelease) {
+        return 0;
+    }
+    return (parsedLeft.prerelease ?? '').localeCompare(parsedRight.prerelease ?? '');
+}
+function isVersionNewer(candidate, baseline) {
+    return compareVersions(candidate, baseline) > 0;
+}

package/dist/shared/logger.js

@@ -15,6 +15,9 @@ class Logger {
     info(message) {
         this.plain(message);
     }
+    warn(message) {
+        this.plain(`Warning: ${message}`);
+    }
     error(message) {
         process.stderr.write(`Error: ${message}\n`);
     }

package/dist/state/paths.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCliPaths = createCliPaths;
 exports.ensureCliDirectories = ensureCliDirectories;
+exports.resolveUpdateStateFile = resolveUpdateStateFile;
 const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
@@ -30,3 +31,6 @@ async function ensureCliDirectories(paths) {
     await (0, promises_1.mkdir)(paths.rootDir, { recursive: true });
     await (0, promises_1.mkdir)(paths.stateDir, { recursive: true });
 }
+function resolveUpdateStateFile(paths) {
+    return (0, node_path_1.join)(paths.stateDir, 'update.json');
+}

package/dist/state/stores/update-state-store.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateStateStore = void 0;
+const file_json_store_1 = require("./file-json-store");
+class UpdateStateStore {
+    store;
+    constructor(filePath) {
+        this.store = new file_json_store_1.FileJsonStore(filePath);
+    }
+    async read() {
+        return this.store.read();
+    }
+    async save(state) {
+        await this.store.write(state);
+    }
+    async clear() {
+        await this.store.clear();
+    }
+}
+exports.UpdateStateStore = UpdateStateStore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solarains/va-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Bootstrap CLI for the VAOne product.",
   "bin": {
     "vaone": "dist/main.js"