fss-link 1.0.40 → 1.0.45

package/dist/gemini.tsx

@@ -0,0 +1,357 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { render } from 'ink';
+import { AppWrapper } from './ui/App.js';
+import { loadCliConfig, parseArguments } from './config/config.js';
+import { readStdin } from './utils/readStdin.js';
+import { basename } from 'node:path';
+import v8 from 'node:v8';
+import os from 'node:os';
+import dns from 'node:dns';
+import { spawn } from 'node:child_process';
+import { start_sandbox } from './utils/sandbox.js';
+import {
+  DnsResolutionOrder,
+  LoadedSettings,
+  loadSettings,
+  SettingScope,
+} from './config/settings.js';
+import { themeManager } from './ui/themes/theme-manager.js';
+import { getStartupWarnings } from './utils/startupWarnings.js';
+import { getUserStartupWarnings } from './utils/userStartupWarnings.js';
+import { ConsolePatcher } from './ui/utils/ConsolePatcher.js';
+import { runNonInteractive } from './nonInteractiveCli.js';
+import { loadExtensions } from './config/extension.js';
+import { cleanupCheckpoints, registerCleanup } from './utils/cleanup.js';
+import { getCliVersion } from './utils/version.js';
+import {
+  Config,
+  sessionId,
+  logUserPrompt,
+  AuthType,
+  getOauthClient,
+  logIdeConnection,
+  IdeConnectionEvent,
+  IdeConnectionType,
+} from 'fss-link-core';
+import { validateAuthMethod } from './config/auth.js';
+import { setMaxSizedBoxDebugging } from './ui/components/shared/MaxSizedBox.js';
+import { validateNonInteractiveAuth } from './validateNonInterActiveAuth.js';
+import { detectAndEnableKittyProtocol } from './ui/utils/kittyProtocolDetector.js';
+import { checkForUpdates } from './ui/utils/updateCheck.js';
+import { handleAutoUpdate } from './utils/handleAutoUpdate.js';
+import { appEvents, AppEvent } from './utils/events.js';
+import { SettingsContext } from './ui/contexts/SettingsContext.js';
+import { getModelManager } from './config/modelManager.js';
+
+export function validateDnsResolutionOrder(
+  order: string | undefined,
+): DnsResolutionOrder {
+  const defaultValue: DnsResolutionOrder = 'ipv4first';
+  if (order === undefined) {
+    return defaultValue;
+  }
+  if (order === 'ipv4first' || order === 'verbatim') {
+    return order;
+  }
+  // We don't want to throw here, just warn and use the default.
+  console.warn(
+    `Invalid value for dnsResolutionOrder in settings: "${order}". Using default "${defaultValue}".`,
+  );
+  return defaultValue;
+}
+
+function getNodeMemoryArgs(config: Config): string[] {
+  const totalMemoryMB = os.totalmem() / (1024 * 1024);
+  const heapStats = v8.getHeapStatistics();
+  const currentMaxOldSpaceSizeMb = Math.floor(
+    heapStats.heap_size_limit / 1024 / 1024,
+  );
+
+  // Set target to 50% of total memory
+  const targetMaxOldSpaceSizeInMB = Math.floor(totalMemoryMB * 0.5);
+  if (config.getDebugMode()) {
+    console.debug(
+      `Current heap size ${currentMaxOldSpaceSizeMb.toFixed(2)} MB`,
+    );
+  }
+
+  if (process.env['GEMINI_CLI_NO_RELAUNCH']) {
+    return [];
+  }
+
+  if (targetMaxOldSpaceSizeInMB > currentMaxOldSpaceSizeMb) {
+    if (config.getDebugMode()) {
+      console.debug(
+        `Need to relaunch with more memory: ${targetMaxOldSpaceSizeInMB.toFixed(2)} MB`,
+      );
+    }
+    return [`--max-old-space-size=${targetMaxOldSpaceSizeInMB}`];
+  }
+
+  return [];
+}
+
+async function relaunchWithAdditionalArgs(additionalArgs: string[]) {
+  const nodeArgs = [...additionalArgs, ...process.argv.slice(1)];
+  const newEnv = { ...process.env, GEMINI_CLI_NO_RELAUNCH: 'true' };
+
+  const child = spawn(process.execPath, nodeArgs, {
+    stdio: 'inherit',
+    env: newEnv,
+  });
+
+  await new Promise((resolve) => child.on('close', resolve));
+  process.exit(0);
+}
+import { runZedIntegration } from './zed-integration/zedIntegration.js';
+
+export function setupUnhandledRejectionHandler() {
+  let unhandledRejectionOccurred = false;
+  process.on('unhandledRejection', (reason, _promise) => {
+    const errorMessage = `=========================================
+This is an unexpected error. Please file a bug report using the /bug tool.
+CRITICAL: Unhandled Promise Rejection!
+=========================================
+Reason: ${reason}${
+      reason instanceof Error && reason.stack
+        ? `
+Stack trace:
+${reason.stack}`
+        : ''
+    }`;
+    appEvents.emit(AppEvent.LogError, errorMessage);
+    if (!unhandledRejectionOccurred) {
+      unhandledRejectionOccurred = true;
+      appEvents.emit(AppEvent.OpenDebugConsole);
+    }
+  });
+}
+
+export async function main() {
+  setupUnhandledRejectionHandler();
+  const workspaceRoot = process.cwd();
+  const settings = loadSettings(workspaceRoot);
+
+  await cleanupCheckpoints();
+  if (settings.errors.length > 0) {
+    for (const error of settings.errors) {
+      let errorMessage = `Error in ${error.path}: ${error.message}`;
+      if (!process.env['NO_COLOR']) {
+        errorMessage = `\x1b[31m${errorMessage}\x1b[0m`;
+      }
+      console.error(errorMessage);
+      console.error(`Please fix ${error.path} and try again.`);
+    }
+    process.exit(1);
+  }
+
+  const argv = await parseArguments();
+  const extensions = loadExtensions(workspaceRoot);
+  const config = await loadCliConfig(
+    settings.merged,
+    extensions,
+    sessionId,
+    argv,
+  );
+
+  const consolePatcher = new ConsolePatcher({
+    stderr: true,
+    debugMode: config.getDebugMode(),
+  });
+  consolePatcher.patch();
+  registerCleanup(consolePatcher.cleanup);
+
+  dns.setDefaultResultOrder(
+    validateDnsResolutionOrder(settings.merged.dnsResolutionOrder),
+  );
+
+  if (argv.promptInteractive && !process.stdin.isTTY) {
+    console.error(
+      'Error: The --prompt-interactive flag is not supported when piping input from stdin.',
+    );
+    process.exit(1);
+  }
+
+  if (config.getListExtensions()) {
+    console.log('Installed extensions:');
+    for (const extension of extensions) {
+      console.log(`- ${extension.config.name}`);
+    }
+    process.exit(0);
+  }
+
+  // Set a default auth type if one isn't set.
+  if (!settings.merged.selectedAuthType) {
+    if (process.env['CLOUD_SHELL'] === 'true') {
+      settings.setValue(
+        SettingScope.User,
+        'selectedAuthType',
+        AuthType.CLOUD_SHELL,
+      );
+    }
+  }
+
+  setMaxSizedBoxDebugging(config.getDebugMode());
+
+  await config.initialize();
+
+  // Connect Config with ModelManager for persistent model state
+  const modelManager = getModelManager();
+  config.setModelStateProvider(modelManager);
+
+  if (config.getIdeMode()) {
+    await config.getIdeClient().connect();
+    logIdeConnection(config, new IdeConnectionEvent(IdeConnectionType.START));
+  }
+
+  // Load custom themes from settings
+  themeManager.loadCustomThemes(settings.merged.customThemes);
+
+  if (settings.merged.theme) {
+    if (!themeManager.setActiveTheme(settings.merged.theme)) {
+      // If the theme is not found during initial load, log a warning and continue.
+      // The useThemeCommand hook in App.tsx will handle opening the dialog.
+      console.warn(`Warning: Theme "${settings.merged.theme}" not found.`);
+    }
+  }
+
+  // hop into sandbox if we are outside and sandboxing is enabled
+  if (!process.env['SANDBOX']) {
+    const memoryArgs = settings.merged.autoConfigureMaxOldSpaceSize
+      ? getNodeMemoryArgs(config)
+      : [];
+    const sandboxConfig = config.getSandbox();
+    if (sandboxConfig) {
+      if (
+        settings.merged.selectedAuthType &&
+        !settings.merged.useExternalAuth
+      ) {
+        // Validate authentication here because the sandbox will interfere with the Oauth2 web redirect.
+        try {
+          const err = validateAuthMethod(settings.merged.selectedAuthType);
+          if (err) {
+            throw new Error(err);
+          }
+          await config.refreshAuth(settings.merged.selectedAuthType);
+        } catch (err) {
+          console.error('Error authenticating:', err);
+          process.exit(1);
+        }
+      }
+      await start_sandbox(sandboxConfig, memoryArgs, config);
+      process.exit(0);
+    } else {
+      // Not in a sandbox and not entering one, so relaunch with additional
+      // arguments to control memory usage if needed.
+      if (memoryArgs.length > 0) {
+        await relaunchWithAdditionalArgs(memoryArgs);
+        process.exit(0);
+      }
+    }
+  }
+
+  if (
+    settings.merged.selectedAuthType === AuthType.LOGIN_WITH_GOOGLE &&
+    config.isBrowserLaunchSuppressed()
+  ) {
+    // Do oauth before app renders to make copying the link possible.
+    await getOauthClient(settings.merged.selectedAuthType, config);
+  }
+
+  if (config.getExperimentalZedIntegration()) {
+    return runZedIntegration(config, settings, extensions, argv);
+  }
+
+  let input = config.getQuestion();
+  const startupWarnings = [
+    ...(await getStartupWarnings()),
+    ...(await getUserStartupWarnings(workspaceRoot)),
+  ];
+
+  // Render UI, passing necessary config values. Check that there is no command line question.
+  if (config.isInteractive()) {
+    const version = await getCliVersion();
+    // Detect and enable Kitty keyboard protocol once at startup
+    await detectAndEnableKittyProtocol();
+    setWindowTitle(basename(workspaceRoot), settings);
+    const instance = render(
+      <React.StrictMode>
+        <SettingsContext.Provider value={settings}>
+          <AppWrapper
+            config={config}
+            settings={settings}
+            startupWarnings={startupWarnings}
+            version={version}
+          />
+        </SettingsContext.Provider>
+      </React.StrictMode>,
+      { exitOnCtrlC: false },
+    );
+
+    checkForUpdates()
+      .then((info) => {
+        handleAutoUpdate(info, settings, config.getProjectRoot());
+      })
+      .catch((err) => {
+        // Silently ignore update check errors.
+        if (config.getDebugMode()) {
+          console.error('Update check failed:', err);
+        }
+      });
+
+    registerCleanup(() => instance.unmount());
+    return;
+  }
+  // If not a TTY, read from stdin
+  // This is for cases where the user pipes input directly into the command
+  if (!process.stdin.isTTY) {
+    const stdinData = await readStdin();
+    if (stdinData) {
+      input = `${stdinData}\n\n${input}`;
+    }
+  }
+  if (!input) {
+    console.error('No input provided via stdin.');
+    process.exit(1);
+  }
+
+  const prompt_id = Math.random().toString(16).slice(2);
+  logUserPrompt(config, {
+    'event.name': 'user_prompt',
+    'event.timestamp': new Date().toISOString(),
+    prompt: input,
+    prompt_id,
+    auth_type: config.getContentGeneratorConfig()?.authType,
+    prompt_length: input.length,
+  });
+
+  const nonInteractiveConfig = await validateNonInteractiveAuth(
+    settings.merged.selectedAuthType,
+    settings.merged.useExternalAuth,
+    config,
+  );
+
+  await runNonInteractive(nonInteractiveConfig, input, prompt_id);
+  process.exit(0);
+}
+
+function setWindowTitle(title: string, settings: LoadedSettings) {
+  if (!settings.merged.hideWindowTitle) {
+    const windowTitle = (process.env['CLI_TITLE'] || `Qwen - ${title}`).replace(
+      // eslint-disable-next-line no-control-regex
+      /[\x00-\x1F\x7F]/g,
+      '',
+    );
+    process.stdout.write(`\x1b]2;${windowTitle}\x07`);
+
+    process.on('exit', () => {
+      process.stdout.write(`\x1b]2;\x07`);
+    });
+  }
+}

package/dist/generated/git-commit.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// This file is auto-generated by the build script (scripts/generate-git-commit-info.js)
+// Do not edit this file manually.
+export const GIT_COMMIT_INFO = '696dd3d0';
+export const CLI_VERSION = '1.0.31';

package/dist/index.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import './src/gemini.js';
+import { main } from './src/gemini.js';
+
+// --- Global Entry Point ---
+main().catch((error) => {
+  console.error('An unexpected critical error occurred:');
+  if (error instanceof Error) {
+    console.error(error.stack);
+  } else {
+    console.error(String(error));
+  }
+  process.exit(1);
+});

package/dist/nonInteractiveCli.test.ts

@@ -0,0 +1,276 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  Config,
+  executeToolCall,
+  ToolRegistry,
+  ToolErrorType,
+  shutdownTelemetry,
+  GeminiEventType,
+  ServerGeminiStreamEvent,
+} from 'fss-link-core';
+import { Part } from '@google/genai';
+import { runNonInteractive } from './nonInteractiveCli.js';
+import { vi } from 'vitest';
+
+// Mock core modules
+vi.mock('fss-link-core', async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import('fss-link-core')>();
+  return {
+    ...original,
+    executeToolCall: vi.fn(),
+    shutdownTelemetry: vi.fn(),
+    isTelemetrySdkInitialized: vi.fn().mockReturnValue(true),
+  };
+});
+
+describe('runNonInteractive', () => {
+  let mockConfig: Config;
+  let mockToolRegistry: ToolRegistry;
+  let mockCoreExecuteToolCall: vi.Mock;
+  let mockShutdownTelemetry: vi.Mock;
+  let consoleErrorSpy: vi.SpyInstance;
+  let processExitSpy: vi.SpyInstance;
+  let processStdoutSpy: vi.SpyInstance;
+  let mockGeminiClient: {
+    sendMessageStream: vi.Mock;
+  };
+
+  beforeEach(() => {
+    mockCoreExecuteToolCall = vi.mocked(executeToolCall);
+    mockShutdownTelemetry = vi.mocked(shutdownTelemetry);
+
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    processExitSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation((() => {}) as (code?: number) => never);
+    processStdoutSpy = vi
+      .spyOn(process.stdout, 'write')
+      .mockImplementation(() => true);
+
+    mockToolRegistry = {
+      getTool: vi.fn(),
+      getFunctionDeclarations: vi.fn().mockReturnValue([]),
+    } as unknown as ToolRegistry;
+
+    mockGeminiClient = {
+      sendMessageStream: vi.fn(),
+    };
+
+    mockConfig = {
+      initialize: vi.fn().mockResolvedValue(undefined),
+      getGeminiClient: vi.fn().mockReturnValue(mockGeminiClient),
+      getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
+      getMaxSessionTurns: vi.fn().mockReturnValue(10),
+      getIdeMode: vi.fn().mockReturnValue(false),
+      getFullContext: vi.fn().mockReturnValue(false),
+      getContentGeneratorConfig: vi.fn().mockReturnValue({}),
+      getDebugMode: vi.fn().mockReturnValue(false),
+    } as unknown as Config;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  async function* createStreamFromEvents(
+    events: ServerGeminiStreamEvent[],
+  ): AsyncGenerator<ServerGeminiStreamEvent> {
+    for (const event of events) {
+      yield event;
+    }
+  }
+
+  it('should process input and write text output', async () => {
+    const events: ServerGeminiStreamEvent[] = [
+      { type: GeminiEventType.Content, value: 'Hello' },
+      { type: GeminiEventType.Content, value: ' World' },
+    ];
+    mockGeminiClient.sendMessageStream.mockReturnValue(
+      createStreamFromEvents(events),
+    );
+
+    await runNonInteractive(mockConfig, 'Test input', 'prompt-id-1');
+
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith(
+      [{ text: 'Test input' }],
+      expect.any(AbortSignal),
+      'prompt-id-1',
+    );
+    expect(processStdoutSpy).toHaveBeenCalledWith('Hello');
+    expect(processStdoutSpy).toHaveBeenCalledWith(' World');
+    expect(processStdoutSpy).toHaveBeenCalledWith('\n');
+    expect(mockShutdownTelemetry).toHaveBeenCalled();
+  });
+
+  it('should handle a single tool call and respond', async () => {
+    const toolCallEvent: ServerGeminiStreamEvent = {
+      type: GeminiEventType.ToolCallRequest,
+      value: {
+        callId: 'tool-1',
+        name: 'testTool',
+        args: { arg1: 'value1' },
+        isClientInitiated: false,
+        prompt_id: 'prompt-id-2',
+      },
+    };
+    const toolResponse: Part[] = [{ text: 'Tool response' }];
+    mockCoreExecuteToolCall.mockResolvedValue({ responseParts: toolResponse });
+
+    const firstCallEvents: ServerGeminiStreamEvent[] = [toolCallEvent];
+    const secondCallEvents: ServerGeminiStreamEvent[] = [
+      { type: GeminiEventType.Content, value: 'Final answer' },
+    ];
+
+    mockGeminiClient.sendMessageStream
+      .mockReturnValueOnce(createStreamFromEvents(firstCallEvents))
+      .mockReturnValueOnce(createStreamFromEvents(secondCallEvents));
+
+    await runNonInteractive(mockConfig, 'Use a tool', 'prompt-id-2');
+
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(2);
+    expect(mockCoreExecuteToolCall).toHaveBeenCalledWith(
+      mockConfig,
+      expect.objectContaining({ name: 'testTool' }),
+      expect.any(AbortSignal),
+    );
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenNthCalledWith(
+      2,
+      [{ text: 'Tool response' }],
+      expect.any(AbortSignal),
+      'prompt-id-2',
+    );
+    expect(processStdoutSpy).toHaveBeenCalledWith('Final answer');
+    expect(processStdoutSpy).toHaveBeenCalledWith('\n');
+  });
+
+  it('should handle error during tool execution and should send error back to the model', async () => {
+    const toolCallEvent: ServerGeminiStreamEvent = {
+      type: GeminiEventType.ToolCallRequest,
+      value: {
+        callId: 'tool-1',
+        name: 'errorTool',
+        args: {},
+        isClientInitiated: false,
+        prompt_id: 'prompt-id-3',
+      },
+    };
+    mockCoreExecuteToolCall.mockResolvedValue({
+      error: new Error('Execution failed'),
+      errorType: ToolErrorType.EXECUTION_FAILED,
+      responseParts: {
+        functionResponse: {
+          name: 'errorTool',
+          response: {
+            output: 'Error: Execution failed',
+          },
+        },
+      },
+      resultDisplay: 'Execution failed',
+    });
+    const finalResponse: ServerGeminiStreamEvent[] = [
+      {
+        type: GeminiEventType.Content,
+        value: 'Sorry, let me try again.',
+      },
+    ];
+    mockGeminiClient.sendMessageStream
+      .mockReturnValueOnce(createStreamFromEvents([toolCallEvent]))
+      .mockReturnValueOnce(createStreamFromEvents(finalResponse));
+
+    await runNonInteractive(mockConfig, 'Trigger tool error', 'prompt-id-3');
+
+    expect(mockCoreExecuteToolCall).toHaveBeenCalled();
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Error executing tool errorTool: Execution failed',
+    );
+    expect(processExitSpy).not.toHaveBeenCalled();
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(2);
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenNthCalledWith(
+      2,
+      [
+        {
+          functionResponse: {
+            name: 'errorTool',
+            response: {
+              output: 'Error: Execution failed',
+            },
+          },
+        },
+      ],
+      expect.any(AbortSignal),
+      'prompt-id-3',
+    );
+    expect(processStdoutSpy).toHaveBeenCalledWith('Sorry, let me try again.');
+  });
+
+  it('should exit with error if sendMessageStream throws initially', async () => {
+    const apiError = new Error('API connection failed');
+    mockGeminiClient.sendMessageStream.mockImplementation(() => {
+      throw apiError;
+    });
+
+    await runNonInteractive(mockConfig, 'Initial fail', 'prompt-id-4');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      '[API Error: API connection failed]',
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('should not exit if a tool is not found, and should send error back to model', async () => {
+    const toolCallEvent: ServerGeminiStreamEvent = {
+      type: GeminiEventType.ToolCallRequest,
+      value: {
+        callId: 'tool-1',
+        name: 'nonexistentTool',
+        args: {},
+        isClientInitiated: false,
+        prompt_id: 'prompt-id-5',
+      },
+    };
+    mockCoreExecuteToolCall.mockResolvedValue({
+      error: new Error('Tool "nonexistentTool" not found in registry.'),
+      resultDisplay: 'Tool "nonexistentTool" not found in registry.',
+    });
+    const finalResponse: ServerGeminiStreamEvent[] = [
+      {
+        type: GeminiEventType.Content,
+        value: "Sorry, I can't find that tool.",
+      },
+    ];
+
+    mockGeminiClient.sendMessageStream
+      .mockReturnValueOnce(createStreamFromEvents([toolCallEvent]))
+      .mockReturnValueOnce(createStreamFromEvents(finalResponse));
+
+    await runNonInteractive(
+      mockConfig,
+      'Trigger tool not found',
+      'prompt-id-5',
+    );
+
+    expect(mockCoreExecuteToolCall).toHaveBeenCalled();
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'Error executing tool nonexistentTool: Tool "nonexistentTool" not found in registry.',
+    );
+    expect(processExitSpy).not.toHaveBeenCalled();
+    expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(2);
+    expect(processStdoutSpy).toHaveBeenCalledWith(
+      "Sorry, I can't find that tool.",
+    );
+  });
+
+  it('should exit when max session turns are exceeded', async () => {
+    vi.mocked(mockConfig.getMaxSessionTurns).mockReturnValue(0);
+    await runNonInteractive(mockConfig, 'Trigger loop', 'prompt-id-6');
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      '\n Reached max session turns for this session. Increase the number of turns by specifying maxSessionTurns in settings.json.',
+    );
+  });
+});