vana-cli 0.15.1 → 0.23.4

package/dist/cli/index.js

@@ -2,11 +2,12 @@ import fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 import { spawn, execSync } from "node:child_process";
 import os from "node:os";
 import { confirm, input, password } from "@inquirer/prompts";
 import { searchSelect } from "./search-select.js";
-import { Command, CommanderError } from "commander";
+import { Command, CommanderError, Option } from "commander";
 // Vana-branded theme for inquirer prompts — matches brand palette
 const VANA_BLUE = "\x1b[38;2;65;65;252m";
 const VANA_GREEN = "\x1b[38;2;0;213;11m";
@@ -28,14 +29,91 @@ const vanaPromptTheme = {
 };
 import { createConnectRenderer, createHumanRenderer, createLoginRenderer, formatDisplayPath, formatRelativeTime, } from "./render/index.js";
 import { CliOutcomeStatus, migrateLegacyDataHome, getBrowserProfilesDir, getConnectorCacheDir, getLogsDir, getSessionsDir, getSourceResultPath, readCliState, readCliConfig, updateCliConfig, updateSourceState, } from "../core/index.js";
+import { UnknownNetworkError, VANA_NETWORKS, isVanaNetworkName, resolveNetwork, } from "../core/network.js";
+import { CliExitCode } from "../core/exit-codes.js";
+import { registerAppCommands } from "./app/index.js";
+import { lookupRegisteredServers } from "../personal-server/registered.js";
 import { fetchConnectorToCache, listAvailableSources, readCachedConnectorMetadata, } from "../connectors/registry.js";
 import { detectPersonalServerTarget, ingestResult, resolvePersonalServerAuthConfig, } from "../personal-server/index.js";
 import { findDataConnectorsDir, ManagedPlaywrightRuntime, } from "../runtime/index.js";
 import { listAvailableSkills, installSkill, readInstalledSkills, } from "../skills/index.js";
 import { queryStatus, querySources, queryDataList, queryDataShow, queryDoctor, } from "./queries.js";
 import { checkForUpdate, readUpdateCheck, isNewerVersion, } from "./update-check.js";
-import { loadCredentials, saveCredentials, clearCredentials, isExpired, formatAddress, formatExpiresIn, getAuthTarget, resolvePersonalServerUrl, runDeviceCodeFlow, runSelfHostedLoginFlow, } from "./auth.js";
+import { loadCredentials, readStoredAuthFile, saveCredentials, clearCredentials, isExpired, formatAddress, formatExpiresIn, getAuthTarget, resolvePersonalServerUrl, runDeviceCodeFlow, runSelfHostedLoginFlow, } from "./auth.js";
 import { createCliTelemetrySession, flushTelemetryOutbox, getActiveTelemetrySession, getTelemetryStatus, setActiveTelemetrySession, setTelemetryEnabled, trackActiveTelemetryEvent, } from "./telemetry.js";
+/** Long flags shared by every command; declared once, applied to all leaves. */
+const GLOBAL_FLAG_DEFS = [
+    ["--json", "Output machine-readable JSON"],
+    ["--no-input", "Never prompt; fail or print a URL instead"],
+    ["--yes", "Assume yes for confirmation prompts"],
+    ["--quiet", "Suppress non-essential output"],
+    ["--ipc", "Emit structured IPC events (internal)"],
+    ["--detach", "Run in the background where supported"],
+];
+/**
+ * Declare the shared global flags on every leaf command that does not
+ * already define them, so commander accepts them anywhere on the line and
+ * `--help` documents them. Idempotent per flag.
+ */
+function applyGlobalOptions(command) {
+    if (command.commands.length === 0) {
+        for (const [flags, description] of GLOBAL_FLAG_DEFS) {
+            const long = `--${flags.replace(/^--(no-)?/, "")}`;
+            const exists = command.options.some((option) => option.long === flags || option.long === long);
+            if (!exists) {
+                command.option(flags, description);
+            }
+        }
+        if (!command.options.some((option) => option.long === "--network")) {
+            command.addOption(new Option("--network <network>", "Vana network").choices([
+                ...VANA_NETWORKS,
+            ]));
+        }
+        return;
+    }
+    for (const child of command.commands) {
+        applyGlobalOptions(child);
+    }
+}
+/**
+ * Merge the options commander actually parsed (root -> action command, child
+ * wins) into the pre-parse seed, so action handlers see the authoritative
+ * values while pre-parse consumers (update-notifier suppression, telemetry
+ * context) keep working from the argv scan.
+ */
+function mergeParsedGlobalOptions(target, actionCommand) {
+    const chain = [];
+    for (let current = actionCommand; current; current = current.parent) {
+        chain.unshift(current);
+    }
+    // Only values commander actually parsed count; a leaf's implicit
+    // default (e.g. --no-input declaring input: true) must never overwrite a
+    // value the user set at another level of the command line.
+    const merged = {};
+    for (const command of chain) {
+        const opts = command.opts();
+        for (const key of Object.keys(opts)) {
+            if (command.getOptionValueSource(key) !== "default") {
+                merged[key] = opts[key];
+            }
+        }
+    }
+    if (merged.json === true)
+        target.json = true;
+    if (merged.input === false)
+        target.noInput = true;
+    if (merged.yes === true)
+        target.yes = true;
+    if (merged.quiet === true)
+        target.quiet = true;
+    if (merged.ipc === true)
+        target.ipc = true;
+    if (merged.detach === true)
+        target.detach = true;
+    if (typeof merged.network === "string" && isVanaNetworkName(merged.network)) {
+        target.network = merged.network;
+    }
+}
 function cleanDescription(desc) {
     return desc
         .replace(/ using Playwright browser automation\.?/i, ".")
@@ -43,8 +121,10 @@ function cleanDescription(desc) {
 }
 const require = createRequire(import.meta.url);
 export async function runCli(argv = process.argv) {
-    // Migrate ~/.dataconnect → ~/.vana, symlink old path for DataConnect compat
-    if (migrateLegacyDataHome()) {
+    // Migrate ~/.dataconnect → ~/.vana, symlink old path for DataConnect compat.
+    // Only an actual data migration announces itself; the compat symlink that
+    // every fresh install gets on its second run stays silent.
+    if (migrateLegacyDataHome() === "migrated") {
         process.stderr.write("Moved your data to ~/.vana.\n\n");
     }
     const normalizedArgv = normalizeArgv(argv);
@@ -110,6 +190,16 @@ More:
   vana setup             Install or repair runtime
 `);
     program.exitOverride();
+    // Global flags: declared here for `vana --help`, mirrored onto every leaf
+    // command by applyGlobalOptions() so they are accepted anywhere on the
+    // line. Values are merged back into parsedOptions in the preAction hook.
+    for (const [flags, description] of GLOBAL_FLAG_DEFS) {
+        program.option(flags, description);
+    }
+    program.addOption(new Option("--network <network>", "Vana network for protocol operations (default: moksha)").choices([...VANA_NETWORKS]));
+    program.hook("preAction", (_thisCommand, actionCommand) => {
+        mergeParsedGlobalOptions(parsedOptions, actionCommand);
+    });
     program
         .command("version")
         .description("Print CLI version")
@@ -383,12 +473,14 @@ Examples:
     telemetry
         .command("enable")
         .description("Enable telemetry")
+        .option("--json", "Output machine-readable JSON")
         .action(async () => {
         process.exitCode = await runTelemetryEnable(parsedOptions);
     });
     telemetry
         .command("disable")
         .description("Disable telemetry")
+        .option("--json", "Output machine-readable JSON")
         .action(async () => {
         process.exitCode = await runTelemetryDisable(parsedOptions);
     });
@@ -468,6 +560,8 @@ Examples:
         .action(async () => {
         process.exitCode = await runCommandWithTelemetry({ ...telemetryBaseContext, command: "schedule", subcommand: "remove" }, async () => runScheduleRemove(parsedOptions));
     });
+    registerAppCommands(program, () => parsedOptions);
+    applyGlobalOptions(program);
     try {
         await program.parseAsync(normalizedArgv);
     }
@@ -479,8 +573,13 @@ Examples:
                 process.exitCode = error.exitCode;
                 return Number(process.exitCode ?? 0);
             }
-            // Commander already printed to stderr; just set exit code.
-            process.exitCode = error.exitCode;
+            // Commander already printed to stderr. Usage errors (unknown command
+            // or option, missing or invalid argument) exit 2 per the exit-code
+            // table in docs/CLI-EXIT-CODE-MATRIX.md; anything else keeps
+            // commander's own code.
+            process.exitCode = error.code.startsWith("commander.")
+                ? CliExitCode.USAGE
+                : error.exitCode;
             return Number(process.exitCode ?? 1);
         }
         throw error;
@@ -767,9 +866,7 @@ async function runConnect(rawSource, options) {
                         connectorInstalled: false,
                         lastRunAt: new Date().toISOString(),
                         lastRunOutcome: CliOutcomeStatus.CONNECTOR_UNAVAILABLE,
-                        dataState: "none",
                         lastError: message,
-                        lastResultPath: null,
                         lastLogPath: getErrorLogPath(retryError),
                     });
                     renderer?.fail(`${displayName} connector could not be verified.`);
@@ -790,9 +887,7 @@ async function runConnect(rawSource, options) {
                     connectorInstalled: false,
                     lastRunAt: new Date().toISOString(),
                     lastRunOutcome: CliOutcomeStatus.CONNECTOR_UNAVAILABLE,
-                    dataState: "none",
                     lastError: message,
-                    lastResultPath: null,
                     lastLogPath: getErrorLogPath(firstError),
                 });
                 renderer?.fail(`${displayName} is not available.`);
@@ -845,9 +940,7 @@ async function runConnect(rawSource, options) {
                 sessionPresent: fs.existsSync(profilePath),
                 lastRunAt: new Date().toISOString(),
                 lastRunOutcome: CliOutcomeStatus.LEGACY_AUTH,
-                dataState: "none",
                 lastError: message,
-                lastResultPath: null,
                 lastLogPath: fetchLogPath ?? null,
             });
             renderer?.fail(`${displayName} requires a browser window, but no display is available.`);
@@ -1002,8 +1095,6 @@ async function runConnect(rawSource, options) {
                     lastRunAt: new Date().toISOString(),
                     lastRunOutcome: CliOutcomeStatus.LEGACY_AUTH,
                     lastError: event.message ?? "Legacy authentication is required.",
-                    dataState: "none",
-                    lastResultPath: null,
                     lastLogPath: event.logPath,
                     connectionHealth: "needs_reauth",
                     connectionHealthChangedAt: new Date().toISOString(),
@@ -1118,9 +1209,7 @@ async function runConnect(rawSource, options) {
                 sessionPresent: fs.existsSync(profilePath),
                 lastRunAt: new Date().toISOString(),
                 lastRunOutcome: CliOutcomeStatus.UNEXPECTED_INTERNAL_ERROR,
-                dataState: "none",
                 lastError: "Connector run ended without a result.",
-                lastResultPath: null,
                 lastLogPath: runLogPath ?? fetchLogPath ?? null,
             });
             renderer?.fail(`Problem connecting ${displayName}.`);
@@ -1171,6 +1260,9 @@ async function runConnect(rawSource, options) {
         else if (finalDataState === "ingest_unavailable") {
             successSummary = `Collected your ${displayName} data. Personal Server sync is pending.`;
         }
+        else if (finalDataState === "ingest_failed") {
+            successSummary = `Collected your ${displayName} data, but Personal Server sync failed.`;
+        }
         else {
             successSummary = `Collected your ${displayName} data and saved it locally.`;
         }
@@ -1187,6 +1279,14 @@ async function runConnect(rawSource, options) {
             renderer?.detail(`Pending sync will retry during scheduled collection.`);
             renderer?.detail(`Retry now: vana server sync`);
         }
+        else if (finalDataState === "ingest_failed") {
+            if (ingestFailureMessage?.includes("401")) {
+                renderer?.detail("Your Personal Server requires authentication. Run `vana login` to authenticate, then `vana server sync`.");
+            }
+            else {
+                renderer?.detail(`Retry: vana server sync`);
+            }
+        }
         // Journey-aware next step
         const state = await readCliState();
         const connectedSourceCount = Object.values(state.sources ?? {}).filter((s) => hasCollectedData(s?.dataState)).length;
@@ -1288,15 +1388,15 @@ async function runConnectEntry(options) {
                 }
                 : null,
         })}\n`);
-        return 1;
+        return CliExitCode.USAGE;
     }
     if (options.noInput) {
         emit.info(missingSourceMessage);
-        return 1;
+        return CliExitCode.USAGE;
     }
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         emit.info(missingSourceMessage);
-        return 1;
+        return CliExitCode.USAGE;
     }
     if (enrichedSources.length === 0) {
         emit.info("No sources are available right now.");
@@ -1587,7 +1687,41 @@ function formatSyncFailureSummary(source) {
     return `${failedScopes.length} scopes failed to sync: ${summaryParts.join("; ")}. Run \`vana connect ${source.source}\`.`;
 }
 async function runDoctor(options) {
-    const payload = await queryDoctor();
+    const basePayload = await queryDoctor();
+    // Builder-side protocol network (owner-side server config is separate and
+    // reported by its own checks). Additive field; the rest of the payload
+    // still matches CliDoctor exactly. A bad VANA_NETWORK/VANA_ENV combination
+    // is a usage problem, not a crash: exit 2 with a structured message.
+    let network;
+    try {
+        network = resolveNetwork(options.network);
+    }
+    catch (error) {
+        if (error instanceof UnknownNetworkError) {
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({ error: "bad_usage", message: error.message })}\n`);
+            }
+            else {
+                process.stderr.write(`${error.message}\n`);
+            }
+            return CliExitCode.USAGE;
+        }
+        throw error;
+    }
+    const payload = {
+        ...basePayload,
+        network: {
+            name: network.name,
+            env: network.env,
+            chainId: network.chainId,
+            gatewayUrl: network.gatewayUrl,
+            source: options.network
+                ? "flag"
+                : process.env.VANA_NETWORK
+                    ? "env"
+                    : "default",
+        },
+    };
     if (options.json) {
         process.stdout.write(`${JSON.stringify(payload)}\n`);
         return 0;
@@ -1603,6 +1737,7 @@ async function runDoctor(options) {
     emit.keyValue("Install", formatInstallMethodLabel(payload.installMethod), "muted");
     emit.keyValue("Runtime", payload.runtime, toneForRuntime(payload.runtime));
     emit.keyValue("Personal Server", payload.personalServer, payload.personalServer === "available" ? "success" : "warning");
+    emit.keyValue("Network", `${payload.network.name} (chain ${payload.network.chainId}, ${payload.network.source})`, "muted");
     emit.keyValue("Tracked sources", String(payload.summary.trackedSourceCount), "muted");
     emit.keyValue("Attention", String(payload.summary.attentionCount), payload.summary.attentionCount > 0 ? "warning" : "muted");
     emit.keyValue("Connected", String(payload.summary.connectedCount), payload.summary.connectedCount > 0 ? "success" : "muted");
@@ -1669,6 +1804,11 @@ async function runDoctor(options) {
 async function runServerStatus(options) {
     const emit = createEmitter(options);
     const target = await detectPersonalServerTarget();
+    // The local transport URL and the gateway-registered public URL are two
+    // names for the same server; show both when the owner is known.
+    const registeredServers = target.health?.owner
+        ? await lookupRegisteredServers(target.health.owner)
+        : [];
     const state = await readCliState();
     // Count scopes from state
     let totalScopeCount = 0;
@@ -1682,6 +1822,7 @@ async function runServerStatus(options) {
             state: target.state,
             url: target.url,
             source: target.source,
+            registeredServers,
             health: target.health,
             scopeCount: totalScopeCount,
         })}\n`);
@@ -1701,6 +1842,9 @@ async function runServerStatus(options) {
                         : `(${target.source ?? "unknown"})`;
         emit.keyValue("URL", `${target.url} ${urlSuffix}`, "muted");
     }
+    for (const server of registeredServers) {
+        emit.keyValue("Registered", `${server.url} (${server.network})`, "muted");
+    }
     const stateLabel = target.state === "available" ? "healthy" : "Not connected";
     emit.keyValue("Status", stateLabel, target.state === "available" ? "success" : "warning");
     if (target.health) {
@@ -3293,8 +3437,25 @@ export function getCliChannel(version = getCliVersion()) {
         ? "canary"
         : "stable";
 }
-export function getCliInstallMethod(execPath = process.execPath) {
-    const candidates = [process.env.VANA_APP_ROOT ?? "", execPath].map((value) => value.replace(/\\/g, "/").toLowerCase());
+function normalizePathForMatch(value) {
+    return value.replace(/\\/g, "/").toLowerCase();
+}
+/** Where this file itself sits, which is what separates npm from a checkout. */
+function getOwnModulePath() {
+    try {
+        return fileURLToPath(import.meta.url);
+    }
+    catch {
+        return "";
+    }
+}
+/** True when the CLI is running out of an npm install or an npx cache. */
+function isPackagedUnderNodeModules(normalizedPath) {
+    return (normalizedPath.includes("/node_modules/vana-cli/") ||
+        normalizedPath.includes("/_npx/"));
+}
+export function getCliInstallMethod(execPath = process.execPath, modulePath = getOwnModulePath()) {
+    const candidates = [process.env.VANA_APP_ROOT ?? "", execPath].map(normalizePathForMatch);
     for (const normalizedPath of candidates) {
         if (!normalizedPath) {
             continue;
@@ -3308,6 +3469,18 @@ export function getCliInstallMethod(execPath = process.execPath) {
             /\/releases\/[^/]+\/app$/.test(normalizedPath)) {
             return "installer";
         }
+    }
+    // npm and npx both run under the user's own node, so execPath looks exactly
+    // like a development checkout. Only the package's own location tells them
+    // apart, and getting it wrong costs an npm user every update notification.
+    if (modulePath &&
+        isPackagedUnderNodeModules(normalizePathForMatch(modulePath))) {
+        return "npm";
+    }
+    for (const normalizedPath of candidates) {
+        if (!normalizedPath) {
+            continue;
+        }
         if (normalizedPath.endsWith("/node") ||
             normalizedPath.endsWith("/node.exe") ||
             normalizedPath.includes("/.nvm/") ||
@@ -3336,14 +3509,28 @@ export function formatInstallMethodLabel(method) {
             return "Homebrew";
         case "installer":
             return "Hosted installer";
+        case "npm":
+            return "npm";
         case "development":
             return "Development checkout";
         default:
             return "Unknown";
     }
 }
-export function getLifecycleCommands(installMethod, channel) {
+export function getLifecycleCommands(installMethod, channel, modulePath = getOwnModulePath()) {
     switch (installMethod) {
+        case "npm":
+            // npx installs nothing, so there is nothing to upgrade or remove:
+            // asking for @latest is the whole update story there.
+            return normalizePathForMatch(modulePath).includes("/_npx/")
+                ? {
+                    upgrade: "npx vana-cli@latest",
+                    uninstall: "npx leaves nothing installed. Remove ~/.vana for any state you no longer need.",
+                }
+                : {
+                    upgrade: "npm install -g vana-cli@latest",
+                    uninstall: "npm uninstall -g vana-cli",
+                };
         case "homebrew":
             return {
                 upgrade: "brew update && brew upgrade vana",
@@ -3374,7 +3561,30 @@ export function getLifecycleCommands(installMethod, channel) {
             };
     }
 }
-function extractGlobalOptions(argv) {
+/**
+ * Pre-parse seed for the global options. Needed before commander runs (the
+ * update-notifier suppression and the telemetry context read it); the
+ * preAction hook overlays the authoritative parsed values afterwards.
+ */
+function extractGlobalOptions(rawArgv) {
+    // Everything after a bare "--" is positional; commander will not parse it
+    // as options, so the seed must not either.
+    const boundary = rawArgv.indexOf("--");
+    const argv = boundary === -1 ? rawArgv : rawArgv.slice(0, boundary);
+    let network;
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        let candidate;
+        if (argument === "--network") {
+            candidate = argv[index + 1];
+        }
+        else if (argument.startsWith("--network=")) {
+            candidate = argument.slice("--network=".length);
+        }
+        if (candidate && isVanaNetworkName(candidate)) {
+            network = candidate;
+        }
+    }
     return {
         json: argv.includes("--json"),
         noInput: argv.includes("--no-input"),
@@ -3382,6 +3592,7 @@ function extractGlobalOptions(argv) {
         yes: argv.includes("--yes"),
         quiet: argv.includes("--quiet"),
         detach: argv.includes("--detach"),
+        network,
     };
 }
 export function createSourceLabelMap(sources) {
@@ -4337,7 +4548,7 @@ async function runSkillsGuidedPicker(options) {
         // In JSON mode, fall back to list behavior
         return runSkillList(options);
     }
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    if (options.noInput || !process.stdin.isTTY || !process.stdout.isTTY) {
         return runSkillList(options);
     }
     try {
@@ -4506,23 +4717,32 @@ async function runLogin(options, serverUrl, clientId) {
         try {
             const result = await runSelfHostedLoginFlow(psUrl, (url) => {
                 if (!options.json && !options.quiet) {
-                    process.stderr.write(`  ${humanRenderer.theme.muted("Open this URL in your browser:")}\n`);
-                    process.stderr.write(`  ${humanRenderer.theme.muted(url)}\n`);
+                    // Same emphasis rule as the cloud flow: the actionable URL
+                    // carries the Vana accent, the label stays muted.
+                    process.stderr.write(`  ${humanRenderer.theme.muted("Open")}  ${humanRenderer.theme.accent(url)}\n`);
                 }
                 renderer?.scopeActive("Waiting for authorization");
                 // Try to open browser — use spawn with args array to prevent shell injection
-                // (a malicious self-hosted PS could return a URL with shell metacharacters)
-                try {
-                    const { spawn } = require("node:child_process");
-                    const opener = process.platform === "darwin"
-                        ? "open"
-                        : process.platform === "win32"
-                            ? "start"
-                            : "xdg-open";
-                    spawn(opener, [url], { detached: true, stdio: "ignore" }).unref();
-                }
-                catch {
-                    // Browser open failed — user will open manually
+                // (a malicious self-hosted PS could return a URL with shell metacharacters).
+                // Interactive terminals only: agents, CI and the test suite must never
+                // pop a browser (a vitest run used to open the fixture URL for real).
+                const browserAllowed = Boolean(process.stdout.isTTY) &&
+                    !options.json &&
+                    !options.noInput &&
+                    !process.env.VANA_NO_BROWSER;
+                if (browserAllowed) {
+                    try {
+                        const { spawn } = require("node:child_process");
+                        const opener = process.platform === "darwin"
+                            ? "open"
+                            : process.platform === "win32"
+                                ? "start"
+                                : "xdg-open";
+                        spawn(opener, [url], { detached: true, stdio: "ignore" }).unref();
+                    }
+                    catch {
+                        // Browser open failed — user will open manually
+                    }
                 }
             });
             await saveCredentials({
@@ -4570,6 +4790,10 @@ async function runLogin(options, serverUrl, clientId) {
     }
     // Check if already logged in
     const existing = loadCredentials();
+    // For the account-switch check below: the previous auth file content even
+    // when the stored credentials have expired (loadCredentials hides those).
+    const previousAuth = readStoredAuthFile();
+    const previousAddress = previousAuth?.address ?? null;
     if (existing && !isExpired(existing)) {
         if (options.json) {
             process.stdout.write(`${JSON.stringify({
@@ -4610,13 +4834,27 @@ async function runLogin(options, serverUrl, clientId) {
             },
         }, { clientId });
         if (creds) {
+            if (!creds.personal_server &&
+                previousAuth?.personalServer &&
+                (!previousAddress || previousAddress === creds.account.address)) {
+                // The cloud flow cannot mint PS sessions; keep the one we had.
+                creds.personal_server = previousAuth.personalServer;
+            }
             await saveCredentials(creds);
             // Always sync the pinned PS config to this login's result — including
             // clearing it when this account has no PS, so a stale PS URL from a
             // previously logged-in account can't linger and be used by mistake.
-            await updateCliConfig({
-                personalServerUrl: creds.personal_server?.url,
-            });
+            if (creds.personal_server?.url) {
+                await updateCliConfig({
+                    personalServerUrl: creds.personal_server.url,
+                });
+            }
+            else if (previousAddress && previousAddress !== creds.account.address) {
+                // A different account logged in: its pinned Personal Server URL is
+                // stale. Same-account logins keep the pin - the prod token flow
+                // carries no PS info, so its absence proves nothing.
+                await updateCliConfig({ personalServerUrl: undefined });
+            }
             process.stdout.write(`${JSON.stringify({
                 status: "authenticated",
                 address: creds.account.address,
@@ -4630,34 +4868,46 @@ async function runLogin(options, serverUrl, clientId) {
     // Interactive mode
     const renderer = createLoginRenderer();
     const humanRenderer = createHumanRenderer();
-    const writeStaticLoginNotes = (lines) => {
+    // Branding lives in emphasis, not chrome (CLI-BEAUTY doctrine: no
+    // banners). The two things the user must act on - the URL and the code -
+    // carry the Vana accent; everything around them stays muted.
+    const writeDeviceCodePrompt = (code, uri) => {
         if (options.json || options.quiet) {
             return;
         }
-        for (const line of lines) {
-            process.stderr.write(`  ${humanRenderer.theme.muted(line)}\n`);
-        }
+        const theme = humanRenderer.theme;
+        process.stderr.write(`  ${theme.muted("Open")}  ${theme.accent(uri)}\n`);
+        process.stderr.write(`  ${theme.muted("Enter")} ${theme.heading(code)}\n`);
     };
     renderer.title("Vana");
     const creds = await runDeviceCodeFlow({
         onCode: (code, uri) => {
-            writeStaticLoginNotes([
-                "Open this URL in your browser:",
-                uri,
-                `Enter this code: ${code}`,
-            ]);
+            writeDeviceCodePrompt(code, uri);
         },
         onWaiting: () => {
             renderer.scopeActive("Waiting for authorization");
         },
         onAuthorized: async (authedCreds) => {
+            if (!authedCreds.personal_server &&
+                previousAuth?.personalServer &&
+                (!previousAddress || previousAddress === authedCreds.account.address)) {
+                // The cloud flow cannot mint PS sessions; keep the one we had.
+                authedCreds.personal_server = previousAuth.personalServer;
+            }
             await saveCredentials(authedCreds);
             // Always sync the pinned PS config to this login's result — including
             // clearing it when this account has no PS, so a stale PS URL from a
             // previously logged-in account can't linger and be used by mistake.
-            await updateCliConfig({
-                personalServerUrl: authedCreds.personal_server?.url,
-            });
+            if (authedCreds.personal_server?.url) {
+                await updateCliConfig({
+                    personalServerUrl: authedCreds.personal_server.url,
+                });
+            }
+            else if (previousAddress &&
+                previousAddress !== authedCreds.account.address) {
+                // See the JSON branch: clear only on an account switch.
+                await updateCliConfig({ personalServerUrl: undefined });
+            }
             renderer.success(`Logged in as ${formatAddress(authedCreds.account.address)}`);
             if (authedCreds.personal_server) {
                 renderer.detail(`Personal Server: ${authedCreds.personal_server.url}`);