fss-link 1.0.40 → 1.0.45

package/dist/ui/components/AuthDialog.test.tsx

@@ -0,0 +1,334 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { AuthDialog } from './AuthDialog.js';
+import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import { AuthType } from 'fss-link-core';
+import { renderWithProviders } from '../../test-utils/render.js';
+
+describe('AuthDialog', () => {
+  const wait = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+    process.env['GEMINI_API_KEY'] = '';
+    process.env['GEMINI_DEFAULT_AUTH_TYPE'] = '';
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('should show an error if the initial auth type is invalid', () => {
+    process.env['GEMINI_API_KEY'] = '';
+
+    const settings: LoadedSettings = new LoadedSettings(
+      {
+        settings: { customThemes: {}, mcpServers: {} },
+        path: '',
+      },
+      {
+        settings: {
+          selectedAuthType: AuthType.USE_GEMINI,
+        },
+        path: '',
+      },
+      {
+        settings: { customThemes: {}, mcpServers: {} },
+        path: '',
+      },
+      [],
+    );
+
+    const { lastFrame } = renderWithProviders(
+      <AuthDialog
+        onSelect={() => {}}
+        settings={settings}
+        initialErrorMessage="GEMINI_API_KEY  environment variable not found"
+      />,
+    );
+
+    expect(lastFrame()).toContain(
+      'GEMINI_API_KEY  environment variable not found',
+    );
+  });
+
+  describe('GEMINI_API_KEY environment variable', () => {
+    it('should detect GEMINI_API_KEY environment variable', () => {
+      process.env['GEMINI_API_KEY'] = 'foobar';
+
+      const settings: LoadedSettings = new LoadedSettings(
+        {
+          settings: {
+            selectedAuthType: undefined,
+            customThemes: {},
+            mcpServers: {},
+          },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        [],
+      );
+
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );
+
+      // Since the auth dialog only shows OpenAI option now,
+      // it won't show GEMINI_API_KEY messages
+      expect(lastFrame()).toContain('OpenAI');
+    });
+
+    it('should not show the GEMINI_API_KEY message if GEMINI_DEFAULT_AUTH_TYPE is set to something else', () => {
+      process.env['GEMINI_API_KEY'] = 'foobar';
+      process.env['GEMINI_DEFAULT_AUTH_TYPE'] = AuthType.LOGIN_WITH_GOOGLE;
+
+      const settings: LoadedSettings = new LoadedSettings(
+        {
+          settings: {
+            selectedAuthType: undefined,
+            customThemes: {},
+            mcpServers: {},
+          },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        [],
+      );
+
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );
+
+      expect(lastFrame()).not.toContain(
+        'Existing API key detected (GEMINI_API_KEY)',
+      );
+    });
+
+    it('should show the GEMINI_API_KEY message if GEMINI_DEFAULT_AUTH_TYPE is set to use api key', () => {
+      process.env['GEMINI_API_KEY'] = 'foobar';
+      process.env['GEMINI_DEFAULT_AUTH_TYPE'] = AuthType.USE_GEMINI;
+
+      const settings: LoadedSettings = new LoadedSettings(
+        {
+          settings: {
+            selectedAuthType: undefined,
+            customThemes: {},
+            mcpServers: {},
+          },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        [],
+      );
+
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );
+
+      // Since the auth dialog only shows OpenAI option now,
+      // it won't show GEMINI_API_KEY messages
+      expect(lastFrame()).toContain('OpenAI');
+    });
+  });
+
+  describe('GEMINI_DEFAULT_AUTH_TYPE environment variable', () => {
+    it('should select the auth type specified by GEMINI_DEFAULT_AUTH_TYPE', () => {
+      process.env['GEMINI_DEFAULT_AUTH_TYPE'] = AuthType.USE_OPENAI;
+
+      const settings: LoadedSettings = new LoadedSettings(
+        {
+          settings: {
+            selectedAuthType: undefined,
+            customThemes: {},
+            mcpServers: {},
+          },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        [],
+      );
+
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );
+
+      // This is a bit brittle, but it's the best way to check which item is selected.
+      expect(lastFrame()).toContain('● 2. OpenAI');
+    });
+
+    it('should fall back to default if GEMINI_DEFAULT_AUTH_TYPE is not set', () => {
+      const settings: LoadedSettings = new LoadedSettings(
+        {
+          settings: {
+            selectedAuthType: undefined,
+            customThemes: {},
+            mcpServers: {},
+          },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        [],
+      );
+
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );
+
+      // Default is FSS Link OAuth (first option)
+      expect(lastFrame()).toContain('● 1. FSS Link OAuth');
+    });
+
+    it('should show an error and fall back to default if GEMINI_DEFAULT_AUTH_TYPE is invalid', () => {
+      process.env['GEMINI_DEFAULT_AUTH_TYPE'] = 'invalid-auth-type';
+
+      const settings: LoadedSettings = new LoadedSettings(
+        {
+          settings: {
+            selectedAuthType: undefined,
+            customThemes: {},
+            mcpServers: {},
+          },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        {
+          settings: { customThemes: {}, mcpServers: {} },
+          path: '',
+        },
+        [],
+      );
+
+      const { lastFrame } = renderWithProviders(
+        <AuthDialog onSelect={() => {}} settings={settings} />,
+      );
+
+      // Since the auth dialog doesn't show GEMINI_DEFAULT_AUTH_TYPE errors anymore,
+      // it will just show the default FSS Link OAuth option
+      expect(lastFrame()).toContain('● 1. FSS Link OAuth');
+    });
+  });
+
+  it('should not exit if there is already an error message', async () => {
+    const onSelect = vi.fn();
+    const settings: LoadedSettings = new LoadedSettings(
+      {
+        settings: { customThemes: {}, mcpServers: {} },
+        path: '',
+      },
+      {
+        settings: {
+          selectedAuthType: undefined,
+          customThemes: {},
+          mcpServers: {},
+        },
+        path: '',
+      },
+      {
+        settings: { customThemes: {}, mcpServers: {} },
+        path: '',
+      },
+      [],
+    );
+
+    const { lastFrame, stdin, unmount } = renderWithProviders(
+      <AuthDialog
+        onSelect={onSelect}
+        settings={settings}
+        initialErrorMessage="Initial error"
+      />,
+    );
+    await wait();
+
+    expect(lastFrame()).toContain('Initial error');
+
+    // Simulate pressing escape key
+    stdin.write('\u001b'); // ESC key
+    await wait();
+
+    // Should not call onSelect
+    expect(onSelect).not.toHaveBeenCalled();
+    unmount();
+  });
+
+  it('should allow exiting when auth method is already selected', async () => {
+    const onSelect = vi.fn();
+    const settings: LoadedSettings = new LoadedSettings(
+      {
+        settings: { customThemes: {}, mcpServers: {} },
+        path: '',
+      },
+      {
+        settings: {
+          selectedAuthType: AuthType.USE_GEMINI,
+          customThemes: {},
+          mcpServers: {},
+        },
+        path: '',
+      },
+      {
+        settings: { customThemes: {}, mcpServers: {} },
+        path: '',
+      },
+      [],
+    );
+
+    const { stdin, unmount } = renderWithProviders(
+      <AuthDialog onSelect={onSelect} settings={settings} />,
+    );
+    await wait();
+
+    // Simulate pressing escape key
+    stdin.write('\u001b'); // ESC key
+    await wait();
+
+    // Should call onSelect with undefined to exit
+    expect(onSelect).toHaveBeenCalledWith(undefined, SettingScope.User);
+    unmount();
+  });
+});

package/dist/ui/components/AuthDialog.tsx

@@ -0,0 +1,289 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { AuthType } from 'fss-link-core';
+import { Box, Text } from 'ink';
+import React, { useState } from 'react';
+import {
+  setOpenAIApiKey,
+  setOpenAIBaseUrl,
+  setOpenAIModel,
+  setOllamaBaseUrl,
+  setOllamaModel,
+  setLMStudioBaseUrl,
+  setLMStudioModel,
+  validateAuthMethod,
+} from '../../config/auth.js';
+import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import { Colors } from '../colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+import { OpenAIKeyPrompt } from './OpenAIKeyPrompt.js';
+import { OllamaModelPrompt } from './OllamaModelPrompt.js';
+import { LMStudioModelPrompt } from './LMStudioModelPrompt.js';
+import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
+import { getModelManager } from '../../config/modelManager.js';
+
+interface AuthDialogProps {
+  onSelect: (authMethod: AuthType | undefined, scope: SettingScope) => void;
+  settings: LoadedSettings;
+  initialErrorMessage?: string | null;
+}
+
+function parseDefaultAuthType(
+  defaultAuthType: string | undefined,
+): AuthType | null {
+  if (
+    defaultAuthType &&
+    Object.values(AuthType).includes(defaultAuthType as AuthType)
+  ) {
+    return defaultAuthType as AuthType;
+  }
+  return null;
+}
+
+export function AuthDialog({
+  onSelect,
+  settings,
+  initialErrorMessage,
+}: AuthDialogProps): React.JSX.Element {
+  const [errorMessage, setErrorMessage] = useState<string | null>(
+    initialErrorMessage || null,
+  );
+  const [showOpenAIKeyPrompt, setShowOpenAIKeyPrompt] = useState(false);
+  const [showOllamaModelPrompt, setShowOllamaModelPrompt] = useState(false);
+  const [showLMStudioModelPrompt, setShowLMStudioModelPrompt] = useState(false);
+  const items = [
+    { label: 'FSS Link OAuth', value: AuthType.QWEN_OAUTH },
+    { label: 'OpenAI', value: AuthType.USE_OPENAI },
+    { label: 'Ollama (Local)', value: AuthType.OLLAMA },
+    { label: 'LM Studio (Local)', value: AuthType.LM_STUDIO },
+  ];
+
+  const initialAuthIndex = Math.max(
+    0,
+    items.findIndex((item) => {
+      if (settings.merged.selectedAuthType) {
+        return item.value === settings.merged.selectedAuthType;
+      }
+
+      const defaultAuthType = parseDefaultAuthType(
+        process.env['GEMINI_DEFAULT_AUTH_TYPE'],
+      );
+      if (defaultAuthType) {
+        return item.value === defaultAuthType;
+      }
+
+      if (process.env['GEMINI_API_KEY']) {
+        return item.value === AuthType.USE_GEMINI;
+      }
+
+      return item.value === AuthType.LOGIN_WITH_GOOGLE;
+    }),
+  );
+
+  const handleAuthSelect = (authMethod: AuthType) => {
+    const error = validateAuthMethod(authMethod);
+    if (error) {
+      if (
+        authMethod === AuthType.USE_OPENAI &&
+        !process.env['OPENAI_API_KEY']
+      ) {
+        setShowOpenAIKeyPrompt(true);
+        setErrorMessage(null);
+      } else {
+        setErrorMessage(error);
+      }
+    } else if (authMethod === AuthType.OLLAMA) {
+      // Show Ollama model selection even if validation passes
+      setShowOllamaModelPrompt(true);
+      setErrorMessage(null);
+    } else if (authMethod === AuthType.LM_STUDIO) {
+      // Show LM Studio model selection even if validation passes
+      setShowLMStudioModelPrompt(true);
+      setErrorMessage(null);
+    } else {
+      setErrorMessage(null);
+      onSelect(authMethod, SettingScope.User);
+    }
+  };
+
+  const handleOpenAIKeySubmit = (
+    apiKey: string,
+    baseUrl: string,
+    model: string,
+  ) => {
+    // Save to process.env for immediate use
+    setOpenAIApiKey(apiKey);
+    setOpenAIBaseUrl(baseUrl);
+    setOpenAIModel(model);
+    
+    // Save to database for persistence
+    const modelManager = getModelManager();
+    modelManager.configureModel(
+      AuthType.USE_OPENAI,
+      model,
+      baseUrl,
+      apiKey,
+      `OpenAI: ${model}`
+    );
+    
+    setShowOpenAIKeyPrompt(false);
+    onSelect(AuthType.USE_OPENAI, SettingScope.User);
+  };
+
+  const handleOpenAIKeyCancel = () => {
+    setShowOpenAIKeyPrompt(false);
+    setErrorMessage('OpenAI API key is required to use OpenAI authentication.');
+  };
+
+  const handleOllamaModelSubmit = (
+    apiKey: string,
+    baseUrl: string,
+    model: string,
+  ) => {
+    // Save to process.env for immediate use
+    setOllamaBaseUrl(baseUrl);
+    setOllamaModel(model);
+    process.env['OLLAMA_API_KEY'] = apiKey;
+    
+    // Save to database for persistence
+    const modelManager = getModelManager();
+    modelManager.configureModel(
+      AuthType.OLLAMA,
+      model,
+      baseUrl,
+      apiKey,
+      `Ollama: ${model}`
+    );
+    
+    setShowOllamaModelPrompt(false);
+    onSelect(AuthType.OLLAMA, SettingScope.User);
+  };
+
+  const handleOllamaModelCancel = () => {
+    setShowOllamaModelPrompt(false);
+    setErrorMessage(null);
+  };
+
+  const handleLMStudioModelSubmit = (
+    apiKey: string,
+    baseUrl: string,
+    model: string,
+  ) => {
+    // Save to process.env for immediate use
+    setLMStudioBaseUrl(baseUrl);
+    setLMStudioModel(model);
+    process.env['LM_STUDIO_API_KEY'] = apiKey;
+    
+    // Save to database for persistence
+    const modelManager = getModelManager();
+    modelManager.configureModel(
+      AuthType.LM_STUDIO,
+      model,
+      baseUrl,
+      apiKey,
+      `LM Studio: ${model}`
+    );
+    
+    setShowLMStudioModelPrompt(false);
+    onSelect(AuthType.LM_STUDIO, SettingScope.User);
+  };
+
+  const handleLMStudioModelCancel = () => {
+    setShowLMStudioModelPrompt(false);
+    setErrorMessage(null);
+  };
+
+  useKeypress(
+    (key) => {
+      if (showOpenAIKeyPrompt || showOllamaModelPrompt || showLMStudioModelPrompt) {
+        return;
+      }
+
+      if (key.name === 'escape') {
+        // Prevent exit if there is an error message.
+        // This means they user is not authenticated yet.
+        if (errorMessage) {
+          return;
+        }
+        if (settings.merged.selectedAuthType === undefined) {
+          // Prevent exiting if no auth method is set
+          setErrorMessage(
+            'You must select an auth method to proceed. Press Ctrl+C twice to exit.',
+          );
+          return;
+        }
+        onSelect(undefined, SettingScope.User);
+      }
+    },
+    { isActive: true },
+  );
+
+  if (showOpenAIKeyPrompt) {
+    return (
+      <OpenAIKeyPrompt
+        onSubmit={handleOpenAIKeySubmit}
+        onCancel={handleOpenAIKeyCancel}
+      />
+    );
+  }
+
+  if (showOllamaModelPrompt) {
+    return (
+      <OllamaModelPrompt
+        onSubmit={handleOllamaModelSubmit}
+        onCancel={handleOllamaModelCancel}
+      />
+    );
+  }
+
+  if (showLMStudioModelPrompt) {
+    return (
+      <LMStudioModelPrompt
+        onSubmit={handleLMStudioModelSubmit}
+        onCancel={handleLMStudioModelCancel}
+      />
+    );
+  }
+
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={Colors.Gray}
+      flexDirection="column"
+      padding={1}
+      width="100%"
+    >
+      <Text bold>Get started</Text>
+      <Box marginTop={1}>
+        <Text>How would you like to authenticate for this project?</Text>
+      </Box>
+      <Box marginTop={1}>
+        <RadioButtonSelect
+          items={items}
+          initialIndex={initialAuthIndex}
+          onSelect={handleAuthSelect}
+        />
+      </Box>
+      {errorMessage && (
+        <Box marginTop={1}>
+          <Text color={Colors.AccentRed}>{errorMessage}</Text>
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Text color={Colors.AccentPurple}>(Use Enter to Set Auth)</Text>
+      </Box>
+      <Box marginTop={1}>
+        <Text>Terms of Services and Privacy Notice for FSS Link</Text>
+      </Box>
+      <Box marginTop={1}>
+        <Text color={Colors.AccentBlue}>
+          {'https://github.com/FSSCoding/fss-link/blob/main/README.md'}
+        </Text>
+      </Box>
+    </Box>
+  );
+}

package/dist/ui/components/AuthInProgress.tsx

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { Colors } from '../colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+
+interface AuthInProgressProps {
+  onTimeout: () => void;
+}
+
+export function AuthInProgress({
+  onTimeout,
+}: AuthInProgressProps): React.JSX.Element {
+  const [timedOut, setTimedOut] = useState(false);
+
+  useKeypress(
+    (key) => {
+      if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+        onTimeout();
+      }
+    },
+    { isActive: true },
+  );
+
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setTimedOut(true);
+      onTimeout();
+    }, 180000);
+
+    return () => clearTimeout(timer);
+  }, [onTimeout]);
+
+  return (
+    <Box
+      borderStyle="round"
+      borderColor={Colors.Gray}
+      flexDirection="column"
+      padding={1}
+      width="100%"
+    >
+      {timedOut ? (
+        <Text color={Colors.AccentRed}>
+          Authentication timed out. Please try again.
+        </Text>
+      ) : (
+        <Box>
+          <Text>
+            <Spinner type="dots" /> Waiting for auth... (Press ESC or CTRL+C to
+            cancel)
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+}