@solarains/va-cli 0.1.4 → 0.1.5

package/README.md

@@ -12,7 +12,9 @@ npm install -g @solarains/va-cli
 
 ```bash
 vaone --help
+vaone --version
 vaone init
+vaone update
 ```
 
 Use `vaone ...` to access the CLI command surface.

package/dist/cli/help-copy.js

@@ -9,11 +9,20 @@ const HELP_COPY = {
         globalFlagsHeading: 'Global flags:',
         helpFlag: 'Show help',
         debugFlag: 'Enable debug logging',
+        versionFlag: 'Show CLI version',
         commandHelp: {
             '': {
-                summary: 'VAOne CLI with guided init, auth, assets, usage, daily reports, intelligence queries, and diagnostics.',
+                summary: 'VAOne CLI with versioning, self-update, guided init, auth, assets, usage, daily reports, intelligence queries, and diagnostics.',
                 usage: 'vaone <command> [subcommand] [options]',
             },
+            'version': {
+                summary: 'Show the current VAOne CLI version.',
+                usage: 'vaone version',
+            },
+            'update': {
+                summary: 'Check for a newer packaged CLI release and sync VA-managed skill packs.',
+                usage: 'vaone update',
+            },
             '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]',
@@ -50,11 +59,20 @@ const HELP_COPY = {
         globalFlagsHeading: '全局参数：',
         helpFlag: '显示帮助',
         debugFlag: '启用调试日志',
+        versionFlag: '显示 CLI 版本',
         commandHelp: {
             '': {
-                summary: 'VAOne CLI，提供引导式 init、认证、资产、usage、日报、intelligence 查询与诊断能力。',
+                summary: 'VAOne CLI，提供版本查看、自更新、引导式 init、认证、资产、usage、日报、intelligence 查询与诊断能力。',
                 usage: 'vaone <命令> [子命令] [参数]',
             },
+            'version': {
+                summary: '显示当前 VAOne CLI 版本。',
+                usage: 'vaone version',
+            },
+            'update': {
+                summary: '检查新版 CLI，并同步所有 VA 受管 skill pack。',
+                usage: 'vaone update',
+            },
             'init': {
                 summary: '通过带品牌感的引导流程安装 VisionAlpha operator skills，并可选串联浏览器登录。',
                 usage: 'vaone init [.] [--agents codex,claude,openclaw] [--scope project|user] [--lang en|zh-CN] [--skip-login] [--force] [--yes]',

package/dist/cli/help.js

@@ -25,5 +25,7 @@ function renderHelp(command, pathSegments = [], locale = 'en') {
     lines.push(copy.globalFlagsHeading);
     lines.push(`  --help, -h   ${copy.helpFlag}`);
     lines.push(`  --debug      ${copy.debugFlag}`);
+    lines.push(`  --version    ${copy.versionFlag}`);
+    lines.push(`  -V, -v       ${copy.versionFlag}`);
     return lines.join('\n');
 }

package/dist/cli/root-command.js

@@ -7,13 +7,17 @@ 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 update_command_1 = require("../commands/update/update-command");
 const uninstall_command_1 = require("../commands/uninstall/uninstall-command");
 const usage_command_1 = require("../commands/usage/usage-command");
+const version_command_1 = require("../commands/version/version-command");
 exports.rootCommand = {
     name: 'vaone',
-    summary: 'VAOne CLI with guided init, auth, assets, usage, daily reports, intelligence queries, and diagnostics.',
+    summary: 'VAOne CLI with versioning, self-update, guided init, auth, assets, usage, daily reports, intelligence queries, and diagnostics.',
     usage: 'vaone <command> [subcommand] [options]',
     children: [
+        version_command_1.versionCommand,
+        update_command_1.updateCommand,
         init_command_1.initCommand,
         uninstall_command_1.uninstallCommand,
         auth_command_1.authCommand,

package/dist/cli/run-cli.js

@@ -11,10 +11,12 @@ const logger_1 = require("../shared/logger");
 const help_1 = require("./help");
 const help_copy_1 = require("./help-copy");
 const root_command_1 = require("./root-command");
+const version_command_1 = require("../commands/version/version-command");
 function parseArgv(argv) {
     const tokens = [];
     let debug = false;
     let help = false;
+    let version = false;
     for (const token of argv) {
         if (token === '--') {
             continue;
@@ -27,6 +29,10 @@ function parseArgv(argv) {
             help = true;
             continue;
         }
+        if (token === '--version' || token === '-V' || token === '-v') {
+            version = true;
+            continue;
+        }
         tokens.push(token);
     }
     if (tokens[0] === 'help') {
@@ -36,6 +42,7 @@ function parseArgv(argv) {
     return {
         debug,
         help,
+        version,
         tokens,
     };
 }
@@ -67,12 +74,24 @@ function printUnknownCommand(logger, command, path, token, locale) {
 async function runCli(argv, env, deps = {}) {
     const parsedArgv = parseArgv(argv);
     const logger = new logger_1.Logger(parsedArgv.debug || env.VAONE_DEBUG === 'true');
+    if (parsedArgv.version) {
+        return (0, version_command_1.printCliVersion)(logger);
+    }
+    const resolvedCommand = resolveCommand(parsedArgv.tokens);
+    if (!parsedArgv.help && resolvedCommand.path[0] === 'version') {
+        try {
+            return await (0, version_command_1.printCliVersion)(logger, resolvedCommand.remainingArgs);
+        }
+        catch (error) {
+            logger.error(error instanceof Error ? error.message : 'Unknown CLI failure.');
+            return 1;
+        }
+    }
     const paths = (0, paths_1.createCliPaths)(env);
     const runtimeConfig = await (0, runtime_config_1.loadRuntimeConfig)(env, paths);
     logger.setDebugMode(parsedArgv.debug || runtimeConfig.debug);
     const tokenStore = new token_store_1.TokenStore(paths.authStateFile);
     const installationStore = new installation_store_1.InstallationStore(paths.installationStateFile);
-    const resolvedCommand = resolveCommand(parsedArgv.tokens);
     const unknownToken = resolvedCommand.remainingArgs[0];
     const canTraverseFurther = Boolean(resolvedCommand.command.children?.length && unknownToken);
     const locale = runtimeConfig.locale;
@@ -96,19 +115,22 @@ async function runCli(argv, env, deps = {}) {
         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;
+    if (!((0, preflight_1.shouldSkipManagedSync)(resolvedCommand.path) &&
+        (0, preflight_1.shouldSkipCliUpdate)(resolvedCommand.path))) {
+        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/update/update-command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCommand = void 0;
+const node_os_1 = require("node:os");
+const preflight_1 = require("../../features/update/preflight");
+const argv_1 = require("../../shared/argv");
+exports.updateCommand = {
+    name: 'update',
+    summary: 'Check for a newer packaged CLI release and sync VA-managed skill packs.',
+    usage: 'vaone update',
+    async run(context, args) {
+        const parsed = (0, argv_1.parseCommandArgs)(args);
+        if (parsed.positionals.length > 0) {
+            throw new Error('`vaone update` does not accept positional arguments.');
+        }
+        return (0, preflight_1.runExplicitUpdate)({
+            argv: context.argv,
+            env: process.env,
+            logger: context.logger,
+            paths: context.paths,
+            runtimeConfig: context.runtimeConfig,
+            cwd: process.cwd(),
+            homeDir: (0, node_os_1.homedir)(),
+        });
+    },
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionCommand = void 0;
+exports.printCliVersion = printCliVersion;
+const package_metadata_1 = require("../../features/runtime/package-metadata");
+async function printCliVersion(logger, args = []) {
+    if (args.length > 0) {
+        throw new Error('`vaone version` does not accept positional arguments.');
+    }
+    const runtimePackage = await (0, package_metadata_1.resolveRuntimePackageInfo)();
+    logger.plain(runtimePackage.version);
+    return 0;
+}
+exports.versionCommand = {
+    name: 'version',
+    summary: 'Show the current VAOne CLI version.',
+    usage: 'vaone version',
+    async run(context, args) {
+        return printCliVersion(context.logger, args);
+    },
+};

package/dist/features/update/preflight.js

@@ -1,6 +1,14 @@
 "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");
@@ -11,7 +19,9 @@ 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';
+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) {
@@ -57,10 +67,14 @@ function shouldSkipManagedSync(commandPath) {
     return (commandPath.length === 0 ||
         commandPath[0] === 'init' ||
         commandPath[0] === 'doctor' ||
-        commandPath[0] === 'uninstall');
+        commandPath[0] === 'uninstall' ||
+        commandPath[0] === 'update' ||
+        commandPath[0] === 'version');
 }
 function shouldSkipCliUpdate(commandPath) {
-    return commandPath[0] === 'doctor';
+    return (commandPath[0] === 'doctor' ||
+        commandPath[0] === 'update' ||
+        commandPath[0] === 'version');
 }
 function canPromptForUpdate(env) {
     return (process.stdin.isTTY === true &&
@@ -101,7 +115,7 @@ async function performSelfUpdate(packageName, version) {
         failureMessage: result.stderr?.trim() || result.stdout?.trim() || 'npm update failed.',
     };
 }
-async function reexecCommand(argv) {
+async function reexecCommand(argv, extraEnv) {
     if (!process.argv[1]) {
         return null;
     }
@@ -109,7 +123,8 @@ async function reexecCommand(argv) {
         stdio: 'inherit',
         env: {
             ...process.env,
-            [PREFLIGHT_GUARD_ENV]: '1',
+            [exports.PREFLIGHT_GUARD_ENV]: '1',
+            ...extraEnv,
         },
     });
     if (typeof result.status === 'number') {
@@ -144,14 +159,17 @@ async function resolveUpdateAction(input) {
         ],
     })
         .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]);
+    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';
@@ -161,25 +179,211 @@ async function resolveUpdateAction(input) {
     }
     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[PREFLIGHT_GUARD_ENV] === '1') {
+    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 {
-            const refreshed = await (deps.syncManagedPacks ?? managed_pack_1.syncManagedPacks)({
+            await syncManagedPacksForVersion({
+                logger: input.logger,
                 cwd: input.cwd,
                 homeDir: input.homeDir,
                 currentVersion: runtimePackage.version,
+                syncManagedPacksImpl: deps.syncManagedPacks,
             });
-            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'}`);
@@ -191,7 +395,7 @@ async function runStartupPreflight(input, deps = {}) {
     if (!runtimePackage.isPackagedInstall || !canPromptForUpdate(input.env)) {
         return null;
     }
-    const updateStateStore = new update_state_store_1.UpdateStateStore((0, paths_1.resolveUpdateStateFile)(input.paths));
+    const updateStateStore = createUpdateStateStore(input.paths);
     const updateState = (await updateStateStore.read()) ?? {};
     const lastCheckedAt = updateState.lastCheckedAt
         ? Date.parse(updateState.lastCheckedAt)
@@ -202,15 +406,15 @@ async function runStartupPreflight(input, deps = {}) {
     }
     let latestVersion;
     try {
-        latestVersion = await (deps.fetchLatestVersion ?? fetchLatestPublishedVersion)(runtimePackage.name);
+        latestVersion = (await resolvePublishedUpdate({
+            now,
+            logger: input.logger,
+            paths: input.paths,
+            packageName: runtimePackage.name,
+            fetchLatestVersionImpl: deps.fetchLatestVersion,
+        })).latestVersion;
     }
     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;
     }

package/package.json

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