@solarains/va-cli 0.1.1

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

@@ -0,0 +1,661 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInitOptions = resolveInitOptions;
+exports.runInitFlow = runInitFlow;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const locale_1 = require("../../config/locale");
+const runtime_config_1 = require("../../config/runtime-config");
+const argv_1 = require("../../shared/argv");
+const logger_1 = require("../../shared/logger");
+const ora_1 = __importDefault(require("ora"));
+const detect_targets_1 = require("./detect-targets");
+const init_copy_1 = require("./init-copy");
+const installer_1 = require("./installer");
+const presentation_1 = require("./presentation");
+const prompt_1 = require("./prompt");
+const target_registry_1 = require("./target-registry");
+class CapturedStepLogger extends logger_1.Logger {
+    onLine;
+    lineCount = 0;
+    constructor(debugEnabled, onLine) {
+        super(debugEnabled);
+        this.onLine = onLine;
+    }
+    plain(message) {
+        const lines = message.split('\n');
+        for (const line of lines) {
+            this.lineCount += 1;
+            this.onLine(line);
+        }
+    }
+    error(message) {
+        this.plain(`Error: ${message}`);
+    }
+}
+function isDebugEnabled(logger) {
+    return Boolean(Reflect.get(logger, 'debugEnabled'));
+}
+function createCapturedStepLogger(logger, onLine) {
+    return new CapturedStepLogger(isDebugEnabled(logger), onLine);
+}
+function compactLines(lines) {
+    const compacted = [];
+    let previousWasEmpty = false;
+    for (const line of lines) {
+        const isEmpty = line.trim().length === 0;
+        if (isEmpty && previousWasEmpty) {
+            continue;
+        }
+        compacted.push(line);
+        previousWasEmpty = isEmpty;
+    }
+    while (compacted[0]?.trim() === '') {
+        compacted.shift();
+    }
+    while (compacted[compacted.length - 1]?.trim() === '') {
+        compacted.pop();
+    }
+    return compacted;
+}
+function extractValue(lines, key) {
+    const prefix = `${key}: `;
+    const line = lines.find((entry) => entry.startsWith(prefix));
+    return line ? line.slice(prefix.length).trim() : undefined;
+}
+function extractLoginSummary(lines, copy) {
+    const summary = [];
+    const details = [];
+    const browserLine = lines.find((line) => line.includes('Automatic browser launch failed') ||
+        line.includes('Browser opened'));
+    const callbackMode = extractValue(lines, 'Callback mode');
+    const continuationUrl = extractValue(lines, 'URL');
+    const account = extractValue(lines, 'Account');
+    const installation = extractValue(lines, 'Installation');
+    const accessTokenExpiresAt = extractValue(lines, 'Access token expires at');
+    if (browserLine) {
+        summary.push(copy.messages.summaryBrowser(browserLine));
+    }
+    if (callbackMode) {
+        summary.push(copy.messages.summaryCallbackMode(callbackMode));
+    }
+    if (continuationUrl) {
+        summary.push(copy.messages.summaryContinuationUrl(continuationUrl));
+    }
+    if (account) {
+        summary.push(copy.messages.summaryAccount(account));
+    }
+    if (installation) {
+        summary.push(copy.messages.summaryInstallation(installation));
+    }
+    if (accessTokenExpiresAt) {
+        summary.push(copy.messages.summaryAccessTokenExpiresAt(accessTokenExpiresAt));
+    }
+    for (const line of lines) {
+        if (line.startsWith('Login context') ||
+            line.startsWith('Login complete') ||
+            /^-+$/.test(line.trim())) {
+            continue;
+        }
+        if (line.includes('Automatic browser launch failed') || line.startsWith('URL:')) {
+            details.push(line);
+            continue;
+        }
+        if (line.includes('Do not enter credentials inside the terminal.')) {
+            details.push(line);
+            continue;
+        }
+    }
+    return {
+        summary,
+        details: compactLines(details),
+    };
+}
+function extractDoctorSummary(lines, copy) {
+    const summary = [];
+    const environment = extractValue(lines, 'Environment');
+    const apiBaseUrl = extractValue(lines, 'API base URL');
+    const root = extractValue(lines, 'Root');
+    const authState = lines.find((line) => line.startsWith('- Auth token state file'));
+    const installationState = lines.find((line) => line.startsWith('- Installation state file'));
+    if (environment) {
+        summary.push(copy.messages.summaryEnvironment(environment));
+    }
+    if (apiBaseUrl) {
+        summary.push(copy.messages.summaryApiBaseUrl(apiBaseUrl));
+    }
+    if (root) {
+        summary.push(copy.messages.summaryRoot(root));
+    }
+    if (authState) {
+        summary.push(copy.messages.summaryAuthState(authState.replace(/^- /, '')));
+    }
+    if (installationState) {
+        summary.push(copy.messages.summaryInstallationState(installationState.replace(/^- /, '')));
+    }
+    return { summary };
+}
+function extractUsageSummary(lines, copy) {
+    const summary = [];
+    let section = '';
+    for (const line of lines) {
+        if (!line.trim() || /^-+$/.test(line.trim())) {
+            continue;
+        }
+        if (line === 'Plan' ||
+            line === 'Daily report' ||
+            line === 'Intelligence quota') {
+            section = line;
+            continue;
+        }
+        if (section === 'Plan') {
+            const currentPlan = extractValue([line], 'Current plan');
+            const commercialStatus = extractValue([line], 'Commercial status');
+            if (currentPlan) {
+                summary.push(copy.messages.summaryPlan(currentPlan));
+            }
+            if (commercialStatus) {
+                summary.push(copy.messages.summaryCommercialStatus(commercialStatus));
+            }
+            continue;
+        }
+        if (section === 'Daily report') {
+            const status = extractValue([line], 'Status');
+            const lockedReport = extractValue([line], 'Locked report');
+            if (status) {
+                summary.push(copy.messages.summaryDailyReport(status));
+            }
+            if (lockedReport) {
+                summary.push(copy.messages.summaryLockedReport(lockedReport));
+            }
+            continue;
+        }
+        if (section === 'Intelligence quota') {
+            const status = extractValue([line], 'Status');
+            if (status) {
+                summary.push(copy.messages.summaryIntelligence(status));
+                continue;
+            }
+            const normalized = line.replace(/^- /, '');
+            const resetCadence = extractValue([normalized], 'Reset cadence');
+            if (resetCadence) {
+                summary.push(copy.messages.summaryResetCadence(resetCadence));
+            }
+        }
+    }
+    return { summary };
+}
+function createSpinner(text, isInteractive) {
+    if (!isInteractive || !process.stdout.isTTY) {
+        return null;
+    }
+    return (0, ora_1.default)({
+        text,
+        color: 'cyan',
+        discardStdin: false,
+        isEnabled: true,
+        stream: process.stdout,
+    }).start();
+}
+function resolveDetailsTitle(copy, boxTitle) {
+    if (boxTitle === copy.boxes.loginOutput) {
+        return copy.boxes.loginDetails;
+    }
+    if (boxTitle === copy.boxes.doctorOutput) {
+        return copy.boxes.doctorDetails;
+    }
+    return copy.boxes.usageDetails;
+}
+function parseAgentIds(raw, copy) {
+    if (!raw) {
+        return [];
+    }
+    const supported = new Set((0, target_registry_1.getAgentTargetRegistry)().map((target) => target.id));
+    return raw
+        .split(',')
+        .map((value) => value.trim().toLowerCase())
+        .filter(Boolean)
+        .map((value) => {
+        if (!supported.has(value)) {
+            throw new Error(copy.errors.unsupportedAgent(value, Array.from(supported)));
+        }
+        return value;
+    })
+        .filter((value, index, items) => items.indexOf(value) === index);
+}
+function parseScope(raw, copy) {
+    if (!raw) {
+        return undefined;
+    }
+    if (raw === 'project' || raw === 'user') {
+        return raw;
+    }
+    throw new Error(copy.errors.invalidScopeOption);
+}
+function parsePositionalScope(positionals, copy) {
+    if (positionals.length === 0) {
+        return undefined;
+    }
+    if (positionals.length !== 1 || positionals[0] !== '.') {
+        throw new Error(copy.errors.invalidPositionalArgument);
+    }
+    return 'project';
+}
+function getScopeSurface(scope) {
+    return scope === 'project' ? 'workspace' : 'user';
+}
+function defaultAgentsForScope(detectedTargets, scope) {
+    const detected = detectedTargets
+        .filter((target) => target.detectedIn.includes(getScopeSurface(scope)))
+        .map((target) => target.targetId);
+    return detected;
+}
+function buildAgentChoices(detectedTargets, scope, defaults, copy) {
+    return detectedTargets
+        .filter((target) => !(scope === 'project' && target.targetId === 'openclaw'))
+        .map((target) => ({
+        value: target.targetId,
+        label: target.displayName,
+        description: copy.messages.agentChoiceDescription(target, scope),
+        checked: defaults.includes(target.targetId),
+    }));
+}
+async function resolveInitLocale(input) {
+    const parsedArgs = (0, argv_1.parseCommandArgs)(input.args);
+    const yes = (0, argv_1.getBooleanOption)(parsedArgs, 'yes');
+    const explicitLocale = (0, locale_1.parseSupportedLocale)((0, argv_1.getStringOption)(parsedArgs, 'lang'), '--lang');
+    if (explicitLocale) {
+        return {
+            parsedArgs,
+            locale: explicitLocale,
+            shouldPersistLocale: !input.hasConfiguredLocale || explicitLocale !== input.preferredLocale,
+        };
+    }
+    if (input.hasConfiguredLocale) {
+        return {
+            parsedArgs,
+            locale: input.preferredLocale,
+            shouldPersistLocale: false,
+        };
+    }
+    if (!input.isInteractive || yes || !input.prompt) {
+        return {
+            parsedArgs,
+            locale: locale_1.DEFAULT_LOCALE,
+            shouldPersistLocale: false,
+        };
+    }
+    const locale = await input.prompt.select({
+        message: 'Select CLI language / 选择 CLI 语言',
+        choices: [
+            {
+                value: 'en',
+                label: 'English',
+                description: 'Use English for the init flow',
+            },
+            {
+                value: 'zh-CN',
+                label: '简体中文',
+                description: '在 init 流程中使用中文',
+            },
+        ],
+        defaultValue: locale_1.DEFAULT_LOCALE,
+    });
+    return {
+        parsedArgs,
+        locale,
+        shouldPersistLocale: true,
+    };
+}
+function resolveInitOptions(input) {
+    const resolve = async () => {
+        const { parsedArgs, locale, shouldPersistLocale } = await resolveInitLocale({
+            args: input.args,
+            preferredLocale: input.preferredLocale,
+            hasConfiguredLocale: input.hasConfiguredLocale,
+            isInteractive: input.isInteractive,
+            prompt: input.prompt,
+        });
+        const copy = (0, init_copy_1.getInitCopy)(locale);
+        const parsedAgents = parseAgentIds((0, argv_1.getStringOption)(parsedArgs, 'agents'), copy);
+        const parsedScope = parseScope((0, argv_1.getStringOption)(parsedArgs, 'scope'), copy);
+        const positionalScope = parsePositionalScope(parsedArgs.positionals, copy);
+        const skipLogin = (0, argv_1.getBooleanOption)(parsedArgs, 'skip-login');
+        const force = (0, argv_1.getBooleanOption)(parsedArgs, 'force');
+        const yes = (0, argv_1.getBooleanOption)(parsedArgs, 'yes');
+        let agents = parsedAgents;
+        let scope = positionalScope ?? parsedScope;
+        if (positionalscopeAndScopeConflict(positionalScope, parsedScope)) {
+            throw new Error(copy.errors.initDotScopeConflict);
+        }
+        if (!scope) {
+            if (!input.isInteractive) {
+                throw new Error(copy.errors.nonInteractiveNeedsScope);
+            }
+            if (yes) {
+                scope = 'project';
+            }
+            else if (input.prompt) {
+                scope = await input.prompt.select({
+                    message: copy.prompts.selectInstallLocation,
+                    choices: [
+                        {
+                            value: 'project',
+                            label: copy.choices.currentProject,
+                            description: copy.choices.currentProjectDescription,
+                        },
+                        {
+                            value: 'user',
+                            label: copy.choices.global,
+                            description: copy.choices.globalDescription,
+                        },
+                    ],
+                    defaultValue: 'project',
+                    locale,
+                });
+            }
+        }
+        if (!scope) {
+            throw new Error(copy.errors.unresolvedScope);
+        }
+        if (!agents.length) {
+            if (!input.isInteractive) {
+                throw new Error(copy.errors.nonInteractiveNeedsAgents);
+            }
+            const defaults = defaultAgentsForScope(input.detectedTargets, scope);
+            if (yes) {
+                agents =
+                    defaults.length > 0
+                        ? defaults
+                        : (0, target_registry_1.getAgentTargetRegistry)().map((target) => target.id);
+            }
+            else if (input.prompt) {
+                agents = await input.prompt.multiselect({
+                    message: copy.prompts.selectAgentApps,
+                    choices: buildAgentChoices(input.detectedTargets, scope, defaults, copy),
+                    locale,
+                });
+            }
+        }
+        if (!agents.length) {
+            throw new Error(copy.errors.noAgentSelected);
+        }
+        return {
+            agents,
+            scope,
+            skipLogin,
+            force,
+            yes,
+            interactive: input.isInteractive,
+            locale,
+            shouldPersistLocale,
+        };
+    };
+    return resolve();
+}
+function positionalscopeAndScopeConflict(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;
+        presenter.list([
+            `${target.displayName}: ${summary}`,
+            ...(target.detectedIn.length > 0
+                ? target.detectedIn.map((surface) => copy.messages.detectedIn(target.displayName, surface, target.targetId))
+                : [copy.messages.notDetectedReason(target.displayName)]),
+        ]);
+    }
+}
+function describePlan(presenter, copy, options, prepared, cwd) {
+    presenter.section(copy.sections.installationPlan);
+    presenter.list([
+        `${copy.labels.installLocation}: ${(0, init_copy_1.formatInstallLocationLabel)(options.locale, options.scope)}`,
+        `${copy.labels.targets}: ${prepared
+            .map((entry) => entry.target.displayName)
+            .join(', ')}`,
+    ]);
+    for (const entry of prepared) {
+        const relativeRoot = (0, node_path_1.relative)(cwd, entry.rootDir) || '.';
+        presenter.list([
+            `${entry.target.displayName} ${copy.labels.root}: ${relativeRoot}`,
+            `${entry.target.displayName} ${copy.labels.create}: ${entry.analysis.toCreate.length}`,
+            `${entry.target.displayName} ${copy.labels.refresh}: ${entry.analysis.toRefresh.length}`,
+            `${entry.target.displayName} ${copy.labels.conflicts}: ${entry.analysis.conflicts.length}`,
+        ]);
+    }
+}
+async function confirmConflicts(prompt, prepared, copy) {
+    if (!prompt) {
+        return false;
+    }
+    const files = prepared.flatMap((entry) => entry.analysis.conflicts.map((relativePath) => `${entry.target.displayName}: ${relativePath}`));
+    return prompt.confirm(`${copy.prompts.confirmOverwriteConflicts}\n${files
+        .map((file) => `- ${file}`)
+        .join('\n')}`, false);
+}
+function describeApplied(presenter, copy, applied, cwd) {
+    presenter.section(copy.sections.installation);
+    for (const entry of applied) {
+        const relativeRoot = (0, node_path_1.relative)(cwd, entry.rootDir) || '.';
+        presenter.list([
+            `${entry.target.displayName}: ${copy.labels.installedAt} ${relativeRoot}`,
+            `${entry.target.displayName}: ${copy.labels.created} ${entry.created.length}`,
+            `${entry.target.displayName}: ${copy.labels.refreshed} ${entry.refreshed.length}`,
+            `${entry.target.displayName}: ${copy.labels.overwritten} ${entry.overwritten.length}`,
+        ]);
+    }
+}
+async function runVerification(context, presenter, copy, options, dependencies) {
+    presenter.section(copy.sections.verification);
+    await runCommandInBox({
+        context,
+        presenter,
+        copy,
+        isInteractive: dependencies.isInteractive,
+        spinnerText: copy.messages.spinnerDoctor,
+        statusLabels: copy.statuses,
+        stepLabel: copy.steps.doctor,
+        boxTitle: copy.boxes.doctorOutput,
+        command: dependencies.verifyDoctor,
+        nonZeroError: copy.errors.postInitDoctorFailed,
+        summarize: extractDoctorSummary,
+    });
+    if (options.skipLogin) {
+        presenter.step('skipped', copy.statuses.skipped, copy.steps.usageSkipped);
+        presenter.list([
+            copy.messages.usageVerificationSkippedDeferred,
+        ]);
+        return;
+    }
+    await runCommandInBox({
+        context,
+        presenter,
+        copy,
+        isInteractive: dependencies.isInteractive,
+        spinnerText: copy.messages.spinnerUsage,
+        statusLabels: copy.statuses,
+        stepLabel: copy.steps.usage,
+        boxTitle: copy.boxes.usageOutput,
+        command: dependencies.verifyUsage,
+        nonZeroError: copy.errors.postInitUsageFailed,
+        summarize: extractUsageSummary,
+    });
+}
+function printRestartGuidance(presenter, copy, applied) {
+    presenter.section(copy.sections.nextSteps);
+    presenter.step('completed', copy.statuses.completed, copy.steps.completed);
+    presenter.list([
+        `${copy.labels.configuredTargets}: ${applied
+            .map((entry) => entry.target.displayName)
+            .join(', ')}`,
+        copy.messages.restartAgent,
+        copy.messages.startUsingAfterRestart,
+    ]);
+}
+async function runCommandInBox(input) {
+    input.presenter.step('in_progress', input.statusLabels.inProgress, input.stepLabel);
+    const capturedLines = [];
+    const logger = createCapturedStepLogger(input.context.logger, (line) => {
+        capturedLines.push(line);
+    });
+    const spinner = createSpinner(input.spinnerText, input.isInteractive);
+    try {
+        const exitCode = await input.command(logger);
+        if (exitCode !== 0) {
+            throw new Error(input.nonZeroError);
+        }
+        spinner?.stop();
+        const rendered = input.summarize(capturedLines, input.copy);
+        const box = input.presenter.openBox(input.boxTitle);
+        for (const line of rendered.summary) {
+            box.write(line);
+        }
+        box.close();
+        if (rendered.details && rendered.details.length > 0) {
+            const detailsBox = input.presenter.openBox(resolveDetailsTitle(input.copy, input.boxTitle));
+            for (const line of rendered.details) {
+                detailsBox.write(line);
+            }
+            detailsBox.close();
+        }
+        input.presenter.step('completed', input.statusLabels.completed, input.stepLabel);
+    }
+    catch (error) {
+        spinner?.stop();
+        const box = input.presenter.openBox(resolveDetailsTitle(input.copy, input.boxTitle));
+        const detailLines = compactLines(capturedLines);
+        if (detailLines.length > 0) {
+            for (const line of detailLines) {
+                box.write(line);
+            }
+        }
+        else {
+            const message = error instanceof Error ? error.message : 'Unknown subcommand failure.';
+            box.write(`Error: ${message}`);
+        }
+        box.close();
+        input.presenter.step('failed', input.statusLabels.failed, input.stepLabel);
+        throw error;
+    }
+}
+async function runInitFlow(context, args, partialDependencies = {}) {
+    const dependencies = {
+        cwd: process.cwd(),
+        homeDir: (0, node_os_1.homedir)(),
+        isInteractive: Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY),
+        promptFactory: prompt_1.createTerminalPrompt,
+        showWelcome: presentation_1.showVisionAlphaWelcome,
+        pauseForExit: presentation_1.waitForTerminalEnter,
+        exitProcess: (code) => process.exit(code),
+        ...partialDependencies,
+    };
+    const parsedArgs = (0, argv_1.parseCommandArgs)(args);
+    const skipInteractiveWelcome = (0, argv_1.getBooleanOption)(parsedArgs, 'yes');
+    const detectedTargets = await (0, detect_targets_1.detectAgentTargets)({
+        cwd: dependencies.cwd,
+        homeDir: dependencies.homeDir,
+    });
+    const prompt = dependencies.isInteractive ? dependencies.promptFactory() : null;
+    let shouldForceExit = false;
+    let exitCode = 1;
+    try {
+        if (dependencies.isInteractive && !skipInteractiveWelcome) {
+            await dependencies.showWelcome();
+        }
+        const options = await resolveInitOptions({
+            args,
+            detectedTargets,
+            isInteractive: dependencies.isInteractive,
+            prompt,
+            preferredLocale: context.runtimeConfig.locale,
+            hasConfiguredLocale: context.runtimeConfig.localeConfigured,
+        });
+        const copy = (0, init_copy_1.getInitCopy)(options.locale);
+        const presenter = (0, presentation_1.createInitPresenter)(context.logger);
+        if (options.shouldPersistLocale) {
+            await (0, runtime_config_1.saveRuntimeConfig)(context.paths, {
+                locale: options.locale,
+            });
+        }
+        context.runtimeConfig.locale = options.locale;
+        context.runtimeConfig.localeConfigured = true;
+        describeDetection(presenter, copy, detectedTargets);
+        const prepared = await (0, installer_1.prepareInstallations)({
+            agentIds: options.agents,
+            scope: options.scope,
+            cwd: dependencies.cwd,
+            homeDir: dependencies.homeDir,
+        });
+        describePlan(presenter, copy, options, prepared, dependencies.cwd);
+        const hasConflicts = prepared.some((entry) => entry.analysis.conflicts.length > 0);
+        let allowUnmanagedOverwrite = options.force;
+        if (hasConflicts && !allowUnmanagedOverwrite) {
+            if (!options.interactive) {
+                throw new Error(copy.errors.unmanagedFilesNeedOverride);
+            }
+            allowUnmanagedOverwrite = await confirmConflicts(prompt, prepared, copy);
+            if (!allowUnmanagedOverwrite) {
+                throw new Error(copy.errors.cancelledForUnmanagedFiles);
+            }
+        }
+        const installSpinner = createSpinner(copy.messages.spinnerInstalling, dependencies.isInteractive);
+        let applied;
+        try {
+            applied = await (0, installer_1.applyInstallations)(prepared, {
+                allowUnmanagedOverwrite,
+            });
+        }
+        finally {
+            installSpinner?.stop();
+        }
+        describeApplied(presenter, copy, applied, dependencies.cwd);
+        if (options.skipLogin) {
+            presenter.section(copy.sections.login);
+            presenter.step('skipped', copy.statuses.skipped, copy.steps.loginSkipped);
+            const box = presenter.openBox(copy.boxes.loginOutput);
+            box.write(copy.messages.loginSkippedByFlag);
+            box.write(copy.messages.runLoginLater);
+            box.close();
+        }
+        else {
+            presenter.section(copy.sections.login);
+            await runCommandInBox({
+                context,
+                presenter,
+                copy,
+                isInteractive: dependencies.isInteractive,
+                spinnerText: copy.messages.spinnerLoggingIn,
+                statusLabels: copy.statuses,
+                stepLabel: copy.steps.login,
+                boxTitle: copy.boxes.loginOutput,
+                command: dependencies.login,
+                nonZeroError: 'Login phase failed after installation.',
+                summarize: extractLoginSummary,
+            });
+        }
+        await runVerification(context, presenter, copy, options, dependencies);
+        printRestartGuidance(presenter, copy, applied);
+        if (options.interactive) {
+            presenter.list([copy.messages.pressEnterToExit]);
+            presenter.emptyLine();
+            await dependencies.pauseForExit();
+            shouldForceExit = true;
+        }
+        presenter.emptyLine();
+        exitCode = 0;
+        return exitCode;
+    }
+    finally {
+        await prompt?.close();
+        if (shouldForceExit && exitCode === 0) {
+            dependencies.exitProcess(0);
+        }
+    }
+}