fss-link 1.0.40 → 1.0.45

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

@@ -0,0 +1,283 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+  type MockedFunction,
+} from 'vitest';
+import { act } from 'react';
+import { renderHook } from '@testing-library/react';
+import { useEditorSettings } from './useEditorSettings.js';
+import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import { MessageType, type HistoryItem } from '../types.js';
+import {
+  type EditorType,
+  checkHasEditorType,
+  allowEditorTypeInSandbox,
+} from 'fss-link-core';
+
+vi.mock('fss-link-core', async () => {
+  const actual = await vi.importActual('fss-link-core');
+  return {
+    ...actual,
+    checkHasEditorType: vi.fn(() => true),
+    allowEditorTypeInSandbox: vi.fn(() => true),
+  };
+});
+
+const mockCheckHasEditorType = vi.mocked(checkHasEditorType);
+const mockAllowEditorTypeInSandbox = vi.mocked(allowEditorTypeInSandbox);
+
+describe('useEditorSettings', () => {
+  let mockLoadedSettings: LoadedSettings;
+  let mockSetEditorError: MockedFunction<(error: string | null) => void>;
+  let mockAddItem: MockedFunction<
+    (item: Omit<HistoryItem, 'id'>, timestamp: number) => void
+  >;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    mockLoadedSettings = {
+      setValue: vi.fn(),
+    } as unknown as LoadedSettings;
+
+    mockSetEditorError = vi.fn();
+    mockAddItem = vi.fn();
+
+    // Reset mock implementations to default
+    mockCheckHasEditorType.mockReturnValue(true);
+    mockAllowEditorTypeInSandbox.mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should initialize with dialog closed', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+
+    expect(result.current.isEditorDialogOpen).toBe(false);
+  });
+
+  it('should open editor dialog when openEditorDialog is called', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+
+    act(() => {
+      result.current.openEditorDialog();
+    });
+
+    expect(result.current.isEditorDialogOpen).toBe(true);
+  });
+
+  it('should close editor dialog when exitEditorDialog is called', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+    act(() => {
+      result.current.openEditorDialog();
+      result.current.exitEditorDialog();
+    });
+    expect(result.current.isEditorDialogOpen).toBe(false);
+  });
+
+  it('should handle editor selection successfully', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+
+    const editorType: EditorType = 'vscode';
+    const scope = SettingScope.User;
+
+    act(() => {
+      result.current.openEditorDialog();
+      result.current.handleEditorSelect(editorType, scope);
+    });
+
+    expect(mockLoadedSettings.setValue).toHaveBeenCalledWith(
+      scope,
+      'preferredEditor',
+      editorType,
+    );
+
+    expect(mockAddItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.INFO,
+        text: 'Editor preference set to "vscode" in User settings.',
+      },
+      expect.any(Number),
+    );
+
+    expect(mockSetEditorError).toHaveBeenCalledWith(null);
+    expect(result.current.isEditorDialogOpen).toBe(false);
+  });
+
+  it('should handle clearing editor preference (undefined editor)', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+
+    const scope = SettingScope.Workspace;
+
+    act(() => {
+      result.current.openEditorDialog();
+      result.current.handleEditorSelect(undefined, scope);
+    });
+
+    expect(mockLoadedSettings.setValue).toHaveBeenCalledWith(
+      scope,
+      'preferredEditor',
+      undefined,
+    );
+
+    expect(mockAddItem).toHaveBeenCalledWith(
+      {
+        type: MessageType.INFO,
+        text: 'Editor preference cleared in Workspace settings.',
+      },
+      expect.any(Number),
+    );
+
+    expect(mockSetEditorError).toHaveBeenCalledWith(null);
+    expect(result.current.isEditorDialogOpen).toBe(false);
+  });
+
+  it('should handle different editor types', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+
+    const editorTypes: EditorType[] = ['cursor', 'windsurf', 'vim'];
+    const scope = SettingScope.User;
+
+    editorTypes.forEach((editorType) => {
+      act(() => {
+        result.current.handleEditorSelect(editorType, scope);
+      });
+
+      expect(mockLoadedSettings.setValue).toHaveBeenCalledWith(
+        scope,
+        'preferredEditor',
+        editorType,
+      );
+
+      expect(mockAddItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: `Editor preference set to "${editorType}" in User settings.`,
+        },
+        expect.any(Number),
+      );
+    });
+  });
+
+  it('should handle different setting scopes', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+
+    const editorType: EditorType = 'vscode';
+    const scopes = [SettingScope.User, SettingScope.Workspace];
+
+    scopes.forEach((scope) => {
+      act(() => {
+        result.current.handleEditorSelect(editorType, scope);
+      });
+
+      expect(mockLoadedSettings.setValue).toHaveBeenCalledWith(
+        scope,
+        'preferredEditor',
+        editorType,
+      );
+
+      expect(mockAddItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: `Editor preference set to "vscode" in ${scope} settings.`,
+        },
+        expect.any(Number),
+      );
+    });
+  });
+
+  it('should not set preference for unavailable editors', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+
+    mockCheckHasEditorType.mockReturnValue(false);
+
+    const editorType: EditorType = 'vscode';
+    const scope = SettingScope.User;
+
+    act(() => {
+      result.current.openEditorDialog();
+      result.current.handleEditorSelect(editorType, scope);
+    });
+
+    expect(mockLoadedSettings.setValue).not.toHaveBeenCalled();
+    expect(mockAddItem).not.toHaveBeenCalled();
+    expect(result.current.isEditorDialogOpen).toBe(true);
+  });
+
+  it('should not set preference for editors not allowed in sandbox', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+
+    mockAllowEditorTypeInSandbox.mockReturnValue(false);
+
+    const editorType: EditorType = 'vscode';
+    const scope = SettingScope.User;
+
+    act(() => {
+      result.current.openEditorDialog();
+      result.current.handleEditorSelect(editorType, scope);
+    });
+
+    expect(mockLoadedSettings.setValue).not.toHaveBeenCalled();
+    expect(mockAddItem).not.toHaveBeenCalled();
+    expect(result.current.isEditorDialogOpen).toBe(true);
+  });
+
+  it('should handle errors during editor selection', () => {
+    const { result } = renderHook(() =>
+      useEditorSettings(mockLoadedSettings, mockSetEditorError, mockAddItem),
+    );
+
+    const errorMessage = 'Failed to save settings';
+    (
+      mockLoadedSettings.setValue as MockedFunction<
+        typeof mockLoadedSettings.setValue
+      >
+    ).mockImplementation(() => {
+      throw new Error(errorMessage);
+    });
+
+    const editorType: EditorType = 'vscode';
+    const scope = SettingScope.User;
+
+    act(() => {
+      result.current.openEditorDialog();
+      result.current.handleEditorSelect(editorType, scope);
+    });
+
+    expect(mockSetEditorError).toHaveBeenCalledWith(
+      `Failed to set editor preference: Error: ${errorMessage}`,
+    );
+    expect(mockAddItem).not.toHaveBeenCalled();
+    expect(result.current.isEditorDialogOpen).toBe(true);
+  });
+});

package/dist/ui/hooks/useEditorSettings.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback } from 'react';
+import { LoadedSettings, SettingScope } from '../../config/settings.js';
+import { type HistoryItem, MessageType } from '../types.js';
+import {
+  allowEditorTypeInSandbox,
+  checkHasEditorType,
+  EditorType,
+} from 'fss-link-core';
+
+interface UseEditorSettingsReturn {
+  isEditorDialogOpen: boolean;
+  openEditorDialog: () => void;
+  handleEditorSelect: (
+    editorType: EditorType | undefined,
+    scope: SettingScope,
+  ) => void;
+  exitEditorDialog: () => void;
+}
+
+export const useEditorSettings = (
+  loadedSettings: LoadedSettings,
+  setEditorError: (error: string | null) => void,
+  addItem: (item: Omit<HistoryItem, 'id'>, timestamp: number) => void,
+): UseEditorSettingsReturn => {
+  const [isEditorDialogOpen, setIsEditorDialogOpen] = useState(false);
+
+  const openEditorDialog = useCallback(() => {
+    setIsEditorDialogOpen(true);
+  }, []);
+
+  const handleEditorSelect = useCallback(
+    (editorType: EditorType | undefined, scope: SettingScope) => {
+      if (
+        editorType &&
+        (!checkHasEditorType(editorType) ||
+          !allowEditorTypeInSandbox(editorType))
+      ) {
+        return;
+      }
+
+      try {
+        loadedSettings.setValue(scope, 'preferredEditor', editorType);
+        addItem(
+          {
+            type: MessageType.INFO,
+            text: `Editor preference ${editorType ? `set to "${editorType}"` : 'cleared'} in ${scope} settings.`,
+          },
+          Date.now(),
+        );
+        setEditorError(null);
+        setIsEditorDialogOpen(false);
+      } catch (error) {
+        setEditorError(`Failed to set editor preference: ${error}`);
+      }
+    },
+    [loadedSettings, setEditorError, addItem],
+  );
+
+  const exitEditorDialog = useCallback(() => {
+    setIsEditorDialogOpen(false);
+  }, []);
+
+  return {
+    isEditorDialogOpen,
+    openEditorDialog,
+    handleEditorSelect,
+    exitEditorDialog,
+  };
+};

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

@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { renderHook, act } from '@testing-library/react';
+import { EventEmitter } from 'events';
+import { useFocus } from './useFocus.js';
+import { vi } from 'vitest';
+import { useStdin, useStdout } from 'ink';
+
+// Mock the ink hooks
+vi.mock('ink', async (importOriginal) => {
+  const original = await importOriginal<typeof import('ink')>();
+  return {
+    ...original,
+    useStdin: vi.fn(),
+    useStdout: vi.fn(),
+  };
+});
+
+const mockedUseStdin = vi.mocked(useStdin);
+const mockedUseStdout = vi.mocked(useStdout);
+
+describe('useFocus', () => {
+  let stdin: EventEmitter;
+  let stdout: { write: vi.Func };
+
+  beforeEach(() => {
+    stdin = new EventEmitter();
+    stdout = { write: vi.fn() };
+    mockedUseStdin.mockReturnValue({ stdin } as ReturnType<typeof useStdin>);
+    mockedUseStdout.mockReturnValue({ stdout } as unknown as ReturnType<
+      typeof useStdout
+    >);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should initialize with focus and enable focus reporting', () => {
+    const { result } = renderHook(() => useFocus());
+
+    expect(result.current).toBe(true);
+    expect(stdout.write).toHaveBeenCalledWith('\x1b[?1004h');
+  });
+
+  it('should set isFocused to false when a focus-out event is received', () => {
+    const { result } = renderHook(() => useFocus());
+
+    // Initial state is focused
+    expect(result.current).toBe(true);
+
+    // Simulate focus-out event
+    act(() => {
+      stdin.emit('data', Buffer.from('\x1b[O'));
+    });
+
+    // State should now be unfocused
+    expect(result.current).toBe(false);
+  });
+
+  it('should set isFocused to true when a focus-in event is received', () => {
+    const { result } = renderHook(() => useFocus());
+
+    // Simulate focus-out to set initial state to false
+    act(() => {
+      stdin.emit('data', Buffer.from('\x1b[O'));
+    });
+    expect(result.current).toBe(false);
+
+    // Simulate focus-in event
+    act(() => {
+      stdin.emit('data', Buffer.from('\x1b[I'));
+    });
+
+    // State should now be focused
+    expect(result.current).toBe(true);
+  });
+
+  it('should clean up and disable focus reporting on unmount', () => {
+    const { unmount } = renderHook(() => useFocus());
+
+    // Ensure listener was attached
+    expect(stdin.listenerCount('data')).toBe(1);
+
+    unmount();
+
+    // Assert that the cleanup function was called
+    expect(stdout.write).toHaveBeenCalledWith('\x1b[?1004l');
+    expect(stdin.listenerCount('data')).toBe(0);
+  });
+
+  it('should handle multiple focus events correctly', () => {
+    const { result } = renderHook(() => useFocus());
+
+    act(() => {
+      stdin.emit('data', Buffer.from('\x1b[O'));
+    });
+    expect(result.current).toBe(false);
+
+    act(() => {
+      stdin.emit('data', Buffer.from('\x1b[O'));
+    });
+    expect(result.current).toBe(false);
+
+    act(() => {
+      stdin.emit('data', Buffer.from('\x1b[I'));
+    });
+    expect(result.current).toBe(true);
+
+    act(() => {
+      stdin.emit('data', Buffer.from('\x1b[I'));
+    });
+    expect(result.current).toBe(true);
+  });
+});

package/dist/ui/hooks/useFocus.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useStdin, useStdout } from 'ink';
+import { useEffect, useState } from 'react';
+
+// ANSI escape codes to enable/disable terminal focus reporting
+export const ENABLE_FOCUS_REPORTING = '\x1b[?1004h';
+export const DISABLE_FOCUS_REPORTING = '\x1b[?1004l';
+
+// ANSI escape codes for focus events
+export const FOCUS_IN = '\x1b[I';
+export const FOCUS_OUT = '\x1b[O';
+
+export const useFocus = () => {
+  const { stdin } = useStdin();
+  const { stdout } = useStdout();
+  const [isFocused, setIsFocused] = useState(true);
+
+  useEffect(() => {
+    const handleData = (data: Buffer) => {
+      const sequence = data.toString();
+      const lastFocusIn = sequence.lastIndexOf(FOCUS_IN);
+      const lastFocusOut = sequence.lastIndexOf(FOCUS_OUT);
+
+      if (lastFocusIn > lastFocusOut) {
+        setIsFocused(true);
+      } else if (lastFocusOut > lastFocusIn) {
+        setIsFocused(false);
+      }
+    };
+
+    // Enable focus reporting
+    stdout?.write(ENABLE_FOCUS_REPORTING);
+    stdin?.on('data', handleData);
+
+    return () => {
+      // Disable focus reporting on cleanup
+      stdout?.write(DISABLE_FOCUS_REPORTING);
+      stdin?.removeListener('data', handleData);
+    };
+  }, [stdin, stdout]);
+
+  return isFocused;
+};

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

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useFolderTrust } from './useFolderTrust.js';
+import { LoadedSettings } from '../../config/settings.js';
+import { FolderTrustChoice } from '../components/FolderTrustDialog.js';
+import {
+  LoadedTrustedFolders,
+  TrustLevel,
+} from '../../config/trustedFolders.js';
+import * as process from 'process';
+
+import * as trustedFolders from '../../config/trustedFolders.js';
+
+vi.mock('process', () => ({
+  cwd: vi.fn(),
+  platform: 'linux',
+}));
+
+describe('useFolderTrust', () => {
+  let mockSettings: LoadedSettings;
+  let mockTrustedFolders: LoadedTrustedFolders;
+  let loadTrustedFoldersSpy: vi.SpyInstance;
+  let isWorkspaceTrustedSpy: vi.SpyInstance;
+  let onTrustChange: (isTrusted: boolean | undefined) => void;
+
+  beforeEach(() => {
+    mockSettings = {
+      merged: {
+        folderTrustFeature: true,
+        folderTrust: undefined,
+      },
+      setValue: vi.fn(),
+    } as unknown as LoadedSettings;
+
+    mockTrustedFolders = {
+      setValue: vi.fn(),
+    } as unknown as LoadedTrustedFolders;
+
+    loadTrustedFoldersSpy = vi
+      .spyOn(trustedFolders, 'loadTrustedFolders')
+      .mockReturnValue(mockTrustedFolders);
+    isWorkspaceTrustedSpy = vi.spyOn(trustedFolders, 'isWorkspaceTrusted');
+    (process.cwd as vi.Mock).mockReturnValue('/test/path');
+    onTrustChange = vi.fn();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should not open dialog when folder is already trusted', () => {
+    isWorkspaceTrustedSpy.mockReturnValue(true);
+    const { result } = renderHook(() =>
+      useFolderTrust(mockSettings, onTrustChange),
+    );
+    expect(result.current.isFolderTrustDialogOpen).toBe(false);
+    expect(onTrustChange).toHaveBeenCalledWith(true);
+  });
+
+  it('should not open dialog when folder is already untrusted', () => {
+    isWorkspaceTrustedSpy.mockReturnValue(false);
+    const { result } = renderHook(() =>
+      useFolderTrust(mockSettings, onTrustChange),
+    );
+    expect(result.current.isFolderTrustDialogOpen).toBe(false);
+    expect(onTrustChange).toHaveBeenCalledWith(false);
+  });
+
+  it('should open dialog when folder trust is undefined', () => {
+    isWorkspaceTrustedSpy.mockReturnValue(undefined);
+    const { result } = renderHook(() =>
+      useFolderTrust(mockSettings, onTrustChange),
+    );
+    expect(result.current.isFolderTrustDialogOpen).toBe(true);
+    expect(onTrustChange).toHaveBeenCalledWith(undefined);
+  });
+
+  it('should handle TRUST_FOLDER choice', () => {
+    isWorkspaceTrustedSpy.mockReturnValue(undefined);
+    const { result } = renderHook(() =>
+      useFolderTrust(mockSettings, onTrustChange),
+    );
+
+    isWorkspaceTrustedSpy.mockReturnValue(true);
+    act(() => {
+      result.current.handleFolderTrustSelect(FolderTrustChoice.TRUST_FOLDER);
+    });
+
+    expect(loadTrustedFoldersSpy).toHaveBeenCalled();
+    expect(mockTrustedFolders.setValue).toHaveBeenCalledWith(
+      '/test/path',
+      TrustLevel.TRUST_FOLDER,
+    );
+    expect(result.current.isFolderTrustDialogOpen).toBe(false);
+    expect(onTrustChange).toHaveBeenLastCalledWith(true);
+  });
+
+  it('should handle TRUST_PARENT choice', () => {
+    isWorkspaceTrustedSpy.mockReturnValue(undefined);
+    const { result } = renderHook(() =>
+      useFolderTrust(mockSettings, onTrustChange),
+    );
+
+    isWorkspaceTrustedSpy.mockReturnValue(true);
+    act(() => {
+      result.current.handleFolderTrustSelect(FolderTrustChoice.TRUST_PARENT);
+    });
+
+    expect(mockTrustedFolders.setValue).toHaveBeenCalledWith(
+      '/test/path',
+      TrustLevel.TRUST_PARENT,
+    );
+    expect(result.current.isFolderTrustDialogOpen).toBe(false);
+    expect(onTrustChange).toHaveBeenLastCalledWith(true);
+  });
+
+  it('should handle DO_NOT_TRUST choice', () => {
+    isWorkspaceTrustedSpy.mockReturnValue(undefined);
+    const { result } = renderHook(() =>
+      useFolderTrust(mockSettings, onTrustChange),
+    );
+
+    isWorkspaceTrustedSpy.mockReturnValue(false);
+    act(() => {
+      result.current.handleFolderTrustSelect(FolderTrustChoice.DO_NOT_TRUST);
+    });
+
+    expect(mockTrustedFolders.setValue).toHaveBeenCalledWith(
+      '/test/path',
+      TrustLevel.DO_NOT_TRUST,
+    );
+    expect(result.current.isFolderTrustDialogOpen).toBe(false);
+    expect(onTrustChange).toHaveBeenLastCalledWith(false);
+  });
+
+  it('should do nothing for default choice', () => {
+    isWorkspaceTrustedSpy.mockReturnValue(undefined);
+    const { result } = renderHook(() =>
+      useFolderTrust(mockSettings, onTrustChange),
+    );
+
+    act(() => {
+      result.current.handleFolderTrustSelect(
+        'invalid_choice' as FolderTrustChoice,
+      );
+    });
+
+    expect(mockTrustedFolders.setValue).not.toHaveBeenCalled();
+    expect(mockSettings.setValue).not.toHaveBeenCalled();
+    expect(result.current.isFolderTrustDialogOpen).toBe(true);
+    expect(onTrustChange).toHaveBeenCalledWith(undefined);
+  });
+});