@amplitude/wizard 1.0.0-beta.0

package/dist/bin.js

@@ -0,0 +1,763 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver_1 = require("semver");
+const logging_1 = require("./src/utils/logging");
+const dotenv_1 = require("dotenv");
+(0, dotenv_1.config)();
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const zod_1 = require("zod");
+const WIZARD_VERSION = (() => {
+    // npm/pnpm set this when running via package scripts
+    if (process.env.npm_package_version)
+        return process.env.npm_package_version;
+    // Fallback: read package.json relative to this file
+    try {
+        const pkg = zod_1.z
+            .object({ version: zod_1.z.string().optional() })
+            .passthrough()
+            .parse(JSON.parse((0, fs_1.readFileSync)((0, path_1.resolve)((0, path_1.dirname)(__filename), '..', 'package.json'), 'utf-8')));
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+})();
+const NODE_VERSION_RANGE = '>=18.17.0';
+// Have to run this above the other imports because they are importing clack that
+// has the problematic imports.
+if (!(0, semver_1.satisfies)(process.version, NODE_VERSION_RANGE)) {
+    (0, logging_1.red)(`Amplitude wizard requires Node.js ${NODE_VERSION_RANGE}. You are using Node.js ${process.version}. Please upgrade your Node.js version.`);
+    process.exit(1);
+}
+const run_1 = require("./src/run");
+const environment_1 = require("./src/utils/environment");
+const ui_1 = require("./src/ui");
+const logging_ui_1 = require("./src/ui/logging-ui");
+const shell_completions_1 = require("./src/utils/shell-completions");
+const api_key_store_1 = require("./src/utils/api-key-store");
+if (process.env.NODE_ENV === 'test') {
+    void (async () => {
+        try {
+            const { server } = await import('./e2e-tests/mocks/server.js');
+            server.listen({
+                onUnhandledRequest: 'bypass',
+            });
+        }
+        catch {
+            // Mock server import failed - this can happen during non-E2E tests
+        }
+    })();
+}
+void (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    .env('AMPLITUDE_WIZARD')
+    // global options
+    .options({
+    debug: {
+        default: false,
+        describe: 'Enable verbose logging\nenv: AMPLITUDE_WIZARD_DEBUG',
+        type: 'boolean',
+    },
+    verbose: {
+        default: false,
+        describe: 'Print diagnostic info (working dir, config, etc.) to the log\nenv: AMPLITUDE_WIZARD_VERBOSE',
+        type: 'boolean',
+    },
+    default: {
+        default: true,
+        describe: 'Use default options for all prompts\nenv: AMPLITUDE_WIZARD_DEFAULT',
+        type: 'boolean',
+    },
+    signup: {
+        default: false,
+        describe: 'Create a new Amplitude account during setup\nenv: AMPLITUDE_WIZARD_SIGNUP',
+        type: 'boolean',
+    },
+    'local-mcp': {
+        default: false,
+        describe: 'Use local MCP server at http://localhost:8787/mcp\nenv: AMPLITUDE_WIZARD_LOCAL_MCP',
+        type: 'boolean',
+    },
+    ci: {
+        default: false,
+        describe: 'Enable CI mode for non-interactive execution\nenv: AMPLITUDE_WIZARD_CI',
+        type: 'boolean',
+    },
+    'api-key': {
+        describe: 'Amplitude API key for authentication\nenv: AMPLITUDE_WIZARD_API_KEY',
+        type: 'string',
+    },
+    'project-id': {
+        describe: 'Amplitude project ID to use (optional; when not set, uses default from API key or OAuth)\nenv: AMPLITUDE_WIZARD_PROJECT_ID',
+        type: 'string',
+    },
+})
+    .command(['$0'], 'Run the Amplitude setup wizard', (yargs) => {
+    return yargs.options({
+        'force-install': {
+            default: false,
+            describe: 'Force install packages even if peer dependency checks fail\nenv: AMPLITUDE_WIZARD_FORCE_INSTALL',
+            type: 'boolean',
+        },
+        'install-dir': {
+            describe: 'Directory to install Amplitude in\nenv: AMPLITUDE_WIZARD_INSTALL_DIR',
+            type: 'string',
+        },
+        integration: {
+            describe: 'Integration to set up',
+            choices: [
+                'nextjs',
+                'vue',
+                'react-router',
+                'django',
+                'flask',
+                'fastapi',
+                'javascript_web',
+                'javascript_node',
+                'python',
+            ],
+            type: 'string',
+        },
+        menu: {
+            default: false,
+            describe: 'Show menu for manual integration selection instead of auto-detecting\nenv: AMPLITUDE_WIZARD_MENU',
+            type: 'boolean',
+        },
+        benchmark: {
+            default: false,
+            describe: 'Run in benchmark mode with per-phase token tracking\nenv: AMPLITUDE_WIZARD_BENCHMARK',
+            type: 'boolean',
+        },
+    });
+}, (argv) => {
+    const options = { ...argv };
+    // CI mode validation and TTY check
+    if (options.ci) {
+        // Use LoggingUI for CI mode (no dependencies, no prompts)
+        (0, ui_1.setUI)(new logging_ui_1.LoggingUI());
+        if (!options.apiKey) {
+            (0, ui_1.getUI)().intro(chalk_1.default.inverse(`Amplitude Wizard`));
+            (0, ui_1.getUI)().log.error('CI mode requires --api-key (Amplitude project API key)');
+            process.exit(1);
+        }
+        if (!options.installDir) {
+            (0, ui_1.getUI)().intro(chalk_1.default.inverse(`Amplitude Wizard`));
+            (0, ui_1.getUI)().log.error('CI mode requires --install-dir (directory to install Amplitude in)');
+            process.exit(1);
+        }
+        void (0, run_1.runWizard)(options);
+    }
+    else if ((0, environment_1.isNonInteractiveEnvironment)()) {
+        // Non-interactive non-CI: error out
+        (0, ui_1.getUI)().intro(chalk_1.default.inverse(`Amplitude Wizard`));
+        (0, ui_1.getUI)().log.error('This installer requires an interactive terminal (TTY) to run.\n' +
+            'It appears you are running in a non-interactive environment.\n' +
+            'Please run the wizard in an interactive terminal.\n\n' +
+            'For CI/CD environments, use --ci mode:\n' +
+            '  npx @amplitude/wizard --ci --api-key <your-key> --install-dir .');
+        process.exit(1);
+    }
+    else {
+        // Interactive TTY: launch the Ink TUI
+        void (async () => {
+            // Silently install shell completions on first run.
+            const { installCompletions } = await import('./src/utils/shell-completions.js');
+            installCompletions();
+            try {
+                const { startTUI } = await import('./src/ui/tui/start-tui.js');
+                const { buildSession } = await import('./src/lib/wizard-session.js');
+                const tui = startTUI(WIZARD_VERSION);
+                // Build session from CLI args and attach to store
+                const session = buildSession({
+                    debug: options.debug,
+                    verbose: options.verbose,
+                    forceInstall: options.forceInstall,
+                    installDir: options.installDir,
+                    ci: false,
+                    signup: options.signup,
+                    localMcp: options.localMcp,
+                    apiKey: options.apiKey,
+                    menu: options.menu,
+                    integration: options.integration,
+                    benchmark: options.benchmark,
+                    projectId: options.projectId,
+                });
+                // If --api-key was provided, skip the OAuth/TUI auth flow entirely.
+                if (session.apiKey) {
+                    const { DEFAULT_HOST_URL } = await import('./src/lib/constants.js');
+                    session.credentials = {
+                        accessToken: session.apiKey,
+                        projectApiKey: session.apiKey,
+                        host: DEFAULT_HOST_URL,
+                        projectId: session.projectId ?? 0,
+                    };
+                    session.projectHasData = false;
+                }
+                else {
+                    // Pre-populate region + credentials from all available sources for
+                    // returning users. This skips RegionSelect and Auth without requiring
+                    // a persisted OAuth token.
+                    const installDir = session.installDir;
+                    const [{ getStoredUser, getStoredToken }, { readAmpliConfig }, { getAPIKey }, { getHostFromRegion }, { logToFile },] = await Promise.all([
+                        import('./src/utils/ampli-settings.js'),
+                        import('./src/lib/ampli-config.js'),
+                        import('./src/utils/get-api-key.js'),
+                        import('./src/utils/urls.js'),
+                        import('./src/utils/debug.js'),
+                    ]);
+                    // Zone: prefer a real (non-pending) stored user, fall back to
+                    // the Zone field in the project-level ampli.json.
+                    const storedUser = getStoredUser();
+                    const realUser = storedUser && storedUser.id !== 'pending' ? storedUser : null;
+                    const projectConfig = readAmpliConfig(installDir);
+                    const projectZone = projectConfig.ok
+                        ? projectConfig.config.Zone
+                        : undefined;
+                    const zone = realUser?.zone ?? projectZone ?? null;
+                    if (zone) {
+                        session.region = zone;
+                    }
+                    // Skip Auth when we have a stored OAuth token — use it to fetch
+                    // (or look up) the project API key, then pre-populate credentials.
+                    if (zone) {
+                        const storedToken = realUser
+                            ? getStoredToken(realUser.id, realUser.zone)
+                            : getStoredToken(undefined, zone);
+                        if (storedToken) {
+                            logToFile(`[bin] getAPIKey: zone=${zone} hasWorkspaceId=${!!session.selectedWorkspaceId}`);
+                            const projectApiKey = await getAPIKey({
+                                installDir,
+                                idToken: storedToken.idToken,
+                                zone,
+                                workspaceId: session.selectedWorkspaceId ?? undefined,
+                            });
+                            if (projectApiKey) {
+                                logToFile('[bin] getAPIKey: resolved project API key');
+                                (0, api_key_store_1.persistApiKey)(projectApiKey, installDir);
+                                session.credentials = {
+                                    accessToken: storedToken.idToken,
+                                    idToken: storedToken.idToken,
+                                    projectApiKey,
+                                    host: getHostFromRegion(zone),
+                                    projectId: 0,
+                                };
+                                // Pre-populate activationLevel so DataSetup is also skipped,
+                                // giving a single wipe from Intro → Run/Setup.
+                                // DataSetup would set 'none' anyway (projectId=0 prevents the
+                                // real check), so this is equivalent — just earlier.
+                                session.activationLevel = 'none';
+                                session.projectHasData = false;
+                            }
+                            else {
+                                logToFile('[bin] getAPIKey: returned null — showing apiKeyNotice');
+                                // Region is already pre-populated above; prompt for the
+                                // key manually with a hint about org-admin permissions.
+                                session.apiKeyNotice =
+                                    "Your API key couldn't be fetched automatically. " +
+                                        'Only organization admins can access project API keys — ' +
+                                        'if you need one, ask an admin to share it with you.';
+                            }
+                        }
+                    }
+                    // Pre-populate org/workspace from ampli.json so activation checks
+                    // (DataSetupScreen, DataIngestionCheckScreen) have the IDs they need
+                    // even when the SUSI flow was skipped.
+                    if (projectConfig.ok && projectConfig.config.OrgId) {
+                        session.selectedOrgId = String(projectConfig.config.OrgId);
+                    }
+                    if (projectConfig.ok && projectConfig.config.WorkspaceId) {
+                        session.selectedWorkspaceId = projectConfig.config.WorkspaceId;
+                    }
+                }
+                tui.store.session = session;
+                const { FRAMEWORK_REGISTRY } = await import('./src/lib/registry.js');
+                const { detectIntegration } = await import('./src/run.js');
+                const installDir = session.installDir ?? process.cwd();
+                // Verbose startup diagnostics — always written to the log file;
+                // visible in the RunScreen "Logs" tab.
+                if (session.verbose || session.debug) {
+                    const { enableDebugLogs, logToFile } = await import('./src/utils/debug.js');
+                    enableDebugLogs();
+                    logToFile('[verbose] Amplitude Wizard starting');
+                    logToFile(`[verbose] node          : ${process.version}`);
+                    logToFile(`[verbose] process.cwd() : ${process.cwd()}`);
+                    logToFile(`[verbose] installDir    : ${installDir}`);
+                    logToFile(`[verbose] platform      : ${process.platform}`);
+                    logToFile(`[verbose] argv          : ${process.argv.join(' ')}`);
+                }
+                const { DETECTION_TIMEOUT_MS } = await import('./src/lib/constants.js');
+                // ── OAuth + account setup ──────────────────────────────
+                // Runs concurrently with framework detection while AuthScreen shows.
+                // When OAuth completes, store.setOAuthComplete() triggers the
+                // AuthScreen SUSI pickers (org → workspace → API key).
+                // AuthScreen calls store.setCredentials() when done, advancing the
+                // router past Auth → RegionSelect → DataSetup → to IntroScreen.
+                const authTask = (async () => {
+                    // Skip the full OAuth + SUSI flow when credentials were pre-populated
+                    // from ~/.ampli.json + the saved API key (returning user).
+                    if (tui.store.session.credentials !== null)
+                        return;
+                    try {
+                        const { ampliConfigExists } = await import('./src/lib/ampli-config.js');
+                        const { performAmplitudeAuth } = await import('./src/utils/oauth.js');
+                        const { fetchAmplitudeUser } = await import('./src/lib/api.js');
+                        const { DEFAULT_AMPLITUDE_ZONE } = await import('./src/lib/constants.js');
+                        const { storeToken } = await import('./src/utils/ampli-settings.js');
+                        const forceFresh = !ampliConfigExists(installDir);
+                        // Wait for the user to pick a region (or for it to be pre-populated
+                        // from ~/.ampli.json for returning users) before opening the OAuth URL,
+                        // since the auth endpoint differs between US and EU.
+                        await new Promise((resolve) => {
+                            if (tui.store.session.region !== null) {
+                                resolve();
+                                return;
+                            }
+                            const unsub = tui.store.subscribe(() => {
+                                if (tui.store.session.region !== null) {
+                                    unsub();
+                                    resolve();
+                                }
+                            });
+                        });
+                        const zone = tui.store.session.region === 'eu'
+                            ? 'eu'
+                            : DEFAULT_AMPLITUDE_ZONE;
+                        let auth = await performAmplitudeAuth({
+                            zone,
+                            forceFresh,
+                        });
+                        // Update login URL (clears the "copy this URL" hint)
+                        tui.store.setLoginUrl(null);
+                        // Zone was already selected by the user before OAuth started.
+                        const cloudRegion = zone;
+                        let userInfo;
+                        try {
+                            userInfo = await fetchAmplitudeUser(auth.idToken, cloudRegion);
+                        }
+                        catch {
+                            // Token may be expired — re-open the browser for a fresh login
+                            tui.store.setLoginUrl(null);
+                            auth = await performAmplitudeAuth({ zone, forceFresh: true });
+                            userInfo = await fetchAmplitudeUser(auth.idToken, cloudRegion);
+                        }
+                        // Persist to ~/.ampli.json
+                        storeToken({
+                            id: userInfo.id,
+                            firstName: userInfo.firstName,
+                            lastName: userInfo.lastName,
+                            email: userInfo.email,
+                            zone: auth.zone,
+                        }, {
+                            accessToken: auth.accessToken,
+                            idToken: auth.idToken,
+                            refreshToken: auth.refreshToken,
+                            expiresAt: new Date(Date.now() + 3600 * 1000).toISOString(),
+                        });
+                        // Signal AuthScreen — triggers org/workspace/API key pickers
+                        tui.store.setOAuthComplete({
+                            accessToken: auth.accessToken,
+                            idToken: auth.idToken,
+                            cloudRegion,
+                            orgs: userInfo.orgs,
+                        });
+                    }
+                    catch (err) {
+                        // Auth failure is non-fatal here — agent-runner will retry/handle it
+                        if (process.env.DEBUG || process.env.AMPLITUDE_WIZARD_DEBUG) {
+                            console.error('OAuth setup error:', err);
+                        }
+                    }
+                })();
+                // ── Framework detection ────────────────────────────────
+                // Runs concurrently with auth while AuthScreen shows.
+                const detectionTask = (async () => {
+                    const detectedIntegration = await Promise.race([
+                        detectIntegration(installDir),
+                        new Promise((resolve) => setTimeout(() => resolve(undefined), DETECTION_TIMEOUT_MS)),
+                    ]);
+                    if (detectedIntegration) {
+                        const config = FRAMEWORK_REGISTRY[detectedIntegration];
+                        // Run gatherContext for the friendly variant label
+                        if (config.metadata.gatherContext) {
+                            try {
+                                const context = await Promise.race([
+                                    config.metadata.gatherContext({
+                                        installDir,
+                                        debug: session.debug,
+                                        forceInstall: session.forceInstall,
+                                        default: false,
+                                        signup: session.signup,
+                                        localMcp: session.localMcp,
+                                        ci: session.ci,
+                                        menu: session.menu,
+                                        benchmark: session.benchmark,
+                                    }),
+                                    new Promise((resolve) => setTimeout(() => resolve({}), DETECTION_TIMEOUT_MS)),
+                                ]);
+                                for (const [key, value] of Object.entries(context)) {
+                                    if (!(key in session.frameworkContext)) {
+                                        tui.store.setFrameworkContext(key, value);
+                                    }
+                                }
+                            }
+                            catch {
+                                // Detection failed — will show generic name
+                            }
+                        }
+                        tui.store.setFrameworkConfig(detectedIntegration, config);
+                        if (!session.detectedFrameworkLabel) {
+                            tui.store.setDetectedFramework(config.metadata.name);
+                        }
+                    }
+                    // Feature discovery — deterministic scan of package.json deps
+                    try {
+                        const { readFileSync } = await import('fs');
+                        const pkgPath = (0, path_1.join)(installDir, 'package.json');
+                        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                        const allDeps = {
+                            ...pkg.dependencies,
+                            ...pkg.devDependencies,
+                        };
+                        const depNames = Object.keys(allDeps);
+                        const { DiscoveredFeature } = await import('./src/lib/wizard-session.js');
+                        if (depNames.some((d) => ['stripe', '@stripe/stripe-js'].includes(d))) {
+                            tui.store.addDiscoveredFeature(DiscoveredFeature.Stripe);
+                        }
+                        // LLM SDK detection — sourced from Amplitude LLM analytics skill
+                        const LLM_PACKAGES = [
+                            'openai',
+                            '@anthropic-ai/sdk',
+                            'ai',
+                            '@ai-sdk/openai',
+                            'langchain',
+                            '@langchain/openai',
+                            '@langchain/langgraph',
+                            '@google/generative-ai',
+                            '@google/genai',
+                            '@instructor-ai/instructor',
+                            '@mastra/core',
+                            'portkey-ai',
+                        ];
+                        if (depNames.some((d) => LLM_PACKAGES.includes(d))) {
+                            tui.store.addDiscoveredFeature(DiscoveredFeature.LLM);
+                        }
+                    }
+                    catch {
+                        // No package.json or parse error — skip feature discovery
+                    }
+                    // Signal detection is done — IntroScreen shows picker or results
+                    tui.store.setDetectionComplete();
+                })();
+                // Gate runWizard on the user reaching RunScreen — at that point
+                // auth, data check, and any setup questions are all complete.
+                const { Screen } = await import('./src/ui/tui/router.js');
+                tui.store.onEnterScreen(Screen.Run, () => tui.store.completeSetup());
+                // Wait for auth and framework detection to finish concurrently.
+                await Promise.all([authTask, detectionTask]);
+                if (session.verbose || session.debug) {
+                    const { logToFile } = await import('./src/utils/debug.js');
+                    logToFile(`[verbose] detection    : ${tui.store.session.integration ?? 'none'}`);
+                    logToFile(`[verbose] framework    : ${tui.store.session.detectedFrameworkLabel ?? 'unknown'}`);
+                    logToFile(`[verbose] region       : ${tui.store.session.region ?? 'not set'}`);
+                }
+                // Blocks until onEnterScreen(Screen.Run) fires completeSetup().
+                await tui.waitForSetup();
+                // Before calling the AI agent, do a quick static check to see if
+                // Amplitude is already installed in the project. If so, skip the
+                // agent entirely and advance directly to MCP setup.
+                const { detectAmplitudeInProject } = await import('./src/lib/detect-amplitude.js');
+                const localDetection = detectAmplitudeInProject(installDir);
+                if (localDetection.confidence !== 'none') {
+                    const { logToFile: log } = await import('./src/utils/debug.js');
+                    log(`[bin] Amplitude already detected (${localDetection.reason ?? 'unknown'}) — skipping agent`);
+                    const { RunPhase, OutroKind } = await import('./src/lib/wizard-session.js');
+                    tui.store.setAmplitudePreDetected();
+                    tui.store.setOutroData({ kind: OutroKind.Success });
+                    tui.store.setRunPhase(RunPhase.Completed);
+                }
+                else {
+                    await (0, run_1.runWizard)(options, tui.store.session);
+                }
+                // Keep the outro screen visible — let process.exit() handle cleanup
+            }
+            catch (err) {
+                // TUI unavailable (e.g., in test environment) — continue with default UI
+                if (process.env.DEBUG || process.env.AMPLITUDE_WIZARD_DEBUG) {
+                    console.error('TUI init failed:', err);
+                }
+                await (0, run_1.runWizard)(options);
+            }
+        })();
+    }
+})
+    .command('login', 'Log in to your Amplitude account', (yargs) => {
+    return yargs.options({
+        zone: {
+            describe: 'Amplitude data center zone (us or eu)',
+            choices: ['us', 'eu'],
+            default: 'us',
+            type: 'string',
+        },
+    });
+}, (argv) => {
+    void (async () => {
+        (0, ui_1.setUI)(new logging_ui_1.LoggingUI());
+        const { performAmplitudeAuth } = await import('./src/utils/oauth.js');
+        const { fetchAmplitudeUser } = await import('./src/lib/api.js');
+        const { storeToken } = await import('./src/utils/ampli-settings.js');
+        const zone = argv.zone;
+        try {
+            const { getStoredUser, getStoredToken } = await import('./src/utils/ampli-settings.js');
+            // If a valid cached session exists, display the stored user without
+            // re-fetching from the API (the cached idToken may be expired).
+            const cachedToken = getStoredToken(undefined, zone);
+            const cachedUser = cachedToken ? getStoredUser() : undefined;
+            if (cachedUser && cachedUser.id !== 'pending') {
+                console.log(chalk_1.default.green(`✔ Already logged in as ${cachedUser.firstName} ${cachedUser.lastName} <${cachedUser.email}>`));
+                if (cachedUser.zone !== 'us') {
+                    console.log(chalk_1.default.dim(`  Zone: ${cachedUser.zone}`));
+                }
+                process.exit(0);
+            }
+            const auth = await performAmplitudeAuth({ zone });
+            const user = await fetchAmplitudeUser(auth.idToken, auth.zone);
+            storeToken({
+                id: user.id,
+                firstName: user.firstName,
+                lastName: user.lastName,
+                email: user.email,
+                zone: auth.zone,
+            }, {
+                accessToken: auth.accessToken,
+                idToken: auth.idToken,
+                refreshToken: auth.refreshToken,
+                expiresAt: new Date(Date.now() + 3600 * 1000).toISOString(),
+            });
+            console.log(chalk_1.default.green(`✔ Logged in as ${user.firstName} ${user.lastName} <${user.email}>`));
+            if (user.orgs.length > 0) {
+                console.log(chalk_1.default.dim(`  Org: ${user.orgs.map((o) => o.name).join(', ')}`));
+            }
+            process.exit(0);
+        }
+        catch (e) {
+            console.error(chalk_1.default.red(`Login failed: ${e instanceof Error ? e.message : String(e)}`));
+            process.exit(1);
+        }
+    })();
+})
+    .command('logout', 'Log out of your Amplitude account', () => { }, (argv) => {
+    void (async () => {
+        const { getStoredUser, clearStoredCredentials } = await import('./src/utils/ampli-settings.js');
+        const { clearApiKey } = await import('./src/utils/api-key-store.js');
+        const installDir = argv.installDir ?? process.cwd();
+        const user = getStoredUser();
+        try {
+            clearStoredCredentials();
+            clearApiKey(installDir);
+            if (user) {
+                console.log(chalk_1.default.green(`✔ Logged out ${user.email}`));
+            }
+            else {
+                console.log(chalk_1.default.dim('No active session found.'));
+            }
+        }
+        catch {
+            console.log(chalk_1.default.dim('No active session found.'));
+        }
+        process.exit(0);
+    })();
+})
+    .command('whoami', 'Show the currently logged-in Amplitude account', () => { }, (_argv) => {
+    void (async () => {
+        const { getStoredUser, getStoredToken } = await import('./src/utils/ampli-settings.js');
+        const user = getStoredUser();
+        const token = getStoredToken();
+        if (user && token && user.id !== 'pending') {
+            console.log(`Logged in as ${chalk_1.default.bold(user.firstName + ' ' + user.lastName)} <${user.email}>`);
+            if (user.zone !== 'us')
+                console.log(chalk_1.default.dim(`Zone: ${user.zone}`));
+        }
+        else {
+            console.log(chalk_1.default.yellow('Not logged in. Run `amplitude-wizard login` to authenticate.'));
+        }
+        process.exit(0);
+    })();
+})
+    .command('slack', 'Set up Amplitude Slack integration', (y) => y, (argv) => {
+    void (async () => {
+        try {
+            const { startTUI } = await import('./src/ui/tui/start-tui.js');
+            const { buildSession } = await import('./src/lib/wizard-session.js');
+            const { Flow } = await import('./src/ui/tui/router.js');
+            const { getStoredUser, getStoredToken } = await import('./src/utils/ampli-settings.js');
+            const { getHostFromRegion } = await import('./src/utils/urls.js');
+            const session = buildSession({
+                debug: typeof argv['debug'] === 'boolean' ? argv['debug'] : undefined,
+            });
+            // Pre-populate credentials from ~/.ampli.json so SlackScreen can
+            // resolve the org name via fetchAmplitudeUser.
+            const storedUser = getStoredUser();
+            const zone = storedUser?.zone ?? 'us';
+            const storedToken = getStoredToken(storedUser?.id, zone);
+            if (storedToken) {
+                session.region = zone;
+                session.credentials = {
+                    accessToken: storedToken.idToken,
+                    projectApiKey: '',
+                    host: getHostFromRegion(zone),
+                    projectId: 0,
+                };
+            }
+            // Pass the pre-populated session so it's available before the first render.
+            startTUI(WIZARD_VERSION, Flow.SlackSetup, session);
+        }
+        catch {
+            (0, ui_1.setUI)(new logging_ui_1.LoggingUI());
+            const { getCloudUrlFromRegion } = await import('./src/utils/urls.js');
+            const opn = (await import('opn')).default;
+            const url = `${getCloudUrlFromRegion('us')}/settings/profile`;
+            (0, ui_1.getUI)().log.info(`Opening Amplitude Settings to connect Slack: ${url}`);
+            await opn(url, { wait: false });
+        }
+    })();
+})
+    .command('region', 'Switch data-center region (US or EU)', (y) => y, (argv) => {
+    void (async () => {
+        try {
+            const { startTUI } = await import('./src/ui/tui/start-tui.js');
+            const { buildSession } = await import('./src/lib/wizard-session.js');
+            const { Flow } = await import('./src/ui/tui/router.js');
+            const { getStoredUser, getStoredToken, updateStoredUserZone } = await import('./src/utils/ampli-settings.js');
+            const { getHostFromRegion } = await import('./src/utils/urls.js');
+            const session = buildSession({
+                debug: typeof argv['debug'] === 'boolean' ? argv['debug'] : undefined,
+            });
+            // Show the "Switch data-center region" variant of RegionSelectScreen.
+            session.regionForced = true;
+            // Pre-populate credentials from ~/.ampli.json so the screen has context.
+            const storedUser = getStoredUser();
+            const zone = storedUser?.zone ?? 'us';
+            const storedToken = getStoredToken(storedUser?.id, zone);
+            if (storedToken) {
+                session.credentials = {
+                    accessToken: storedToken.idToken,
+                    projectApiKey: '',
+                    host: getHostFromRegion(zone),
+                    projectId: 0,
+                };
+            }
+            const tui = startTUI(WIZARD_VERSION, Flow.RegionSelect, session);
+            // Wait for the user to pick a region, then persist and exit.
+            const pickedRegion = await new Promise((resolve) => {
+                const unsub = tui.store.subscribe(() => {
+                    const s = tui.store.session;
+                    if (s.region !== null && !s.regionForced) {
+                        unsub();
+                        resolve(s.region);
+                    }
+                });
+            });
+            const updated = updateStoredUserZone(pickedRegion);
+            if (updated) {
+                console.log(chalk_1.default.green(`\n✔ Region updated to ${pickedRegion.toUpperCase()}`));
+            }
+            else {
+                console.log(chalk_1.default.dim(`\nRegion set to ${pickedRegion.toUpperCase()}. Run \`amplitude-wizard login\` to authenticate.`));
+            }
+            process.exit(0);
+        }
+        catch {
+            (0, ui_1.setUI)(new logging_ui_1.LoggingUI());
+            (0, ui_1.getUI)().log.error('Could not start region picker. Use --zone with `amplitude-wizard login` to set your region.');
+            process.exit(1);
+        }
+    })();
+})
+    .command('mcp <command>', 'MCP server management commands', (yargs) => {
+    return yargs
+        .command('add', 'Install Amplitude MCP server to supported clients', (yargs) => {
+        return yargs.options({
+            local: {
+                default: false,
+                describe: 'Add local development MCP server (http://localhost:8787)',
+                type: 'boolean',
+            },
+        });
+    }, (argv) => {
+        const options = { ...argv };
+        void (async () => {
+            try {
+                const { startTUI } = await import('./src/ui/tui/start-tui.js');
+                const { buildSession } = await import('./src/lib/wizard-session.js');
+                const { Flow } = await import('./src/ui/tui/router.js');
+                const tui = startTUI(WIZARD_VERSION, Flow.McpAdd);
+                const session = buildSession({
+                    debug: options.debug,
+                    localMcp: options.local,
+                });
+                tui.store.session = session;
+            }
+            catch {
+                // TUI unavailable — fallback to logging
+                (0, ui_1.setUI)(new logging_ui_1.LoggingUI());
+                const { addMCPServerToClientsStep } = await import('./src/steps/add-mcp-server-to-clients/index.js');
+                await addMCPServerToClientsStep({
+                    local: options.local,
+                });
+            }
+        })();
+    })
+        .command('remove', 'Remove Amplitude MCP server from supported clients', (yargs) => {
+        return yargs.options({
+            local: {
+                default: false,
+                describe: 'Remove local development MCP server (http://localhost:8787)',
+                type: 'boolean',
+            },
+        });
+    }, (argv) => {
+        const options = { ...argv };
+        void (async () => {
+            try {
+                const { startTUI } = await import('./src/ui/tui/start-tui.js');
+                const { buildSession } = await import('./src/lib/wizard-session.js');
+                const { Flow } = await import('./src/ui/tui/router.js');
+                const tui = startTUI(WIZARD_VERSION, Flow.McpRemove);
+                const session = buildSession({
+                    debug: options.debug,
+                    localMcp: options.local,
+                });
+                tui.store.session = session;
+            }
+            catch {
+                // TUI unavailable — fallback to logging
+                (0, ui_1.setUI)(new logging_ui_1.LoggingUI());
+                const { removeMCPServerFromClientsStep } = await import('./src/steps/add-mcp-server-to-clients/index.js');
+                await removeMCPServerFromClientsStep({
+                    local: options.local,
+                });
+            }
+        })();
+    })
+        .demandCommand(1, 'You must specify a subcommand (add or remove)')
+        .help();
+})
+    .command('completion', 'Print shell completion script\n(add `eval "$(amplitude-wizard completion)"` to ~/.zshrc or ~/.bashrc)', () => { }, () => {
+    const script = (process.env.SHELL ?? '').endsWith('zsh')
+        ? shell_completions_1.ZSH_COMPLETION_SCRIPT
+        : shell_completions_1.BASH_COMPLETION_SCRIPT;
+    process.stdout.write(script + '\n');
+    process.exit(0);
+})
+    .help()
+    .alias('help', 'h')
+    .version()
+    .alias('version', 'v')
+    .wrap(process.stdout.isTTY ? yargs_1.default.terminalWidth() : 80).argv;