neozip-cli 0.90.0 → 0.95.0

package/dist/src/connection/interactive.js

@@ -0,0 +1,871 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptTokenServiceUrl = promptTokenServiceUrl;
+exports.parseVerificationCodeInput = parseVerificationCodeInput;
+exports.promptVerificationCode = promptVerificationCode;
+exports.promptRecoveryPhraseBackup = promptRecoveryPhraseBackup;
+exports.promptWalletOverwriteConfirm = promptWalletOverwriteConfirm;
+exports.promptWalletChoice = promptWalletChoice;
+exports.promptBrokenStoreReset = promptBrokenStoreReset;
+exports.promptIncompleteAccountAction = promptIncompleteAccountAction;
+exports.promptReadyAccountAction = promptReadyAccountAction;
+exports.promptSwitchConnection = promptSwitchConnection;
+exports.promptDeleteConnection = promptDeleteConnection;
+exports.runInteractiveConnect = runInteractiveConnect;
+const readline = __importStar(require("node:readline/promises"));
+const node_process_1 = require("node:process");
+const account_state_1 = require("../account/account-state");
+const format_account_status_1 = require("../account/format-account-status");
+const wallet_evm_1 = require("../account/wallet-evm");
+const onboarding_1 = require("./onboarding");
+const phone_1 = require("./phone");
+const promote_active_1 = require("./promote-active");
+const phase_1 = require("./phase");
+const origin_1 = require("./origin");
+const store_1 = require("./store");
+const migrate_1 = require("./migrate");
+const wallet_json_migration_1 = require("./wallet-json-migration");
+const coordinator_1 = require("./coordinator");
+const dump_1 = require("./dump");
+const cli_settings_1 = require("./cli-settings");
+const incomplete_setup_1 = require("./incomplete-setup");
+const reset_1 = require("./reset");
+const wallet_setup_1 = require("./wallet-setup");
+function defaultPrompter(rl) {
+    return {
+        async question(prompt, defaultValue) {
+            const suffix = defaultValue ? ` [${defaultValue}]` : "";
+            const answer = (await rl.question(`${prompt}${suffix}: `)).trim();
+            return answer || defaultValue || "";
+        },
+    };
+}
+function promptWithDefault(prompter, prompt, defaultValue) {
+    return prompter.question(prompt, defaultValue);
+}
+async function promptTokenServiceUrl(prompter, options) {
+    if (options?.tokenServiceUrl?.trim()) {
+        return (0, origin_1.resolveTokenServiceOrigin)(options.tokenServiceUrl);
+    }
+    console.error(`
+Token Service — choose deployment:
+  1) NeoZip Testnet — ${origin_1.NEOZIP_TOKEN_SERVICE_DEFAULT_URL} (default)
+  2) NeoZip Production — ${origin_1.NEOZIP_TOKEN_SERVICE_PRODUCTION_URL}
+  3) Local Development — ${origin_1.NEOZIP_TOKEN_SERVICE_LOCALHOST}
+  4) Custom URL
+`);
+    const choice = await promptWithDefault(prompter, "Choice", (0, origin_1.defaultTokenServiceMenuChoice)());
+    switch (choice) {
+        case "1":
+        case "testnet":
+            return (0, origin_1.normalizeTokenServiceOrigin)(origin_1.KNOWN_TOKEN_SERVICE_PRESETS[0].url);
+        case "2":
+        case "production":
+        case "prod":
+            return (0, origin_1.normalizeTokenServiceOrigin)(origin_1.KNOWN_TOKEN_SERVICE_PRESETS[1].url);
+        case "3":
+        case "local":
+            return (0, origin_1.normalizeTokenServiceOrigin)(origin_1.KNOWN_TOKEN_SERVICE_PRESETS[2].url);
+        case "4":
+        case "custom": {
+            const url = await promptWithDefault(prompter, "Custom Token Service URL", undefined);
+            if (!url)
+                throw new Error("Token Service URL is required");
+            return (0, origin_1.resolveTokenServiceOrigin)(url);
+        }
+        default:
+            throw new Error(`Invalid choice: ${choice}. Enter 1, 2, 3, or 4.`);
+    }
+}
+async function ensureConnectionShell(prompter, options) {
+    const phase = (0, phase_1.computeConnectionPhase)();
+    if (phase !== "no_profile")
+        return;
+    const existing = (0, store_1.listConnections)();
+    if (existing.length > 0) {
+        if (existing.length === 1) {
+            (0, store_1.selectConnection)(existing[0].id);
+            console.error(`Using connection: ${existing[0].label} (${existing[0].id})`);
+            return;
+        }
+        console.error("Existing connections:");
+        existing.forEach((c, i) => {
+            console.error(`  ${i + 1}) ${c.label} — ${c.email ?? "no email"} (${c.id})`);
+        });
+        console.error(`  ${existing.length + 1}) Create new connection`);
+        const pick = await promptWithDefault(prompter, `Select connection (1-${existing.length + 1})`, "1");
+        const idx = parseInt(pick, 10);
+        if (idx >= 1 && idx <= existing.length) {
+            (0, store_1.selectConnection)(existing[idx - 1].id);
+            return;
+        }
+    }
+    const tokenServiceUrl = await promptTokenServiceUrl(prompter, options);
+    const label = options?.label?.trim() || (0, origin_1.connectionLabelForOrigin)(tokenServiceUrl);
+    (0, store_1.createConnection)({ label, tokenServiceUrl });
+    console.error(`Connection "${label}" stored under ${(0, store_1.getConnectionDir)()}`);
+}
+async function sendVerificationCode(origin, email, label) {
+    console.error(`Sending verification code to ${email}…`);
+    const reg = await (0, onboarding_1.connectRegister)({
+        email,
+        tokenServiceUrl: origin,
+        label,
+    });
+    if (!reg.success) {
+        throw new Error(reg.message ?? "Failed to send verification email.");
+    }
+    console.error(`Verification code sent to ${email}.`);
+}
+function parseVerificationCodeInput(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return null;
+    const key = trimmed.toLowerCase();
+    if (key === "r" || key === "resend")
+        return { kind: "resend" };
+    if (key === "c" || key === "change")
+        return { kind: "change_email" };
+    if (key === "a" || key === "abort")
+        return { kind: "abort" };
+    return { kind: "code", code: trimmed };
+}
+async function promptVerificationCode(prompter) {
+    const answer = await prompter.question("6-digit verification code from email [r=resend, c=change email, a=abort]");
+    return parseVerificationCodeInput(answer);
+}
+async function runEmailStep(prompter) {
+    if ((0, phase_1.computeConnectionPhase)() !== "email_unverified")
+        return;
+    const conn = (0, store_1.getActiveConnection)();
+    if (!conn)
+        throw new Error("No active connection");
+    const origin = conn.tokenServiceOrigin;
+    const reachable = await (0, coordinator_1.probeTokenServiceReachable)(origin);
+    if (!reachable) {
+        throw new Error(`Token Service unreachable at ${origin}. Start the server (e.g. local development on port 14789) or choose another deployment.`);
+    }
+    const defaultEmail = conn.email?.trim() ||
+        process.env.NEOZIP_RECIPIENT_EMAIL?.trim() ||
+        undefined;
+    let email = await promptWithDefault(prompter, "Email for Token Service", defaultEmail);
+    if (!email)
+        throw new Error("Email is required");
+    await sendVerificationCode(origin, email, conn.label);
+    while (true) {
+        const input = await promptVerificationCode(prompter);
+        if (input === null) {
+            console.error("Enter the verification code, r to resend, c to change email, or a to abort.");
+            continue;
+        }
+        if (input.kind === "abort") {
+            throw new Error("Email verification aborted.");
+        }
+        if (input.kind === "change_email") {
+            email = await promptWithDefault(prompter, "Email for Token Service");
+            if (!email) {
+                console.error("Email is required.");
+                continue;
+            }
+            await sendVerificationCode(origin, email, conn.label);
+            continue;
+        }
+        if (input.kind === "resend") {
+            await sendVerificationCode(origin, email, conn.label);
+            continue;
+        }
+        console.error("Verifying email…");
+        try {
+            const ver = await (0, onboarding_1.connectVerify)({
+                email,
+                code: input.code,
+                tokenServiceUrl: origin,
+            });
+            if (!ver.success && ver.phase === "phone_required" && !ver.message?.includes("Email verified")) {
+                throw new Error(ver.message ?? "Phone verification required");
+            }
+            console.error("Email verified.");
+            return;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(message);
+            console.error("Try again, enter r to resend, c to change email, or a to abort.");
+        }
+    }
+}
+async function runPhoneStep(prompter) {
+    const conn = (0, store_1.getActiveConnection)();
+    if (!conn)
+        throw new Error("No active connection");
+    if ((0, phone_1.isPhoneVerified)(conn))
+        return;
+    const coordinator = await (0, coordinator_1.fetchCoordinatorConfigParsed)(conn.tokenServiceOrigin);
+    if (!coordinator?.cryptoRequirePhoneVerified)
+        return;
+    console.error(`
+Phone verification — required by this Token Service deployment.
+Enter your phone in E.164 format (e.g. +14155551234). We will send a 6-digit SMS code.
+`);
+    let phone = conn.phoneE164?.trim() || "";
+    if (!phone) {
+        phone = await promptWithDefault(prompter, "Phone number (E.164)", undefined);
+    }
+    if (!phone)
+        throw new Error("Phone number is required");
+    let smsSent = false;
+    while (true) {
+        if (!smsSent) {
+            console.error(`Sending SMS code to ${phone}…`);
+            const req = await (0, onboarding_1.connectPhoneRequest)({
+                phone,
+                tokenServiceUrl: conn.tokenServiceOrigin,
+            });
+            if (!req.success) {
+                throw new Error(req.message ?? "Failed to send SMS code");
+            }
+            smsSent = true;
+            console.error(req.message ?? "SMS code sent.");
+        }
+        const answer = await prompter.question("6-digit SMS code [r=resend, c=change phone, a=abort]");
+        const trimmed = answer.trim().toLowerCase();
+        if (trimmed === "a" || trimmed === "abort") {
+            throw new Error("Phone verification aborted.");
+        }
+        if (trimmed === "r" || trimmed === "resend") {
+            smsSent = false;
+            continue;
+        }
+        if (trimmed === "c" || trimmed === "change") {
+            phone = await promptWithDefault(prompter, "Phone number (E.164)");
+            if (!phone) {
+                console.error("Phone number is required.");
+                continue;
+            }
+            smsSent = false;
+            continue;
+        }
+        if (!trimmed) {
+            console.error("Enter the SMS code, r to resend, c to change phone, or a to abort.");
+            continue;
+        }
+        console.error("Verifying phone…");
+        try {
+            const ver = await (0, onboarding_1.connectPhoneVerify)({
+                phone,
+                code: trimmed,
+                tokenServiceUrl: conn.tokenServiceOrigin,
+            });
+            if (!ver.success) {
+                console.error(ver.message ?? "Verification failed");
+                continue;
+            }
+            console.error("Phone verified.");
+            return;
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+        }
+    }
+}
+async function promptRecoveryPhraseBackup(prompter, input) {
+    console.error(`
+Back up your Data Wallet (same as NeoZip Desktop)
+This is the one and only time we will show this recovery phrase. Write it down and store it
+somewhere safe. NeoZip does not store this phrase on the server.
+
+Note: This is your wallet recovery phrase. Connection file encryption uses this machine by
+default unless you set NEOZIP_UNLOCK_PASSPHRASE.
+
+Address: ${input.address}
+
+Recovery phrase:
+${input.mnemonic}
+`);
+    while (true) {
+        const ack = (await prompter.question("Have you written down and stored your recovery phrase? (yes/no)", "no"))
+            .trim()
+            .toLowerCase();
+        if (ack === "yes" || ack === "y") {
+            return;
+        }
+        if (ack === "no" || ack === "n") {
+            console.error("You must save your recovery phrase before continuing. You cannot recover this wallet without it.");
+            continue;
+        }
+        console.error('Answer "yes" or "no".');
+    }
+}
+async function promptWalletOverwriteConfirm(prompter, serverAddress, newAddress) {
+    console.error(`
+WARNING: Token Service wallet on file: ${serverAddress}
+Your choice would use a different wallet: ${newAddress}
+Continuing will replace the server-linked wallet when you finish setup.
+`);
+    const answer = (await prompter.question('Type "yes" to continue', "no"))
+        .trim()
+        .toLowerCase();
+    return answer === "yes" || answer === "y";
+}
+async function promptWalletChoice(prompter, options) {
+    const serverLinkedAddress = options?.serverLinkedAddress?.trim() || null;
+    if (serverLinkedAddress) {
+        console.error(`
+This account already has a Data Wallet on Token Service: ${serverLinkedAddress}
+Restore it with your recovery phrase or private key, or create a new wallet (requires confirmation).
+`);
+    }
+    console.error(`
+Data Wallet — choose one (same options as NeoZip Desktop):
+  1) Create new wallet (generated locally; secrets stay on this device)
+  2) Import recovery phrase (12 or 24 words)
+  3) Import private key (hex, with or without 0x prefix)
+`);
+    const defaultChoice = serverLinkedAddress ? "2" : "1";
+    const choice = await promptWithDefault(prompter, "Choice", defaultChoice);
+    switch (choice) {
+        case "1":
+        case "create":
+        case "new": {
+            const evm = (0, wallet_evm_1.generateEvmIdentity)();
+            if (!evm.mnemonic) {
+                throw new Error("Failed to generate recovery phrase for new Data Wallet");
+            }
+            if (serverLinkedAddress &&
+                evm.address.toLowerCase() !== serverLinkedAddress.toLowerCase()) {
+                const ok = await promptWalletOverwriteConfirm(prompter, serverLinkedAddress, evm.address);
+                if (!ok)
+                    throw new Error("Wallet creation cancelled.");
+            }
+            await promptRecoveryPhraseBackup(prompter, {
+                mnemonic: evm.mnemonic,
+                address: evm.address,
+            });
+            console.error(`New Data Wallet: ${evm.address}`);
+            return evm;
+        }
+        case "2":
+        case "mnemonic":
+        case "phrase": {
+            const mnemonic = await promptWithDefault(prompter, "Recovery phrase (space-separated words)");
+            if (!mnemonic)
+                throw new Error("Recovery phrase is required");
+            const evm = (0, wallet_evm_1.evmIdentityFromMnemonic)(mnemonic);
+            if (serverLinkedAddress &&
+                evm.address.toLowerCase() !== serverLinkedAddress.toLowerCase()) {
+                const ok = await promptWalletOverwriteConfirm(prompter, serverLinkedAddress, evm.address);
+                if (!ok)
+                    throw new Error("Wallet import cancelled.");
+            }
+            console.error(`Imported wallet: ${evm.address}`);
+            return evm;
+        }
+        case "3":
+        case "key":
+        case "private": {
+            const privateKey = await promptWithDefault(prompter, "EVM private key (hex)");
+            if (!privateKey)
+                throw new Error("Private key is required");
+            const evm = (0, wallet_evm_1.evmIdentityFromPrivateKey)(privateKey);
+            if (serverLinkedAddress &&
+                evm.address.toLowerCase() !== serverLinkedAddress.toLowerCase()) {
+                const ok = await promptWalletOverwriteConfirm(prompter, serverLinkedAddress, evm.address);
+                if (!ok)
+                    throw new Error("Wallet import cancelled.");
+            }
+            console.error(`Imported wallet: ${evm.address}`);
+            return evm;
+        }
+        default:
+            throw new Error(`Invalid choice: ${choice}. Enter 1, 2, or 3.`);
+    }
+}
+async function runWalletStep(prompter) {
+    if ((0, phase_1.computeConnectionPhase)() !== "no_wallet")
+        return;
+    const conn = (0, store_1.getActiveConnection)();
+    if (!conn)
+        throw new Error("No active connection");
+    let serverLinkedAddress = null;
+    const secrets = (0, store_1.readActiveConnectionSecrets)();
+    if (secrets?.accessToken) {
+        console.error("Checking Token Service for an existing linked wallet…");
+        serverLinkedAddress = await (0, wallet_setup_1.fetchServerLinkedWalletAddress)(conn.tokenServiceOrigin, secrets.accessToken);
+    }
+    const evm = await promptWalletChoice(prompter, { serverLinkedAddress });
+    (0, store_1.saveEvmWallet)(conn.id, evm.privateKey, evm.address);
+    console.error("Data Wallet saved to encrypted connection file.");
+}
+async function promptBrokenStoreReset(prompter, message) {
+    console.error(`\n${message}\n`);
+    console.error(`  1) Reset all connection data and start fresh (recommended)
+  2) Exit without changes
+  3) Show account summary
+  4) Show connection JSON (no secrets)
+`);
+    while (true) {
+        const choice = await promptWithDefault(prompter, "Choice", "1");
+        switch (choice) {
+            case "1":
+            case "reset":
+                return "reset";
+            case "2":
+            case "exit":
+            case "quit":
+                return "exit";
+            case "3":
+            case "summary":
+            case "accounts":
+                return "summary";
+            case "4":
+            case "dump":
+            case "json":
+                return "dump";
+            default:
+                console.error("Invalid choice. Enter 1, 2, 3, or 4.");
+        }
+    }
+}
+function rollbackFailedNewConnection(previousActiveId) {
+    const currentId = (0, store_1.getActiveConnectionId)();
+    if (currentId &&
+        currentId !== previousActiveId &&
+        (0, phase_1.computeConnectionPhaseForId)(currentId) === "email_unverified") {
+        const removed = (0, store_1.deleteConnection)(currentId);
+        console.error(`Removed incomplete account "${removed.label}".`);
+    }
+    if (previousActiveId && (0, store_1.readConnectionPublic)(previousActiveId)) {
+        const restored = (0, store_1.selectConnection)(previousActiveId);
+        console.error(`Restored active account: ${formatConnectionSummary(restored, restored.id)}`);
+        return;
+    }
+    const promoted = (0, promote_active_1.promoteReadyActiveConnection)();
+    if (promoted.connectionId && promoted.label) {
+        console.error(`Restored active account: ${promoted.label}`);
+    }
+}
+async function promptIncompleteAccountAction(prompter, active) {
+    const email = active.email ?? "no email yet";
+    console.error(`
+Incomplete account setup (${active.label} — ${email} — ${active.tokenServiceOrigin}).
+  1) Continue setup
+  2) Delete this incomplete account
+  3) Switch to a ready account
+  4) Show account summary
+  5) Show connection JSON (no secrets)
+`);
+    while (true) {
+        const choice = await promptWithDefault(prompter, "Choice", "3");
+        switch (choice) {
+            case "1":
+            case "continue":
+                return "continue_setup";
+            case "2":
+            case "delete":
+                return "delete";
+            case "3":
+            case "switch":
+            case "ready":
+                return "switch_ready";
+            case "4":
+            case "summary":
+            case "accounts":
+                return "summary";
+            case "5":
+            case "dump":
+            case "json":
+                return "dump";
+            default:
+                console.error("Invalid choice. Enter 1, 2, 3, 4, or 5.");
+        }
+    }
+}
+function formatConnectionSummary(meta, activeId) {
+    const active = activeId === meta.id ? " (active)" : "";
+    const email = meta.email ?? "no email";
+    return `${meta.label} — ${email} — ${meta.tokenServiceOrigin}${active}`;
+}
+async function promptReadyAccountAction(prompter, active) {
+    const all = (0, store_1.listConnections)();
+    const switchLine = all.length > 1 ? `\n  5) Switch active account (${all.length} saved)` : "";
+    const summaryChoice = all.length > 1 ? "6" : "5";
+    const dumpChoice = all.length > 1 ? "7" : "6";
+    console.error(`
+Account is ready. What would you like to do?
+  1) Done — use current account (default)
+  2) Add another account on ${active.tokenServiceOrigin}
+  3) Add another account on a different Token Service
+  4) Delete an account${switchLine}
+  ${summaryChoice}) Show account summary
+  ${dumpChoice}) Show connection JSON (no secrets)
+`);
+    while (true) {
+        const choice = await promptWithDefault(prompter, "Choice", "1");
+        switch (choice) {
+            case "1":
+            case "done":
+                return "done";
+            case "2":
+            case "add":
+            case "same":
+                return "add_same";
+            case "3":
+            case "other":
+                return "add_other";
+            case "4":
+            case "delete":
+                return "delete";
+            case "5":
+                if (all.length > 1)
+                    return "switch";
+                return "summary";
+            case "6":
+                if (all.length > 1)
+                    return "summary";
+                return "dump";
+            case "7":
+            case "dump":
+            case "json":
+            case "show":
+                if (all.length > 1)
+                    return "dump";
+                break;
+            case "summary":
+            case "accounts":
+                return "summary";
+            default:
+                break;
+        }
+        const valid = all.length > 1 ? "1, 2, 3, 4, 5, 6, or 7" : "1, 2, 3, 4, 5, or 6";
+        console.error(`Invalid choice. Enter ${valid}.`);
+    }
+}
+async function promptSwitchConnection(prompter) {
+    const connections = (0, store_1.listConnections)();
+    if (connections.length <= 1) {
+        console.error("Only one account is saved.");
+        return;
+    }
+    console.error("\nSaved accounts:");
+    connections.forEach((conn, index) => {
+        console.error(`  ${index + 1}) ${formatConnectionSummary(conn, (0, store_1.getActiveConnectionId)())}`);
+    });
+    const pick = await promptWithDefault(prompter, `Switch active account (1-${connections.length})`, "1");
+    const idx = parseInt(pick, 10);
+    if (idx < 1 || idx > connections.length) {
+        throw new Error(`Invalid selection: ${pick}`);
+    }
+    const selected = (0, store_1.selectConnection)(connections[idx - 1].id);
+    console.error(`Active account: ${formatConnectionSummary(selected, selected.id)}`);
+}
+async function promptDeleteConnection(prompter) {
+    const connections = (0, store_1.listConnections)();
+    if (connections.length === 0) {
+        console.error("No accounts to delete.");
+        return;
+    }
+    console.error("\nSaved accounts:");
+    connections.forEach((conn, index) => {
+        console.error(`  ${index + 1}) ${formatConnectionSummary(conn, (0, store_1.getActiveConnectionId)())}`);
+    });
+    const pick = await promptWithDefault(prompter, `Delete which account (1-${connections.length}, or cancel)`, "cancel");
+    if (pick === "cancel" || pick === "") {
+        console.error("Delete cancelled.");
+        return;
+    }
+    const idx = parseInt(pick, 10);
+    if (idx < 1 || idx > connections.length) {
+        throw new Error(`Invalid selection: ${pick}`);
+    }
+    const target = connections[idx - 1];
+    const confirm = (await promptWithDefault(prompter, `Delete "${target.label}" (${target.email ?? target.id})? Type yes to confirm`, "no"))
+        .trim()
+        .toLowerCase();
+    if (confirm !== "yes") {
+        console.error("Delete cancelled.");
+        return;
+    }
+    const deleted = (0, store_1.deleteConnection)(target.id);
+    console.error(`Deleted account "${deleted.label}".`);
+    if (deleted.newActiveConnectionId) {
+        const next = (0, store_1.readConnectionPublic)(deleted.newActiveConnectionId);
+        if (next) {
+            console.error(`Active account is now: ${formatConnectionSummary(next, next.id)}`);
+        }
+    }
+    else {
+        console.error("No accounts remain.");
+    }
+}
+async function runNewConnectionSetup(prompter, options) {
+    await ensureConnectionShell(prompter, options);
+    await runEmailStep(prompter);
+    await runPhoneStep(prompter);
+    await runWalletStep(prompter);
+    return runFinishStep(options?.tokenServiceUrl ?? (0, store_1.getActiveConnection)()?.tokenServiceOrigin, prompter);
+}
+async function runAddConnectionOnService(prompter, tokenServiceUrl) {
+    const label = (0, origin_1.connectionLabelForOrigin)(tokenServiceUrl);
+    (0, store_1.createConnection)({ label, tokenServiceUrl });
+    console.error(`New account on ${tokenServiceUrl}`);
+    await runEmailStep(prompter);
+    await runPhoneStep(prompter);
+    await runWalletStep(prompter);
+    return runFinishStep(tokenServiceUrl, prompter);
+}
+async function logFinishMeta() {
+    const meta = (0, store_1.getActiveConnection)();
+    if (meta?.walletId != null && meta.linkId != null) {
+        console.error(`Wallet linked (walletId=${meta.walletId})`);
+    }
+    if (meta?.identityKeyId != null) {
+        console.error(`Identity ready (identityKeyId=${meta.identityKeyId})`);
+    }
+}
+function readyResult(origin, message) {
+    return {
+        success: true,
+        phase: "ready",
+        connectionId: (0, store_1.getActiveConnection)()?.id ?? null,
+        tokenServiceOrigin: (0, store_1.getActiveConnection)()?.tokenServiceOrigin ?? origin,
+        message,
+    };
+}
+async function runFinishStep(tokenServiceUrl, prompter) {
+    const phase = (0, phase_1.computeConnectionPhase)();
+    if (phase === "wallet_unlinked") {
+        console.error("Linking wallet on Token Service (signed challenges)…");
+    }
+    if (phase === "identity_missing") {
+        console.error("Provisioning X25519 identity key (wallet-encrypted)…");
+    }
+    const result = phase === "ready"
+        ? await (0, onboarding_1.connectFinish)({ tokenServiceUrl })
+        : await (0, onboarding_1.connectFinish)({ tokenServiceUrl });
+    if (result.phase === "ready" && prompter) {
+        await (0, cli_settings_1.promptDefaultNetworkAfterReady)(prompter);
+    }
+    return result;
+}
+/** Interactive wizard — desktop-equivalent onboarding (email → wallet → link → identity). */
+async function runInteractiveConnect(options) {
+    if ((0, migrate_1.hasLegacyMcpProfiles)()) {
+        const migrated = (0, migrate_1.migrateFromMcpProfileStore)();
+        if (migrated.migrated > 0) {
+            console.error(`Migrated ${migrated.migrated} legacy profile(s) to ${migrated.connectionDir}.`);
+        }
+    }
+    if ((0, wallet_json_migration_1.walletJsonExists)()) {
+        const wallet = (0, wallet_json_migration_1.migrateFromWalletJson)();
+        for (const msg of wallet.messages) {
+            console.error(msg);
+        }
+    }
+    const origin = (0, origin_1.resolveTokenServiceOrigin)(options?.tokenServiceUrl);
+    const ownsRl = !options?.prompter;
+    const rl = ownsRl ? readline.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout }) : null;
+    const prompter = options?.prompter ?? defaultPrompter(rl);
+    try {
+        const autoRecover = (0, incomplete_setup_1.tryAutoRecoverConnectionStore)();
+        if (autoRecover.recovered && autoRecover.message) {
+            console.error(autoRecover.message);
+        }
+        let unrecoverable = (0, incomplete_setup_1.diagnoseUnrecoverableStore)();
+        while (unrecoverable) {
+            const action = await promptBrokenStoreReset(prompter, (0, incomplete_setup_1.formatUnrecoverableStoreMessage)(unrecoverable));
+            if (action === "exit") {
+                return {
+                    success: false,
+                    phase: (0, phase_1.computeConnectionPhase)(),
+                    connectionId: (0, store_1.getActiveConnectionId)(),
+                    tokenServiceOrigin: origin,
+                    message: "Exited without resetting connection data.",
+                };
+            }
+            if (action === "dump") {
+                console.log((0, dump_1.formatConnectionDump)((0, dump_1.buildConnectionDump)()));
+                unrecoverable = (0, incomplete_setup_1.diagnoseUnrecoverableStore)();
+                continue;
+            }
+            if (action === "summary") {
+                console.error(`\n${(0, dump_1.formatConnectionsSummaryText)()}\n`);
+                unrecoverable = (0, incomplete_setup_1.diagnoseUnrecoverableStore)();
+                continue;
+            }
+            const reset = (0, reset_1.resetConnectionStore)();
+            console.error(reset.removedConnection
+                ? "Connection store reset. Starting fresh setup.\n"
+                : "Nothing to reset.\n");
+            break;
+        }
+        while (true) {
+            const phase = (0, phase_1.computeConnectionPhase)();
+            if (phase === "ready") {
+                const active = (0, store_1.getActiveConnection)();
+                if (!active) {
+                    throw new Error("Connection phase is ready but no active connection was found.");
+                }
+                const report = await (0, account_state_1.buildAccountStatusReport)({ probeTokenService: true });
+                console.error((0, format_account_status_1.formatAccountStatusText)(report));
+                const action = await promptReadyAccountAction(prompter, active);
+                if (action === "done") {
+                    console.error("\nReload MCP in Cursor Settings if you changed the active account.");
+                    return readyResult(origin, "Connection ready.");
+                }
+                if (action === "add_same") {
+                    const previousActiveId = active.id;
+                    try {
+                        const finish = await runAddConnectionOnService(prompter, active.tokenServiceOrigin);
+                        if (!finish.success) {
+                            rollbackFailedNewConnection(previousActiveId);
+                            console.error(finish.message ?? "Setup failed.");
+                            continue;
+                        }
+                        await logFinishMeta();
+                    }
+                    catch (err) {
+                        rollbackFailedNewConnection(previousActiveId);
+                        console.error(err instanceof Error ? err.message : String(err));
+                        console.error("Setup paused. Start the Token Service and try again, or delete the incomplete account from the menu.");
+                    }
+                    continue;
+                }
+                if (action === "add_other") {
+                    const previousActiveId = active.id;
+                    try {
+                        const tokenServiceUrl = await promptTokenServiceUrl(prompter, options);
+                        const finish = await runAddConnectionOnService(prompter, tokenServiceUrl);
+                        if (!finish.success) {
+                            rollbackFailedNewConnection(previousActiveId);
+                            console.error(finish.message ?? "Setup failed.");
+                            continue;
+                        }
+                        await logFinishMeta();
+                    }
+                    catch (err) {
+                        rollbackFailedNewConnection(previousActiveId);
+                        console.error(err instanceof Error ? err.message : String(err));
+                        console.error("Setup paused. Start the Token Service and try again, or delete the incomplete account from the menu.");
+                    }
+                    continue;
+                }
+                if (action === "delete") {
+                    await promptDeleteConnection(prompter);
+                    continue;
+                }
+                if (action === "switch") {
+                    await promptSwitchConnection(prompter);
+                    continue;
+                }
+                if (action === "summary") {
+                    console.error(`\n${(0, dump_1.formatConnectionsSummaryText)()}\n`);
+                    continue;
+                }
+                if (action === "dump") {
+                    console.log((0, dump_1.formatConnectionDump)((0, dump_1.buildConnectionDump)()));
+                    continue;
+                }
+            }
+            if ((0, phase_1.listReadyConnectionIds)().length > 0) {
+                const incomplete = (0, store_1.getActiveConnection)();
+                if (!incomplete) {
+                    (0, promote_active_1.promoteReadyActiveConnection)();
+                    continue;
+                }
+                const incompleteAction = await promptIncompleteAccountAction(prompter, incomplete);
+                if (incompleteAction === "continue_setup") {
+                    try {
+                        await runEmailStep(prompter);
+                        await runPhoneStep(prompter);
+                        await runWalletStep(prompter);
+                        const finish = await runFinishStep(incomplete.tokenServiceOrigin, prompter);
+                        if (!finish.success) {
+                            console.error(finish.message ?? "Setup failed.");
+                        }
+                        else {
+                            await logFinishMeta();
+                        }
+                    }
+                    catch (err) {
+                        console.error(err instanceof Error ? err.message : String(err));
+                    }
+                    continue;
+                }
+                if (incompleteAction === "delete") {
+                    await promptDeleteConnection(prompter);
+                    (0, promote_active_1.promoteReadyActiveConnection)();
+                    continue;
+                }
+                if (incompleteAction === "switch_ready") {
+                    const promoted = (0, promote_active_1.promoteReadyActiveConnection)();
+                    if (promoted.label) {
+                        console.error(`Active account: ${promoted.label}`);
+                    }
+                    continue;
+                }
+                if (incompleteAction === "summary") {
+                    console.error(`\n${(0, dump_1.formatConnectionsSummaryText)()}\n`);
+                    continue;
+                }
+                if (incompleteAction === "dump") {
+                    console.log((0, dump_1.formatConnectionDump)((0, dump_1.buildConnectionDump)()));
+                    continue;
+                }
+            }
+            console.error("NeoZip Connect — interactive setup");
+            console.error("Complete this once in a terminal before starting the MCP server.\n");
+            try {
+                const finish = await runNewConnectionSetup(prompter, options);
+                if (!finish.success) {
+                    return finish;
+                }
+                await logFinishMeta();
+            }
+            catch (err) {
+                console.error(err instanceof Error ? err.message : String(err));
+                if ((0, phase_1.listReadyConnectionIds)().length > 0) {
+                    (0, promote_active_1.promoteReadyActiveConnection)();
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+    finally {
+        rl?.close();
+    }
+}
+//# sourceMappingURL=interactive.js.map