@solarains/va-cli 0.1.3 → 0.1.4

package/dist/cli/help-copy.js

@@ -4,7 +4,7 @@ exports.getHelpCopy = getHelpCopy;
 exports.getLocalizedCommandHelp = getLocalizedCommandHelp;
 exports.getLocalizedChildSummary = getLocalizedChildSummary;
 const HELP_COPY = {
-    en: {
+    'en': {
         commandsHeading: 'Commands:',
         globalFlagsHeading: 'Global flags:',
         helpFlag: 'Show help',
@@ -14,26 +14,30 @@ const HELP_COPY = {
                 summary: 'VAOne CLI with guided init, auth, assets, usage, daily reports, intelligence queries, and diagnostics.',
                 usage: 'vaone <command> [subcommand] [options]',
             },
-            init: {
+            'init': {
                 summary: 'Install VisionAlpha operator skills with branded onboarding and optional browser login.',
                 usage: 'vaone init [.] [--agents codex,claude,openclaw] [--scope project|user] [--lang en|zh-CN] [--skip-login] [--force] [--yes]',
             },
-            auth: {
+            'uninstall': {
+                summary: 'Remove VA-managed skill packs from project or global agent roots.',
+                usage: 'vaone uninstall [--scope project|user|all] [--agents codex,claude,openclaw]',
+            },
+            'auth': {
                 summary: 'Authentication placeholder commands for future browser login.',
             },
-            assets: {
+            'assets': {
                 summary: 'Browse asset catalog commands.',
             },
-            usage: {
+            'usage': {
                 summary: 'Show current account usage summary.',
             },
-            reports: {
+            'reports': {
                 summary: 'List or read normalized daily reports.',
             },
-            intelligence: {
+            'intelligence': {
                 summary: 'Query paid asset intelligence data.',
             },
-            doctor: {
+            'doctor': {
                 summary: 'Run local diagnostics for auth, install, and configuration state.',
             },
         },
@@ -51,26 +55,30 @@ const HELP_COPY = {
                 summary: 'VAOne CLI，提供引导式 init、认证、资产、usage、日报、intelligence 查询与诊断能力。',
                 usage: 'vaone <命令> [子命令] [参数]',
             },
-            init: {
+            'init': {
                 summary: '通过带品牌感的引导流程安装 VisionAlpha operator skills，并可选串联浏览器登录。',
                 usage: 'vaone init [.] [--agents codex,claude,openclaw] [--scope project|user] [--lang en|zh-CN] [--skip-login] [--force] [--yes]',
             },
-            auth: {
+            'uninstall': {
+                summary: '从当前项目或全局 agent 根目录移除 VA 受管 skill pack。',
+                usage: 'vaone uninstall [--scope project|user|all] [--agents codex,claude,openclaw]',
+            },
+            'auth': {
                 summary: '认证相关命令，包括浏览器登录与退出登录。',
             },
-            assets: {
+            'assets': {
                 summary: '浏览资产目录相关命令。',
             },
-            usage: {
+            'usage': {
                 summary: '显示当前账户 usage 摘要。',
             },
-            reports: {
+            'reports': {
                 summary: '列出或读取标准化日报。',
             },
-            intelligence: {
+            'intelligence': {
                 summary: '查询付费资产 intelligence 数据。',
             },
-            doctor: {
+            'doctor': {
                 summary: '运行本地认证、安装和配置状态诊断。',
             },
         },

package/dist/cli/root-command.js

@@ -7,6 +7,7 @@ const doctor_command_1 = require("../commands/doctor/doctor-command");
 const init_command_1 = require("../commands/init/init-command");
 const intelligence_command_1 = require("../commands/intelligence/intelligence-command");
 const reports_command_1 = require("../commands/reports/reports-command");
+const uninstall_command_1 = require("../commands/uninstall/uninstall-command");
 const usage_command_1 = require("../commands/usage/usage-command");
 exports.rootCommand = {
     name: 'vaone',
@@ -14,6 +15,7 @@ exports.rootCommand = {
     usage: 'vaone <command> [subcommand] [options]',
     children: [
         init_command_1.initCommand,
+        uninstall_command_1.uninstallCommand,
         auth_command_1.authCommand,
         assets_command_1.assetsCommand,
         usage_command_1.usageCommand,

package/dist/cli/run-cli.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCli = runCli;
+const node_os_1 = require("node:os");
 const runtime_config_1 = require("../config/runtime-config");
+const preflight_1 = require("../features/update/preflight");
 const paths_1 = require("../state/paths");
 const installation_store_1 = require("../state/stores/installation-store");
 const token_store_1 = require("../state/stores/token-store");
@@ -62,7 +64,7 @@ function printUnknownCommand(logger, command, path, token, locale) {
     logger.plain('');
     logger.plain((0, help_1.renderHelp)(command, path, locale));
 }
-async function runCli(argv, env) {
+async function runCli(argv, env, deps = {}) {
     const parsedArgv = parseArgv(argv);
     const logger = new logger_1.Logger(parsedArgv.debug || env.VAONE_DEBUG === 'true');
     const paths = (0, paths_1.createCliPaths)(env);
@@ -86,7 +88,6 @@ async function runCli(argv, env) {
         logger.plain((0, help_1.renderHelp)(resolvedCommand.command, resolvedCommand.path, locale));
         return 0;
     }
-    await (0, paths_1.ensureCliDirectories)(paths);
     if (canTraverseFurther && !resolvedCommand.command.run) {
         printUnknownCommand(logger, resolvedCommand.command, resolvedCommand.path, unknownToken, locale);
         return 1;
@@ -95,6 +96,20 @@ async function runCli(argv, env) {
         logger.plain((0, help_1.renderHelp)(resolvedCommand.command, resolvedCommand.path, locale));
         return 0;
     }
+    await (0, paths_1.ensureCliDirectories)(paths);
+    const preflightExitCode = await (deps.runStartupPreflight ?? preflight_1.runStartupPreflight)({
+        argv,
+        env,
+        logger,
+        paths,
+        runtimeConfig,
+        commandPath: resolvedCommand.path,
+        cwd: process.cwd(),
+        homeDir: (0, node_os_1.homedir)(),
+    });
+    if (typeof preflightExitCode === 'number') {
+        return preflightExitCode;
+    }
     try {
         return await resolvedCommand.command.run(context, resolvedCommand.remainingArgs);
     }

package/dist/commands/auth/logout-command.js

@@ -22,7 +22,9 @@ exports.logoutCommand = {
             }
             catch (error) {
                 remoteLogoutFailure =
-                    error instanceof Error ? error.message : 'Unknown remote logout failure.';
+                    error instanceof Error
+                        ? error.message
+                        : 'Unknown remote logout failure.';
                 context.logger.debug('Remote logout request failed.', error);
             }
         }

package/dist/commands/doctor/doctor-command.js

@@ -1,7 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.doctorCommand = void 0;
+const node_os_1 = require("node:os");
 const output_1 = require("../../shared/output");
+const package_metadata_1 = require("../../features/runtime/package-metadata");
+const managed_pack_1 = require("../../features/init/managed-pack");
+const paths_1 = require("../../state/paths");
+const update_state_store_1 = require("../../state/stores/update-state-store");
+function formatManagedStatus(input) {
+    if (input.kind === 'current') {
+        return `current (${input.installedVersion})`;
+    }
+    if (input.kind === 'stale') {
+        return `stale (${input.installedVersion} -> ${input.currentVersion})`;
+    }
+    if (input.kind === 'legacy') {
+        return `legacy (missing pack version; current ${input.currentVersion})`;
+    }
+    if (input.kind === 'ahead') {
+        return `ahead (${input.installedVersion})`;
+    }
+    if (input.kind === 'untracked') {
+        return 'managed files detected without a valid manifest';
+    }
+    return 'not installed';
+}
 exports.doctorCommand = {
     name: 'doctor',
     summary: 'Inspect config, paths, and local bootstrap state.',
@@ -9,6 +32,14 @@ exports.doctorCommand = {
     async run(context) {
         const tokens = await context.tokenStore.read();
         const installation = await context.installationStore.read();
+        const runtimePackage = await (0, package_metadata_1.resolveRuntimePackageInfo)();
+        const updateStateStore = new update_state_store_1.UpdateStateStore((0, paths_1.resolveUpdateStateFile)(context.paths));
+        const updateState = await updateStateStore.read();
+        const managedStatuses = await (0, managed_pack_1.collectManagedPackStatuses)({
+            cwd: process.cwd(),
+            homeDir: (0, node_os_1.homedir)(),
+            currentVersion: runtimePackage.version,
+        });
         (0, output_1.printSection)(context.logger, 'Runtime configuration');
         (0, output_1.printKeyValue)(context.logger, 'Environment', context.runtimeConfig.appEnv);
         (0, output_1.printKeyValue)(context.logger, 'API base URL', context.runtimeConfig.apiBaseUrl);
@@ -19,6 +50,13 @@ exports.doctorCommand = {
         (0, output_1.printKeyValue)(context.logger, 'State directory', context.paths.stateDir);
         (0, output_1.printKeyValue)(context.logger, 'Auth state', context.paths.authStateFile);
         (0, output_1.printKeyValue)(context.logger, 'Installation state', context.paths.installationStateFile);
+        (0, output_1.printKeyValue)(context.logger, 'Update state', (0, paths_1.resolveUpdateStateFile)(context.paths));
+        (0, output_1.printSection)(context.logger, 'Runtime version state');
+        (0, output_1.printKeyValue)(context.logger, 'CLI version', runtimePackage.version);
+        (0, output_1.printKeyValue)(context.logger, 'Packaged install', String(runtimePackage.isPackagedInstall));
+        (0, output_1.printKeyValue)(context.logger, 'Deferred update boundary', context.runtimeConfig.updateDeferredUntilVersion ?? 'none');
+        (0, output_1.printKeyValue)(context.logger, 'Last checked', updateState?.lastCheckedAt ?? 'never');
+        (0, output_1.printKeyValue)(context.logger, 'Last known latest version', updateState?.lastKnownLatestVersion ?? 'unknown');
         (0, output_1.printSection)(context.logger, 'Stored bootstrap state');
         (0, output_1.printList)(context.logger, [
             tokens
@@ -28,6 +66,12 @@ exports.doctorCommand = {
                 ? 'Installation state file exists.'
                 : 'Installation state file is empty.',
         ]);
+        (0, output_1.printSection)(context.logger, 'Managed skill packs');
+        (0, output_1.printList)(context.logger, managedStatuses.map((status) => `${status.target.displayName} (${status.scope}): ${formatManagedStatus({
+            kind: status.kind,
+            installedVersion: status.installedVersion,
+            currentVersion: status.currentVersion,
+        })} at ${status.rootDir}`));
         return 0;
     },
 };

package/dist/commands/uninstall/uninstall-command.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uninstallCommand = void 0;
+const node_os_1 = require("node:os");
+const argv_1 = require("../../shared/argv");
+const target_registry_1 = require("../../features/init/target-registry");
+const managed_pack_1 = require("../../features/init/managed-pack");
+function parseScope(value) {
+    if (!value) {
+        return 'project';
+    }
+    if (value === 'project' || value === 'user' || value === 'all') {
+        return value;
+    }
+    throw new Error('Option "--scope" must be project, user, or all.');
+}
+function parseAgentIds(value) {
+    if (!value) {
+        return (0, target_registry_1.getAgentTargetRegistry)().map((target) => target.id);
+    }
+    const supported = new Set((0, target_registry_1.getAgentTargetRegistry)().map((target) => target.id));
+    return value
+        .split(',')
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean)
+        .map((entry) => {
+        if (!supported.has(entry)) {
+            throw new Error(`Unsupported agent "${entry}". Use one or more of: ${Array.from(supported).join(', ')}.`);
+        }
+        return entry;
+    })
+        .filter((entry, index, items) => items.indexOf(entry) === index);
+}
+exports.uninstallCommand = {
+    name: 'uninstall',
+    summary: 'Remove VA-managed skill packs from project or global agent roots.',
+    usage: 'vaone uninstall [--scope project|user|all] [--agents codex,claude,openclaw]',
+    async run(context, args) {
+        const parsed = (0, argv_1.parseCommandArgs)(args);
+        if (parsed.positionals.length) {
+            throw new Error('`vaone uninstall` does not accept positional arguments.');
+        }
+        const scope = parseScope((0, argv_1.getStringOption)(parsed, 'scope'));
+        const scopes = scope === 'all' ? ['project', 'user'] : [scope];
+        const agentIds = parseAgentIds((0, argv_1.getStringOption)(parsed, 'agents'));
+        const removed = await (0, managed_pack_1.removeManagedPacks)({
+            cwd: process.cwd(),
+            homeDir: (0, node_os_1.homedir)(),
+            agentIds,
+            scopes,
+        });
+        if (removed.length === 0) {
+            context.logger.info('No VA-managed skill packs were found for removal.');
+            return 0;
+        }
+        context.logger.plain('Managed skill packs removed:');
+        for (const entry of removed) {
+            context.logger.plain(`- ${entry.target.displayName} (${entry.scope}): ${entry.rootDir}`);
+        }
+        return 0;
+    },
+};

package/dist/config/runtime-config.js

@@ -46,13 +46,12 @@ async function loadRuntimeConfig(env, paths) {
     const locale = envLocale ?? fileLocale ?? locale_1.DEFAULT_LOCALE;
     return {
         appEnv: env.VAONE_ENV ?? fileConfig.appEnv ?? 'local',
-        apiBaseUrl: normalizeHomePath(env.VAONE_API_BASE_URL ??
-            fileConfig.apiBaseUrl ??
-            exports.DEFAULT_API_BASE_URL).replace(/\/$/, ''),
+        apiBaseUrl: normalizeHomePath(env.VAONE_API_BASE_URL ?? fileConfig.apiBaseUrl ?? exports.DEFAULT_API_BASE_URL).replace(/\/$/, ''),
         debug: parseBoolean(env.VAONE_DEBUG) ?? fileConfig.debug ?? false,
         authCallbackMode,
         locale,
         localeConfigured: envLocale !== undefined || fileLocale !== undefined,
+        updateDeferredUntilVersion: fileConfig.updateDeferredUntilVersion?.trim() || undefined,
     };
 }
 async function saveRuntimeConfig(paths, patch) {

package/dist/features/auth/installation-state.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureInstallationState = ensureInstallationState;
 const node_crypto_1 = require("node:crypto");
 const node_os_1 = require("node:os");
-const CLI_VERSION = '0.1.0';
+const package_metadata_1 = require("../runtime/package-metadata");
 function exportPublicKeyPem(publicKey) {
     return publicKey.export({
         type: 'spki',
@@ -28,6 +28,7 @@ function hasUsableKeys(installation) {
         installation.updatedAt);
 }
 async function ensureInstallationState(installationStore) {
+    const runtimePackage = await (0, package_metadata_1.resolveRuntimePackageInfo)();
     const existing = await installationStore.read();
     const now = new Date().toISOString();
     if (hasUsableKeys(existing)) {
@@ -35,7 +36,7 @@ async function ensureInstallationState(installationStore) {
             ...existing,
             clientPlatform: (0, node_os_1.platform)(),
             clientArch: (0, node_os_1.arch)(),
-            cliVersion: existing.cliVersion ?? CLI_VERSION,
+            cliVersion: runtimePackage.version,
             deviceName: existing.deviceName ?? (0, node_os_1.hostname)(),
             updatedAt: now,
         };
@@ -55,7 +56,7 @@ async function ensureInstallationState(installationStore) {
         keyFingerprint,
         clientPlatform: (0, node_os_1.platform)(),
         clientArch: (0, node_os_1.arch)(),
-        cliVersion: CLI_VERSION,
+        cliVersion: runtimePackage.version,
         deviceName: (0, node_os_1.hostname)(),
         createdAt: now,
         updatedAt: now,

package/dist/features/auth/loopback-callback-page.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderLoopbackCallbackPage = renderLoopbackCallbackPage;
 const CALLBACK_PAGE_COPY = {
-    en: {
+    'en': {
         brand: 'VAOne',
         closeAction: 'Close page',
         success: {

package/dist/features/init/init-flow.js

@@ -108,7 +108,8 @@ function extractLoginSummary(lines, copy) {
             /^-+$/.test(line.trim())) {
             continue;
         }
-        if (line.includes('Automatic browser launch failed') || line.startsWith('URL:')) {
+        if (line.includes('Automatic browser launch failed') ||
+            line.startsWith('URL:')) {
             details.push(line);
             continue;
         }
@@ -405,14 +406,14 @@ function resolveInitOptions(input) {
     return resolve();
 }
 function positionalscopeAndScopeConflict(positionalScope, parsedScope) {
-    return Boolean(positionalScope &&
-        parsedScope &&
-        positionalScope !== parsedScope);
+    return Boolean(positionalScope && parsedScope && positionalScope !== parsedScope);
 }
 function describeDetection(presenter, copy, detectedTargets) {
     presenter.section(copy.sections.detection);
     for (const target of detectedTargets) {
-        const summary = target.detected ? copy.labels.detected : copy.labels.notDetected;
+        const summary = target.detected
+            ? copy.labels.detected
+            : copy.labels.notDetected;
         presenter.list([
             `${target.displayName}: ${summary}`,
             ...(target.detectedIn.length > 0
@@ -477,9 +478,7 @@ async function runVerification(context, presenter, copy, options, dependencies)
     });
     if (options.skipLogin) {
         presenter.step('skipped', copy.statuses.skipped, copy.steps.usageSkipped);
-        presenter.list([
-            copy.messages.usageVerificationSkippedDeferred,
-        ]);
+        presenter.list([copy.messages.usageVerificationSkippedDeferred]);
         return;
     }
     await runCommandInBox({
@@ -570,7 +569,9 @@ async function runInitFlow(context, args, partialDependencies = {}) {
         cwd: dependencies.cwd,
         homeDir: dependencies.homeDir,
     });
-    const prompt = dependencies.isInteractive ? dependencies.promptFactory() : null;
+    const prompt = dependencies.isInteractive
+        ? dependencies.promptFactory()
+        : null;
     let shouldForceExit = false;
     let exitCode = 1;
     try {

package/dist/features/init/installer.js

@@ -4,6 +4,7 @@ exports.prepareInstallations = prepareInstallations;
 exports.applyInstallations = applyInstallations;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const package_metadata_1 = require("../runtime/package-metadata");
 const manifest_1 = require("./manifest");
 const target_registry_1 = require("./target-registry");
 const templates_1 = require("./templates");
@@ -85,8 +86,10 @@ async function prepareInstallations(input) {
 async function applyInstallations(prepared, options) {
     const applied = [];
     const timestamp = options.now ?? (() => new Date().toISOString());
+    const runtimePackage = await (0, package_metadata_1.resolveRuntimePackageInfo)();
     for (const entry of prepared) {
-        if (entry.analysis.conflicts.length > 0 && !options.allowUnmanagedOverwrite) {
+        if (entry.analysis.conflicts.length > 0 &&
+            !options.allowUnmanagedOverwrite) {
             throw new Error(`Unmanaged files block ${entry.target.displayName} installation: ${entry.analysis.conflicts.join(', ')}. Re-run with --force or confirm overwrite interactively.`);
         }
         const overwritten = [...entry.analysis.conflicts];
@@ -106,6 +109,7 @@ async function applyInstallations(prepared, options) {
             packId: 'vaone-agent-pack',
             targetId: entry.target.id,
             scope: entry.scope,
+            packVersion: runtimePackage.version,
             updatedAt: timestamp(),
             files: entry.files.map((file) => file.relativePath),
         });

package/dist/features/init/managed-pack.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectManagedPack = inspectManagedPack;
+exports.collectManagedPackStatuses = collectManagedPackStatuses;
+exports.syncManagedPacks = syncManagedPacks;
+exports.removeManagedPacks = removeManagedPacks;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const version_1 = require("../update/version");
+const package_metadata_1 = require("../runtime/package-metadata");
+const manifest_1 = require("./manifest");
+const installer_1 = require("./installer");
+const target_registry_1 = require("./target-registry");
+const templates_1 = require("./templates");
+async function readText(path) {
+    try {
+        return await (0, promises_1.readFile)(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+async function pruneEmptyDirectories(startDir, stopDir) {
+    let current = startDir;
+    while (current.startsWith(stopDir) && current !== stopDir) {
+        try {
+            await (0, promises_1.rmdir)(current);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOTEMPTY' || code === 'ENOENT') {
+                return;
+            }
+            throw error;
+        }
+        current = (0, node_path_1.dirname)(current);
+    }
+}
+function resolveRoot(input) {
+    const target = (0, target_registry_1.getAgentTarget)(input.targetId);
+    const cwd = input.cwd ?? process.cwd();
+    const homeDir = input.homeDir ?? (0, node_os_1.homedir)();
+    const rootDir = target.resolveRoot({
+        cwd,
+        homeDir,
+        scope: input.scope,
+    });
+    return {
+        target,
+        rootDir,
+        manifestPath: (0, node_path_1.join)(rootDir, manifest_1.MANIFEST_FILE_NAME),
+    };
+}
+async function inspectManagedPack(input) {
+    const runtimePackage = input.currentVersion === undefined
+        ? await (0, package_metadata_1.resolveRuntimePackageInfo)()
+        : null;
+    const currentVersion = input.currentVersion ?? runtimePackage?.version ?? '';
+    const { target, rootDir, manifestPath } = resolveRoot(input);
+    const manifest = await (0, manifest_1.readManagedManifest)(manifestPath);
+    const managedSkillPath = (0, node_path_1.join)(rootDir, templates_1.SKILL_NAME, 'SKILL.md');
+    const existingSkill = await readText(managedSkillPath);
+    const hasManagedSkillFile = existingSkill?.includes(templates_1.MANAGED_MARKER) ?? false;
+    if (!manifest) {
+        return {
+            target,
+            scope: input.scope,
+            rootDir,
+            manifestPath,
+            kind: hasManagedSkillFile ? 'untracked' : 'missing',
+            currentVersion,
+        };
+    }
+    const installedVersion = manifest.packVersion;
+    if (!installedVersion) {
+        return {
+            target,
+            scope: input.scope,
+            rootDir,
+            manifestPath,
+            kind: 'legacy',
+            currentVersion,
+        };
+    }
+    const comparison = (0, version_1.compareVersions)(installedVersion, currentVersion);
+    return {
+        target,
+        scope: input.scope,
+        rootDir,
+        manifestPath,
+        kind: comparison === 0 ? 'current' : comparison < 0 ? 'stale' : 'ahead',
+        currentVersion,
+        installedVersion,
+    };
+}
+async function collectManagedPackStatuses(input) {
+    const runtimePackage = input?.currentVersion === undefined
+        ? await (0, package_metadata_1.resolveRuntimePackageInfo)()
+        : null;
+    const currentVersion = input?.currentVersion ?? runtimePackage?.version ?? '';
+    const agentIds = input?.agentIds ?? (0, target_registry_1.getAgentTargetRegistry)().map((target) => target.id);
+    const scopes = input?.scopes ?? ['project', 'user'];
+    const statuses = [];
+    for (const scope of scopes) {
+        for (const agentId of agentIds) {
+            statuses.push(await inspectManagedPack({
+                targetId: agentId,
+                scope,
+                cwd: input?.cwd,
+                homeDir: input?.homeDir,
+                currentVersion,
+            }));
+        }
+    }
+    return statuses;
+}
+async function syncManagedPacks(input) {
+    const runtimePackage = input?.currentVersion === undefined
+        ? await (0, package_metadata_1.resolveRuntimePackageInfo)()
+        : null;
+    const currentVersion = input?.currentVersion ?? runtimePackage?.version ?? '';
+    const statuses = await collectManagedPackStatuses({
+        ...input,
+        currentVersion,
+    });
+    const refreshed = [];
+    for (const status of statuses) {
+        if (status.kind !== 'legacy' && status.kind !== 'stale') {
+            continue;
+        }
+        const prepared = await (0, installer_1.prepareInstallations)({
+            agentIds: [status.target.id],
+            scope: status.scope,
+            cwd: input?.cwd ?? process.cwd(),
+            homeDir: input?.homeDir ?? (0, node_os_1.homedir)(),
+        });
+        await (0, installer_1.applyInstallations)(prepared, {
+            allowUnmanagedOverwrite: false,
+        });
+        refreshed.push({
+            target: status.target,
+            scope: status.scope,
+            rootDir: status.rootDir,
+            previousStatus: status.kind,
+        });
+    }
+    return refreshed;
+}
+async function removeManagedPacks(input) {
+    const agentIds = input?.agentIds ?? (0, target_registry_1.getAgentTargetRegistry)().map((target) => target.id);
+    const scopes = input?.scopes ?? ['project', 'user'];
+    const removed = [];
+    for (const scope of scopes) {
+        for (const agentId of agentIds) {
+            const { target, rootDir, manifestPath } = resolveRoot({
+                targetId: agentId,
+                scope,
+                cwd: input?.cwd,
+                homeDir: input?.homeDir,
+            });
+            const manifest = await (0, manifest_1.readManagedManifest)(manifestPath);
+            if (!manifest) {
+                continue;
+            }
+            const removedFiles = [];
+            for (const relativePath of manifest.files) {
+                await (0, promises_1.rm)((0, node_path_1.join)(rootDir, relativePath), { force: true });
+                removedFiles.push(relativePath);
+            }
+            await (0, promises_1.rm)(manifestPath, { force: true });
+            await pruneEmptyDirectories((0, node_path_1.join)(rootDir, templates_1.SKILL_NAME), rootDir);
+            removed.push({
+                target,
+                scope,
+                rootDir,
+                removedFiles,
+            });
+        }
+    }
+    return removed;
+}

package/dist/features/init/target-registry.js

@@ -29,7 +29,9 @@ const TARGET_REGISTRY = [
         displayName: 'OpenClaw',
         supportedScopes: ['project', 'user'],
         resolveRoot({ cwd, homeDir, scope }) {
-            return scope === 'project' ? (0, node_path_1.join)(cwd, 'skills') : (0, node_path_1.join)(homeDir, '.openclaw', 'skills');
+            return scope === 'project'
+                ? (0, node_path_1.join)(cwd, 'skills')
+                : (0, node_path_1.join)(homeDir, '.openclaw', 'skills');
         },
     },
 ];

package/dist/features/init/templates.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MANAGED_MARKER = void 0;
+exports.SKILL_NAME = exports.MANAGED_MARKER = void 0;
 exports.resolveSkillSourceRoot = resolveSkillSourceRoot;
 exports.createAgentPackFiles = createAgentPackFiles;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const package_metadata_1 = require("../runtime/package-metadata");
 exports.MANAGED_MARKER = 'VAONE-MANAGED FILE';
-const SKILL_NAME = 'visionalpha-operator';
+exports.SKILL_NAME = 'visionalpha-operator';
 async function pathExists(path) {
     try {
         await (0, promises_1.access)((0, node_path_1.join)(path, 'SKILL.md'));
@@ -23,12 +24,12 @@ async function resolveSkillSourceRoot(input) {
     const env = input?.env ?? process.env;
     const candidates = [
         env.VAONE_SKILL_SOURCE_DIR,
-        (0, node_path_1.join)(moduleDir, '..', '..', '..', 'skills', SKILL_NAME),
-        (0, node_path_1.join)(cwd, 'skills', SKILL_NAME),
-        (0, node_path_1.join)(cwd, 'va-cli', 'skills', SKILL_NAME),
-        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), 'skills', SKILL_NAME),
-        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'skills', SKILL_NAME),
-        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'va-cli', 'skills', SKILL_NAME),
+        (0, node_path_1.join)(moduleDir, '..', '..', '..', 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)(cwd, 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)(cwd, 'va-cli', 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'skills', exports.SKILL_NAME),
+        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'va-cli', 'skills', exports.SKILL_NAME),
     ]
         .filter((candidate) => Boolean(candidate))
         .map((candidate) => (0, node_path_1.resolve)(candidate));
@@ -38,7 +39,7 @@ async function resolveSkillSourceRoot(input) {
             return candidate;
         }
     }
-    throw new Error(`Unable to locate the managed skill source for "${SKILL_NAME}". Checked: ${deduped.join(', ')}. Set VAONE_SKILL_SOURCE_DIR to override the lookup path.`);
+    throw new Error(`Unable to locate the managed skill source for "${exports.SKILL_NAME}". Checked: ${deduped.join(', ')}. Set VAONE_SKILL_SOURCE_DIR to override the lookup path.`);
 }
 function buildManagedHeader(target, relativePath) {
     if (relativePath.endsWith('.yaml') || relativePath.endsWith('.yml')) {
@@ -58,6 +59,27 @@ function injectManagedHeader(target, relativePath, contents) {
     const insertAt = closingIndex + '\n---\n'.length;
     return `${contents.slice(0, insertAt)}${header}\n\n${contents.slice(insertAt)}`;
 }
+function upsertFrontMatterValue(contents, key, value) {
+    if (!contents.startsWith('---\n')) {
+        return contents;
+    }
+    const closingIndex = contents.indexOf('\n---\n', 4);
+    if (closingIndex === -1) {
+        return contents;
+    }
+    const frontMatter = contents.slice(4, closingIndex);
+    const body = contents.slice(closingIndex);
+    const lines = frontMatter.split('\n');
+    const nextLine = `${key}: "${value}"`;
+    const existingIndex = lines.findIndex((line) => line.startsWith(`${key}:`));
+    if (existingIndex >= 0) {
+        lines[existingIndex] = nextLine;
+    }
+    else {
+        lines.push(nextLine);
+    }
+    return `---\n${lines.join('\n')}${body}`;
+}
 async function listRelativeFiles(rootDir, currentDir = rootDir) {
     const entries = await (0, promises_1.readdir)(currentDir, { withFileTypes: true });
     const files = await Promise.all(entries.map(async (entry) => {
@@ -71,14 +93,18 @@ async function listRelativeFiles(rootDir, currentDir = rootDir) {
 }
 async function createAgentPackFiles(target, scope) {
     void scope;
+    const runtimePackage = await (0, package_metadata_1.resolveRuntimePackageInfo)();
     const skillSourceRoot = await resolveSkillSourceRoot();
     const relativeFiles = await listRelativeFiles(skillSourceRoot);
     return Promise.all(relativeFiles.map(async (relativePath) => {
-        const contents = await (0, promises_1.readFile)((0, node_path_1.join)(skillSourceRoot, relativePath), 'utf8');
+        const rawContents = await (0, promises_1.readFile)((0, node_path_1.join)(skillSourceRoot, relativePath), 'utf8');
+        const contents = relativePath.endsWith('SKILL.md')
+            ? upsertFrontMatterValue(rawContents, 'version', runtimePackage.version)
+            : rawContents;
         return {
-            relativePath: (0, node_path_1.join)(SKILL_NAME, relativePath),
+            relativePath: (0, node_path_1.join)(exports.SKILL_NAME, relativePath),
             description: `${target.displayName} VisionAlpha operator skill asset`,
-            contents: injectManagedHeader(target, (0, node_path_1.join)(SKILL_NAME, relativePath), contents),
+            contents: injectManagedHeader(target, (0, node_path_1.join)(exports.SKILL_NAME, relativePath), contents),
         };
     }));
 }

package/dist/features/runtime/package-metadata.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimePackageInfo = resolveRuntimePackageInfo;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+async function pathExists(path) {
+    try {
+        await (0, promises_1.access)(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findNearestPackageJson(startDir) {
+    let current = (0, node_path_1.resolve)(startDir);
+    for (;;) {
+        const packageJsonPath = (0, node_path_1.resolve)(current, 'package.json');
+        if (await pathExists(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+async function resolveRuntimePackageInfo(input) {
+    const entryPath = input?.entryPath ?? process.argv[1];
+    const moduleDir = input?.moduleDir ?? __dirname;
+    const candidateDirs = [
+        entryPath ? (0, node_path_1.dirname)((0, node_path_1.resolve)(entryPath)) : null,
+        (0, node_path_1.resolve)(moduleDir),
+    ].filter((value) => Boolean(value));
+    const seen = new Set();
+    for (const candidateDir of candidateDirs) {
+        const packageJsonPath = await findNearestPackageJson(candidateDir);
+        if (!packageJsonPath || seen.has(packageJsonPath)) {
+            continue;
+        }
+        seen.add(packageJsonPath);
+        const raw = await (0, promises_1.readFile)(packageJsonPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.name || !parsed.version) {
+            continue;
+        }
+        return {
+            rootDir: (0, node_path_1.dirname)(packageJsonPath),
+            packageJsonPath,
+            name: parsed.name,
+            version: parsed.version,
+            private: parsed.private === true,
+            isPackagedInstall: parsed.private !== true,
+        };
+    }
+    throw new Error('Unable to resolve runtime package metadata for `vaone`.');
+}

package/dist/features/update/preflight.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUpdateAction = resolveUpdateAction;
+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;
+const PREFLIGHT_GUARD_ENV = 'VAONE_SKIP_PREFLIGHT';
+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');
+}
+function shouldSkipCliUpdate(commandPath) {
+    return commandPath[0] === 'doctor';
+}
+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) {
+    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,
+            [PREFLIGHT_GUARD_ENV]: '1',
+        },
+    });
+    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 timeoutMs = input.timeoutMs ?? 5_000;
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => {
+            void prompt.close().catch(() => undefined);
+            resolve({ kind: 'timeout' });
+        }, timeoutMs);
+    });
+    const result = await Promise.race([selectionPromise, timeoutPromise]);
+    if (result.kind === 'timeout') {
+        input.logger.info(copy.timeoutNotice(input.latestVersion));
+        return 'update';
+    }
+    if (result.kind === 'error') {
+        throw result.error;
+    }
+    return result.choice;
+}
+async function runStartupPreflight(input, deps = {}) {
+    if (input.env[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 {
+            const refreshed = await (deps.syncManagedPacks ?? managed_pack_1.syncManagedPacks)({
+                cwd: input.cwd,
+                homeDir: input.homeDir,
+                currentVersion: runtimePackage.version,
+            });
+            if (refreshed.length > 0) {
+                const summary = refreshed
+                    .map((entry) => `${entry.target.displayName} (${entry.scope})`)
+                    .join(', ');
+                input.logger.info(`Refreshed stale managed skill packs: ${summary}.`);
+            }
+        }
+        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 = new update_state_store_1.UpdateStateStore((0, paths_1.resolveUpdateStateFile)(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 (deps.fetchLatestVersion ?? fetchLatestPublishedVersion)(runtimePackage.name);
+    }
+    catch (error) {
+        await updateStateStore.save({
+            ...updateState,
+            lastCheckedAt: new Date(now()).toISOString(),
+            lastFailureCode: 'version_check_failed',
+            lastFailureMessage: error instanceof Error ? error.message : 'Version check failed.',
+        });
+        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.4",
   "description": "Bootstrap CLI for the VAOne product.",
   "bin": {
     "vaone": "dist/main.js"