fss-link 1.0.49 → 1.0.51

package/dist/ui/hooks/usePhraseCycler.ts

@@ -1,198 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useState, useEffect, useRef } from 'react';
-
-export const WITTY_LOADING_PHRASES = [
-  "I'm Feeling Lucky",
-  'Shipping awesomeness... ',
-  'Painting the serifs back on...',
-  'Navigating the slime mold...',
-  'Consulting the digital spirits...',
-  'Reticulating splines...',
-  'Warming up the AI hamsters...',
-  'Asking the magic conch shell...',
-  'Generating witty retort...',
-  'Polishing the algorithms...',
-  "Don't rush perfection (or my code)...",
-  'Brewing fresh bytes...',
-  'Counting electrons...',
-  'Engaging cognitive processors...',
-  'Checking for syntax errors in the universe...',
-  'One moment, optimizing humor...',
-  'Shuffling punchlines...',
-  'Untangling neural nets...',
-  'Compiling brilliance...',
-  'Loading wit.exe...',
-  'Summoning the cloud of wisdom...',
-  'Preparing a witty response...',
-  "Just a sec, I'm debugging reality...",
-  'Confuzzling the options...',
-  'Tuning the cosmic frequencies...',
-  'Crafting a response worthy of your patience...',
-  'Compiling the 1s and 0s...',
-  'Resolving dependencies... and existential crises...',
-  'Defragmenting memories... both RAM and personal...',
-  'Rebooting the humor module...',
-  'Caching the essentials (mostly cat memes)...',
-  'Optimizing for ludicrous speed',
-  "Swapping bits... don't tell the bytes...",
-  'Garbage collecting... be right back...',
-  'Assembling the interwebs...',
-  'Converting coffee into code...',
-  'Updating the syntax for reality...',
-  'Rewiring the synapses...',
-  'Looking for a misplaced semicolon...',
-  "Greasin' the cogs of the machine...",
-  'Pre-heating the servers...',
-  'Calibrating the flux capacitor...',
-  'Engaging the improbability drive...',
-  'Channeling the Force...',
-  'Aligning the stars for optimal response...',
-  'So say we all...',
-  'Loading the next great idea...',
-  "Just a moment, I'm in the zone...",
-  'Preparing to dazzle you with brilliance...',
-  "Just a tick, I'm polishing my wit...",
-  "Hold tight, I'm crafting a masterpiece...",
-  "Just a jiffy, I'm debugging the universe...",
-  "Just a moment, I'm aligning the pixels...",
-  "Just a sec, I'm optimizing the humor...",
-  "Just a moment, I'm tuning the algorithms...",
-  'Warp speed engaged...',
-  'Mining for more Dilithium crystals...',
-  "Don't panic...",
-  'Following the white rabbit...',
-  'The truth is in here... somewhere...',
-  'Blowing on the cartridge...',
-  'Loading... Do a barrel roll!',
-  'Waiting for the respawn...',
-  'Finishing the Kessel Run in less than 12 parsecs...',
-  "The cake is not a lie, it's just still loading...",
-  'Fiddling with the character creation screen...',
-  "Just a moment, I'm finding the right meme...",
-  "Pressing 'A' to continue...",
-  'Herding digital cats...',
-  'Polishing the pixels...',
-  'Finding a suitable loading screen pun...',
-  'Distracting you with this witty phrase...',
-  'Almost there... probably...',
-  'Our hamsters are working as fast as they can...',
-  'Giving Cloudy a pat on the head...',
-  'Petting the cat...',
-  'Rickrolling my boss...',
-  'Never gonna give you up, never gonna let you down...',
-  'Slapping the bass...',
-  'Tasting the snozberries...',
-  "I'm going the distance, I'm going for speed...",
-  'Is this the real life? Is this just fantasy?...',
-  "I've got a good feeling about this...",
-  'Poking the bear...',
-  'Doing research on the latest memes...',
-  'Figuring out how to make this more witty...',
-  'Hmmm... let me think...',
-  'What do you call a fish with no eyes? A fsh...',
-  'Why did the computer go to therapy? It had too many bytes...',
-  "Why don't programmers like nature? It has too many bugs...",
-  'Why do programmers prefer dark mode? Because light attracts bugs...',
-  'Why did the developer go broke? Because they used up all their cache...',
-  "What can you do with a broken pencil? Nothing, it's pointless...",
-  'Applying percussive maintenance...',
-  'Searching for the correct USB orientation...',
-  'Ensuring the magic smoke stays inside the wires...',
-  'Rewriting in Rust for no particular reason...',
-  'Trying to exit Vim...',
-  'Spinning up the hamster wheel...',
-  "That's not a bug, it's an undocumented feature...",
-  'Engage.',
-  "I'll be back... with an answer.",
-  'My other process is a TARDIS...',
-  'Communing with the machine spirit...',
-  'Letting the thoughts marinate...',
-  'Just remembered where I put my keys...',
-  'Pondering the orb...',
-  "I've seen things you people wouldn't believe... like a user who reads loading messages.",
-  'Initiating thoughtful gaze...',
-  "What's a computer's favorite snack? Microchips.",
-  "Why do Java developers wear glasses? Because they don't C#.",
-  'Charging the laser... pew pew!',
-  'Dividing by zero... just kidding!',
-  'Looking for an adult superviso... I mean, processing.',
-  'Making it go beep boop.',
-  'Buffering... because even AIs need a moment.',
-  'Entangling quantum particles for a faster response...',
-  'Polishing the chrome... on the algorithms.',
-  'Are you not entertained? (Working on it!)',
-  'Summoning the code gremlins... to help, of course.',
-  'Just waiting for the dial-up tone to finish...',
-  'Recalibrating the humor-o-meter.',
-  'My other loading screen is even funnier.',
-  "Pretty sure there's a cat walking on the keyboard somewhere...",
-  'Enhancing... Enhancing... Still loading.',
-  "It's not a bug, it's a feature... of this loading screen.",
-  'Have you tried turning it off and on again? (The loading screen, not me.)',
-  'Constructing additional pylons...',
-  'New line? That’s Ctrl+J.',
-];
-
-export const PHRASE_CHANGE_INTERVAL_MS = 15000;
-
-/**
- * Custom hook to manage cycling through loading phrases.
- * @param isActive Whether the phrase cycling should be active.
- * @param isWaiting Whether to show a specific waiting phrase.
- * @returns The current loading phrase.
- */
-export const usePhraseCycler = (isActive: boolean, isWaiting: boolean) => {
-  const [currentLoadingPhrase, setCurrentLoadingPhrase] = useState(
-    WITTY_LOADING_PHRASES[0],
-  );
-  const phraseIntervalRef = useRef<NodeJS.Timeout | null>(null);
-
-  useEffect(() => {
-    if (isWaiting) {
-      setCurrentLoadingPhrase('Waiting for user confirmation...');
-      if (phraseIntervalRef.current) {
-        clearInterval(phraseIntervalRef.current);
-        phraseIntervalRef.current = null;
-      }
-    } else if (isActive) {
-      if (phraseIntervalRef.current) {
-        clearInterval(phraseIntervalRef.current);
-      }
-      // Select an initial random phrase
-      const initialRandomIndex = Math.floor(
-        Math.random() * WITTY_LOADING_PHRASES.length,
-      );
-      setCurrentLoadingPhrase(WITTY_LOADING_PHRASES[initialRandomIndex]);
-
-      phraseIntervalRef.current = setInterval(() => {
-        // Select a new random phrase
-        const randomIndex = Math.floor(
-          Math.random() * WITTY_LOADING_PHRASES.length,
-        );
-        setCurrentLoadingPhrase(WITTY_LOADING_PHRASES[randomIndex]);
-      }, PHRASE_CHANGE_INTERVAL_MS);
-    } else {
-      // Idle or other states, clear the phrase interval
-      // and reset to the first phrase for next active state.
-      if (phraseIntervalRef.current) {
-        clearInterval(phraseIntervalRef.current);
-        phraseIntervalRef.current = null;
-      }
-      setCurrentLoadingPhrase(WITTY_LOADING_PHRASES[0]);
-    }
-
-    return () => {
-      if (phraseIntervalRef.current) {
-        clearInterval(phraseIntervalRef.current);
-        phraseIntervalRef.current = null;
-      }
-    };
-  }, [isActive, isWaiting]);
-
-  return currentLoadingPhrase;
-};

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

@@ -1,242 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { renderHook, waitFor } from '@testing-library/react';
-import {
-  Config,
-  CodeAssistServer,
-  LoggingContentGenerator,
-  UserTierId,
-  GeminiClient,
-  ContentGenerator,
-} from 'fss-link-core';
-import { OAuth2Client } from 'google-auth-library';
-import { usePrivacySettings } from './usePrivacySettings.js';
-
-// Mock the dependencies
-vi.mock('fss-link-core', () => {
-  // Mock classes for instanceof checks
-  class MockCodeAssistServer {
-    projectId = 'test-project-id';
-    loadCodeAssist = vi.fn();
-    getCodeAssistGlobalUserSetting = vi.fn();
-    setCodeAssistGlobalUserSetting = vi.fn();
-
-    constructor(
-      _client?: GeminiClient,
-      _projectId?: string,
-      _httpOptions?: Record<string, unknown>,
-      _sessionId?: string,
-      _userTier?: UserTierId,
-    ) {}
-  }
-
-  class MockLoggingContentGenerator {
-    getWrapped = vi.fn();
-
-    constructor(
-      _wrapped?: ContentGenerator,
-      _config?: Record<string, unknown>,
-    ) {}
-  }
-
-  return {
-    Config: vi.fn(),
-    CodeAssistServer: MockCodeAssistServer,
-    LoggingContentGenerator: MockLoggingContentGenerator,
-    GeminiClient: vi.fn(),
-    UserTierId: {
-      FREE: 'free-tier',
-      LEGACY: 'legacy-tier',
-      STANDARD: 'standard-tier',
-    },
-  };
-});
-
-describe('usePrivacySettings', () => {
-  let mockConfig: Config;
-  let mockClient: GeminiClient;
-  let mockCodeAssistServer: CodeAssistServer;
-  let mockLoggingContentGenerator: LoggingContentGenerator;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Create mock CodeAssistServer instance
-    mockCodeAssistServer = new CodeAssistServer(
-      null as unknown as OAuth2Client,
-      'test-project-id',
-    ) as unknown as CodeAssistServer;
-    (
-      mockCodeAssistServer.loadCodeAssist as ReturnType<typeof vi.fn>
-    ).mockResolvedValue({
-      currentTier: { id: UserTierId.FREE },
-    });
-    (
-      mockCodeAssistServer.getCodeAssistGlobalUserSetting as ReturnType<
-        typeof vi.fn
-      >
-    ).mockResolvedValue({
-      freeTierDataCollectionOptin: true,
-    });
-    (
-      mockCodeAssistServer.setCodeAssistGlobalUserSetting as ReturnType<
-        typeof vi.fn
-      >
-    ).mockResolvedValue({
-      freeTierDataCollectionOptin: false,
-    });
-
-    // Create mock LoggingContentGenerator that wraps the CodeAssistServer
-    mockLoggingContentGenerator = new LoggingContentGenerator(
-      mockCodeAssistServer,
-      null as unknown as Config,
-    ) as unknown as LoggingContentGenerator;
-    (
-      mockLoggingContentGenerator.getWrapped as ReturnType<typeof vi.fn>
-    ).mockReturnValue(mockCodeAssistServer);
-
-    // Create mock GeminiClient
-    mockClient = {
-      getContentGenerator: vi.fn().mockReturnValue(mockLoggingContentGenerator),
-    } as unknown as GeminiClient;
-
-    // Create mock Config
-    mockConfig = {
-      getGeminiClient: vi.fn().mockReturnValue(mockClient),
-    } as unknown as Config;
-  });
-
-  it('should handle LoggingContentGenerator wrapper correctly and not throw "Oauth not being used" error', async () => {
-    const { result } = renderHook(() => usePrivacySettings(mockConfig));
-
-    // Initial state should be loading
-    expect(result.current.privacyState.isLoading).toBe(true);
-    expect(result.current.privacyState.error).toBeUndefined();
-
-    // Wait for the hook to complete
-    await waitFor(() => {
-      expect(result.current.privacyState.isLoading).toBe(false);
-    });
-
-    // Should not have the "Oauth not being used" error
-    expect(result.current.privacyState.error).toBeUndefined();
-    expect(result.current.privacyState.isFreeTier).toBe(true);
-    expect(result.current.privacyState.dataCollectionOptIn).toBe(true);
-
-    // Verify that getWrapped was called to unwrap the LoggingContentGenerator
-    expect(mockLoggingContentGenerator.getWrapped).toHaveBeenCalled();
-  });
-
-  it('should work with direct CodeAssistServer (no wrapper)', async () => {
-    // Test case where the content generator is directly a CodeAssistServer
-    const directServer = new CodeAssistServer(
-      null as unknown as OAuth2Client,
-      'test-project-id',
-    ) as unknown as CodeAssistServer;
-    (directServer.loadCodeAssist as ReturnType<typeof vi.fn>).mockResolvedValue(
-      {
-        currentTier: { id: UserTierId.FREE },
-      },
-    );
-    (
-      directServer.getCodeAssistGlobalUserSetting as ReturnType<typeof vi.fn>
-    ).mockResolvedValue({
-      freeTierDataCollectionOptin: true,
-    });
-
-    mockClient.getContentGenerator = vi.fn().mockReturnValue(directServer);
-
-    const { result } = renderHook(() => usePrivacySettings(mockConfig));
-
-    await waitFor(() => {
-      expect(result.current.privacyState.isLoading).toBe(false);
-    });
-
-    expect(result.current.privacyState.error).toBeUndefined();
-    expect(result.current.privacyState.isFreeTier).toBe(true);
-    expect(result.current.privacyState.dataCollectionOptIn).toBe(true);
-  });
-
-  it('should handle paid tier users correctly', async () => {
-    // Mock paid tier response
-    (
-      mockCodeAssistServer.loadCodeAssist as ReturnType<typeof vi.fn>
-    ).mockResolvedValue({
-      currentTier: { id: UserTierId.STANDARD },
-    });
-
-    const { result } = renderHook(() => usePrivacySettings(mockConfig));
-
-    await waitFor(() => {
-      expect(result.current.privacyState.isLoading).toBe(false);
-    });
-
-    expect(result.current.privacyState.error).toBeUndefined();
-    expect(result.current.privacyState.isFreeTier).toBe(false);
-    expect(result.current.privacyState.dataCollectionOptIn).toBeUndefined();
-  });
-
-  it('should throw error when content generator is not a CodeAssistServer', async () => {
-    // Mock a non-CodeAssistServer content generator
-    const mockOtherGenerator = { someOtherMethod: vi.fn() };
-    (
-      mockLoggingContentGenerator.getWrapped as ReturnType<typeof vi.fn>
-    ).mockReturnValue(mockOtherGenerator);
-
-    const { result } = renderHook(() => usePrivacySettings(mockConfig));
-
-    await waitFor(() => {
-      expect(result.current.privacyState.isLoading).toBe(false);
-    });
-
-    expect(result.current.privacyState.error).toBe('Oauth not being used');
-  });
-
-  it('should throw error when CodeAssistServer has no projectId', async () => {
-    // Mock CodeAssistServer without projectId
-    const mockServerNoProject = {
-      ...mockCodeAssistServer,
-      projectId: undefined,
-    };
-    (
-      mockLoggingContentGenerator.getWrapped as ReturnType<typeof vi.fn>
-    ).mockReturnValue(mockServerNoProject);
-
-    const { result } = renderHook(() => usePrivacySettings(mockConfig));
-
-    await waitFor(() => {
-      expect(result.current.privacyState.isLoading).toBe(false);
-    });
-
-    expect(result.current.privacyState.error).toBe('Oauth not being used');
-  });
-
-  it('should update data collection opt-in setting', async () => {
-    const { result } = renderHook(() => usePrivacySettings(mockConfig));
-
-    // Wait for initial load
-    await waitFor(() => {
-      expect(result.current.privacyState.isLoading).toBe(false);
-    });
-
-    // Update the setting
-    await result.current.updateDataCollectionOptIn(false);
-
-    // Wait for update to complete
-    await waitFor(() => {
-      expect(result.current.privacyState.dataCollectionOptIn).toBe(false);
-    });
-
-    expect(
-      mockCodeAssistServer.setCodeAssistGlobalUserSetting,
-    ).toHaveBeenCalledWith({
-      cloudaicompanionProject: 'test-project-id',
-      freeTierDataCollectionOptin: false,
-    });
-  });
-});

package/dist/ui/hooks/usePrivacySettings.ts

@@ -1,150 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useState, useEffect, useCallback } from 'react';
-import {
-  Config,
-  CodeAssistServer,
-  UserTierId,
-  LoggingContentGenerator,
-} from 'fss-link-core';
-
-export interface PrivacyState {
-  isLoading: boolean;
-  error?: string;
-  isFreeTier?: boolean;
-  dataCollectionOptIn?: boolean;
-}
-
-export const usePrivacySettings = (config: Config) => {
-  const [privacyState, setPrivacyState] = useState<PrivacyState>({
-    isLoading: true,
-  });
-
-  useEffect(() => {
-    const fetchInitialState = async () => {
-      setPrivacyState({
-        isLoading: true,
-      });
-      try {
-        const server = getCodeAssistServer(config);
-        const tier = await getTier(server);
-        if (tier !== UserTierId.FREE) {
-          // We don't need to fetch opt-out info since non-free tier
-          // data gathering is already worked out some other way.
-          setPrivacyState({
-            isLoading: false,
-            isFreeTier: false,
-          });
-          return;
-        }
-
-        const optIn = await getRemoteDataCollectionOptIn(server);
-        setPrivacyState({
-          isLoading: false,
-          isFreeTier: true,
-          dataCollectionOptIn: optIn,
-        });
-      } catch (e) {
-        setPrivacyState({
-          isLoading: false,
-          error: e instanceof Error ? e.message : String(e),
-        });
-      }
-    };
-    fetchInitialState();
-  }, [config]);
-
-  const updateDataCollectionOptIn = useCallback(
-    async (optIn: boolean) => {
-      try {
-        const server = getCodeAssistServer(config);
-        const updatedOptIn = await setRemoteDataCollectionOptIn(server, optIn);
-        setPrivacyState({
-          isLoading: false,
-          isFreeTier: true,
-          dataCollectionOptIn: updatedOptIn,
-        });
-      } catch (e) {
-        setPrivacyState({
-          isLoading: false,
-          error: e instanceof Error ? e.message : String(e),
-        });
-      }
-    },
-    [config],
-  );
-
-  return {
-    privacyState,
-    updateDataCollectionOptIn,
-  };
-};
-
-function getCodeAssistServer(config: Config): CodeAssistServer {
-  let server = config.getGeminiClient().getContentGenerator();
-
-  // Unwrap LoggingContentGenerator if present
-  if (server instanceof LoggingContentGenerator) {
-    server = server.getWrapped();
-  }
-
-  // Neither of these cases should ever happen.
-  if (!(server instanceof CodeAssistServer)) {
-    throw new Error('Oauth not being used');
-  } else if (!server.projectId) {
-    throw new Error('Oauth not being used');
-  }
-  return server;
-}
-
-async function getTier(server: CodeAssistServer): Promise<UserTierId> {
-  const loadRes = await server.loadCodeAssist({
-    cloudaicompanionProject: server.projectId,
-    metadata: {
-      ideType: 'IDE_UNSPECIFIED',
-      platform: 'PLATFORM_UNSPECIFIED',
-      pluginType: 'GEMINI',
-      duetProject: server.projectId,
-    },
-  });
-  if (!loadRes.currentTier) {
-    throw new Error('User does not have a current tier');
-  }
-  return loadRes.currentTier.id;
-}
-
-async function getRemoteDataCollectionOptIn(
-  server: CodeAssistServer,
-): Promise<boolean> {
-  try {
-    const resp = await server.getCodeAssistGlobalUserSetting();
-    return resp.freeTierDataCollectionOptin;
-  } catch (error: unknown) {
-    if (error && typeof error === 'object' && 'response' in error) {
-      const gaxiosError = error as {
-        response?: {
-          status?: unknown;
-        };
-      };
-      if (gaxiosError.response?.status === 404) {
-        return true;
-      }
-    }
-    throw error;
-  }
-}
-
-async function setRemoteDataCollectionOptIn(
-  server: CodeAssistServer,
-  optIn: boolean,
-): Promise<boolean> {
-  const resp = await server.setCodeAssistGlobalUserSetting({
-    cloudaicompanionProject: server.projectId,
-    freeTierDataCollectionOptin: optIn,
-  });
-  return resp.freeTierDataCollectionOptin;
-}