fss-link 1.0.43 → 1.0.45

package/dist/utils/gitUtils.ts

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { execSync } from 'child_process';
+import { ProxyAgent } from 'undici';
+
+/**
+ * Checks if a directory is within a git repository hosted on GitHub.
+ * @returns true if the directory is in a git repository with a github.com remote, false otherwise
+ */
+export const isGitHubRepository = (): boolean => {
+  try {
+    const remotes = (
+      execSync('git remote -v', {
+        encoding: 'utf-8',
+      }) || ''
+    ).trim();
+
+    const pattern = /github\.com/;
+
+    return pattern.test(remotes);
+  } catch (_error) {
+    // If any filesystem error occurs, assume not a git repo
+    console.debug(`Failed to get git remote:`, _error);
+    return false;
+  }
+};
+
+/**
+ * getGitRepoRoot returns the root directory of the git repository.
+ * @returns the path to the root of the git repo.
+ * @throws error if the exec command fails.
+ */
+export const getGitRepoRoot = (): string => {
+  const gitRepoRoot = (
+    execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf-8',
+    }) || ''
+  ).trim();
+
+  if (!gitRepoRoot) {
+    throw new Error(`Git repo returned empty value`);
+  }
+
+  return gitRepoRoot;
+};
+
+/**
+ * getLatestGitHubRelease returns the release tag as a string.
+ * @returns string of the release tag (e.g. "v1.2.3").
+ */
+export const getLatestGitHubRelease = async (
+  proxy?: string,
+): Promise<string> => {
+  try {
+    const controller = new AbortController();
+
+    const endpoint = `https://api.github.com/repos/google-github-actions/run-gemini-cli/releases/latest`;
+
+    const response = await fetch(endpoint, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/vnd.github+json',
+        'Content-Type': 'application/json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+      dispatcher: proxy ? new ProxyAgent(proxy) : undefined,
+      signal: AbortSignal.any([AbortSignal.timeout(30_000), controller.signal]),
+    } as RequestInit);
+
+    if (!response.ok) {
+      throw new Error(
+        `Invalid response code: ${response.status} - ${response.statusText}`,
+      );
+    }
+
+    const releaseTag = (await response.json()).tag_name;
+    if (!releaseTag) {
+      throw new Error(`Response did not include tag_name field`);
+    }
+    return releaseTag;
+  } catch (_error) {
+    console.debug(`Failed to determine latest run-gemini-cli release:`, _error);
+    throw new Error(
+      `Unable to determine the latest run-gemini-cli release on GitHub.`,
+    );
+  }
+};
+
+/**
+ * getGitHubRepoInfo returns the owner and repository for a GitHub repo.
+ * @returns the owner and repository of the github repo.
+ * @throws error if the exec command fails.
+ */
+export function getGitHubRepoInfo(): { owner: string; repo: string } {
+  const remoteUrl = execSync('git remote get-url origin', {
+    encoding: 'utf-8',
+  }).trim();
+
+  // Matches either https://github.com/owner/repo.git or git@github.com:owner/repo.git
+  const match = remoteUrl.match(
+    /(?:https?:\/\/|git@)github\.com(?::|\/)([^/]+)\/([^/]+?)(?:\.git)?$/,
+  );
+
+  // If the regex fails match, throw an error.
+  if (!match || !match[1] || !match[2]) {
+    throw new Error(
+      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`,
+    );
+  }
+
+  return { owner: match[1], repo: match[2] };
+}

package/dist/utils/handleAutoUpdate.test.ts

@@ -0,0 +1,272 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach, Mock } from 'vitest';
+import { getInstallationInfo, PackageManager } from './installationInfo.js';
+import { updateEventEmitter } from './updateEventEmitter.js';
+import { UpdateObject } from '../ui/utils/updateCheck.js';
+import { LoadedSettings } from '../config/settings.js';
+import EventEmitter from 'node:events';
+import { handleAutoUpdate } from './handleAutoUpdate.js';
+
+vi.mock('./installationInfo.js', async () => {
+  const actual = await vi.importActual('./installationInfo.js');
+  return {
+    ...actual,
+    getInstallationInfo: vi.fn(),
+  };
+});
+
+vi.mock('./updateEventEmitter.js', async () => {
+  const actual = await vi.importActual('./updateEventEmitter.js');
+  return {
+    ...actual,
+    updateEventEmitter: {
+      ...actual.updateEventEmitter,
+      emit: vi.fn(),
+    },
+  };
+});
+
+interface MockChildProcess extends EventEmitter {
+  stdin: EventEmitter & {
+    write: Mock;
+    end: Mock;
+  };
+  stderr: EventEmitter;
+}
+
+const mockGetInstallationInfo = vi.mocked(getInstallationInfo);
+const mockUpdateEventEmitter = vi.mocked(updateEventEmitter);
+
+describe('handleAutoUpdate', () => {
+  let mockSpawn: Mock;
+  let mockUpdateInfo: UpdateObject;
+  let mockSettings: LoadedSettings;
+  let mockChildProcess: MockChildProcess;
+
+  beforeEach(() => {
+    mockSpawn = vi.fn();
+    vi.clearAllMocks();
+    mockUpdateInfo = {
+      update: {
+        latest: '2.0.0',
+        current: '1.0.0',
+        type: 'major',
+        name: 'fss-link-core',
+      },
+      message: 'An update is available!',
+    };
+
+    mockSettings = {
+      merged: {
+        disableAutoUpdate: false,
+      },
+    } as LoadedSettings;
+
+    mockChildProcess = Object.assign(new EventEmitter(), {
+      stdin: Object.assign(new EventEmitter(), {
+        write: vi.fn(),
+        end: vi.fn(),
+      }),
+      stderr: new EventEmitter(),
+    }) as MockChildProcess;
+
+    mockSpawn.mockReturnValue(
+      mockChildProcess as unknown as ReturnType<typeof mockSpawn>,
+    );
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should do nothing if update info is null', () => {
+    handleAutoUpdate(null, mockSettings, '/root', mockSpawn);
+    expect(mockGetInstallationInfo).not.toHaveBeenCalled();
+    expect(mockUpdateEventEmitter.emit).not.toHaveBeenCalled();
+    expect(mockSpawn).not.toHaveBeenCalled();
+  });
+
+  it('should do nothing if update nag is disabled', () => {
+    mockSettings.merged.disableUpdateNag = true;
+    handleAutoUpdate(mockUpdateInfo, mockSettings, '/root', mockSpawn);
+    expect(mockGetInstallationInfo).not.toHaveBeenCalled();
+    expect(mockUpdateEventEmitter.emit).not.toHaveBeenCalled();
+    expect(mockSpawn).not.toHaveBeenCalled();
+  });
+
+  it('should emit "update-received" but not update if auto-updates are disabled', () => {
+    mockSettings.merged.disableAutoUpdate = true;
+    mockGetInstallationInfo.mockReturnValue({
+      updateCommand: 'npm i -g fss-link-core@latest',
+      updateMessage: 'Please update manually.',
+      isGlobal: true,
+      packageManager: PackageManager.NPM,
+    });
+
+    handleAutoUpdate(mockUpdateInfo, mockSettings, '/root', mockSpawn);
+
+    expect(mockUpdateEventEmitter.emit).toHaveBeenCalledTimes(1);
+    expect(mockUpdateEventEmitter.emit).toHaveBeenCalledWith(
+      'update-received',
+      {
+        message: 'An update is available!\nPlease update manually.',
+      },
+    );
+    expect(mockSpawn).not.toHaveBeenCalled();
+  });
+
+  it('should emit "update-received" but not update if no update command is found', () => {
+    mockGetInstallationInfo.mockReturnValue({
+      updateCommand: undefined,
+      updateMessage: 'Cannot determine update command.',
+      isGlobal: false,
+      packageManager: PackageManager.NPM,
+    });
+
+    handleAutoUpdate(mockUpdateInfo, mockSettings, '/root', mockSpawn);
+
+    expect(mockUpdateEventEmitter.emit).toHaveBeenCalledTimes(1);
+    expect(mockUpdateEventEmitter.emit).toHaveBeenCalledWith(
+      'update-received',
+      {
+        message: 'An update is available!\nCannot determine update command.',
+      },
+    );
+    expect(mockSpawn).not.toHaveBeenCalled();
+  });
+
+  it('should combine update messages correctly', () => {
+    mockGetInstallationInfo.mockReturnValue({
+      updateCommand: undefined, // No command to prevent spawn
+      updateMessage: 'This is an additional message.',
+      isGlobal: false,
+      packageManager: PackageManager.NPM,
+    });
+
+    handleAutoUpdate(mockUpdateInfo, mockSettings, '/root', mockSpawn);
+
+    expect(mockUpdateEventEmitter.emit).toHaveBeenCalledTimes(1);
+    expect(mockUpdateEventEmitter.emit).toHaveBeenCalledWith(
+      'update-received',
+      {
+        message: 'An update is available!\nThis is an additional message.',
+      },
+    );
+  });
+
+  it('should attempt to perform an update when conditions are met', async () => {
+    mockGetInstallationInfo.mockReturnValue({
+      updateCommand: 'npm i -g fss-link-core@latest',
+      updateMessage: 'This is an additional message.',
+      isGlobal: false,
+      packageManager: PackageManager.NPM,
+    });
+
+    // Simulate successful execution
+    setTimeout(() => {
+      mockChildProcess.emit('close', 0);
+    }, 0);
+
+    handleAutoUpdate(mockUpdateInfo, mockSettings, '/root', mockSpawn);
+
+    expect(mockSpawn).toHaveBeenCalledOnce();
+  });
+
+  it('should emit "update-failed" when the update process fails', async () => {
+    await new Promise<void>((resolve) => {
+      mockGetInstallationInfo.mockReturnValue({
+        updateCommand: 'npm i -g fss-link-core@latest',
+        updateMessage: 'This is an additional message.',
+        isGlobal: false,
+        packageManager: PackageManager.NPM,
+      });
+
+      // Simulate failed execution
+      setTimeout(() => {
+        mockChildProcess.stderr.emit('data', 'An error occurred');
+        mockChildProcess.emit('close', 1);
+        resolve();
+      }, 0);
+
+      handleAutoUpdate(mockUpdateInfo, mockSettings, '/root', mockSpawn);
+    });
+
+    expect(mockUpdateEventEmitter.emit).toHaveBeenCalledWith('update-failed', {
+      message:
+        'Automatic update failed. Please try updating manually. (command: npm i -g fss-link-core@2.0.0, stderr: An error occurred)',
+    });
+  });
+
+  it('should emit "update-failed" when the spawn function throws an error', async () => {
+    await new Promise<void>((resolve) => {
+      mockGetInstallationInfo.mockReturnValue({
+        updateCommand: 'npm i -g fss-link-core@latest',
+        updateMessage: 'This is an additional message.',
+        isGlobal: false,
+        packageManager: PackageManager.NPM,
+      });
+
+      // Simulate an error event
+      setTimeout(() => {
+        mockChildProcess.emit('error', new Error('Spawn error'));
+        resolve();
+      }, 0);
+
+      handleAutoUpdate(mockUpdateInfo, mockSettings, '/root', mockSpawn);
+    });
+
+    expect(mockUpdateEventEmitter.emit).toHaveBeenCalledWith('update-failed', {
+      message:
+        'Automatic update failed. Please try updating manually. (error: Spawn error)',
+    });
+  });
+
+  it('should use the "@nightly" tag for nightly updates', async () => {
+    mockUpdateInfo.update.latest = '2.0.0-nightly';
+    mockGetInstallationInfo.mockReturnValue({
+      updateCommand: 'npm i -g fss-link-core@latest',
+      updateMessage: 'This is an additional message.',
+      isGlobal: false,
+      packageManager: PackageManager.NPM,
+    });
+
+    handleAutoUpdate(mockUpdateInfo, mockSettings, '/root', mockSpawn);
+
+    expect(mockSpawn).toHaveBeenCalledWith(
+      'npm i -g fss-link-core@nightly',
+      {
+        shell: true,
+        stdio: 'pipe',
+      },
+    );
+  });
+
+  it('should emit "update-success" when the update process succeeds', async () => {
+    await new Promise<void>((resolve) => {
+      mockGetInstallationInfo.mockReturnValue({
+        updateCommand: 'npm i -g fss-link-core@latest',
+        updateMessage: 'This is an additional message.',
+        isGlobal: false,
+        packageManager: PackageManager.NPM,
+      });
+
+      // Simulate successful execution
+      setTimeout(() => {
+        mockChildProcess.emit('close', 0);
+        resolve();
+      }, 0);
+
+      handleAutoUpdate(mockUpdateInfo, mockSettings, '/root', mockSpawn);
+    });
+
+    expect(mockUpdateEventEmitter.emit).toHaveBeenCalledWith('update-success', {
+      message:
+        'Update successful! The new version will be used on your next run.',
+    });
+  });
+});

package/dist/utils/handleAutoUpdate.ts

@@ -0,0 +1,145 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { UpdateObject } from '../ui/utils/updateCheck.js';
+import { LoadedSettings } from '../config/settings.js';
+import { getInstallationInfo } from './installationInfo.js';
+import { updateEventEmitter } from './updateEventEmitter.js';
+import { HistoryItem, MessageType } from '../ui/types.js';
+import { spawnWrapper } from './spawnWrapper.js';
+import { spawn } from 'child_process';
+
+export function handleAutoUpdate(
+  info: UpdateObject | null,
+  settings: LoadedSettings,
+  projectRoot: string,
+  spawnFn: typeof spawn = spawnWrapper,
+) {
+  if (!info) {
+    return;
+  }
+
+  if (settings.merged.disableUpdateNag) {
+    return;
+  }
+
+  const installationInfo = getInstallationInfo(
+    projectRoot,
+    settings.merged.disableAutoUpdate ?? false,
+  );
+
+  let combinedMessage = info.message;
+  if (installationInfo.updateMessage) {
+    combinedMessage += `\n${installationInfo.updateMessage}`;
+  }
+
+  updateEventEmitter.emit('update-received', {
+    message: combinedMessage,
+  });
+
+  if (!installationInfo.updateCommand || settings.merged.disableAutoUpdate) {
+    return;
+  }
+  const isNightly = info.update.latest.includes('nightly');
+
+  const updateCommand = installationInfo.updateCommand.replace(
+    '@latest',
+    isNightly ? '@nightly' : `@${info.update.latest}`,
+  );
+  const updateProcess = spawnFn(updateCommand, { stdio: 'pipe', shell: true });
+  let errorOutput = '';
+  updateProcess.stderr.on('data', (data) => {
+    errorOutput += data.toString();
+  });
+
+  updateProcess.on('close', (code) => {
+    if (code === 0) {
+      updateEventEmitter.emit('update-success', {
+        message:
+          'Update successful! The new version will be used on your next run.',
+      });
+    } else {
+      updateEventEmitter.emit('update-failed', {
+        message: `Automatic update failed. Please try updating manually. (command: ${updateCommand}, stderr: ${errorOutput.trim()})`,
+      });
+    }
+  });
+
+  updateProcess.on('error', (err) => {
+    updateEventEmitter.emit('update-failed', {
+      message: `Automatic update failed. Please try updating manually. (error: ${err.message})`,
+    });
+  });
+  return updateProcess;
+}
+
+export function setUpdateHandler(
+  addItem: (item: Omit<HistoryItem, 'id'>, timestamp: number) => void,
+  setUpdateInfo: (info: UpdateObject | null) => void,
+) {
+  let successfullyInstalled = false;
+  const handleUpdateRecieved = (info: UpdateObject) => {
+    setUpdateInfo(info);
+    const savedMessage = info.message;
+    setTimeout(() => {
+      if (!successfullyInstalled) {
+        addItem(
+          {
+            type: MessageType.INFO,
+            text: savedMessage,
+          },
+          Date.now(),
+        );
+      }
+      setUpdateInfo(null);
+    }, 60000);
+  };
+
+  const handleUpdateFailed = () => {
+    setUpdateInfo(null);
+    addItem(
+      {
+        type: MessageType.ERROR,
+        text: `Automatic update failed. Please try updating manually`,
+      },
+      Date.now(),
+    );
+  };
+
+  const handleUpdateSuccess = () => {
+    successfullyInstalled = true;
+    setUpdateInfo(null);
+    addItem(
+      {
+        type: MessageType.INFO,
+        text: `Update successful! The new version will be used on your next run.`,
+      },
+      Date.now(),
+    );
+  };
+
+  const handleUpdateInfo = (data: { message: string }) => {
+    addItem(
+      {
+        type: MessageType.INFO,
+        text: data.message,
+      },
+      Date.now(),
+    );
+  };
+
+  updateEventEmitter.on('update-received', handleUpdateRecieved);
+  updateEventEmitter.on('update-failed', handleUpdateFailed);
+  updateEventEmitter.on('update-success', handleUpdateSuccess);
+  updateEventEmitter.on('update-info', handleUpdateInfo);
+
+  return () => {
+    updateEventEmitter.off('update-received', handleUpdateRecieved);
+    updateEventEmitter.off('update-failed', handleUpdateFailed);
+    updateEventEmitter.off('update-success', handleUpdateSuccess);
+    updateEventEmitter.off('update-info', handleUpdateInfo);
+  };
+}