fss-link 1.0.49 → 1.0.51

package/dist/config/trustedFolders.test.ts

@@ -1,208 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// Mock 'os' first.
-import * as osActual from 'os';
-vi.mock('os', async (importOriginal) => {
-  const actualOs = await importOriginal<typeof osActual>();
-  return {
-    ...actualOs,
-    homedir: vi.fn(() => '/mock/home/user'),
-    platform: vi.fn(() => 'linux'),
-  };
-});
-
-import {
-  describe,
-  it,
-  expect,
-  vi,
-  beforeEach,
-  afterEach,
-  type Mocked,
-  type Mock,
-} from 'vitest';
-import * as fs from 'fs';
-import stripJsonComments from 'strip-json-comments';
-import * as path from 'path';
-
-import {
-  loadTrustedFolders,
-  USER_TRUSTED_FOLDERS_PATH,
-  TrustLevel,
-  isWorkspaceTrusted,
-} from './trustedFolders.js';
-import { Settings } from './settings.js';
-
-vi.mock('fs', async (importOriginal) => {
-  const actualFs = await importOriginal<typeof fs>();
-  return {
-    ...actualFs,
-    existsSync: vi.fn(),
-    readFileSync: vi.fn(),
-    writeFileSync: vi.fn(),
-    mkdirSync: vi.fn(),
-  };
-});
-
-vi.mock('strip-json-comments', () => ({
-  default: vi.fn((content) => content),
-}));
-
-describe('Trusted Folders Loading', () => {
-  let mockFsExistsSync: Mocked<typeof fs.existsSync>;
-  let mockStripJsonComments: Mocked<typeof stripJsonComments>;
-  let mockFsWriteFileSync: Mocked<typeof fs.writeFileSync>;
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-    mockFsExistsSync = vi.mocked(fs.existsSync);
-    mockStripJsonComments = vi.mocked(stripJsonComments);
-    mockFsWriteFileSync = vi.mocked(fs.writeFileSync);
-    vi.mocked(osActual.homedir).mockReturnValue('/mock/home/user');
-    (mockStripJsonComments as unknown as Mock).mockImplementation(
-      (jsonString: string) => jsonString,
-    );
-    (mockFsExistsSync as Mock).mockReturnValue(false);
-    (fs.readFileSync as Mock).mockReturnValue('{}');
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should load empty rules if no files exist', () => {
-    const { rules, errors } = loadTrustedFolders();
-    expect(rules).toEqual([]);
-    expect(errors).toEqual([]);
-  });
-
-  it('should load user rules if only user file exists', () => {
-    const userPath = USER_TRUSTED_FOLDERS_PATH;
-    (mockFsExistsSync as Mock).mockImplementation((p) => p === userPath);
-    const userContent = {
-      '/user/folder': TrustLevel.TRUST_FOLDER,
-    };
-    (fs.readFileSync as Mock).mockImplementation((p) => {
-      if (p === userPath) return JSON.stringify(userContent);
-      return '{}';
-    });
-
-    const { rules, errors } = loadTrustedFolders();
-    expect(rules).toEqual([
-      { path: '/user/folder', trustLevel: TrustLevel.TRUST_FOLDER },
-    ]);
-    expect(errors).toEqual([]);
-  });
-
-  it('should handle JSON parsing errors gracefully', () => {
-    const userPath = USER_TRUSTED_FOLDERS_PATH;
-    (mockFsExistsSync as Mock).mockImplementation((p) => p === userPath);
-    (fs.readFileSync as Mock).mockImplementation((p) => {
-      if (p === userPath) return 'invalid json';
-      return '{}';
-    });
-
-    const { rules, errors } = loadTrustedFolders();
-    expect(rules).toEqual([]);
-    expect(errors.length).toBe(1);
-    expect(errors[0].path).toBe(userPath);
-    expect(errors[0].message).toContain('Unexpected token');
-  });
-
-  it('setValue should update the user config and save it', () => {
-    const loadedFolders = loadTrustedFolders();
-    loadedFolders.setValue('/new/path', TrustLevel.TRUST_FOLDER);
-
-    expect(loadedFolders.user.config['/new/path']).toBe(
-      TrustLevel.TRUST_FOLDER,
-    );
-    expect(mockFsWriteFileSync).toHaveBeenCalledWith(
-      USER_TRUSTED_FOLDERS_PATH,
-      JSON.stringify({ '/new/path': TrustLevel.TRUST_FOLDER }, null, 2),
-      'utf-8',
-    );
-  });
-});
-
-describe('isWorkspaceTrusted', () => {
-  let mockCwd: string;
-  const mockRules: Record<string, TrustLevel> = {};
-  const mockSettings: Settings = {
-    folderTrustFeature: true,
-    folderTrust: true,
-  };
-
-  beforeEach(() => {
-    vi.spyOn(process, 'cwd').mockImplementation(() => mockCwd);
-    vi.spyOn(fs, 'readFileSync').mockImplementation((p) => {
-      if (p === USER_TRUSTED_FOLDERS_PATH) {
-        return JSON.stringify(mockRules);
-      }
-      return '{}';
-    });
-    vi.spyOn(fs, 'existsSync').mockImplementation(
-      (p) => p === USER_TRUSTED_FOLDERS_PATH,
-    );
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    // Clear the object
-    Object.keys(mockRules).forEach((key) => delete mockRules[key]);
-  });
-
-  it('should return true for a directly trusted folder', () => {
-    mockCwd = '/home/user/projectA';
-    mockRules['/home/user/projectA'] = TrustLevel.TRUST_FOLDER;
-    expect(isWorkspaceTrusted(mockSettings)).toBe(true);
-  });
-
-  it('should return true for a child of a trusted folder', () => {
-    mockCwd = '/home/user/projectA/src';
-    mockRules['/home/user/projectA'] = TrustLevel.TRUST_FOLDER;
-    expect(isWorkspaceTrusted(mockSettings)).toBe(true);
-  });
-
-  it('should return true for a child of a trusted parent folder', () => {
-    mockCwd = '/home/user/projectB';
-    mockRules['/home/user/projectB/somefile.txt'] = TrustLevel.TRUST_PARENT;
-    expect(isWorkspaceTrusted(mockSettings)).toBe(true);
-  });
-
-  it('should return false for a directly untrusted folder', () => {
-    mockCwd = '/home/user/untrusted';
-    mockRules['/home/user/untrusted'] = TrustLevel.DO_NOT_TRUST;
-    expect(isWorkspaceTrusted(mockSettings)).toBe(false);
-  });
-
-  it('should return undefined for a child of an untrusted folder', () => {
-    mockCwd = '/home/user/untrusted/src';
-    mockRules['/home/user/untrusted'] = TrustLevel.DO_NOT_TRUST;
-    expect(isWorkspaceTrusted(mockSettings)).toBeUndefined();
-  });
-
-  it('should return undefined when no rules match', () => {
-    mockCwd = '/home/user/other';
-    mockRules['/home/user/projectA'] = TrustLevel.TRUST_FOLDER;
-    mockRules['/home/user/untrusted'] = TrustLevel.DO_NOT_TRUST;
-    expect(isWorkspaceTrusted(mockSettings)).toBeUndefined();
-  });
-
-  it('should prioritize trust over distrust', () => {
-    mockCwd = '/home/user/projectA/untrusted';
-    mockRules['/home/user/projectA'] = TrustLevel.TRUST_FOLDER;
-    mockRules['/home/user/projectA/untrusted'] = TrustLevel.DO_NOT_TRUST;
-    expect(isWorkspaceTrusted(mockSettings)).toBe(true);
-  });
-
-  it('should handle path normalization', () => {
-    mockCwd = '/home/user/projectA';
-    mockRules[`/home/user/../user/${path.basename('/home/user/projectA')}`] =
-      TrustLevel.TRUST_FOLDER;
-    expect(isWorkspaceTrusted(mockSettings)).toBe(true);
-  });
-});

package/dist/config/trustedFolders.ts

@@ -1,167 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { homedir } from 'os';
-import { getErrorMessage, isWithinRoot } from 'fss-link-core';
-import { Settings } from './settings.js';
-import stripJsonComments from 'strip-json-comments';
-
-export const TRUSTED_FOLDERS_FILENAME = 'trustedFolders.json';
-export const SETTINGS_DIRECTORY_NAME = '.fss-link';
-export const USER_SETTINGS_DIR = path.join(homedir(), SETTINGS_DIRECTORY_NAME);
-export const USER_TRUSTED_FOLDERS_PATH = path.join(
-  USER_SETTINGS_DIR,
-  TRUSTED_FOLDERS_FILENAME,
-);
-
-export enum TrustLevel {
-  TRUST_FOLDER = 'TRUST_FOLDER',
-  TRUST_PARENT = 'TRUST_PARENT',
-  DO_NOT_TRUST = 'DO_NOT_TRUST',
-}
-
-export interface TrustRule {
-  path: string;
-  trustLevel: TrustLevel;
-}
-
-export interface TrustedFoldersError {
-  message: string;
-  path: string;
-}
-
-export interface TrustedFoldersFile {
-  config: Record<string, TrustLevel>;
-  path: string;
-}
-
-export class LoadedTrustedFolders {
-  constructor(
-    public user: TrustedFoldersFile,
-    public errors: TrustedFoldersError[],
-  ) {}
-
-  get rules(): TrustRule[] {
-    return Object.entries(this.user.config).map(([path, trustLevel]) => ({
-      path,
-      trustLevel,
-    }));
-  }
-
-  setValue(path: string, trustLevel: TrustLevel): void {
-    this.user.config[path] = trustLevel;
-    saveTrustedFolders(this.user);
-  }
-}
-
-export function loadTrustedFolders(): LoadedTrustedFolders {
-  const errors: TrustedFoldersError[] = [];
-  const userConfig: Record<string, TrustLevel> = {};
-
-  const userPath = USER_TRUSTED_FOLDERS_PATH;
-
-  // Load user trusted folders
-  try {
-    if (fs.existsSync(userPath)) {
-      const content = fs.readFileSync(userPath, 'utf-8');
-      const parsed = JSON.parse(stripJsonComments(content)) as Record<
-        string,
-        TrustLevel
-      >;
-      if (parsed) {
-        Object.assign(userConfig, parsed);
-      }
-    }
-  } catch (error: unknown) {
-    errors.push({
-      message: getErrorMessage(error),
-      path: userPath,
-    });
-  }
-
-  return new LoadedTrustedFolders(
-    { path: userPath, config: userConfig },
-    errors,
-  );
-}
-
-export function saveTrustedFolders(
-  trustedFoldersFile: TrustedFoldersFile,
-): void {
-  try {
-    // Ensure the directory exists
-    const dirPath = path.dirname(trustedFoldersFile.path);
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
-    }
-
-    fs.writeFileSync(
-      trustedFoldersFile.path,
-      JSON.stringify(trustedFoldersFile.config, null, 2),
-      'utf-8',
-    );
-  } catch (error) {
-    console.error('Error saving trusted folders file:', error);
-  }
-}
-
-export function isWorkspaceTrusted(settings: Settings): boolean | undefined {
-  const folderTrustFeature = settings.folderTrustFeature ?? false;
-  const folderTrustSetting = settings.folderTrust ?? true;
-  const folderTrustEnabled = folderTrustFeature && folderTrustSetting;
-
-  if (!folderTrustEnabled) {
-    return true;
-  }
-
-  const { rules, errors } = loadTrustedFolders();
-
-  if (errors.length > 0) {
-    for (const error of errors) {
-      console.error(
-        `Error loading trusted folders config from ${error.path}: ${error.message}`,
-      );
-    }
-  }
-
-  const trustedPaths: string[] = [];
-  const untrustedPaths: string[] = [];
-
-  for (const rule of rules) {
-    switch (rule.trustLevel) {
-      case TrustLevel.TRUST_FOLDER:
-        trustedPaths.push(rule.path);
-        break;
-      case TrustLevel.TRUST_PARENT:
-        trustedPaths.push(path.dirname(rule.path));
-        break;
-      case TrustLevel.DO_NOT_TRUST:
-        untrustedPaths.push(rule.path);
-        break;
-      default:
-        // Do nothing for unknown trust levels.
-        break;
-    }
-  }
-
-  const cwd = process.cwd();
-
-  for (const trustedPath of trustedPaths) {
-    if (isWithinRoot(cwd, trustedPath)) {
-      return true;
-    }
-  }
-
-  for (const untrustedPath of untrustedPaths) {
-    if (path.normalize(cwd) === path.normalize(untrustedPath)) {
-      return false;
-    }
-  }
-
-  return undefined;
-}

package/dist/gemini.test.tsx

@@ -1,252 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import stripAnsi from 'strip-ansi';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import {
-  main,
-  setupUnhandledRejectionHandler,
-  validateDnsResolutionOrder,
-} from './gemini.js';
-import {
-  LoadedSettings,
-  SettingsFile,
-  loadSettings,
-} from './config/settings.js';
-import { appEvents, AppEvent } from './utils/events.js';
-
-// Custom error to identify mock process.exit calls
-class MockProcessExitError extends Error {
-  constructor(readonly code?: string | number | null | undefined) {
-    super('PROCESS_EXIT_MOCKED');
-    this.name = 'MockProcessExitError';
-  }
-}
-
-// Mock dependencies
-vi.mock('./config/settings.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('./config/settings.js')>();
-  return {
-    ...actual,
-    loadSettings: vi.fn(),
-  };
-});
-
-vi.mock('./config/config.js', () => ({
-  loadCliConfig: vi.fn().mockResolvedValue({
-    config: {
-      getSandbox: vi.fn(() => false),
-      getQuestion: vi.fn(() => ''),
-    },
-    modelWasSwitched: false,
-    originalModelBeforeSwitch: null,
-    finalModel: 'test-model',
-  }),
-}));
-
-vi.mock('read-package-up', () => ({
-  readPackageUp: vi.fn().mockResolvedValue({
-    packageJson: { name: 'test-pkg', version: 'test-version' },
-    path: '/fake/path/package.json',
-  }),
-}));
-
-vi.mock('update-notifier', () => ({
-  default: vi.fn(() => ({
-    notify: vi.fn(),
-  })),
-}));
-
-vi.mock('./utils/events.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('./utils/events.js')>();
-  return {
-    ...actual,
-    appEvents: {
-      emit: vi.fn(),
-    },
-  };
-});
-
-vi.mock('./utils/sandbox.js', () => ({
-  sandbox_command: vi.fn(() => ''), // Default to no sandbox command
-  start_sandbox: vi.fn(() => Promise.resolve()), // Mock as an async function that resolves
-}));
-
-describe('gemini.tsx main function', () => {
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-  let loadSettingsMock: ReturnType<typeof vi.mocked<typeof loadSettings>>;
-  let originalEnvGeminiSandbox: string | undefined;
-  let originalEnvSandbox: string | undefined;
-  let initialUnhandledRejectionListeners: NodeJS.UnhandledRejectionListener[] =
-    [];
-
-  const processExitSpy = vi
-    .spyOn(process, 'exit')
-    .mockImplementation((code) => {
-      throw new MockProcessExitError(code);
-    });
-
-  beforeEach(() => {
-    loadSettingsMock = vi.mocked(loadSettings);
-
-    // Store and clear sandbox-related env variables to ensure a consistent test environment
-    originalEnvGeminiSandbox = process.env['FSS_LINK_SANDBOX'];
-    originalEnvSandbox = process.env['SANDBOX'];
-    delete process.env['FSS_LINK_SANDBOX'];
-    delete process.env['SANDBOX'];
-
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    initialUnhandledRejectionListeners =
-      process.listeners('unhandledRejection');
-  });
-
-  afterEach(() => {
-    // Restore original env variables
-    if (originalEnvGeminiSandbox !== undefined) {
-      process.env['FSS_LINK_SANDBOX'] = originalEnvGeminiSandbox;
-    } else {
-      delete process.env['FSS_LINK_SANDBOX'];
-    }
-    if (originalEnvSandbox !== undefined) {
-      process.env['SANDBOX'] = originalEnvSandbox;
-    } else {
-      delete process.env['SANDBOX'];
-    }
-
-    const currentListeners = process.listeners('unhandledRejection');
-    const addedListener = currentListeners.find(
-      (listener) => !initialUnhandledRejectionListeners.includes(listener),
-    );
-
-    if (addedListener) {
-      process.removeListener('unhandledRejection', addedListener);
-    }
-    vi.restoreAllMocks();
-  });
-
-  it('should call process.exit(1) if settings have errors', async () => {
-    const settingsError = {
-      message: 'Test settings error',
-      path: '/test/settings.json',
-    };
-    const userSettingsFile: SettingsFile = {
-      path: '/user/settings.json',
-      settings: {},
-    };
-    const workspaceSettingsFile: SettingsFile = {
-      path: '/workspace/.gemini/settings.json',
-      settings: {},
-    };
-    const systemSettingsFile: SettingsFile = {
-      path: '/system/settings.json',
-      settings: {},
-    };
-    const mockLoadedSettings = new LoadedSettings(
-      systemSettingsFile,
-      userSettingsFile,
-      workspaceSettingsFile,
-      [settingsError],
-    );
-
-    loadSettingsMock.mockReturnValue(mockLoadedSettings);
-
-    try {
-      await main();
-      // If main completes without throwing, the test should fail because process.exit was expected
-      expect.fail('main function did not exit as expected');
-    } catch (error) {
-      expect(error).toBeInstanceOf(MockProcessExitError);
-      if (error instanceof MockProcessExitError) {
-        expect(error.code).toBe(1);
-      }
-    }
-
-    // Verify console.error was called with the error message
-    expect(consoleErrorSpy).toHaveBeenCalledTimes(2);
-    expect(stripAnsi(String(consoleErrorSpy.mock.calls[0][0]))).toBe(
-      'Error in /test/settings.json: Test settings error',
-    );
-    expect(stripAnsi(String(consoleErrorSpy.mock.calls[1][0]))).toBe(
-      'Please fix /test/settings.json and try again.',
-    );
-
-    // Verify process.exit was called.
-    expect(processExitSpy).toHaveBeenCalledWith(1);
-  });
-
-  it('should log unhandled promise rejections and open debug console on first error', async () => {
-    const appEventsMock = vi.mocked(appEvents);
-    const rejectionError = new Error('Test unhandled rejection');
-
-    setupUnhandledRejectionHandler();
-    // Simulate an unhandled rejection.
-    // We are not using Promise.reject here as vitest will catch it.
-    // Instead we will dispatch the event manually.
-    process.emit('unhandledRejection', rejectionError, Promise.resolve());
-
-    // We need to wait for the rejection handler to be called.
-    await new Promise(process.nextTick);
-
-    expect(appEventsMock.emit).toHaveBeenCalledWith(AppEvent.OpenDebugConsole);
-    expect(appEventsMock.emit).toHaveBeenCalledWith(
-      AppEvent.LogError,
-      expect.stringContaining('Unhandled Promise Rejection'),
-    );
-    expect(appEventsMock.emit).toHaveBeenCalledWith(
-      AppEvent.LogError,
-      expect.stringContaining('Please file a bug report using the /bug tool.'),
-    );
-
-    // Simulate a second rejection
-    const secondRejectionError = new Error('Second test unhandled rejection');
-    process.emit('unhandledRejection', secondRejectionError, Promise.resolve());
-    await new Promise(process.nextTick);
-
-    // Ensure emit was only called once for OpenDebugConsole
-    const openDebugConsoleCalls = appEventsMock.emit.mock.calls.filter(
-      (call) => call[0] === AppEvent.OpenDebugConsole,
-    );
-    expect(openDebugConsoleCalls.length).toBe(1);
-
-    // Avoid the process.exit error from being thrown.
-    processExitSpy.mockRestore();
-  });
-});
-
-describe('validateDnsResolutionOrder', () => {
-  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleWarnSpy.mockRestore();
-  });
-
-  it('should return "ipv4first" when the input is "ipv4first"', () => {
-    expect(validateDnsResolutionOrder('ipv4first')).toBe('ipv4first');
-    expect(consoleWarnSpy).not.toHaveBeenCalled();
-  });
-
-  it('should return "verbatim" when the input is "verbatim"', () => {
-    expect(validateDnsResolutionOrder('verbatim')).toBe('verbatim');
-    expect(consoleWarnSpy).not.toHaveBeenCalled();
-  });
-
-  it('should return the default "ipv4first" when the input is undefined', () => {
-    expect(validateDnsResolutionOrder(undefined)).toBe('ipv4first');
-    expect(consoleWarnSpy).not.toHaveBeenCalled();
-  });
-
-  it('should return the default "ipv4first" and log a warning for an invalid string', () => {
-    expect(validateDnsResolutionOrder('invalid-value')).toBe('ipv4first');
-    expect(consoleWarnSpy).toHaveBeenCalledOnce();
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      'Invalid value for dnsResolutionOrder in settings: "invalid-value". Using default "ipv4first".',
-    );
-  });
-});