fss-link 1.0.49 → 1.0.51

package/dist/utils/userStartupWarnings.test.ts

@@ -1,87 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { getUserStartupWarnings } from './userStartupWarnings.js';
-import * as os from 'os';
-import fs from 'fs/promises';
-import path from 'path';
-
-// Mock os.homedir to control the home directory in tests
-vi.mock('os', async (importOriginal) => {
-  const actualOs = await importOriginal<typeof os>();
-  return {
-    ...actualOs,
-    homedir: vi.fn(),
-  };
-});
-
-describe('getUserStartupWarnings', () => {
-  let testRootDir: string;
-  let homeDir: string;
-
-  beforeEach(async () => {
-    testRootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'warnings-test-'));
-    homeDir = path.join(testRootDir, 'home');
-    await fs.mkdir(homeDir, { recursive: true });
-    vi.mocked(os.homedir).mockReturnValue(homeDir);
-  });
-
-  afterEach(async () => {
-    await fs.rm(testRootDir, { recursive: true, force: true });
-    vi.clearAllMocks();
-  });
-
-  describe('home directory check', () => {
-    it('should return a warning when running in home directory', async () => {
-      const warnings = await getUserStartupWarnings(homeDir);
-      expect(warnings).toContainEqual(
-        expect.stringContaining('home directory'),
-      );
-    });
-
-    it('should not return a warning when running in a project directory', async () => {
-      const projectDir = path.join(testRootDir, 'project');
-      await fs.mkdir(projectDir);
-      const warnings = await getUserStartupWarnings(projectDir);
-      expect(warnings).not.toContainEqual(
-        expect.stringContaining('home directory'),
-      );
-    });
-  });
-
-  describe('root directory check', () => {
-    it('should return a warning when running in a root directory', async () => {
-      const rootDir = path.parse(testRootDir).root;
-      const warnings = await getUserStartupWarnings(rootDir);
-      expect(warnings).toContainEqual(
-        expect.stringContaining('root directory'),
-      );
-      expect(warnings).toContainEqual(
-        expect.stringContaining('folder structure will be used'),
-      );
-    });
-
-    it('should not return a warning when running in a non-root directory', async () => {
-      const projectDir = path.join(testRootDir, 'project');
-      await fs.mkdir(projectDir);
-      const warnings = await getUserStartupWarnings(projectDir);
-      expect(warnings).not.toContainEqual(
-        expect.stringContaining('root directory'),
-      );
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle errors when checking directory', async () => {
-      const nonExistentPath = path.join(testRootDir, 'non-existent');
-      const warnings = await getUserStartupWarnings(nonExistentPath);
-      const expectedWarning =
-        'Could not verify the current directory due to a file system error.';
-      expect(warnings).toEqual([expectedWarning, expectedWarning]);
-    });
-  });
-});

package/dist/utils/userStartupWarnings.ts

@@ -1,69 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import fs from 'fs/promises';
-import * as os from 'os';
-import path from 'path';
-
-type WarningCheck = {
-  id: string;
-  check: (workspaceRoot: string) => Promise<string | null>;
-};
-
-// Individual warning checks
-const homeDirectoryCheck: WarningCheck = {
-  id: 'home-directory',
-  check: async (workspaceRoot: string) => {
-    try {
-      const [workspaceRealPath, homeRealPath] = await Promise.all([
-        fs.realpath(workspaceRoot),
-        fs.realpath(os.homedir()),
-      ]);
-
-      if (workspaceRealPath === homeRealPath) {
-        return 'You are running FSS Link in your home directory. It is recommended to run in a project-specific directory.';
-      }
-      return null;
-    } catch (_err: unknown) {
-      return 'Could not verify the current directory due to a file system error.';
-    }
-  },
-};
-
-const rootDirectoryCheck: WarningCheck = {
-  id: 'root-directory',
-  check: async (workspaceRoot: string) => {
-    try {
-      const workspaceRealPath = await fs.realpath(workspaceRoot);
-      const errorMessage =
-        'Warning: You are running FSS Link in the root directory. Your entire folder structure will be used for context. It is strongly recommended to run in a project-specific directory.';
-
-      // Check for Unix root directory
-      if (path.dirname(workspaceRealPath) === workspaceRealPath) {
-        return errorMessage;
-      }
-
-      return null;
-    } catch (_err: unknown) {
-      return 'Could not verify the current directory due to a file system error.';
-    }
-  },
-};
-
-// All warning checks
-const WARNING_CHECKS: readonly WarningCheck[] = [
-  homeDirectoryCheck,
-  rootDirectoryCheck,
-];
-
-export async function getUserStartupWarnings(
-  workspaceRoot: string,
-): Promise<string[]> {
-  const results = await Promise.all(
-    WARNING_CHECKS.map((check) => check.check(workspaceRoot)),
-  );
-  return results.filter((msg) => msg !== null);
-}

package/dist/utils/version.ts

@@ -1,12 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { getPackageJson } from './package.js';
-
-export async function getCliVersion(): Promise<string> {
-  const pkgJson = await getPackageJson();
-  return process.env['CLI_VERSION'] || pkgJson?.version || 'unknown';
-}

package/dist/validateNonInterActiveAuth.test.ts

@@ -1,260 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import {
-  validateNonInteractiveAuth,
-  NonInteractiveConfig,
-} from './validateNonInterActiveAuth.js';
-import { AuthType } from 'fss-link-core';
-import * as auth from './config/auth.js';
-
-describe('validateNonInterActiveAuth', () => {
-  let originalEnvGeminiApiKey: string | undefined;
-  let originalEnvVertexAi: string | undefined;
-  let originalEnvGcp: string | undefined;
-  let originalEnvOpenAiApiKey: string | undefined;
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-  let processExitSpy: ReturnType<typeof vi.spyOn>;
-  let refreshAuthMock: jest.MockedFunction<
-    (authType: AuthType) => Promise<unknown>
-  >;
-
-  beforeEach(() => {
-    originalEnvGeminiApiKey = process.env['GEMINI_API_KEY'];
-    originalEnvVertexAi = process.env['GOOGLE_GENAI_USE_VERTEXAI'];
-    originalEnvGcp = process.env['GOOGLE_GENAI_USE_GCA'];
-    originalEnvOpenAiApiKey = process.env['OPENAI_API_KEY'];
-    delete process.env['GEMINI_API_KEY'];
-    delete process.env['GOOGLE_GENAI_USE_VERTEXAI'];
-    delete process.env['GOOGLE_GENAI_USE_GCA'];
-    delete process.env['OPENAI_API_KEY'];
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code) => {
-      throw new Error(`process.exit(${code}) called`);
-    });
-    refreshAuthMock = vi.fn().mockResolvedValue('refreshed');
-  });
-
-  afterEach(() => {
-    if (originalEnvGeminiApiKey !== undefined) {
-      process.env['GEMINI_API_KEY'] = originalEnvGeminiApiKey;
-    } else {
-      delete process.env['GEMINI_API_KEY'];
-    }
-    if (originalEnvVertexAi !== undefined) {
-      process.env['GOOGLE_GENAI_USE_VERTEXAI'] = originalEnvVertexAi;
-    } else {
-      delete process.env['GOOGLE_GENAI_USE_VERTEXAI'];
-    }
-    if (originalEnvGcp !== undefined) {
-      process.env['GOOGLE_GENAI_USE_GCA'] = originalEnvGcp;
-    } else {
-      delete process.env['GOOGLE_GENAI_USE_GCA'];
-    }
-    if (originalEnvOpenAiApiKey !== undefined) {
-      process.env['OPENAI_API_KEY'] = originalEnvOpenAiApiKey;
-    } else {
-      delete process.env['OPENAI_API_KEY'];
-    }
-    vi.restoreAllMocks();
-  });
-
-  it('exits if no auth type is configured or env vars set', async () => {
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    try {
-      await validateNonInteractiveAuth(
-        undefined,
-        undefined,
-        nonInteractiveConfig,
-      );
-      expect.fail('Should have exited');
-    } catch (e) {
-      expect((e as Error).message).toContain('process.exit(1) called');
-    }
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Please set an Auth method'),
-    );
-    expect(processExitSpy).toHaveBeenCalledWith(1);
-  });
-
-  it('uses LOGIN_WITH_GOOGLE if GOOGLE_GENAI_USE_GCA is set', async () => {
-    process.env['GOOGLE_GENAI_USE_GCA'] = 'true';
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    await validateNonInteractiveAuth(
-      undefined,
-      undefined,
-      nonInteractiveConfig,
-    );
-    expect(refreshAuthMock).toHaveBeenCalledWith(AuthType.LOGIN_WITH_GOOGLE);
-  });
-
-  it('uses USE_GEMINI if GEMINI_API_KEY is set', async () => {
-    process.env['GEMINI_API_KEY'] = 'fake-key';
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    await validateNonInteractiveAuth(
-      undefined,
-      undefined,
-      nonInteractiveConfig,
-    );
-    expect(refreshAuthMock).toHaveBeenCalledWith(AuthType.USE_GEMINI);
-  });
-
-  it('uses USE_OPENAI if OPENAI_API_KEY is set', async () => {
-    process.env['OPENAI_API_KEY'] = 'fake-openai-key';
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    await validateNonInteractiveAuth(
-      undefined,
-      undefined,
-      nonInteractiveConfig,
-    );
-    expect(refreshAuthMock).toHaveBeenCalledWith(AuthType.USE_OPENAI);
-  });
-
-  it('uses USE_VERTEX_AI if GOOGLE_GENAI_USE_VERTEXAI is true (with GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_LOCATION)', async () => {
-    process.env['GOOGLE_GENAI_USE_VERTEXAI'] = 'true';
-    process.env['GOOGLE_CLOUD_PROJECT'] = 'test-project';
-    process.env['GOOGLE_CLOUD_LOCATION'] = 'us-central1';
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    await validateNonInteractiveAuth(
-      undefined,
-      undefined,
-      nonInteractiveConfig,
-    );
-    expect(refreshAuthMock).toHaveBeenCalledWith(AuthType.USE_VERTEX_AI);
-  });
-
-  it('uses USE_VERTEX_AI if GOOGLE_GENAI_USE_VERTEXAI is true and GOOGLE_API_KEY is set', async () => {
-    process.env['GOOGLE_GENAI_USE_VERTEXAI'] = 'true';
-    process.env['GOOGLE_API_KEY'] = 'vertex-api-key';
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    await validateNonInteractiveAuth(
-      undefined,
-      undefined,
-      nonInteractiveConfig,
-    );
-    expect(refreshAuthMock).toHaveBeenCalledWith(AuthType.USE_VERTEX_AI);
-  });
-
-  it('uses LOGIN_WITH_GOOGLE if GOOGLE_GENAI_USE_GCA is set, even with other env vars', async () => {
-    process.env['GOOGLE_GENAI_USE_GCA'] = 'true';
-    process.env['GEMINI_API_KEY'] = 'fake-key';
-    process.env['GOOGLE_GENAI_USE_VERTEXAI'] = 'true';
-    process.env['GOOGLE_CLOUD_PROJECT'] = 'test-project';
-    process.env['GOOGLE_CLOUD_LOCATION'] = 'us-central1';
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    await validateNonInteractiveAuth(
-      undefined,
-      undefined,
-      nonInteractiveConfig,
-    );
-    expect(refreshAuthMock).toHaveBeenCalledWith(AuthType.LOGIN_WITH_GOOGLE);
-  });
-
-  it('uses USE_VERTEX_AI if both GEMINI_API_KEY and GOOGLE_GENAI_USE_VERTEXAI are set', async () => {
-    process.env['GEMINI_API_KEY'] = 'fake-key';
-    process.env['GOOGLE_GENAI_USE_VERTEXAI'] = 'true';
-    process.env['GOOGLE_CLOUD_PROJECT'] = 'test-project';
-    process.env['GOOGLE_CLOUD_LOCATION'] = 'us-central1';
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    await validateNonInteractiveAuth(
-      undefined,
-      undefined,
-      nonInteractiveConfig,
-    );
-    expect(refreshAuthMock).toHaveBeenCalledWith(AuthType.USE_VERTEX_AI);
-  });
-
-  it('uses USE_GEMINI if GOOGLE_GENAI_USE_VERTEXAI is false, GEMINI_API_KEY is set, and project/location are available', async () => {
-    process.env['GOOGLE_GENAI_USE_VERTEXAI'] = 'false';
-    process.env['GEMINI_API_KEY'] = 'fake-key';
-    process.env['GOOGLE_CLOUD_PROJECT'] = 'test-project';
-    process.env['GOOGLE_CLOUD_LOCATION'] = 'us-central1';
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    await validateNonInteractiveAuth(
-      undefined,
-      undefined,
-      nonInteractiveConfig,
-    );
-    expect(refreshAuthMock).toHaveBeenCalledWith(AuthType.USE_GEMINI);
-  });
-
-  it('uses configuredAuthType if provided', async () => {
-    // Set required env var for USE_GEMINI
-    process.env['GEMINI_API_KEY'] = 'fake-key';
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    await validateNonInteractiveAuth(
-      AuthType.USE_GEMINI,
-      undefined,
-      nonInteractiveConfig,
-    );
-    expect(refreshAuthMock).toHaveBeenCalledWith(AuthType.USE_GEMINI);
-  });
-
-  it('exits if validateAuthMethod returns error', async () => {
-    // Mock validateAuthMethod to return error
-    vi.spyOn(auth, 'validateAuthMethod').mockReturnValue('Auth error!');
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-    try {
-      await validateNonInteractiveAuth(
-        AuthType.USE_GEMINI,
-        undefined,
-        nonInteractiveConfig,
-      );
-      expect.fail('Should have exited');
-    } catch (e) {
-      expect((e as Error).message).toContain('process.exit(1) called');
-    }
-    expect(consoleErrorSpy).toHaveBeenCalledWith('Auth error!');
-    expect(processExitSpy).toHaveBeenCalledWith(1);
-  });
-
-  it('skips validation if useExternalAuth is true', async () => {
-    // Mock validateAuthMethod to return error to ensure it's not being called
-    const validateAuthMethodSpy = vi
-      .spyOn(auth, 'validateAuthMethod')
-      .mockReturnValue('Auth error!');
-    const nonInteractiveConfig: NonInteractiveConfig = {
-      refreshAuth: refreshAuthMock,
-    };
-
-    // Even with an invalid auth type, it should not exit
-    // because validation is skipped.
-    await validateNonInteractiveAuth(
-      'invalid-auth-type' as AuthType,
-      true, // useExternalAuth = true
-      nonInteractiveConfig,
-    );
-
-    expect(validateAuthMethodSpy).not.toHaveBeenCalled();
-    expect(consoleErrorSpy).not.toHaveBeenCalled();
-    expect(processExitSpy).not.toHaveBeenCalled();
-    // We still expect refreshAuth to be called with the (invalid) type
-    expect(refreshAuthMock).toHaveBeenCalledWith('invalid-auth-type');
-  });
-});

package/dist/validateNonInterActiveAuth.ts

@@ -1,51 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { AuthType, Config } from 'fss-link-core';
-import { USER_SETTINGS_PATH } from './config/settings.js';
-import { validateAuthMethod } from './config/auth.js';
-
-function getAuthTypeFromEnv(): AuthType | undefined {
-  if (process.env['GOOGLE_GENAI_USE_GCA'] === 'true') {
-    return AuthType.LOGIN_WITH_GOOGLE;
-  }
-  if (process.env['GOOGLE_GENAI_USE_VERTEXAI'] === 'true') {
-    return AuthType.USE_VERTEX_AI;
-  }
-  if (process.env['GEMINI_API_KEY']) {
-    return AuthType.USE_GEMINI;
-  }
-  if (process.env['OPENAI_API_KEY']) {
-    return AuthType.USE_OPENAI;
-  }
-  return undefined;
-}
-
-export async function validateNonInteractiveAuth(
-  configuredAuthType: AuthType | undefined,
-  useExternalAuth: boolean | undefined,
-  nonInteractiveConfig: Config,
-) {
-  const effectiveAuthType = configuredAuthType || getAuthTypeFromEnv();
-
-  if (!effectiveAuthType) {
-    console.error(
-      `Please set an Auth method in your ${USER_SETTINGS_PATH} or specify one of the following environment variables before running: GEMINI_API_KEY, OPENAI_API_KEY, GOOGLE_GENAI_USE_VERTEXAI, GOOGLE_GENAI_USE_GCA`,
-    );
-    process.exit(1);
-  }
-
-  if (!useExternalAuth) {
-    const err = validateAuthMethod(effectiveAuthType);
-    if (err != null) {
-      console.error(err);
-      process.exit(1);
-    }
-  }
-
-  await nonInteractiveConfig.refreshAuth(effectiveAuthType);
-  return nonInteractiveConfig;
-}

package/dist/vitest.config.ts

@@ -1,37 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/// <reference types="vitest" />
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    include: ['**/*.{test,spec}.?(c|m)[jt]s?(x)', 'config.test.ts'],
-    exclude: ['**/node_modules/**', '**/dist/**', '**/cypress/**'],
-    environment: 'jsdom',
-    globals: true,
-    reporters: ['default', 'junit'],
-    silent: true,
-    outputFile: {
-      junit: 'junit.xml',
-    },
-    setupFiles: ['./test-setup.ts'],
-    coverage: {
-      enabled: true,
-      provider: 'v8',
-      reportsDirectory: './coverage',
-      include: ['src/**/*'],
-      reporter: [
-        ['text', { file: 'full-text-summary.txt' }],
-        'html',
-        'json',
-        'lcov',
-        'cobertura',
-        ['json-summary', { outputFile: 'coverage-summary.json' }],
-      ],
-    },
-  },
-});