fss-link 1.0.40 → 1.0.45

package/dist/ui/hooks/useAtCompletion.ts

@@ -0,0 +1,244 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useEffect, useReducer, useRef } from 'react';
+import {
+  Config,
+  FileSearch,
+  FileSearchFactory,
+  escapePath,
+} from 'fss-link-core';
+import {
+  Suggestion,
+  MAX_SUGGESTIONS_TO_SHOW,
+} from '../components/SuggestionsDisplay.js';
+
+export enum AtCompletionStatus {
+  IDLE = 'idle',
+  INITIALIZING = 'initializing',
+  READY = 'ready',
+  SEARCHING = 'searching',
+  ERROR = 'error',
+}
+
+interface AtCompletionState {
+  status: AtCompletionStatus;
+  suggestions: Suggestion[];
+  isLoading: boolean;
+  pattern: string | null;
+}
+
+type AtCompletionAction =
+  | { type: 'INITIALIZE' }
+  | { type: 'INITIALIZE_SUCCESS' }
+  | { type: 'SEARCH'; payload: string }
+  | { type: 'SEARCH_SUCCESS'; payload: Suggestion[] }
+  | { type: 'SET_LOADING'; payload: boolean }
+  | { type: 'ERROR' }
+  | { type: 'RESET' };
+
+const initialState: AtCompletionState = {
+  status: AtCompletionStatus.IDLE,
+  suggestions: [],
+  isLoading: false,
+  pattern: null,
+};
+
+function atCompletionReducer(
+  state: AtCompletionState,
+  action: AtCompletionAction,
+): AtCompletionState {
+  switch (action.type) {
+    case 'INITIALIZE':
+      return {
+        ...state,
+        status: AtCompletionStatus.INITIALIZING,
+        isLoading: true,
+      };
+    case 'INITIALIZE_SUCCESS':
+      return { ...state, status: AtCompletionStatus.READY, isLoading: false };
+    case 'SEARCH':
+      // Keep old suggestions, don't set loading immediately
+      return {
+        ...state,
+        status: AtCompletionStatus.SEARCHING,
+        pattern: action.payload,
+      };
+    case 'SEARCH_SUCCESS':
+      return {
+        ...state,
+        status: AtCompletionStatus.READY,
+        suggestions: action.payload,
+        isLoading: false,
+      };
+    case 'SET_LOADING':
+      // Only show loading if we are still in a searching state
+      if (state.status === AtCompletionStatus.SEARCHING) {
+        return { ...state, isLoading: action.payload, suggestions: [] };
+      }
+      return state;
+    case 'ERROR':
+      return {
+        ...state,
+        status: AtCompletionStatus.ERROR,
+        isLoading: false,
+        suggestions: [],
+      };
+    case 'RESET':
+      return initialState;
+    default:
+      return state;
+  }
+}
+
+export interface UseAtCompletionProps {
+  enabled: boolean;
+  pattern: string;
+  config: Config | undefined;
+  cwd: string;
+  setSuggestions: (suggestions: Suggestion[]) => void;
+  setIsLoadingSuggestions: (isLoading: boolean) => void;
+}
+
+export function useAtCompletion(props: UseAtCompletionProps): void {
+  const {
+    enabled,
+    pattern,
+    config,
+    cwd,
+    setSuggestions,
+    setIsLoadingSuggestions,
+  } = props;
+  const [state, dispatch] = useReducer(atCompletionReducer, initialState);
+  const fileSearch = useRef<FileSearch | null>(null);
+  const searchAbortController = useRef<AbortController | null>(null);
+  const slowSearchTimer = useRef<NodeJS.Timeout | null>(null);
+
+  useEffect(() => {
+    setSuggestions(state.suggestions);
+  }, [state.suggestions, setSuggestions]);
+
+  useEffect(() => {
+    setIsLoadingSuggestions(state.isLoading);
+  }, [state.isLoading, setIsLoadingSuggestions]);
+
+  useEffect(() => {
+    dispatch({ type: 'RESET' });
+  }, [cwd, config]);
+
+  // Reacts to user input (`pattern`) ONLY.
+  useEffect(() => {
+    if (!enabled) {
+      // reset when first getting out of completion suggestions
+      if (
+        state.status === AtCompletionStatus.READY ||
+        state.status === AtCompletionStatus.ERROR
+      ) {
+        dispatch({ type: 'RESET' });
+      }
+      return;
+    }
+    if (pattern === null) {
+      dispatch({ type: 'RESET' });
+      return;
+    }
+
+    if (state.status === AtCompletionStatus.IDLE) {
+      dispatch({ type: 'INITIALIZE' });
+    } else if (
+      (state.status === AtCompletionStatus.READY ||
+        state.status === AtCompletionStatus.SEARCHING) &&
+      pattern !== state.pattern // Only search if the pattern has changed
+    ) {
+      dispatch({ type: 'SEARCH', payload: pattern });
+    }
+  }, [enabled, pattern, state.status, state.pattern]);
+
+  // The "Worker" that performs async operations based on status.
+  useEffect(() => {
+    const initialize = async () => {
+      try {
+        const searcher = FileSearchFactory.create({
+          projectRoot: cwd,
+          ignoreDirs: [],
+          useGitignore:
+            config?.getFileFilteringOptions()?.respectGitIgnore ?? true,
+          useGeminiignore:
+            config?.getFileFilteringOptions()?.respectGeminiIgnore ?? true,
+          useFssLinkignore:
+            config?.getFileFilteringOptions()?.respectFssLinkIgnore ?? true,
+          cache: true,
+          cacheTtl: 30, // 30 seconds
+          enableRecursiveFileSearch:
+            config?.getEnableRecursiveFileSearch() ?? true,
+        });
+        await searcher.initialize();
+        fileSearch.current = searcher;
+        dispatch({ type: 'INITIALIZE_SUCCESS' });
+        if (state.pattern !== null) {
+          dispatch({ type: 'SEARCH', payload: state.pattern });
+        }
+      } catch (_) {
+        dispatch({ type: 'ERROR' });
+      }
+    };
+
+    const search = async () => {
+      if (!fileSearch.current || state.pattern === null) {
+        return;
+      }
+
+      if (slowSearchTimer.current) {
+        clearTimeout(slowSearchTimer.current);
+      }
+
+      const controller = new AbortController();
+      searchAbortController.current = controller;
+
+      slowSearchTimer.current = setTimeout(() => {
+        dispatch({ type: 'SET_LOADING', payload: true });
+      }, 200);
+
+      try {
+        const results = await fileSearch.current.search(state.pattern, {
+          signal: controller.signal,
+          maxResults: MAX_SUGGESTIONS_TO_SHOW * 3,
+        });
+
+        if (slowSearchTimer.current) {
+          clearTimeout(slowSearchTimer.current);
+        }
+
+        if (controller.signal.aborted) {
+          return;
+        }
+
+        const suggestions = results.map((p) => ({
+          label: p,
+          value: escapePath(p),
+        }));
+        dispatch({ type: 'SEARCH_SUCCESS', payload: suggestions });
+      } catch (error) {
+        if (!(error instanceof Error && error.name === 'AbortError')) {
+          dispatch({ type: 'ERROR' });
+        }
+      }
+    };
+
+    if (state.status === AtCompletionStatus.INITIALIZING) {
+      initialize();
+    } else if (state.status === AtCompletionStatus.SEARCHING) {
+      search();
+    }
+
+    return () => {
+      searchAbortController.current?.abort();
+      if (slowSearchTimer.current) {
+        clearTimeout(slowSearchTimer.current);
+      }
+    };
+  }, [state.status, state.pattern, config, cwd]);
+}

package/dist/ui/hooks/useAuthCommand.ts

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback, useEffect } from 'react';
+import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import {
+  AuthType,
+  Config,
+  clearCachedCredentialFile,
+  getErrorMessage,
+} from 'fss-link-core';
+import { runExitCleanup } from '../../utils/cleanup.js';
+import { getModelManager } from '../../config/modelManager.js';
+
+export const useAuthCommand = (
+  settings: LoadedSettings,
+  setAuthError: (error: string | null) => void,
+  config: Config,
+) => {
+  // Check database first - if we have an active model, don't show auth dialog
+  const modelManager = getModelManager();
+  const [hasActiveModel, setHasActiveModel] = useState(false);
+  
+  // Initialize hasActiveModel state asynchronously
+  useEffect(() => {
+    const checkActiveModel = async () => {
+      const result = await modelManager.hasValidConfiguration();
+      setHasActiveModel(result);
+    };
+    void checkActiveModel();
+  }, [modelManager]);
+  
+  const [isAuthDialogOpen, setIsAuthDialogOpen] = useState(
+    !hasActiveModel && settings.merged.selectedAuthType === undefined,
+  );
+
+  const openAuthDialog = useCallback(() => {
+    setIsAuthDialogOpen(true);
+  }, []);
+
+  const [isAuthenticating, setIsAuthenticating] = useState(false);
+
+  useEffect(() => {
+    const authFlow = async () => {
+      if (isAuthDialogOpen) {
+        return;
+      }
+
+      // First, try to initialize from database
+      if (hasActiveModel) {
+        const currentAuthType = await modelManager.getCurrentAuthType();
+        if (currentAuthType) {
+          try {
+            setIsAuthenticating(true);
+            await config.refreshAuth(currentAuthType as AuthType);
+            console.log(`Authenticated via "${currentAuthType}" (from database).`);
+            return;
+          } catch (e) {
+            console.warn(`Database auth failed: ${getErrorMessage(e)}`);
+            // Fall through to settings-based auth
+          } finally {
+            setIsAuthenticating(false);
+          }
+        }
+      }
+
+      // Fallback to settings-based auth
+      const authType = settings.merged.selectedAuthType;
+      if (!authType) {
+        return;
+      }
+
+      try {
+        setIsAuthenticating(true);
+        await config.refreshAuth(authType);
+        console.log(`Authenticated via "${authType}".`);
+      } catch (e) {
+        setAuthError(`Failed to login. Message: ${getErrorMessage(e)}`);
+        openAuthDialog();
+      } finally {
+        setIsAuthenticating(false);
+      }
+    };
+
+    void authFlow();
+  }, [isAuthDialogOpen, hasActiveModel, settings, config, setAuthError, openAuthDialog, modelManager]);
+
+  const handleAuthSelect = useCallback(
+    async (authType: AuthType | undefined, scope: SettingScope) => {
+      if (authType) {
+        await clearCachedCredentialFile();
+
+        settings.setValue(scope, 'selectedAuthType', authType);
+        if (
+          authType === AuthType.LOGIN_WITH_GOOGLE &&
+          config.isBrowserLaunchSuppressed()
+        ) {
+          runExitCleanup();
+          console.log(
+            `
+----------------------------------------------------------------
+Logging in with Google... Please restart Gemini CLI to continue.
+----------------------------------------------------------------
+            `,
+          );
+          process.exit(0);
+        }
+      }
+      setIsAuthDialogOpen(false);
+      setAuthError(null);
+    },
+    [settings, setAuthError, config],
+  );
+
+  const cancelAuthentication = useCallback(() => {
+    setIsAuthenticating(false);
+  }, []);
+
+  return {
+    isAuthDialogOpen,
+    openAuthDialog,
+    handleAuthSelect,
+    isAuthenticating,
+    cancelAuthentication,
+  };
+};

package/dist/ui/hooks/useAutoAcceptIndicator.test.ts

@@ -0,0 +1,300 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeEach,
+  type MockedFunction,
+  type Mock,
+} from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useAutoAcceptIndicator } from './useAutoAcceptIndicator.js';
+
+import {
+  Config,
+  Config as ActualConfigType,
+  ApprovalMode,
+} from 'fss-link-core';
+import { useKeypress, Key } from './useKeypress.js';
+
+vi.mock('./useKeypress.js');
+
+vi.mock('fss-link-core', async () => {
+  const actualServerModule = (await vi.importActual(
+    'fss-link-core',
+  )) as Record<string, unknown>;
+  return {
+    ...actualServerModule,
+    Config: vi.fn(),
+  };
+});
+
+interface MockConfigInstanceShape {
+  getApprovalMode: Mock<() => ApprovalMode>;
+  setApprovalMode: Mock<(value: ApprovalMode) => void>;
+  getCoreTools: Mock<() => string[]>;
+  getToolDiscoveryCommand: Mock<() => string | undefined>;
+  getTargetDir: Mock<() => string>;
+  getApiKey: Mock<() => string>;
+  getModel: Mock<() => string>;
+  getSandbox: Mock<() => boolean | string>;
+  getDebugMode: Mock<() => boolean>;
+  getQuestion: Mock<() => string | undefined>;
+  getFullContext: Mock<() => boolean>;
+  getUserAgent: Mock<() => string>;
+  getUserMemory: Mock<() => string>;
+  getGeminiMdFileCount: Mock<() => number>;
+  getToolRegistry: Mock<() => { discoverTools: Mock<() => void> }>;
+}
+
+type UseKeypressHandler = (key: Key) => void;
+
+describe('useAutoAcceptIndicator', () => {
+  let mockConfigInstance: MockConfigInstanceShape;
+  let capturedUseKeypressHandler: UseKeypressHandler;
+  let mockedUseKeypress: MockedFunction<typeof useKeypress>;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    (
+      Config as unknown as MockedFunction<() => MockConfigInstanceShape>
+    ).mockImplementation(() => {
+      const instanceGetApprovalModeMock = vi.fn();
+      const instanceSetApprovalModeMock = vi.fn();
+
+      const instance: MockConfigInstanceShape = {
+        getApprovalMode: instanceGetApprovalModeMock as Mock<
+          () => ApprovalMode
+        >,
+        setApprovalMode: instanceSetApprovalModeMock as Mock<
+          (value: ApprovalMode) => void
+        >,
+        getCoreTools: vi.fn().mockReturnValue([]) as Mock<() => string[]>,
+        getToolDiscoveryCommand: vi.fn().mockReturnValue(undefined) as Mock<
+          () => string | undefined
+        >,
+        getTargetDir: vi.fn().mockReturnValue('.') as Mock<() => string>,
+        getApiKey: vi.fn().mockReturnValue('test-api-key') as Mock<
+          () => string
+        >,
+        getModel: vi.fn().mockReturnValue('test-model') as Mock<() => string>,
+        getSandbox: vi.fn().mockReturnValue(false) as Mock<
+          () => boolean | string
+        >,
+        getDebugMode: vi.fn().mockReturnValue(false) as Mock<() => boolean>,
+        getQuestion: vi.fn().mockReturnValue(undefined) as Mock<
+          () => string | undefined
+        >,
+        getFullContext: vi.fn().mockReturnValue(false) as Mock<() => boolean>,
+        getUserAgent: vi.fn().mockReturnValue('test-user-agent') as Mock<
+          () => string
+        >,
+        getUserMemory: vi.fn().mockReturnValue('') as Mock<() => string>,
+        getGeminiMdFileCount: vi.fn().mockReturnValue(0) as Mock<() => number>,
+        getToolRegistry: vi
+          .fn()
+          .mockReturnValue({ discoverTools: vi.fn() }) as Mock<
+          () => { discoverTools: Mock<() => void> }
+        >,
+      };
+      instanceSetApprovalModeMock.mockImplementation((value: ApprovalMode) => {
+        instanceGetApprovalModeMock.mockReturnValue(value);
+      });
+      return instance;
+    });
+
+    mockedUseKeypress = useKeypress as MockedFunction<typeof useKeypress>;
+    mockedUseKeypress.mockImplementation(
+      (handler: UseKeypressHandler, _options) => {
+        capturedUseKeypressHandler = handler;
+      },
+    );
+
+     
+    mockConfigInstance = new (Config as any)() as MockConfigInstanceShape;
+  });
+
+  it('should initialize with ApprovalMode.AUTO_EDIT if config.getApprovalMode returns ApprovalMode.AUTO_EDIT', () => {
+    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.AUTO_EDIT);
+    const { result } = renderHook(() =>
+      useAutoAcceptIndicator({
+        config: mockConfigInstance as unknown as ActualConfigType,
+      }),
+    );
+    expect(result.current).toBe(ApprovalMode.AUTO_EDIT);
+    expect(mockConfigInstance.getApprovalMode).toHaveBeenCalledTimes(1);
+  });
+
+  it('should initialize with ApprovalMode.DEFAULT if config.getApprovalMode returns ApprovalMode.DEFAULT', () => {
+    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
+    const { result } = renderHook(() =>
+      useAutoAcceptIndicator({
+        config: mockConfigInstance as unknown as ActualConfigType,
+      }),
+    );
+    expect(result.current).toBe(ApprovalMode.DEFAULT);
+    expect(mockConfigInstance.getApprovalMode).toHaveBeenCalledTimes(1);
+  });
+
+  it('should initialize with ApprovalMode.YOLO if config.getApprovalMode returns ApprovalMode.YOLO', () => {
+    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.YOLO);
+    const { result } = renderHook(() =>
+      useAutoAcceptIndicator({
+        config: mockConfigInstance as unknown as ActualConfigType,
+      }),
+    );
+    expect(result.current).toBe(ApprovalMode.YOLO);
+    expect(mockConfigInstance.getApprovalMode).toHaveBeenCalledTimes(1);
+  });
+
+  it('should toggle the indicator and update config when Shift+Tab or Ctrl+Y is pressed', () => {
+    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
+    const { result } = renderHook(() =>
+      useAutoAcceptIndicator({
+        config: mockConfigInstance as unknown as ActualConfigType,
+      }),
+    );
+    expect(result.current).toBe(ApprovalMode.DEFAULT);
+
+    act(() => {
+      capturedUseKeypressHandler({
+        name: 'tab',
+        shift: true,
+      } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
+      ApprovalMode.AUTO_EDIT,
+    );
+    expect(result.current).toBe(ApprovalMode.AUTO_EDIT);
+
+    act(() => {
+      capturedUseKeypressHandler({ name: 'y', ctrl: true } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
+      ApprovalMode.YOLO,
+    );
+    expect(result.current).toBe(ApprovalMode.YOLO);
+
+    act(() => {
+      capturedUseKeypressHandler({ name: 'y', ctrl: true } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
+      ApprovalMode.DEFAULT,
+    );
+    expect(result.current).toBe(ApprovalMode.DEFAULT);
+
+    act(() => {
+      capturedUseKeypressHandler({ name: 'y', ctrl: true } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
+      ApprovalMode.YOLO,
+    );
+    expect(result.current).toBe(ApprovalMode.YOLO);
+
+    act(() => {
+      capturedUseKeypressHandler({
+        name: 'tab',
+        shift: true,
+      } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
+      ApprovalMode.AUTO_EDIT,
+    );
+    expect(result.current).toBe(ApprovalMode.AUTO_EDIT);
+
+    act(() => {
+      capturedUseKeypressHandler({
+        name: 'tab',
+        shift: true,
+      } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).toHaveBeenCalledWith(
+      ApprovalMode.DEFAULT,
+    );
+    expect(result.current).toBe(ApprovalMode.DEFAULT);
+  });
+
+  it('should not toggle if only one key or other keys combinations are pressed', () => {
+    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
+    renderHook(() =>
+      useAutoAcceptIndicator({
+        config: mockConfigInstance as unknown as ActualConfigType,
+      }),
+    );
+
+    act(() => {
+      capturedUseKeypressHandler({
+        name: 'tab',
+        shift: false,
+      } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
+
+    act(() => {
+      capturedUseKeypressHandler({
+        name: 'unknown',
+        shift: true,
+      } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
+
+    act(() => {
+      capturedUseKeypressHandler({
+        name: 'a',
+        shift: false,
+        ctrl: false,
+      } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
+
+    act(() => {
+      capturedUseKeypressHandler({ name: 'y', ctrl: false } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
+
+    act(() => {
+      capturedUseKeypressHandler({ name: 'a', ctrl: true } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
+
+    act(() => {
+      capturedUseKeypressHandler({ name: 'y', shift: true } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
+
+    act(() => {
+      capturedUseKeypressHandler({
+        name: 'a',
+        ctrl: true,
+        shift: true,
+      } as Key);
+    });
+    expect(mockConfigInstance.setApprovalMode).not.toHaveBeenCalled();
+  });
+
+  it('should update indicator when config value changes externally (useEffect dependency)', () => {
+    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
+    const { result, rerender } = renderHook(
+      (props: { config: ActualConfigType }) => useAutoAcceptIndicator(props),
+      {
+        initialProps: {
+          config: mockConfigInstance as unknown as ActualConfigType,
+        },
+      },
+    );
+    expect(result.current).toBe(ApprovalMode.DEFAULT);
+
+    mockConfigInstance.getApprovalMode.mockReturnValue(ApprovalMode.AUTO_EDIT);
+
+    rerender({ config: mockConfigInstance as unknown as ActualConfigType });
+    expect(result.current).toBe(ApprovalMode.AUTO_EDIT);
+    expect(mockConfigInstance.getApprovalMode).toHaveBeenCalledTimes(3);
+  });
+});