workos 0.18.0 → 0.19.0

package/dist/lib/adapters/cli-adapter.js

@@ -1,14 +1,15 @@
-import clack from '../../utils/clack.js';
+import { relative } from 'node:path';
+import ui, { PromptUnavailableError } from '../../utils/ui.js';
 import chalk from 'chalk';
 import { getConfig } from '../settings.js';
 import { ProgressTracker } from '../progress-tracker.js';
-import { renderCompletionSummary } from '../../utils/summary-box.js';
+import { renderCompletionSummary, renderBrandMark } from '../../utils/summary-box.js';
 import { formatWorkOSCommand } from '../../utils/command-invocation.js';
 /**
- * CLI adapter that renders wizard events via clack.
+ * CLI adapter that renders wizard events via ui.
  *
  * Subscribes to InstallerEventEmitter and translates events into
- * clack UI operations (logs, spinners, prompts).
+ * UI facade operations (logs, spinners, prompts).
  */
 export class CLIAdapter {
     emitter;
@@ -27,8 +28,15 @@ export class CLIAdapter {
     pendingLogs = [];
     // SIGINT handler for cleanup
     sigIntHandler = null;
-    // Long-running agent update interval
-    agentUpdateInterval = null;
+    // Aborts in-flight/queued prompts when the run ends (cancellation, ctrl-c).
+    // The installer's `preparing` state can queue a second prompt behind a live
+    // one (git-dirty + protected-branch); if the first is cancelled, this signal
+    // stops the queued sibling from opening a now-moot question.
+    promptAbort = null;
+    // Last phase message shown on the agent spinner, restored after logging above it.
+    lastAgentMessage = 'Running AI agent...';
+    // Last file path rendered as a step line, to dedupe consecutive same-path ops.
+    lastFileOp = null;
     constructor(config) {
         this.emitter = config.emitter;
         this.sendEvent = config.sendEvent;
@@ -52,29 +60,47 @@ export class CLIAdapter {
         const logs = this.pendingLogs.splice(0);
         logs.forEach((fn) => fn());
     }
+    /**
+     * Run a prompt with the log queue engaged: mark a prompt active so async log
+     * events (detection:complete, branch:created, …) buffer instead of scribbling
+     * over the question, then release and flush once it resolves. Wraps every
+     * prompt handler so the active/flush lifecycle lives in one place.
+     */
+    async withPromptActive(run) {
+        this.isPromptActive = true;
+        try {
+            return await run();
+        }
+        finally {
+            this.isPromptActive = false;
+            this.flushPendingLogs();
+        }
+    }
     async start() {
         if (this.isStarted)
             return;
         this.isStarted = true;
+        this.promptAbort = new AbortController();
         // Show intro
         const config = getConfig();
         if (config.branding.showAsciiArt) {
-            const art = config.branding.useCompact ? config.branding.compactAsciiArt : config.branding.asciiArt;
-            console.log(chalk.cyan(art));
-            console.log();
+            // Compact brand mark (the lock + wordmark) instead of the full block banner.
+            console.log('');
+            console.log(renderBrandMark('AuthKit installer'));
+            console.log('');
         }
         else {
-            clack.intro('Welcome to the WorkOS AuthKit installer');
+            ui.intro('WorkOS', 'AuthKit installer');
         }
         // Handle Ctrl+C gracefully
         const handleSigInt = () => {
+            this.promptAbort?.abort();
             if (this.spinner) {
                 this.spinner.stop('Cancelled');
                 this.spinner = null;
             }
-            this.stopAgentUpdates();
-            clack.log.warn('Installer cancelled');
-            clack.outro('Your project was not modified');
+            ui.log.warn('Installer cancelled');
+            ui.outro('Your project was not modified');
             process.exit(0);
         };
         process.on('SIGINT', handleSigInt);
@@ -93,12 +119,19 @@ export class CLIAdapter {
         this.subscribe('credentials:env:prompt', this.handleEnvScanPrompt);
         this.subscribe('device:started', this.handleDeviceStarted);
         this.subscribe('device:success', this.handleDeviceSuccess);
+        this.subscribe('device:error', this.handleDeviceError);
+        this.subscribe('device:timeout', this.handleDeviceTimeout);
         this.subscribe('staging:fetching', this.handleStagingFetching);
         this.subscribe('staging:success', this.handleStagingSuccess);
+        this.subscribe('staging:error', this.handleStagingError);
         this.subscribe('credentials:env:found', this.handleEnvCredentialsFound);
         this.subscribe('config:complete', this.handleConfigComplete);
         this.subscribe('agent:start', this.handleAgentStart);
         this.subscribe('agent:progress', this.handleAgentProgress);
+        // Persistent, append-only log of file operations + tool calls above the spinner.
+        this.subscribe('file:write', this.handleFileWrite);
+        this.subscribe('file:edit', this.handleFileEdit);
+        this.subscribe('agent:tool', this.handleAgentTool);
         this.subscribe('validation:start', this.handleValidationStart);
         this.subscribe('validation:issues', this.handleValidationIssues);
         this.subscribe('validation:complete', this.handleValidationComplete);
@@ -130,13 +163,15 @@ export class CLIAdapter {
     async stop() {
         if (!this.isStarted)
             return;
+        // Abort any in-flight/queued prompt so a cancelled run can't leave a
+        // now-moot sibling question open (e.g. the branch prompt after git-cancel).
+        this.promptAbort?.abort();
+        this.promptAbort = null;
         // Remove SIGINT handler
         if (this.sigIntHandler) {
             process.off('SIGINT', this.sigIntHandler);
             this.sigIntHandler = null;
         }
-        // Stop agent updates
-        this.stopAgentUpdates();
         // Unsubscribe from all events
         for (const [event, handler] of this.handlers) {
             this.emitter.off(event, handler);
@@ -147,15 +182,9 @@ export class CLIAdapter {
         this.spinner = null;
         this.isStarted = false;
     }
-    stopAgentUpdates = () => {
-        if (this.agentUpdateInterval) {
-            clearInterval(this.agentUpdateInterval);
-            this.agentUpdateInterval = null;
-        }
-    };
-    stopSpinner(message) {
+    stopSpinner(message, code = 0) {
         if (this.spinner) {
-            this.spinner.stop(message);
+            this.spinner.stop(message, code);
             this.spinner = null;
         }
     }
@@ -170,9 +199,43 @@ export class CLIAdapter {
      */
     subscribe(event, handler) {
         const boundHandler = handler.bind(this);
-        this.handlers.set(event, boundHandler);
-        this.emitter.on(event, boundHandler);
+        // Handlers are invoked fire-and-forget by a plain EventEmitter, so an async
+        // rejection would become an unhandledRejection (silent crash). Route a
+        // PromptUnavailableError (prompt attempted where the user can't answer) to a
+        // clean fail-fast; re-surface anything else unchanged so real bugs still crash.
+        const safeHandler = (payload) => {
+            try {
+                const result = boundHandler(payload);
+                if (result instanceof Promise)
+                    result.catch((err) => this.onHandlerError(err));
+            }
+            catch (err) {
+                this.onHandlerError(err);
+            }
+        };
+        this.handlers.set(event, safeHandler);
+        this.emitter.on(event, safeHandler);
     }
+    /**
+     * Terminal handler failure. A PromptUnavailableError means we reached a prompt
+     * in a context that can't answer it (non-TTY stdin) — the CLIAdapter only runs
+     * in human, non-JSON output, so this is always a real human at a broken input,
+     * never a JSON stream. Surface a clear message and exit before anything is
+     * written, rather than hanging or crashing. Re-throw anything else.
+     */
+    onHandlerError = (error) => {
+        if (error instanceof PromptUnavailableError) {
+            this.spinner?.clear();
+            this.spinner = null;
+            ui.log.error(error.message);
+            ui.log.hint('Re-run in an interactive terminal, or pass the flags that answer these prompts.');
+            // Exit 1 (general error), matching the direct-command classification of
+            // this same error in bin.ts. NOT 4 — that's "auth required" (gh
+            // convention), which would send scripts into an auth-retry loop.
+            process.exit(1);
+        }
+        throw error;
+    };
     // ===== Event Handlers =====
     handleStateEnter = ({ state }) => {
         this.progress.enterPhase(state);
@@ -181,39 +244,36 @@ export class CLIAdapter {
         this.progress.exitPhase(state);
     };
     handleAuthSuccess = () => {
-        clack.log.success('Authenticated');
+        ui.log.success('Authenticated');
     };
     handleAuthFailure = ({ message }) => {
-        clack.log.error(`Auth failed: ${message}`);
-        clack.log.info('Visit https://dashboard.workos.com to verify your account');
+        ui.log.error(`Auth failed: ${message}`);
+        ui.log.info('Visit https://dashboard.workos.com to verify your account');
     };
     handleDetectionComplete = ({ integration }) => {
-        this.queueableLog(() => clack.log.success(`Detected ${chalk.bold(integration)}`));
+        this.queueableLog(() => ui.log.success(`Detected ${chalk.bold(integration)}`));
     };
     handleDetectionNone = () => {
-        this.queueableLog(() => clack.log.warn('Could not detect framework automatically'));
+        this.queueableLog(() => ui.log.warn('Could not detect framework automatically'));
     };
     handleCredentialsFound = () => {
-        clack.log.success('Found existing WorkOS credentials in .env.local');
+        ui.log.success('Found existing WorkOS credentials in .env.local');
     };
     handleEnvScanPrompt = async ({ files }) => {
-        this.isPromptActive = true;
         const fileList = files.length === 1 ? files[0] : files.slice(0, 2).join(', ');
-        const confirmed = await clack.confirm({
+        const confirmed = await this.withPromptActive(() => ui.confirm({
             message: `Found ${fileList}. Check for existing WorkOS credentials?`,
             initialValue: true,
-        });
-        this.isPromptActive = false;
-        this.flushPendingLogs();
+        }));
         this.sendEvent({
-            type: clack.isCancel(confirmed) || !confirmed ? 'ENV_SCAN_DECLINED' : 'ENV_SCAN_APPROVED',
+            type: ui.isCancel(confirmed) || !confirmed ? 'ENV_SCAN_DECLINED' : 'ENV_SCAN_APPROVED',
         });
     };
     handleDeviceStarted = ({ verificationUri, userCode }) => {
-        clack.log.info(`\nOpen this URL in your browser:\n`);
+        ui.log.info(`\nOpen this URL in your browser:\n`);
         console.log(`  ${chalk.cyan(verificationUri)}`);
         console.log(`\nEnter code: ${chalk.bold(userCode)}\n`);
-        this.spinner = clack.spinner();
+        this.spinner = ui.spinner();
         this.spinner.start('Waiting for authentication...');
     };
     handleDeviceSuccess = () => {
@@ -223,36 +283,65 @@ export class CLIAdapter {
         if (this.spinner) {
             this.spinner.stop('Authenticated');
         }
-        this.spinner = clack.spinner();
+        this.spinner = ui.spinner();
         this.spinner.start('Fetching your WorkOS credentials...');
     };
-    handleStagingSuccess = () => {
-        this.stopSpinner('Credentials fetched');
-        clack.log.success('WorkOS credentials retrieved automatically');
+    handleStagingSuccess = ({ source }) => {
+        if (source === 'device') {
+            this.stopSpinner('Environment ready');
+            ui.log.success('Set up a WorkOS environment for this install');
+        }
+        else if (source === 'stored') {
+            this.stopSpinner('Using active environment');
+            ui.log.success('Using your active WorkOS environment');
+        }
+        else {
+            this.stopSpinner('Environment ready');
+            ui.log.success('Using your WorkOS environment');
+        }
     };
     handleEnvCredentialsFound = ({ sourcePath }) => {
-        clack.log.success(`Found existing WorkOS credentials in ${sourcePath}`);
+        ui.log.success(`Found existing WorkOS credentials in ${sourcePath}`);
+    };
+    // Automatic auth / credential fetch can fail and fall back to manual entry.
+    // These finalize the spinner with a failure glyph so it isn't left spinning
+    // (orphaned) over the manual-credentials prompt that follows.
+    handleDeviceError = ({ message }) => {
+        this.stopSpinner('Automatic sign-in failed', 1);
+        if (this.debug)
+            this.debugLog(`[device:error] ${message}`);
+    };
+    handleDeviceTimeout = () => {
+        this.stopSpinner('Sign-in timed out', 1);
+    };
+    handleStagingError = ({ message }) => {
+        this.stopSpinner('Could not fetch WorkOS credentials', 1);
+        if (this.debug)
+            this.debugLog(`[staging:error] ${message}`);
     };
     handleGitDirty = async ({ files }) => {
-        clack.log.warn('You have uncommitted or untracked files:');
-        files.slice(0, 5).forEach((f) => clack.log.info(chalk.dim(`  ${f}`)));
+        ui.log.warn('You have uncommitted or untracked files:');
+        files.slice(0, 5).forEach((f) => ui.log.info(chalk.dim(`  ${f}`)));
         if (files.length > 5) {
-            clack.log.info(chalk.dim(`  ... and ${files.length - 5} more`));
+            ui.log.info(chalk.dim(`  ... and ${files.length - 5} more`));
         }
-        this.isPromptActive = true;
-        const confirmed = await clack.confirm({
+        const confirmed = await this.withPromptActive(() => ui.confirm({
             message: 'Continue anyway?',
             initialValue: false,
-        });
-        this.isPromptActive = false;
-        this.flushPendingLogs();
+            signal: this.promptAbort?.signal,
+        }));
         this.sendEvent({
-            type: clack.isCancel(confirmed) || !confirmed ? 'GIT_CANCELLED' : 'GIT_CONFIRMED',
+            type: ui.isCancel(confirmed) || !confirmed ? 'GIT_CANCELLED' : 'GIT_CONFIRMED',
         });
     };
     handleCredentialsRequest = async ({ requiresApiKey, }) => {
-        clack.log.step(`Get your credentials from ${chalk.cyan('https://dashboard.workos.com')}`);
-        const clientId = await clack.text({
+        // Guaranteed chokepoint: promptingManual is the fallback for any auth path,
+        // so clear any still-running spinner before the prompt opens (defense in
+        // depth on top of the device/staging error handlers and withPrompt's pause).
+        this.spinner?.clear();
+        this.spinner = null;
+        ui.log.step(`Get your credentials from ${chalk.cyan('https://dashboard.workos.com')}`);
+        const clientId = await ui.text({
             message: 'Enter your WorkOS Client ID:',
             placeholder: 'client_...',
             validate: (value) => {
@@ -265,14 +354,14 @@ export class CLIAdapter {
                 return undefined;
             },
         });
-        if (clack.isCancel(clientId)) {
+        if (ui.isCancel(clientId)) {
             this.sendEvent({ type: 'CANCEL' });
             return;
         }
         let apiKey = '';
         if (requiresApiKey) {
-            clack.log.info(chalk.dim('ℹ️ Your API key will be hidden for security and saved to .env.local'));
-            const apiKeyResult = await clack.password({
+            ui.log.info(chalk.dim('ℹ️ Your API key will be hidden for security and saved to .env.local'));
+            const apiKeyResult = await ui.password({
                 message: 'Enter your WorkOS API Key:',
                 validate: (value) => {
                     if (!value || value.trim().length === 0) {
@@ -284,14 +373,14 @@ export class CLIAdapter {
                     return undefined;
                 },
             });
-            if (clack.isCancel(apiKeyResult)) {
+            if (ui.isCancel(apiKeyResult)) {
                 this.sendEvent({ type: 'CANCEL' });
                 return;
             }
             apiKey = apiKeyResult;
         }
         else {
-            clack.log.info(chalk.dim('ℹ️ Client-only SDK - API key not required'));
+            ui.log.info(chalk.dim('ℹ️ Client-only SDK - API key not required'));
         }
         this.sendEvent({
             type: 'CREDENTIALS_SUBMITTED',
@@ -300,93 +389,131 @@ export class CLIAdapter {
         });
     };
     handleConfigComplete = () => {
-        clack.log.success('Environment configured');
+        ui.log.success('Environment configured');
     };
     handleAgentStart = () => {
-        this.spinner = clack.spinner();
-        this.spinner.start('Running AI agent...');
-        // Periodic status updates for long-running operations
-        let dots = 0;
-        this.agentUpdateInterval = setInterval(() => {
-            dots = (dots + 1) % 4;
-            const dotStr = '.'.repeat(dots + 1);
-            this.spinner?.message(`Running AI agent${dotStr}`);
-        }, 2000);
+        this.spinner = ui.spinner();
+        this.spinner.start(this.lastAgentMessage);
+        // No setInterval: ui animates its own frames, and the old 2s reset
+        // clobbered the current phase text set by handleAgentProgress.
     };
     handleAgentProgress = ({ step, detail }) => {
         const message = detail ? `${step}: ${detail}` : step;
+        this.lastAgentMessage = message;
         this.spinner?.message(message);
     };
+    /**
+     * Render a persistent line above the running spinner: stop the spinner to
+     * finalize its line, emit the log, then restart it on the last phase message.
+     * Mirrors the existing stop→log and stop→start-new-spinner precedents.
+     */
+    logAboveSpinner(render) {
+        const wasRunning = this.spinner !== null;
+        this.spinner?.stop();
+        this.spinner = null;
+        render();
+        if (wasRunning) {
+            this.spinner = ui.spinner();
+            this.spinner.start(this.lastAgentMessage);
+        }
+    }
+    logFileOp(verb, path) {
+        if (path === this.lastFileOp)
+            return; // dedupe consecutive same-path ops
+        this.lastFileOp = path;
+        const rel = relative(process.cwd(), path);
+        this.logAboveSpinner(() => ui.log.step(`${verb} ${chalk.dim(rel)}`));
+    }
+    handleFileWrite = ({ path }) => {
+        this.logFileOp('Creating', path);
+    };
+    handleFileEdit = ({ path }) => {
+        this.logFileOp('Editing', path);
+    };
+    handleAgentTool = ({ detail }) => {
+        const cmd = detail.length > 80 ? `${detail.slice(0, 77)}…` : detail;
+        this.logAboveSpinner(() => ui.log.step(`Running ${chalk.dim(cmd)}`));
+    };
     handleValidationStart = () => {
-        this.stopAgentUpdates();
         this.stopSpinner('Agent completed');
     };
     handleValidationIssues = ({ issues }) => {
         for (const issue of issues) {
             if (issue.severity === 'error') {
-                clack.log.error(issue.message);
+                ui.log.error(issue.message);
             }
             else {
-                clack.log.warn(issue.message);
+                ui.log.warn(issue.message);
             }
             if (issue.hint) {
-                clack.log.info(`Hint: ${issue.hint}`);
+                ui.log.info(`Hint: ${issue.hint}`);
             }
         }
     };
     handleValidationComplete = ({ passed, issueCount }) => {
         if (passed) {
-            clack.log.success('Validation passed');
+            ui.log.success('Validation passed');
         }
         else {
-            clack.log.warn(`Validation found ${issueCount} issue(s)`);
+            ui.log.warn(`Validation found ${issueCount} issue(s)`);
         }
     };
-    handleComplete = ({ success, summary }) => {
-        this.stopAgentUpdates();
+    handleComplete = ({ success, summary, completion }) => {
+        // Fires synchronously during the cancelled-state transition (emitCancelled),
+        // BEFORE a queued sibling prompt's microtask runs — so aborting here makes a
+        // cancelled run's still-queued prompt (e.g. the branch select after a
+        // git-dirty "No") open with an already-aborted signal and resolve to CANCEL
+        // without ever rendering a now-moot question.
+        this.promptAbort?.abort();
         this.stopSpinner(success ? 'Done' : 'Failed');
         console.log('');
-        console.log(renderCompletionSummary(success, summary));
+        console.log(renderCompletionSummary(success, summary, completion));
         console.log('');
         // When we scaffolded a fresh app, the install ran in the current dir, so
         // point the user straight at the dev server.
         if (success && this.scaffolded) {
-            clack.log.info(`Start your app:  ${chalk.cyan(`${this.scaffoldPackageManager} run dev`)}`);
+            ui.log.info(`Start your app:  ${chalk.cyan(`${this.scaffoldPackageManager} run dev`)}`);
         }
     };
     handleError = ({ message, stack }) => {
-        this.stopSpinner('Error');
-        this.stopAgentUpdates();
-        // Rewrite raw API/SDK errors into user-friendly messages
+        this.stopSpinner('Failed', 1);
+        // Rewrite raw API/SDK errors into user-friendly messages with a next step.
+        // Matching is word-boundary / code-based so 'author' doesn't read as 'auth'
+        // and 'Module not found' doesn't read as a missing-directory error.
         const isServiceError = /\b50[0-9]\b/.test(message) || /server_error|internal_error|overloaded|service.*unavailable/i.test(message);
-        const isRateLimit = /\b429\b/.test(message) || /rate.limit/i.test(message);
+        const isRateLimit = /\b429\b/.test(message) || /\brate.?limit/i.test(message);
         const isNetworkError = /ECONNREFUSED|ETIMEDOUT|ENOTFOUND|fetch failed/i.test(message);
         const isProcessExit = /process exited with code/i.test(message);
+        const isAuthError = /\b(401|403|unauthorized|forbidden|authentication|authorization)\b/i.test(message);
+        const isMissingPath = /\bENOENT\b/.test(message);
         if (isServiceError) {
-            clack.log.error('The AI service is temporarily unavailable.');
-            clack.log.info('This is usually resolved within a few minutes. Please try again shortly.');
+            ui.log.error('The AI service is temporarily unavailable.');
+            ui.log.info('This is usually resolved within a few minutes. Please try again shortly.');
         }
         else if (isRateLimit) {
-            clack.log.error('The AI service is currently rate-limited.');
-            clack.log.info('Please wait a minute and try again.');
+            ui.log.error('The AI service is currently rate-limited.');
+            ui.log.info('Please wait a minute and try again.');
         }
         else if (isNetworkError) {
-            clack.log.error('Could not connect to the AI service.');
-            clack.log.info('Check your internet connection and try again.');
+            ui.log.error('Could not connect to the AI service.');
+            ui.log.info('Check your internet connection and try again.');
         }
         else if (isProcessExit) {
-            clack.log.error('The AI agent process exited unexpectedly.');
-            clack.log.info('Try running again. If this persists, run with --debug for details.');
+            ui.log.error('The AI agent process exited unexpectedly.');
+            ui.log.info('Try running again. If this persists, run with --debug for details.');
         }
-        else {
-            clack.log.error(message);
+        else if (isAuthError) {
+            ui.log.error('Authentication failed.');
+            ui.log.info(`Try running: ${formatWorkOSCommand('auth logout')} && ${formatWorkOSCommand('install')}`);
         }
-        // Add actionable hints for common errors
-        if (message.includes('authentication') || message.includes('auth')) {
-            clack.log.info(`Try running: ${formatWorkOSCommand('auth logout')} && ${formatWorkOSCommand('install')}`);
+        else if (isMissingPath) {
+            ui.log.error(message);
+            ui.log.info('Make sure you are running this in your project directory.');
         }
-        if (message.includes('ENOENT') || message.includes('not found')) {
-            clack.log.info('Ensure you are in a project directory');
+        else {
+            // Unknown error: still give the user somewhere to go next.
+            ui.log.error(message);
+            ui.log.info(`Re-run with ${chalk.cyan('--debug')} for details, or report it at ${chalk.cyan('https://github.com/workos/cli/issues')}`);
         }
         if (stack && this.debug) {
             this.debugLog(stack);
@@ -395,20 +522,17 @@ export class CLIAdapter {
     // ===== Scaffold Event Handlers =====
     handleScaffoldPrompt = async ({ packageManager }) => {
         this.scaffoldPackageManager = packageManager;
-        this.isPromptActive = true;
-        const confirmed = await clack.confirm({
+        const confirmed = await this.withPromptActive(() => ui.confirm({
             message: 'This directory is empty. Scaffold a new Next.js app with AuthKit here?',
             initialValue: true,
-        });
-        this.isPromptActive = false;
-        this.flushPendingLogs();
+        }));
         this.sendEvent({
-            type: clack.isCancel(confirmed) || !confirmed ? 'SCAFFOLD_CANCELLED' : 'SCAFFOLD_CONFIRMED',
+            type: ui.isCancel(confirmed) || !confirmed ? 'SCAFFOLD_CANCELLED' : 'SCAFFOLD_CONFIRMED',
         });
     };
     handleScaffoldStart = ({ packageManager }) => {
         this.scaffoldPackageManager = packageManager;
-        this.spinner = clack.spinner();
+        this.spinner = ui.spinner();
         this.spinner.start(`Scaffolding a new Next.js app with ${packageManager} (this can take a minute)...`);
     };
     // create-next-app output is verbose; surface it only under --debug and keep
@@ -425,21 +549,19 @@ export class CLIAdapter {
     };
     handleScaffoldFailed = ({ error }) => {
         this.stopSpinner('Scaffold failed');
-        clack.log.error(`Could not scaffold the app: ${error}`);
+        ui.log.error(`Could not scaffold the app: ${error}`);
     };
     handleBranchPrompt = async ({ branch }) => {
-        this.isPromptActive = true;
-        const choice = await clack.select({
+        const choice = await this.withPromptActive(() => ui.select({
             message: `You are on ${chalk.bold(branch)}. Create a feature branch?`,
             options: [
                 { value: 'create', label: 'Create feat/add-workos-authkit' },
                 { value: 'continue', label: 'Continue on current branch' },
                 { value: 'cancel', label: 'Cancel' },
             ],
-        });
-        this.isPromptActive = false;
-        this.flushPendingLogs();
-        if (clack.isCancel(choice) || choice === 'cancel') {
+            signal: this.promptAbort?.signal,
+        }));
+        if (ui.isCancel(choice) || choice === 'cancel') {
             this.sendEvent({ type: 'BRANCH_CANCEL' });
         }
         else if (choice === 'create') {
@@ -450,50 +572,44 @@ export class CLIAdapter {
         }
     };
     handleBranchCreated = ({ branch }) => {
-        this.queueableLog(() => clack.log.success(`Created branch ${chalk.bold(branch)}`));
+        this.queueableLog(() => ui.log.success(`Created branch ${chalk.bold(branch)}`));
     };
     // ===== Post-install Event Handlers =====
     handlePostInstallChanges = ({ files }) => {
         this.debugLog(`Post-install: ${files.length} changed files detected`);
     };
     handleCommitPrompt = async () => {
-        this.isPromptActive = true;
-        const confirmed = await clack.confirm({
+        const confirmed = await this.withPromptActive(() => ui.confirm({
             message: 'Commit the changes?',
             initialValue: true,
-        });
-        this.isPromptActive = false;
-        this.flushPendingLogs();
+        }));
         this.sendEvent({
-            type: clack.isCancel(confirmed) || !confirmed ? 'COMMIT_DECLINED' : 'COMMIT_APPROVED',
+            type: ui.isCancel(confirmed) || !confirmed ? 'COMMIT_DECLINED' : 'COMMIT_APPROVED',
         });
     };
     handleCommitGenerating = () => {
-        this.spinner = clack.spinner();
+        this.spinner = ui.spinner();
         this.spinner.start('Generating commit message...');
     };
     handleCommitSuccess = ({ message }) => {
         this.stopSpinner('Committed');
-        clack.log.success(`Committed: ${chalk.dim(message)}`);
+        ui.log.success(`Committed: ${chalk.dim(message)}`);
     };
     handleCommitFailed = ({ error }) => {
         this.stopSpinner('Commit failed');
-        clack.log.error(`Commit failed: ${error}`);
+        ui.log.error(`Commit failed: ${error}`);
     };
     handlePrPrompt = async () => {
-        this.isPromptActive = true;
-        const confirmed = await clack.confirm({
+        const confirmed = await this.withPromptActive(() => ui.confirm({
             message: 'Create a pull request?',
             initialValue: true,
-        });
-        this.isPromptActive = false;
-        this.flushPendingLogs();
+        }));
         this.sendEvent({
-            type: clack.isCancel(confirmed) || !confirmed ? 'PR_DECLINED' : 'PR_APPROVED',
+            type: ui.isCancel(confirmed) || !confirmed ? 'PR_DECLINED' : 'PR_APPROVED',
         });
     };
     handlePrGenerating = () => {
-        this.spinner = clack.spinner();
+        this.spinner = ui.spinner();
         this.spinner.start('Generating PR description...');
     };
     handlePrPushing = () => {
@@ -501,24 +617,24 @@ export class CLIAdapter {
             this.spinner.message('Pushing to remote...');
         }
         else {
-            this.spinner = clack.spinner();
+            this.spinner = ui.spinner();
             this.spinner.start('Pushing to remote...');
         }
     };
     handlePrSuccess = ({ url }) => {
         this.stopSpinner('PR created');
-        clack.log.success(`Pull request created: ${chalk.cyan(url)}`);
+        ui.log.success(`Pull request created: ${chalk.cyan(url)}`);
     };
     handlePrFailed = ({ error }) => {
         this.stopSpinner('PR creation failed');
-        clack.log.error(`PR creation failed: ${error}`);
+        ui.log.error(`PR creation failed: ${error}`);
     };
     handlePushFailed = ({ error }) => {
         this.stopSpinner('Push failed');
-        clack.log.error(`Push failed: ${error}`);
+        ui.log.error(`Push failed: ${error}`);
     };
     handleManualInstructions = ({ instructions }) => {
-        clack.log.info('GitHub CLI not found. Manual steps:');
+        ui.log.info('GitHub CLI not found. Manual steps:');
         console.log(chalk.dim(instructions));
     };
 }