byterover-cli 1.7.2 → 2.0.0

package/dist/tui/features/activity/hooks/use-activity-logs.js

@@ -0,0 +1,208 @@
+/**
+ * Activity Logs Hook
+ *
+ * Transforms tasks from transport events into ActivityLog format for display.
+ */
+import { useMemo } from 'react';
+import { array as zArray, number as zNumber, object as zObject, string as zString } from 'zod';
+import { formatTaskError } from '../../../utils/error-messages.js';
+import { useTasksStore } from '../../tasks/stores/tasks-store.js';
+const ExecutionInputSchema = zObject({
+    content: zString(),
+});
+// Schema for curate tool result (direct call)
+const CurateResultSchema = zObject({
+    result: zObject({
+        applied: zArray(zObject({
+            filePath: zString(),
+            path: zString(),
+            status: zString(),
+            type: zString(),
+        })).optional(),
+    }).optional(),
+});
+// Schema for curate result from code_exec (via tools.curate())
+// Note: summary fields are numbers (added: 1, updated: 0, etc.)
+const CodeExecCurateResultSchema = zObject({
+    returnValue: zObject({
+        applied: zArray(zObject({
+            filePath: zString().optional(),
+            path: zString(),
+            status: zString(),
+            type: zString(),
+        })).optional(),
+        summary: zObject({
+            added: zNumber().optional(),
+            deleted: zNumber().optional(),
+            failed: zNumber().optional(),
+            merged: zNumber().optional(),
+            updated: zNumber().optional(),
+        }).optional(),
+    }).optional(),
+});
+/**
+ * Parse execution input to extract content
+ */
+export function parseExecutionContent(input) {
+    try {
+        return ExecutionInputSchema.safeParse(JSON.parse(input))?.data?.content ?? input;
+    }
+    catch {
+        return input;
+    }
+}
+/**
+ * Extract file changes from curate tool calls (transport events)
+ * Handles both direct curate calls and curate via code_exec (tools.curate())
+ */
+function composeChangesFromToolCalls(toolCalls) {
+    const changes = { created: [], updated: [] };
+    for (const tc of toolCalls) {
+        if (tc.status !== 'completed' || !tc.result) {
+            continue;
+        }
+        // Parse JSON - skip if invalid
+        let parsed;
+        try {
+            parsed = JSON.parse(String(tc.result));
+        }
+        catch {
+            continue;
+        }
+        // Try to extract curate results based on tool type
+        if (tc.toolName === 'curate') {
+            // Direct curate tool call
+            const parseResult = CurateResultSchema.safeParse(parsed);
+            if (!parseResult.success) {
+                continue;
+            }
+            const result = parseResult.data.result || {};
+            extractChangesFromApplied(result.applied || [], changes);
+        }
+        else if (tc.toolName === 'code_exec') {
+            // Curate via code_exec (tools.curate() in sandbox)
+            const parseResult = CodeExecCurateResultSchema.safeParse(parsed);
+            if (!parseResult.success) {
+                continue;
+            }
+            const { returnValue } = parseResult.data;
+            if (returnValue?.applied) {
+                extractChangesFromApplied(returnValue.applied, changes);
+            }
+        }
+    }
+    return changes;
+}
+/**
+ * Helper to extract file changes from curate applied operations
+ */
+function extractChangesFromApplied(applied, changes) {
+    for (const operation of applied) {
+        if (operation.status !== 'success' || !operation.filePath) {
+            continue;
+        }
+        // Handle ADD, UPDATE, and UPSERT types
+        switch (operation.type) {
+            case 'ADD': {
+                changes.created.push(operation.filePath);
+                break;
+            }
+            case 'UPDATE': {
+                changes.updated.push(operation.filePath);
+                break;
+            }
+            case 'UPSERT': {
+                // UPSERT can be either create or update based on message content
+                // Default to updated since UPSERT typically updates existing
+                changes.updated.push(operation.filePath);
+                break;
+            }
+            default: {
+                // Ignore other operation types (DELETE, MERGE, etc.)
+                break;
+            }
+        }
+    }
+}
+/**
+ * Map task status to execution status
+ */
+function mapTaskStatusToExecutionStatus(taskStatus) {
+    switch (taskStatus) {
+        case 'cancelled': {
+            return 'failed';
+        }
+        case 'completed': {
+            return 'completed';
+        }
+        case 'created':
+        case 'started': {
+            return 'running';
+        }
+        case 'error': {
+            return 'failed';
+        }
+        default: {
+            return 'running';
+        }
+    }
+}
+/**
+ * Map tool call status to ToolCallStatus
+ */
+function mapToolCallStatus(status) {
+    switch (status) {
+        case 'completed': {
+            return 'completed';
+        }
+        case 'error': {
+            return 'failed';
+        }
+        case 'running': {
+            return 'running';
+        }
+        default: {
+            return 'running';
+        }
+    }
+}
+/**
+ * Hook that transforms tasks from transport events into ActivityLog format
+ */
+export function useActivityLogs() {
+    const tasks = useTasksStore((s) => s.tasks);
+    const logs = useMemo(() => {
+        const taskArray = [...tasks.values()];
+        return taskArray
+            .filter((task) => task.status !== 'created')
+            .map((task) => {
+            // Include tool args and timestamp in progress items for display
+            const progress = task.toolCalls.map((tc, index) => ({
+                args: tc.args,
+                id: tc.callId ?? `${task.taskId}-${index}`,
+                status: mapToolCallStatus(tc.status),
+                timestamp: tc.timestamp,
+                toolCallName: tc.toolName,
+            }));
+            const changes = composeChangesFromToolCalls(task.toolCalls);
+            const activityLog = {
+                changes,
+                content: task.status === 'error' ? formatTaskError(task.error) : (task.result ?? ''),
+                files: task.files,
+                folders: task.folders,
+                id: task.taskId,
+                input: task.content,
+                isStreaming: task.isStreaming,
+                reasoningContents: task.reasoningContents,
+                source: 'agent',
+                status: mapTaskStatusToExecutionStatus(task.status),
+                streamingContent: task.streamingContent,
+                timestamp: new Date(task.startedAt ?? task.createdAt),
+                toolCalls: progress,
+                type: task.type,
+            };
+            return activityLog;
+        });
+    }, [tasks]);
+    return { logs };
+}

package/dist/tui/features/activity/hooks/use-feed-navigation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Feed Navigation Hook
+ *
+ * Handles keyboard navigation for the activity feed:
+ * - Up/Down arrows to navigate items
+ * - Ctrl+O to expand/collapse selected item
+ * - Escape to collapse expanded item
+ */
+interface UseFeedNavigationOptions {
+    /** Total number of items in the feed */
+    itemCount: number;
+    /** Whether navigation is active */
+    isActive: boolean;
+    /** Current expanded index (null if none expanded) */
+    expandedIndex: null | number;
+    /** Callback when expanded index changes */
+    onExpandedIndexChange: (index: null | number) => void;
+}
+interface UseFeedNavigationReturn {
+    /** Currently selected index */
+    selectedIndex: number;
+}
+export declare function useFeedNavigation({ expandedIndex, isActive, itemCount, onExpandedIndexChange, }: UseFeedNavigationOptions): UseFeedNavigationReturn;
+export {};

package/dist/tui/features/activity/hooks/use-feed-navigation.js

@@ -0,0 +1,43 @@
+/**
+ * Feed Navigation Hook
+ *
+ * Handles keyboard navigation for the activity feed:
+ * - Up/Down arrows to navigate items
+ * - Ctrl+O to expand/collapse selected item
+ * - Escape to collapse expanded item
+ */
+import { useInput } from 'ink';
+import { useEffect, useState } from 'react';
+export function useFeedNavigation({ expandedIndex, isActive, itemCount, onExpandedIndexChange, }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    // Auto-select last item when item count changes
+    useEffect(() => {
+        if (itemCount === 0)
+            return;
+        setSelectedIndex(itemCount - 1);
+    }, [itemCount]);
+    useInput((input, key) => {
+        // Toggle expand on Ctrl+O
+        if (key.ctrl && input === 'o') {
+            if (expandedIndex === selectedIndex) {
+                onExpandedIndexChange(null);
+            }
+            else {
+                onExpandedIndexChange(selectedIndex);
+            }
+        }
+        // Navigate up
+        if (key.upArrow) {
+            setSelectedIndex((prev) => Math.max(0, prev - 1));
+        }
+        // Navigate down
+        if (key.downArrow) {
+            setSelectedIndex((prev) => Math.min(prev + 1, itemCount - 1));
+        }
+        // Collapse on Escape
+        if (key.escape && expandedIndex !== null) {
+            onExpandedIndexChange(null);
+        }
+    }, { isActive });
+    return { selectedIndex };
+}

package/dist/tui/features/activity/index.d.ts

@@ -0,0 +1 @@
+export * from './hooks/index.js';

package/dist/tui/features/activity/index.js

@@ -0,0 +1 @@
+export * from './hooks/index.js';

package/dist/tui/features/auth/api/get-auth-state.d.ts

@@ -0,0 +1,16 @@
+import type { QueryConfig } from '../../../lib/react-query.js';
+import { type AuthGetStateResponse } from '../../../../shared/transport/events/index.js';
+export declare const getAuthState: () => Promise<AuthGetStateResponse>;
+export declare const getAuthStateQueryOptions: () => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<AuthGetStateResponse, Error, AuthGetStateResponse, string[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<AuthGetStateResponse, string[], never> | undefined;
+} & {
+    queryKey: string[] & {
+        [dataTagSymbol]: AuthGetStateResponse;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+type UseGetAuthStateOptions = {
+    queryConfig?: QueryConfig<typeof getAuthStateQueryOptions>;
+};
+export declare const useGetAuthState: ({ queryConfig }?: UseGetAuthStateOptions) => import("@tanstack/react-query").UseQueryResult<AuthGetStateResponse, Error>;
+export {};

package/dist/tui/features/auth/api/get-auth-state.js

@@ -0,0 +1,21 @@
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { AuthEvents } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const getAuthState = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    // Use 500ms timeout to fail fast if handler not ready yet
+    // React Query will retry automatically with exponential backoff
+    return apiClient.request(AuthEvents.GET_STATE, undefined, { timeout: 500 });
+};
+export const getAuthStateQueryOptions = () => queryOptions({
+    gcTime: 5 * 60 * 1000,
+    queryFn: getAuthState,
+    queryKey: ['auth', 'state'],
+    staleTime: 60 * 1000,
+});
+export const useGetAuthState = ({ queryConfig } = {}) => useQuery({
+    ...getAuthStateQueryOptions(),
+    ...queryConfig,
+});

package/dist/tui/features/auth/api/login.d.ts

@@ -0,0 +1,3 @@
+import { type AuthLoginCompletedEvent, type AuthStartLoginResponse } from '../../../../shared/transport/events/index.js';
+export declare const login: () => Promise<AuthStartLoginResponse>;
+export declare const subscribeToLoginCompleted: (callback: (data: AuthLoginCompletedEvent) => void) => (() => void);

package/dist/tui/features/auth/api/login.js

@@ -0,0 +1,14 @@
+import { AuthEvents, } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const login = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(AuthEvents.START_LOGIN);
+};
+export const subscribeToLoginCompleted = (callback) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return () => { };
+    return apiClient.on(AuthEvents.LOGIN_COMPLETED, callback);
+};

package/dist/tui/features/auth/api/logout.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../lib/react-query.js';
+import { type AuthLogoutResponse } from '../../../../shared/transport/events/index.js';
+export declare const logout: () => Promise<AuthLogoutResponse>;
+type UseLogoutOptions = {
+    mutationConfig?: MutationConfig<typeof logout>;
+};
+export declare const useLogout: ({ mutationConfig }?: UseLogoutOptions) => import("@tanstack/react-query").UseMutationResult<AuthLogoutResponse, Error, undefined, unknown>;
+export {};

package/dist/tui/features/auth/api/logout.js

@@ -0,0 +1,24 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { AuthEvents } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+import { getAuthStateQueryOptions } from './get-auth-state.js';
+export const logout = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(AuthEvents.LOGOUT);
+};
+export const useLogout = ({ mutationConfig } = {}) => {
+    const queryClient = useQueryClient();
+    const { onSuccess, ...restConfig } = mutationConfig ?? {};
+    return useMutation({
+        onSuccess(...args) {
+            queryClient.invalidateQueries({
+                queryKey: getAuthStateQueryOptions().queryKey,
+            });
+            onSuccess?.(...args);
+        },
+        ...restConfig,
+        mutationFn: logout,
+    });
+};

package/dist/tui/features/auth/api/refresh-auth.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../lib/react-query.js';
+import { type AuthRefreshResponse } from '../../../../shared/transport/events/index.js';
+export declare const refreshAuth: () => Promise<AuthRefreshResponse>;
+type UseRefreshAuthOptions = {
+    mutationConfig?: MutationConfig<typeof refreshAuth>;
+};
+export declare const useRefreshAuth: ({ mutationConfig }?: UseRefreshAuthOptions) => import("@tanstack/react-query").UseMutationResult<AuthRefreshResponse, Error, undefined, unknown>;
+export {};

package/dist/tui/features/auth/api/refresh-auth.js

@@ -0,0 +1,24 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { AuthEvents } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+import { getAuthStateQueryOptions } from './get-auth-state.js';
+export const refreshAuth = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(AuthEvents.REFRESH);
+};
+export const useRefreshAuth = ({ mutationConfig } = {}) => {
+    const queryClient = useQueryClient();
+    const { onSuccess, ...restConfig } = mutationConfig ?? {};
+    return useMutation({
+        onSuccess(...args) {
+            queryClient.invalidateQueries({
+                queryKey: getAuthStateQueryOptions().queryKey,
+            });
+            onSuccess?.(...args);
+        },
+        ...restConfig,
+        mutationFn: refreshAuth,
+    });
+};

package/dist/tui/features/auth/components/auth-initializer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AuthInitializer Component
+ *
+ * Initializes auth state from transport and subscribes to auth state changes.
+ * Must be rendered within TransportProvider.
+ */
+import React from 'react';
+export declare function AuthInitializer({ children }: {
+    children: React.ReactNode;
+}): React.ReactNode;

package/dist/tui/features/auth/components/auth-initializer.js

@@ -0,0 +1,82 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * AuthInitializer Component
+ *
+ * Initializes auth state from transport and subscribes to auth state changes.
+ * Must be rendered within TransportProvider.
+ */
+import { useQueryClient } from '@tanstack/react-query';
+import { useEffect } from 'react';
+import { AuthEvents } from '../../../../shared/transport/events/index.js';
+import { useCommandsStore } from '../../../features/commands/stores/commands-store.js';
+import { useModelStore } from '../../../features/model/stores/model-store.js';
+import { useProviderStore } from '../../../features/provider/stores/provider-store.js';
+import { useTasksStore } from '../../../features/tasks/stores/tasks-store.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+import { getAuthStateQueryOptions, useGetAuthState } from '../api/get-auth-state.js';
+import { useAuthStore } from '../stores/auth-store.js';
+export function AuthInitializer({ children }) {
+    const { apiClient } = useTransportStore();
+    const queryClient = useQueryClient();
+    const setState = useAuthStore((s) => s.setState);
+    // Fetch initial auth state (only when transport is connected)
+    const { data: authState, isFetched, isLoading, } = useGetAuthState({
+        queryConfig: {
+            enabled: apiClient !== null,
+            retry: 5,
+            retryDelay: (attemptIndex) => Math.min(500 * 2 ** attemptIndex, 2000),
+            staleTime: 2 * 60 * 1000,
+        },
+    });
+    // Update store when auth state is fetched (including loading state)
+    useEffect(() => {
+        if (authState) {
+            setState({
+                brvConfig: authState.brvConfig ?? null,
+                isAuthorized: authState.isAuthorized,
+                user: authState.user ?? null,
+            });
+            useAuthStore.setState({ isLoadingInitial: false });
+        }
+        else if (isFetched && !isLoading) {
+            useAuthStore.setState({ isLoadingInitial: false });
+        }
+    }, [authState, isLoading, isFetched, setState]);
+    // Subscribe to auth state changes
+    useEffect(() => {
+        if (!apiClient)
+            return;
+        const unsubscribe = apiClient.on(AuthEvents.STATE_CHANGED, (data) => {
+            setState({
+                brvConfig: data.brvConfig,
+                isAuthorized: data.isAuthorized,
+                user: data.user,
+            });
+            // Clean up user-specific stores when auth is lost
+            if (!data.isAuthorized) {
+                useCommandsStore.getState().clearMessages();
+                useTasksStore.getState().clearTasks();
+                useProviderStore.getState().reset();
+                useModelStore.getState().reset();
+            }
+            // Re-fetch complete auth state (including brvConfig) when auth is restored.
+            // Broadcast omits brvConfig (project-scoped, can't resolve in global broadcast),
+            // so we re-fetch GET_STATE which resolves brvConfig via clientId.
+            if (data.isAuthorized) {
+                queryClient
+                    .invalidateQueries({
+                    queryKey: getAuthStateQueryOptions().queryKey,
+                })
+                    .catch(() => {
+                    // Silently ignore — next poll cycle retries
+                });
+            }
+        });
+        return unsubscribe;
+    }, [apiClient, queryClient, setState]);
+    // Don't render children until transport is connected
+    if (!apiClient) {
+        return null;
+    }
+    return _jsx(_Fragment, { children: children });
+}

package/dist/tui/features/auth/components/login-flow.d.ts

@@ -0,0 +1,8 @@
+/**
+ * LoginFlow Component
+ *
+ * Starts OAuth login, waits for browser callback, reports result.
+ */
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../types/commands.js';
+export declare function LoginFlow({ onComplete }: CustomDialogCallbacks): React.ReactNode;

package/dist/tui/features/auth/components/login-flow.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * LoginFlow Component
+ *
+ * Starts OAuth login, waits for browser callback, reports result.
+ */
+import { Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useEffect, useState } from 'react';
+import { AuthEvents } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+import { login } from '../api/login.js';
+import { useAuthStore } from '../stores/auth-store.js';
+export function LoginFlow({ onComplete }) {
+    const [step, setStep] = useState('starting');
+    const [authUrl, setAuthUrl] = useState();
+    // Start the login process
+    useEffect(() => {
+        login()
+            .then((data) => {
+            setAuthUrl(data.authUrl);
+            setStep('waiting');
+        })
+            .catch((_error) => {
+            // onComplete(`Login failed: ${_error.message}`)
+        });
+    }, []);
+    // Subscribe to login completion event
+    useEffect(() => {
+        if (step !== 'waiting')
+            return;
+        const { apiClient } = useTransportStore.getState();
+        if (!apiClient) {
+            onComplete('Login failed: Not connected');
+            return;
+        }
+        const unsubscribe = apiClient.on(AuthEvents.LOGIN_COMPLETED, (data) => {
+            unsubscribe();
+            if (data.success && data.user) {
+                useAuthStore.getState().setState({ isAuthorized: true, user: data.user });
+                onComplete(`Logged in as ${data.user.email}`);
+            }
+            else {
+                onComplete(data.error ?? 'Authentication failed');
+            }
+        });
+        return unsubscribe;
+    }, [onComplete, step]);
+    // if (step === 'starting') {
+    //   return (
+    //     <Text>
+    //       {isLoggingIn && (
+    //         <>
+    //           <Spinner type="dots" /> Starting authentication process...
+    //         </>
+    //       )}
+    //       {loginError && <Text color="red">{loginError.message}</Text>}
+    //     </Text>
+    //   )
+    // }
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Opening browser for authentication...", authUrl ? `\nIf the browser did not open, visit: ${authUrl}` : ''] }));
+}

package/dist/tui/features/auth/components/logout-flow.d.ts

@@ -0,0 +1,12 @@
+/**
+ * LogoutFlow Component
+ *
+ * Checks auth state, optionally confirms, then logs out.
+ */
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../types/commands.js';
+interface LogoutFlowProps extends CustomDialogCallbacks {
+    skipConfirm?: boolean;
+}
+export declare function LogoutFlow({ onComplete, skipConfirm }: LogoutFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/auth/components/logout-flow.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * LogoutFlow Component
+ *
+ * Checks auth state, optionally confirms, then logs out.
+ */
+import { Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useEffect, useState } from 'react';
+import { InlineConfirm } from '../../../components/inline-prompts/inline-confirm.js';
+import { useDisconnectProvider } from '../../provider/api/disconnect-provider.js';
+import { useGetAuthState } from '../api/get-auth-state.js';
+import { useLogout } from '../api/logout.js';
+export function LogoutFlow({ onComplete, skipConfirm }) {
+    const [step, setStep] = useState('checking');
+    const [userEmail, setUserEmail] = useState();
+    const { data: authData, error: authError, isLoading: isCheckingAuth } = useGetAuthState();
+    const logoutMutation = useLogout();
+    const disconnectMutation = useDisconnectProvider();
+    // Check auth state
+    useEffect(() => {
+        if (isCheckingAuth || step !== 'checking')
+            return;
+        if (authError) {
+            onComplete(`Logout failed: ${authError.message}`);
+            return;
+        }
+        if (authData && (!authData.isAuthorized || !authData.user)) {
+            onComplete('You are not currently logged in.');
+            return;
+        }
+        if (authData?.user) {
+            setUserEmail(authData.user.email);
+            if (skipConfirm) {
+                setStep('executing');
+            }
+            else {
+                setStep('confirm');
+            }
+        }
+    }, [authData, authError, isCheckingAuth, onComplete, skipConfirm, step]);
+    // Execute logout
+    useEffect(() => {
+        if (step !== 'executing')
+            return;
+        const execute = async () => {
+            try {
+                await disconnectMutation.mutateAsync({ providerId: 'byterover' });
+                // eslint-disable-next-line unicorn/no-useless-undefined
+                const result = await logoutMutation.mutateAsync(undefined);
+                if (result.success) {
+                    onComplete("Successfully logged out.\nRun '/login' to authenticate again.");
+                }
+                else {
+                    onComplete('Logout failed');
+                }
+            }
+            catch (error) {
+                onComplete(`Logout failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        };
+        execute();
+    }, [step]);
+    if (step === 'checking' || isCheckingAuth) {
+        return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Checking authentication..."] }));
+    }
+    if (step === 'confirm') {
+        return (_jsx(InlineConfirm, { default: true, message: `Logging out ${userEmail}. Are you sure`, onConfirm: (confirmed) => {
+                if (confirmed) {
+                    setStep('executing');
+                }
+                else {
+                    onComplete('Logout cancelled');
+                }
+            } }));
+    }
+    if (step === 'executing') {
+        return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Logging out..."] }));
+    }
+    return null;
+}