fss-link 1.0.49 → 1.0.51

package/dist/ui/utils/textUtils.ts

@@ -1,40 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Calculates the maximum width of a multi-line ASCII art string.
- * @param asciiArt The ASCII art string.
- * @returns The length of the longest line in the ASCII art.
- */
-export const getAsciiArtWidth = (asciiArt: string): number => {
-  if (!asciiArt) {
-    return 0;
-  }
-  const lines = asciiArt.split('\n');
-  return Math.max(...lines.map((line) => line.length));
-};
-
-/*
- * -------------------------------------------------------------------------
- *  Unicode‑aware helpers (work at the code‑point level rather than UTF‑16
- *  code units so that surrogate‑pair emoji count as one "column".)
- * ---------------------------------------------------------------------- */
-
-export function toCodePoints(str: string): string[] {
-  // [...str] or Array.from both iterate by UTF‑32 code point, handling
-  // surrogate pairs correctly.
-  return Array.from(str);
-}
-
-export function cpLen(str: string): number {
-  return toCodePoints(str).length;
-}
-
-export function cpSlice(str: string, start: number, end?: number): string {
-  // Slice by code‑point indices and re‑join.
-  const arr = toCodePoints(str).slice(start, end);
-  return arr.join('');
-}

package/dist/ui/utils/updateCheck.test.ts

@@ -1,163 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { checkForUpdates } from './updateCheck.js';
-
-const getPackageJson = vi.hoisted(() => vi.fn());
-vi.mock('../../utils/package.js', () => ({
-  getPackageJson,
-}));
-
-const updateNotifier = vi.hoisted(() => vi.fn());
-vi.mock('update-notifier', () => ({
-  default: updateNotifier,
-}));
-
-describe('checkForUpdates', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.resetAllMocks();
-    // Clear DEV environment variable before each test
-    delete process.env['DEV'];
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  });
-
-  it('should return null when running from source (DEV=true)', async () => {
-    process.env['DEV'] = 'true';
-    getPackageJson.mockResolvedValue({
-      name: 'test-package',
-      version: '1.0.0',
-    });
-    updateNotifier.mockReturnValue({
-      fetchInfo: vi
-        .fn()
-        .mockResolvedValue({ current: '1.0.0', latest: '1.1.0' }),
-    });
-    const result = await checkForUpdates();
-    expect(result).toBeNull();
-    expect(getPackageJson).not.toHaveBeenCalled();
-    expect(updateNotifier).not.toHaveBeenCalled();
-  });
-
-  it('should return null if package.json is missing', async () => {
-    getPackageJson.mockResolvedValue(null);
-    const result = await checkForUpdates();
-    expect(result).toBeNull();
-  });
-
-  it('should return null if there is no update', async () => {
-    getPackageJson.mockResolvedValue({
-      name: 'test-package',
-      version: '1.0.0',
-    });
-    updateNotifier.mockReturnValue({
-      fetchInfo: vi.fn().mockResolvedValue(null),
-    });
-    const result = await checkForUpdates();
-    expect(result).toBeNull();
-  });
-
-  it('should return a message if a newer version is available', async () => {
-    getPackageJson.mockResolvedValue({
-      name: 'test-package',
-      version: '1.0.0',
-    });
-    updateNotifier.mockReturnValue({
-      fetchInfo: vi
-        .fn()
-        .mockResolvedValue({ current: '1.0.0', latest: '1.1.0' }),
-    });
-
-    const result = await checkForUpdates();
-    expect(result?.message).toContain('1.0.0 → 1.1.0');
-    expect(result?.update).toEqual({ current: '1.0.0', latest: '1.1.0' });
-  });
-
-  it('should return null if the latest version is the same as the current version', async () => {
-    getPackageJson.mockResolvedValue({
-      name: 'test-package',
-      version: '1.0.0',
-    });
-    updateNotifier.mockReturnValue({
-      fetchInfo: vi
-        .fn()
-        .mockResolvedValue({ current: '1.0.0', latest: '1.0.0' }),
-    });
-    const result = await checkForUpdates();
-    expect(result).toBeNull();
-  });
-
-  it('should return null if the latest version is older than the current version', async () => {
-    getPackageJson.mockResolvedValue({
-      name: 'test-package',
-      version: '1.1.0',
-    });
-    updateNotifier.mockReturnValue({
-      fetchInfo: vi
-        .fn()
-        .mockResolvedValue({ current: '1.1.0', latest: '1.0.0' }),
-    });
-    const result = await checkForUpdates();
-    expect(result).toBeNull();
-  });
-
-  it('should return null if fetchInfo rejects', async () => {
-    getPackageJson.mockResolvedValue({
-      name: 'test-package',
-      version: '1.0.0',
-    });
-    updateNotifier.mockReturnValue({
-      fetchInfo: vi.fn().mockRejectedValue(new Error('Timeout')),
-    });
-
-    const result = await checkForUpdates();
-    expect(result).toBeNull();
-  });
-
-  it('should handle errors gracefully', async () => {
-    getPackageJson.mockRejectedValue(new Error('test error'));
-    const result = await checkForUpdates();
-    expect(result).toBeNull();
-  });
-
-  describe('nightly updates', () => {
-    it('should notify for a newer nightly version when current is nightly', async () => {
-      getPackageJson.mockResolvedValue({
-        name: 'test-package',
-        version: '1.2.3-nightly.1',
-      });
-
-      const fetchInfoMock = vi.fn().mockImplementation(({ distTag }) => {
-        if (distTag === 'nightly') {
-          return Promise.resolve({
-            latest: '1.2.3-nightly.2',
-            current: '1.2.3-nightly.1',
-          });
-        }
-        if (distTag === 'latest') {
-          return Promise.resolve({
-            latest: '1.2.3',
-            current: '1.2.3-nightly.1',
-          });
-        }
-        return Promise.resolve(null);
-      });
-
-      updateNotifier.mockImplementation(({ pkg, distTag }) => ({
-        fetchInfo: () => fetchInfoMock({ pkg, distTag }),
-      }));
-
-      const result = await checkForUpdates();
-      expect(result?.message).toContain('1.2.3-nightly.1 → 1.2.3-nightly.2');
-      expect(result?.update.latest).toBe('1.2.3-nightly.2');
-    });
-  });
-});

package/dist/ui/utils/updateCheck.ts

@@ -1,100 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import updateNotifier, { UpdateInfo } from 'update-notifier';
-import semver from 'semver';
-import { getPackageJson } from '../../utils/package.js';
-
-export const FETCH_TIMEOUT_MS = 2000;
-
-export interface UpdateObject {
-  message: string;
-  update: UpdateInfo;
-}
-
-/**
- * From a nightly and stable update, determines which is the "best" one to offer.
- * The rule is to always prefer nightly if the base versions are the same.
- */
-function getBestAvailableUpdate(
-  nightly?: UpdateInfo,
-  stable?: UpdateInfo,
-): UpdateInfo | null {
-  if (!nightly) return stable || null;
-  if (!stable) return nightly || null;
-
-  const nightlyVer = nightly.latest;
-  const stableVer = stable.latest;
-
-  if (
-    semver.coerce(stableVer)?.version === semver.coerce(nightlyVer)?.version
-  ) {
-    return nightly;
-  }
-
-  return semver.gt(stableVer, nightlyVer) ? stable : nightly;
-}
-
-export async function checkForUpdates(): Promise<UpdateObject | null> {
-  try {
-    // Skip update check when running from source (development mode)
-    if (process.env['DEV'] === 'true') {
-      return null;
-    }
-    const packageJson = await getPackageJson();
-    if (!packageJson || !packageJson.name || !packageJson.version) {
-      return null;
-    }
-
-    const { name, version: currentVersion } = packageJson;
-    const isNightly = currentVersion.includes('nightly');
-    const createNotifier = (distTag: 'latest' | 'nightly') =>
-      updateNotifier({
-        pkg: {
-          name,
-          version: currentVersion,
-        },
-        updateCheckInterval: 0,
-        shouldNotifyInNpmScript: true,
-        distTag,
-      });
-
-    if (isNightly) {
-      const [nightlyUpdateInfo, latestUpdateInfo] = await Promise.all([
-        createNotifier('nightly').fetchInfo(),
-        createNotifier('latest').fetchInfo(),
-      ]);
-
-      const bestUpdate = getBestAvailableUpdate(
-        nightlyUpdateInfo,
-        latestUpdateInfo,
-      );
-
-      if (bestUpdate && semver.gt(bestUpdate.latest, currentVersion)) {
-        const message = `A new version of FSS Link is available! ${currentVersion} → ${bestUpdate.latest}`;
-        return {
-          message,
-          update: { ...bestUpdate, current: currentVersion },
-        };
-      }
-    } else {
-      const updateInfo = await createNotifier('latest').fetchInfo();
-
-      if (updateInfo && semver.gt(updateInfo.latest, currentVersion)) {
-        const message = `FSS Link update available! ${currentVersion} → ${updateInfo.latest}`;
-        return {
-          message,
-          update: { ...updateInfo, current: currentVersion },
-        };
-      }
-    }
-
-    return null;
-  } catch (e) {
-    console.warn('Failed to check for updates: ' + e);
-    return null;
-  }
-}

package/dist/utils/checks.ts

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/* Fail to compile on unexpected values. */
-export function assumeExhaustive(_value: never): void {}
-
-/**
- * Throws an exception on unexpected values.
- *
- * A common use case is switch statements:
- * switch(enumValue) {
- *   case Enum.A:
- *   case Enum.B:
- *     break;
- *   default:
- *     checkExhaustive(enumValue);
- * }
- */
-export function checkExhaustive(
-  value: never,
-  msg = `unexpected value ${value}!`,
-): never {
-  assumeExhaustive(value);
-  throw new Error(msg);
-}

package/dist/utils/cleanup.test.ts

@@ -1,68 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { vi } from 'vitest';
-import { registerCleanup, runExitCleanup } from './cleanup';
-
-describe('cleanup', () => {
-  const originalCleanupFunctions = global['cleanupFunctions'];
-
-  beforeEach(() => {
-    // Isolate cleanup functions for each test
-    global['cleanupFunctions'] = [];
-  });
-
-  afterAll(() => {
-    // Restore original cleanup functions
-    global['cleanupFunctions'] = originalCleanupFunctions;
-  });
-
-  it('should run a registered synchronous function', async () => {
-    const cleanupFn = vi.fn();
-    registerCleanup(cleanupFn);
-
-    await runExitCleanup();
-
-    expect(cleanupFn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should run a registered asynchronous function', async () => {
-    const cleanupFn = vi.fn().mockResolvedValue(undefined);
-    registerCleanup(cleanupFn);
-
-    await runExitCleanup();
-
-    expect(cleanupFn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should run multiple registered functions', async () => {
-    const syncFn = vi.fn();
-    const asyncFn = vi.fn().mockResolvedValue(undefined);
-
-    registerCleanup(syncFn);
-    registerCleanup(asyncFn);
-
-    await runExitCleanup();
-
-    expect(syncFn).toHaveBeenCalledTimes(1);
-    expect(asyncFn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should continue running cleanup functions even if one throws an error', async () => {
-    const errorFn = vi.fn(() => {
-      throw new Error('Test Error');
-    });
-    const successFn = vi.fn();
-
-    registerCleanup(errorFn);
-    registerCleanup(successFn);
-
-    await runExitCleanup();
-
-    expect(errorFn).toHaveBeenCalledTimes(1);
-    expect(successFn).toHaveBeenCalledTimes(1);
-  });
-});

package/dist/utils/cleanup.ts

@@ -1,36 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import { getProjectTempDir } from 'fss-link-core';
-
-const cleanupFunctions: Array<(() => void) | (() => Promise<void>)> = [];
-
-export function registerCleanup(fn: (() => void) | (() => Promise<void>)) {
-  cleanupFunctions.push(fn);
-}
-
-export async function runExitCleanup() {
-  for (const fn of cleanupFunctions) {
-    try {
-      await fn();
-    } catch (_) {
-      // Ignore errors during cleanup.
-    }
-  }
-  cleanupFunctions.length = 0; // Clear the array
-}
-
-export async function cleanupCheckpoints() {
-  const tempDir = getProjectTempDir(process.cwd());
-  const checkpointsDir = join(tempDir, 'checkpoints');
-  try {
-    await fs.rm(checkpointsDir, { recursive: true, force: true });
-  } catch {
-    // Ignore errors if the directory doesn't exist or fails to delete.
-  }
-}

package/dist/utils/dialogScopeUtils.ts

@@ -1,64 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { SettingScope, LoadedSettings } from '../config/settings.js';
-import { settingExistsInScope } from './settingsUtils.js';
-
-/**
- * Shared scope labels for dialog components that need to display setting scopes
- */
-export const SCOPE_LABELS = {
-  [SettingScope.User]: 'User Settings',
-  [SettingScope.Workspace]: 'Workspace Settings',
-  [SettingScope.System]: 'System Settings',
-} as const;
-
-/**
- * Helper function to get scope items for radio button selects
- */
-export function getScopeItems() {
-  return [
-    { label: SCOPE_LABELS[SettingScope.User], value: SettingScope.User },
-    {
-      label: SCOPE_LABELS[SettingScope.Workspace],
-      value: SettingScope.Workspace,
-    },
-    { label: SCOPE_LABELS[SettingScope.System], value: SettingScope.System },
-  ];
-}
-
-/**
- * Generate scope message for a specific setting
- */
-export function getScopeMessageForSetting(
-  settingKey: string,
-  selectedScope: SettingScope,
-  settings: LoadedSettings,
-): string {
-  const otherScopes = Object.values(SettingScope).filter(
-    (scope) => scope !== selectedScope,
-  );
-
-  const modifiedInOtherScopes = otherScopes.filter((scope) => {
-    const scopeSettings = settings.forScope(scope).settings;
-    return settingExistsInScope(settingKey, scopeSettings);
-  });
-
-  if (modifiedInOtherScopes.length === 0) {
-    return '';
-  }
-
-  const modifiedScopesStr = modifiedInOtherScopes.join(', ');
-  const currentScopeSettings = settings.forScope(selectedScope).settings;
-  const existsInCurrentScope = settingExistsInScope(
-    settingKey,
-    currentScopeSettings,
-  );
-
-  return existsInCurrentScope
-    ? `(Also modified in ${modifiedScopesStr})`
-    : `(Modified in ${modifiedScopesStr})`;
-}

package/dist/utils/events.ts

@@ -1,14 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { EventEmitter } from 'events';
-
-export enum AppEvent {
-  OpenDebugConsole = 'open-debug-console',
-  LogError = 'log-error',
-}
-
-export const appEvents = new EventEmitter();

package/dist/utils/gitUtils.test.ts

@@ -1,149 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { vi, describe, expect, it, afterEach, beforeEach } from 'vitest';
-import * as child_process from 'child_process';
-import {
-  isGitHubRepository,
-  getGitRepoRoot,
-  getLatestGitHubRelease,
-  getGitHubRepoInfo,
-} from './gitUtils.js';
-
-vi.mock('child_process');
-
-describe('isGitHubRepository', async () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('returns false if the git command fails', async () => {
-    vi.mocked(child_process.execSync).mockImplementation((): string => {
-      throw new Error('oops');
-    });
-    expect(isGitHubRepository()).toBe(false);
-  });
-
-  it('returns false if the remote is not github.com', async () => {
-    vi.mocked(child_process.execSync).mockReturnValueOnce('https://gitlab.com');
-    expect(isGitHubRepository()).toBe(false);
-  });
-
-  it('returns true if the remote is github.com', async () => {
-    vi.mocked(child_process.execSync).mockReturnValueOnce(`
-      origin  https://github.com/sethvargo/gemini-cli (fetch)
-      origin  https://github.com/sethvargo/gemini-cli (push)
-    `);
-    expect(isGitHubRepository()).toBe(true);
-  });
-});
-
-describe('getGitHubRepoInfo', async () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('throws an error if github repo info cannot be determined', async () => {
-    vi.mocked(child_process.execSync).mockImplementation((): string => {
-      throw new Error('oops');
-    });
-    expect(() => {
-      getGitHubRepoInfo();
-    }).toThrowError(/oops/);
-  });
-
-  it('throws an error if owner/repo could not be determined', async () => {
-    vi.mocked(child_process.execSync).mockReturnValueOnce('');
-    expect(() => {
-      getGitHubRepoInfo();
-    }).toThrowError(/Owner & repo could not be extracted from remote URL/);
-  });
-
-  it('returns the owner and repo', async () => {
-    vi.mocked(child_process.execSync).mockReturnValueOnce(
-      'https://github.com/owner/repo.git ',
-    );
-    expect(getGitHubRepoInfo()).toEqual({ owner: 'owner', repo: 'repo' });
-  });
-});
-
-describe('getGitRepoRoot', async () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('throws an error if git root cannot be determined', async () => {
-    vi.mocked(child_process.execSync).mockImplementation((): string => {
-      throw new Error('oops');
-    });
-    expect(() => {
-      getGitRepoRoot();
-    }).toThrowError(/oops/);
-  });
-
-  it('throws an error if git root is empty', async () => {
-    vi.mocked(child_process.execSync).mockReturnValueOnce('');
-    expect(() => {
-      getGitRepoRoot();
-    }).toThrowError(/Git repo returned empty value/);
-  });
-
-  it('returns the root', async () => {
-    vi.mocked(child_process.execSync).mockReturnValueOnce('/path/to/git/repo');
-    expect(getGitRepoRoot()).toBe('/path/to/git/repo');
-  });
-});
-
-describe('getLatestRelease', async () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('throws an error if the fetch fails', async () => {
-    global.fetch = vi.fn(() => Promise.reject('nope'));
-    expect(getLatestGitHubRelease()).rejects.toThrowError(
-      /Unable to determine the latest/,
-    );
-  });
-
-  it('throws an error if the fetch does not return a json body', async () => {
-    global.fetch = vi.fn(() =>
-      Promise.resolve({
-        ok: true,
-        json: () => Promise.resolve({ foo: 'bar' }),
-      } as Response),
-    );
-    expect(getLatestGitHubRelease()).rejects.toThrowError(
-      /Unable to determine the latest/,
-    );
-  });
-
-  it('returns the release version', async () => {
-    global.fetch = vi.fn(() =>
-      Promise.resolve({
-        ok: true,
-        json: () => Promise.resolve({ tag_name: 'v1.2.3' }),
-      } as Response),
-    );
-    expect(getLatestGitHubRelease()).resolves.toBe('v1.2.3');
-  });
-});