Add files using upload-large-folder tool

projects/ui/qwen-code/packages/core/src/utils/safeJsonStringify.test.ts

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { safeJsonStringify } from './safeJsonStringify.js';
+
+describe('safeJsonStringify', () => {
+  it('should stringify normal objects without issues', () => {
+    const obj = { name: 'test', value: 42 };
+    const result = safeJsonStringify(obj);
+    expect(result).toBe('{"name":"test","value":42}');
+  });
+
+  it('should handle circular references by replacing them with [Circular]', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const obj: any = { name: 'test' };
+    obj.circular = obj; // Create circular reference
+
+    const result = safeJsonStringify(obj);
+    expect(result).toBe('{"name":"test","circular":"[Circular]"}');
+  });
+
+  it('should handle complex circular structures like HttpsProxyAgent', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const agent: any = {
+      sockets: {},
+      options: { host: 'example.com' },
+    };
+    agent.sockets['example.com'] = [{ agent }];
+
+    const result = safeJsonStringify(agent);
+    expect(result).toContain('[Circular]');
+    expect(result).toContain('example.com');
+  });
+
+  it('should respect the space parameter for formatting', () => {
+    const obj = { name: 'test', value: 42 };
+    const result = safeJsonStringify(obj, 2);
+    expect(result).toBe('{\n  "name": "test",\n  "value": 42\n}');
+  });
+
+  it('should handle circular references with formatting', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const obj: any = { name: 'test' };
+    obj.circular = obj;
+
+    const result = safeJsonStringify(obj, 2);
+    expect(result).toBe('{\n  "name": "test",\n  "circular": "[Circular]"\n}');
+  });
+
+  it('should handle arrays with circular references', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const arr: any[] = [{ id: 1 }];
+    arr[0].parent = arr; // Create circular reference
+
+    const result = safeJsonStringify(arr);
+    expect(result).toBe('[{"id":1,"parent":"[Circular]"}]');
+  });
+
+  it('should handle null and undefined values', () => {
+    expect(safeJsonStringify(null)).toBe('null');
+    expect(safeJsonStringify(undefined)).toBe(undefined);
+  });
+
+  it('should handle primitive values', () => {
+    expect(safeJsonStringify('test')).toBe('"test"');
+    expect(safeJsonStringify(42)).toBe('42');
+    expect(safeJsonStringify(true)).toBe('true');
+  });
+});

projects/ui/qwen-code/packages/core/src/utils/safeJsonStringify.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Safely stringifies an object to JSON, handling circular references by replacing them with [Circular].
+ *
+ * @param obj - The object to stringify
+ * @param space - Optional space parameter for formatting (defaults to no formatting)
+ * @returns JSON string with circular references replaced by [Circular]
+ */
+export function safeJsonStringify(
+  obj: unknown,
+  space?: string | number,
+): string {
+  const seen = new WeakSet();
+  return JSON.stringify(
+    obj,
+    (key, value) => {
+      if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) {
+          return '[Circular]';
+        }
+        seen.add(value);
+      }
+      return value;
+    },
+    space,
+  );
+}

projects/ui/qwen-code/packages/core/src/utils/schemaValidator.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import AjvPkg from 'ajv';
+// Ajv's ESM/CJS interop: use 'any' for compatibility as recommended by Ajv docs
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const AjvClass = (AjvPkg as any).default || AjvPkg;
+const ajValidator = new AjvClass();
+
+/**
+ * Simple utility to validate objects against JSON Schemas
+ */
+export class SchemaValidator {
+  /**
+   * Returns null if the data confroms to the schema described by schema (or if schema
+   *  is null). Otherwise, returns a string describing the error.
+   */
+  static validate(schema: unknown | undefined, data: unknown): string | null {
+    if (!schema) {
+      return null;
+    }
+    if (typeof data !== 'object' || data === null) {
+      return 'Value of params must be an object';
+    }
+    const validate = ajValidator.compile(schema);
+    const valid = validate(data);
+    if (!valid && validate.errors) {
+      return ajValidator.errorsText(validate.errors, { dataVar: 'params' });
+    }
+    return null;
+  }
+}

projects/ui/qwen-code/packages/core/src/utils/secure-browser-launcher.test.ts

@@ -0,0 +1,242 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { openBrowserSecurely } from './secure-browser-launcher.js';
+
+// Create mock function using vi.hoisted
+const mockExecFile = vi.hoisted(() => vi.fn());
+
+// Mock modules
+vi.mock('node:child_process');
+vi.mock('node:util', () => ({
+  promisify: () => mockExecFile,
+}));
+
+describe('secure-browser-launcher', () => {
+  let originalPlatform: PropertyDescriptor | undefined;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExecFile.mockResolvedValue({ stdout: '', stderr: '' });
+    originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
+  });
+
+  afterEach(() => {
+    if (originalPlatform) {
+      Object.defineProperty(process, 'platform', originalPlatform);
+    }
+  });
+
+  function setPlatform(platform: string) {
+    Object.defineProperty(process, 'platform', {
+      value: platform,
+      configurable: true,
+    });
+  }
+
+  describe('URL validation', () => {
+    it('should allow valid HTTP URLs', async () => {
+      setPlatform('darwin');
+      await openBrowserSecurely('http://example.com');
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'open',
+        ['http://example.com'],
+        expect.any(Object),
+      );
+    });
+
+    it('should allow valid HTTPS URLs', async () => {
+      setPlatform('darwin');
+      await openBrowserSecurely('https://example.com');
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'open',
+        ['https://example.com'],
+        expect.any(Object),
+      );
+    });
+
+    it('should reject non-HTTP(S) protocols', async () => {
+      await expect(openBrowserSecurely('file:///etc/passwd')).rejects.toThrow(
+        'Unsafe protocol',
+      );
+      await expect(openBrowserSecurely('javascript:alert(1)')).rejects.toThrow(
+        'Unsafe protocol',
+      );
+      await expect(openBrowserSecurely('ftp://example.com')).rejects.toThrow(
+        'Unsafe protocol',
+      );
+    });
+
+    it('should reject invalid URLs', async () => {
+      await expect(openBrowserSecurely('not-a-url')).rejects.toThrow(
+        'Invalid URL',
+      );
+      await expect(openBrowserSecurely('')).rejects.toThrow('Invalid URL');
+    });
+
+    it('should reject URLs with control characters', async () => {
+      await expect(
+        openBrowserSecurely('http://example.com\nmalicious-command'),
+      ).rejects.toThrow('invalid characters');
+      await expect(
+        openBrowserSecurely('http://example.com\rmalicious-command'),
+      ).rejects.toThrow('invalid characters');
+      await expect(
+        openBrowserSecurely('http://example.com\x00'),
+      ).rejects.toThrow('invalid characters');
+    });
+  });
+
+  describe('Command injection prevention', () => {
+    it('should prevent PowerShell command injection on Windows', async () => {
+      setPlatform('win32');
+
+      // The POC from the vulnerability report
+      const maliciousUrl =
+        "http://127.0.0.1:8080/?param=example#$(Invoke-Expression([System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('Y2FsYy5leGU='))))";
+
+      await openBrowserSecurely(maliciousUrl);
+
+      // Verify that execFile was called (not exec) and the URL is passed safely
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'powershell.exe',
+        [
+          '-NoProfile',
+          '-NonInteractive',
+          '-WindowStyle',
+          'Hidden',
+          '-Command',
+          `Start-Process '${maliciousUrl.replace(/'/g, "''")}'`,
+        ],
+        expect.any(Object),
+      );
+    });
+
+    it('should handle URLs with special shell characters safely', async () => {
+      setPlatform('darwin');
+
+      const urlsWithSpecialChars = [
+        'http://example.com/path?param=value&other=$value',
+        'http://example.com/path#fragment;command',
+        'http://example.com/$(whoami)',
+        'http://example.com/`command`',
+        'http://example.com/|pipe',
+        'http://example.com/>redirect',
+      ];
+
+      for (const url of urlsWithSpecialChars) {
+        await openBrowserSecurely(url);
+        // Verify the URL is passed as an argument, not interpreted by shell
+        expect(mockExecFile).toHaveBeenCalledWith(
+          'open',
+          [url],
+          expect.any(Object),
+        );
+      }
+    });
+
+    it('should properly escape single quotes in URLs on Windows', async () => {
+      setPlatform('win32');
+
+      const urlWithSingleQuotes =
+        "http://example.com/path?name=O'Brien&test='value'";
+      await openBrowserSecurely(urlWithSingleQuotes);
+
+      // Verify that single quotes are escaped by doubling them
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'powershell.exe',
+        [
+          '-NoProfile',
+          '-NonInteractive',
+          '-WindowStyle',
+          'Hidden',
+          '-Command',
+          `Start-Process 'http://example.com/path?name=O''Brien&test=''value'''`,
+        ],
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe('Platform-specific behavior', () => {
+    it('should use correct command on macOS', async () => {
+      setPlatform('darwin');
+      await openBrowserSecurely('https://example.com');
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'open',
+        ['https://example.com'],
+        expect.any(Object),
+      );
+    });
+
+    it('should use PowerShell on Windows', async () => {
+      setPlatform('win32');
+      await openBrowserSecurely('https://example.com');
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'powershell.exe',
+        expect.arrayContaining([
+          '-Command',
+          `Start-Process 'https://example.com'`,
+        ]),
+        expect.any(Object),
+      );
+    });
+
+    it('should use xdg-open on Linux', async () => {
+      setPlatform('linux');
+      await openBrowserSecurely('https://example.com');
+      expect(mockExecFile).toHaveBeenCalledWith(
+        'xdg-open',
+        ['https://example.com'],
+        expect.any(Object),
+      );
+    });
+
+    it('should throw on unsupported platforms', async () => {
+      setPlatform('aix');
+      await expect(openBrowserSecurely('https://example.com')).rejects.toThrow(
+        'Unsupported platform',
+      );
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle browser launch failures gracefully', async () => {
+      setPlatform('darwin');
+      mockExecFile.mockRejectedValueOnce(new Error('Command not found'));
+
+      await expect(openBrowserSecurely('https://example.com')).rejects.toThrow(
+        'Failed to open browser',
+      );
+    });
+
+    it('should try fallback browsers on Linux', async () => {
+      setPlatform('linux');
+
+      // First call to xdg-open fails
+      mockExecFile.mockRejectedValueOnce(new Error('Command not found'));
+      // Second call to gnome-open succeeds
+      mockExecFile.mockResolvedValueOnce({ stdout: '', stderr: '' });
+
+      await openBrowserSecurely('https://example.com');
+
+      expect(mockExecFile).toHaveBeenCalledTimes(2);
+      expect(mockExecFile).toHaveBeenNthCalledWith(
+        1,
+        'xdg-open',
+        ['https://example.com'],
+        expect.any(Object),
+      );
+      expect(mockExecFile).toHaveBeenNthCalledWith(
+        2,
+        'gnome-open',
+        ['https://example.com'],
+        expect.any(Object),
+      );
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/utils/secure-browser-launcher.ts

@@ -0,0 +1,191 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { platform } from 'node:os';
+import { URL } from 'node:url';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Validates that a URL is safe to open in a browser.
+ * Only allows HTTP and HTTPS URLs to prevent command injection.
+ *
+ * @param url The URL to validate
+ * @throws Error if the URL is invalid or uses an unsafe protocol
+ */
+function validateUrl(url: string): void {
+  let parsedUrl: URL;
+
+  try {
+    parsedUrl = new URL(url);
+  } catch (_error) {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+
+  // Only allow HTTP and HTTPS protocols
+  if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+    throw new Error(
+      `Unsafe protocol: ${parsedUrl.protocol}. Only HTTP and HTTPS are allowed.`,
+    );
+  }
+
+  // Additional validation: ensure no newlines or control characters
+  // eslint-disable-next-line no-control-regex
+  if (/[\r\n\x00-\x1f]/.test(url)) {
+    throw new Error('URL contains invalid characters');
+  }
+}
+
+/**
+ * Opens a URL in the default browser using platform-specific commands.
+ * This implementation avoids shell injection vulnerabilities by:
+ * 1. Validating the URL to ensure it's HTTP/HTTPS only
+ * 2. Using execFile instead of exec to avoid shell interpretation
+ * 3. Passing the URL as an argument rather than constructing a command string
+ *
+ * @param url The URL to open
+ * @throws Error if the URL is invalid or if opening the browser fails
+ */
+export async function openBrowserSecurely(url: string): Promise<void> {
+  // Validate the URL first
+  validateUrl(url);
+
+  const platformName = platform();
+  let command: string;
+  let args: string[];
+
+  switch (platformName) {
+    case 'darwin':
+      // macOS
+      command = 'open';
+      args = [url];
+      break;
+
+    case 'win32':
+      // Windows - use PowerShell with Start-Process
+      // This avoids the cmd.exe shell which is vulnerable to injection
+      command = 'powershell.exe';
+      args = [
+        '-NoProfile',
+        '-NonInteractive',
+        '-WindowStyle',
+        'Hidden',
+        '-Command',
+        `Start-Process '${url.replace(/'/g, "''")}'`,
+      ];
+      break;
+
+    case 'linux':
+    case 'freebsd':
+    case 'openbsd':
+      // Linux and BSD variants
+      // Try xdg-open first, fall back to other options
+      command = 'xdg-open';
+      args = [url];
+      break;
+
+    default:
+      throw new Error(`Unsupported platform: ${platformName}`);
+  }
+
+  const options: Record<string, unknown> = {
+    // Don't inherit parent's environment to avoid potential issues
+    env: {
+      ...process.env,
+      // Ensure we're not in a shell that might interpret special characters
+      SHELL: undefined,
+    },
+    // Detach the browser process so it doesn't block
+    detached: true,
+    stdio: 'ignore',
+  };
+
+  try {
+    await execFileAsync(command, args, options);
+  } catch (error) {
+    // For Linux, try fallback commands if xdg-open fails
+    if (
+      (platformName === 'linux' ||
+        platformName === 'freebsd' ||
+        platformName === 'openbsd') &&
+      command === 'xdg-open'
+    ) {
+      const fallbackCommands = [
+        'gnome-open',
+        'kde-open',
+        'firefox',
+        'chromium',
+        'google-chrome',
+      ];
+
+      for (const fallbackCommand of fallbackCommands) {
+        try {
+          await execFileAsync(fallbackCommand, [url], options);
+          return; // Success!
+        } catch {
+          // Try next command
+          continue;
+        }
+      }
+    }
+
+    // Re-throw the error if all attempts failed
+    throw new Error(
+      `Failed to open browser: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    );
+  }
+}
+
+/**
+ * Checks if the current environment should attempt to launch a browser.
+ * This is the same logic as in browser.ts for consistency.
+ *
+ * @returns True if the tool should attempt to launch a browser
+ */
+export function shouldLaunchBrowser(): boolean {
+  // A list of browser names that indicate we should not attempt to open a
+  // web browser for the user.
+  const browserBlocklist = ['www-browser'];
+  const browserEnv = process.env['BROWSER'];
+  if (browserEnv && browserBlocklist.includes(browserEnv)) {
+    return false;
+  }
+
+  // Common environment variables used in CI/CD or other non-interactive shells.
+  if (
+    process.env['CI'] ||
+    process.env['DEBIAN_FRONTEND'] === 'noninteractive'
+  ) {
+    return false;
+  }
+
+  // The presence of SSH_CONNECTION indicates a remote session.
+  // We should not attempt to launch a browser unless a display is explicitly available
+  // (checked below for Linux).
+  const isSSH = !!process.env['SSH_CONNECTION'];
+
+  // On Linux, the presence of a display server is a strong indicator of a GUI.
+  if (platform() === 'linux') {
+    // These are environment variables that can indicate a running compositor on Linux.
+    const displayVariables = ['DISPLAY', 'WAYLAND_DISPLAY', 'MIR_SOCKET'];
+    const hasDisplay = displayVariables.some((v) => !!process.env[v]);
+    if (!hasDisplay) {
+      return false;
+    }
+  }
+
+  // If in an SSH session on a non-Linux OS (e.g., macOS), don't launch browser.
+  // The Linux case is handled above (it's allowed if DISPLAY is set).
+  if (isSSH && platform() !== 'linux') {
+    return false;
+  }
+
+  // For non-Linux OSes, we generally assume a GUI is available
+  // unless other signals (like SSH) suggest otherwise.
+  return true;
+}

projects/ui/qwen-code/packages/core/src/utils/session.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { randomUUID } from 'crypto';
+
+export const sessionId = randomUUID();

projects/ui/qwen-code/packages/core/src/utils/shell-utils.test.ts

@@ -0,0 +1,434 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { expect, describe, it, beforeEach, vi, afterEach } from 'vitest';
+import {
+  checkCommandPermissions,
+  escapeShellArg,
+  getCommandRoots,
+  getShellConfiguration,
+  isCommandAllowed,
+  stripShellWrapper,
+} from './shell-utils.js';
+import { Config } from '../config/config.js';
+
+const mockPlatform = vi.hoisted(() => vi.fn());
+vi.mock('os', () => ({
+  default: {
+    platform: mockPlatform,
+  },
+  platform: mockPlatform,
+}));
+
+const mockQuote = vi.hoisted(() => vi.fn());
+vi.mock('shell-quote', () => ({
+  quote: mockQuote,
+}));
+
+let config: Config;
+
+beforeEach(() => {
+  mockPlatform.mockReturnValue('linux');
+  mockQuote.mockImplementation((args: string[]) =>
+    args.map((arg) => `'${arg}'`).join(' '),
+  );
+  config = {
+    getCoreTools: () => [],
+    getExcludeTools: () => [],
+  } as unknown as Config;
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('isCommandAllowed', () => {
+  it('should allow a command if no restrictions are provided', () => {
+    const result = isCommandAllowed('ls -l', config);
+    expect(result.allowed).toBe(true);
+  });
+
+  it('should allow a command if it is in the global allowlist', () => {
+    config.getCoreTools = () => ['ShellTool(ls)'];
+    const result = isCommandAllowed('ls -l', config);
+    expect(result.allowed).toBe(true);
+  });
+
+  it('should block a command if it is not in a strict global allowlist', () => {
+    config.getCoreTools = () => ['ShellTool(ls -l)'];
+    const result = isCommandAllowed('rm -rf /', config);
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toBe(
+      `Command(s) not in the allowed commands list. Disallowed commands: "rm -rf /"`,
+    );
+  });
+
+  it('should block a command if it is in the blocked list', () => {
+    config.getExcludeTools = () => ['ShellTool(rm -rf /)'];
+    const result = isCommandAllowed('rm -rf /', config);
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toBe(
+      `Command 'rm -rf /' is blocked by configuration`,
+    );
+  });
+
+  it('should prioritize the blocklist over the allowlist', () => {
+    config.getCoreTools = () => ['ShellTool(rm -rf /)'];
+    config.getExcludeTools = () => ['ShellTool(rm -rf /)'];
+    const result = isCommandAllowed('rm -rf /', config);
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toBe(
+      `Command 'rm -rf /' is blocked by configuration`,
+    );
+  });
+
+  it('should allow any command when a wildcard is in coreTools', () => {
+    config.getCoreTools = () => ['ShellTool'];
+    const result = isCommandAllowed('any random command', config);
+    expect(result.allowed).toBe(true);
+  });
+
+  it('should block any command when a wildcard is in excludeTools', () => {
+    config.getExcludeTools = () => ['run_shell_command'];
+    const result = isCommandAllowed('any random command', config);
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toBe(
+      'Shell tool is globally disabled in configuration',
+    );
+  });
+
+  it('should block a command on the blocklist even with a wildcard allow', () => {
+    config.getCoreTools = () => ['ShellTool'];
+    config.getExcludeTools = () => ['ShellTool(rm -rf /)'];
+    const result = isCommandAllowed('rm -rf /', config);
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toBe(
+      `Command 'rm -rf /' is blocked by configuration`,
+    );
+  });
+
+  it('should allow a chained command if all parts are on the global allowlist', () => {
+    config.getCoreTools = () => [
+      'run_shell_command(echo)',
+      'run_shell_command(ls)',
+    ];
+    const result = isCommandAllowed('echo "hello" && ls -l', config);
+    expect(result.allowed).toBe(true);
+  });
+
+  it('should block a chained command if any part is blocked', () => {
+    config.getExcludeTools = () => ['run_shell_command(rm)'];
+    const result = isCommandAllowed('echo "hello" && rm -rf /', config);
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toBe(
+      `Command 'rm -rf /' is blocked by configuration`,
+    );
+  });
+
+  describe('command substitution', () => {
+    it('should block command substitution using `$(...)`', () => {
+      const result = isCommandAllowed('echo $(rm -rf /)', config);
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Command substitution');
+    });
+
+    it('should block command substitution using `<(...)`', () => {
+      const result = isCommandAllowed('diff <(ls) <(ls -a)', config);
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Command substitution');
+    });
+
+    it('should block command substitution using backticks', () => {
+      const result = isCommandAllowed('echo `rm -rf /`', config);
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Command substitution');
+    });
+
+    it('should allow substitution-like patterns inside single quotes', () => {
+      config.getCoreTools = () => ['ShellTool(echo)'];
+      const result = isCommandAllowed("echo '$(pwd)'", config);
+      expect(result.allowed).toBe(true);
+    });
+  });
+});
+
+describe('checkCommandPermissions', () => {
+  describe('in "Default Allow" mode (no sessionAllowlist)', () => {
+    it('should return a detailed success object for an allowed command', () => {
+      const result = checkCommandPermissions('ls -l', config);
+      expect(result).toEqual({
+        allAllowed: true,
+        disallowedCommands: [],
+      });
+    });
+
+    it('should return a detailed failure object for a blocked command', () => {
+      config.getExcludeTools = () => ['ShellTool(rm)'];
+      const result = checkCommandPermissions('rm -rf /', config);
+      expect(result).toEqual({
+        allAllowed: false,
+        disallowedCommands: ['rm -rf /'],
+        blockReason: `Command 'rm -rf /' is blocked by configuration`,
+        isHardDenial: true,
+      });
+    });
+
+    it('should return a detailed failure object for a command not on a strict allowlist', () => {
+      config.getCoreTools = () => ['ShellTool(ls)'];
+      const result = checkCommandPermissions('git status && ls', config);
+      expect(result).toEqual({
+        allAllowed: false,
+        disallowedCommands: ['git status'],
+        blockReason: `Command(s) not in the allowed commands list. Disallowed commands: "git status"`,
+        isHardDenial: false,
+      });
+    });
+  });
+
+  describe('in "Default Deny" mode (with sessionAllowlist)', () => {
+    it('should allow a command on the sessionAllowlist', () => {
+      const result = checkCommandPermissions(
+        'ls -l',
+        config,
+        new Set(['ls -l']),
+      );
+      expect(result.allAllowed).toBe(true);
+    });
+
+    it('should block a command not on the sessionAllowlist or global allowlist', () => {
+      const result = checkCommandPermissions(
+        'rm -rf /',
+        config,
+        new Set(['ls -l']),
+      );
+      expect(result.allAllowed).toBe(false);
+      expect(result.blockReason).toContain(
+        'not on the global or session allowlist',
+      );
+      expect(result.disallowedCommands).toEqual(['rm -rf /']);
+    });
+
+    it('should allow a command on the global allowlist even if not on the session allowlist', () => {
+      config.getCoreTools = () => ['ShellTool(git status)'];
+      const result = checkCommandPermissions(
+        'git status',
+        config,
+        new Set(['ls -l']),
+      );
+      expect(result.allAllowed).toBe(true);
+    });
+
+    it('should allow a chained command if parts are on different allowlists', () => {
+      config.getCoreTools = () => ['ShellTool(git status)'];
+      const result = checkCommandPermissions(
+        'git status && git commit',
+        config,
+        new Set(['git commit']),
+      );
+      expect(result.allAllowed).toBe(true);
+    });
+
+    it('should block a command on the sessionAllowlist if it is also globally blocked', () => {
+      config.getExcludeTools = () => ['run_shell_command(rm)'];
+      const result = checkCommandPermissions(
+        'rm -rf /',
+        config,
+        new Set(['rm -rf /']),
+      );
+      expect(result.allAllowed).toBe(false);
+      expect(result.blockReason).toContain('is blocked by configuration');
+    });
+
+    it('should block a chained command if one part is not on any allowlist', () => {
+      config.getCoreTools = () => ['run_shell_command(echo)'];
+      const result = checkCommandPermissions(
+        'echo "hello" && rm -rf /',
+        config,
+        new Set(['echo']),
+      );
+      expect(result.allAllowed).toBe(false);
+      expect(result.disallowedCommands).toEqual(['rm -rf /']);
+    });
+  });
+});
+
+describe('getCommandRoots', () => {
+  it('should return a single command', () => {
+    expect(getCommandRoots('ls -l')).toEqual(['ls']);
+  });
+
+  it('should handle paths and return the binary name', () => {
+    expect(getCommandRoots('/usr/local/bin/node script.js')).toEqual(['node']);
+  });
+
+  it('should return an empty array for an empty string', () => {
+    expect(getCommandRoots('')).toEqual([]);
+  });
+
+  it('should handle a mix of operators', () => {
+    const result = getCommandRoots('a;b|c&&d||e&f');
+    expect(result).toEqual(['a', 'b', 'c', 'd', 'e', 'f']);
+  });
+
+  it('should correctly parse a chained command with quotes', () => {
+    const result = getCommandRoots('echo "hello" && git commit -m "feat"');
+    expect(result).toEqual(['echo', 'git']);
+  });
+});
+
+describe('stripShellWrapper', () => {
+  it('should strip sh -c with quotes', () => {
+    expect(stripShellWrapper('sh -c "ls -l"')).toEqual('ls -l');
+  });
+
+  it('should strip bash -c with extra whitespace', () => {
+    expect(stripShellWrapper('  bash  -c  "ls -l"  ')).toEqual('ls -l');
+  });
+
+  it('should strip zsh -c without quotes', () => {
+    expect(stripShellWrapper('zsh -c ls -l')).toEqual('ls -l');
+  });
+
+  it('should strip cmd.exe /c', () => {
+    expect(stripShellWrapper('cmd.exe /c "dir"')).toEqual('dir');
+  });
+
+  it('should not strip anything if no wrapper is present', () => {
+    expect(stripShellWrapper('ls -l')).toEqual('ls -l');
+  });
+});
+
+describe('escapeShellArg', () => {
+  describe('POSIX (bash)', () => {
+    it('should use shell-quote for escaping', () => {
+      mockQuote.mockReturnValueOnce("'escaped value'");
+      const result = escapeShellArg('raw value', 'bash');
+      expect(mockQuote).toHaveBeenCalledWith(['raw value']);
+      expect(result).toBe("'escaped value'");
+    });
+
+    it('should handle empty strings', () => {
+      const result = escapeShellArg('', 'bash');
+      expect(result).toBe('');
+      expect(mockQuote).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Windows', () => {
+    describe('when shell is cmd.exe', () => {
+      it('should wrap simple arguments in double quotes', () => {
+        const result = escapeShellArg('search term', 'cmd');
+        expect(result).toBe('"search term"');
+      });
+
+      it('should escape internal double quotes by doubling them', () => {
+        const result = escapeShellArg('He said "Hello"', 'cmd');
+        expect(result).toBe('"He said ""Hello"""');
+      });
+
+      it('should handle empty strings', () => {
+        const result = escapeShellArg('', 'cmd');
+        expect(result).toBe('');
+      });
+    });
+
+    describe('when shell is PowerShell', () => {
+      it('should wrap simple arguments in single quotes', () => {
+        const result = escapeShellArg('search term', 'powershell');
+        expect(result).toBe("'search term'");
+      });
+
+      it('should escape internal single quotes by doubling them', () => {
+        const result = escapeShellArg("It's a test", 'powershell');
+        expect(result).toBe("'It''s a test'");
+      });
+
+      it('should handle double quotes without escaping them', () => {
+        const result = escapeShellArg('He said "Hello"', 'powershell');
+        expect(result).toBe('\'He said "Hello"\'');
+      });
+
+      it('should handle empty strings', () => {
+        const result = escapeShellArg('', 'powershell');
+        expect(result).toBe('');
+      });
+    });
+  });
+});
+
+describe('getShellConfiguration', () => {
+  const originalEnv = { ...process.env };
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('should return bash configuration on Linux', () => {
+    mockPlatform.mockReturnValue('linux');
+    const config = getShellConfiguration();
+    expect(config.executable).toBe('bash');
+    expect(config.argsPrefix).toEqual(['-c']);
+    expect(config.shell).toBe('bash');
+  });
+
+  it('should return bash configuration on macOS (darwin)', () => {
+    mockPlatform.mockReturnValue('darwin');
+    const config = getShellConfiguration();
+    expect(config.executable).toBe('bash');
+    expect(config.argsPrefix).toEqual(['-c']);
+    expect(config.shell).toBe('bash');
+  });
+
+  describe('on Windows', () => {
+    beforeEach(() => {
+      mockPlatform.mockReturnValue('win32');
+    });
+
+    it('should return cmd.exe configuration by default', () => {
+      delete process.env['ComSpec'];
+      const config = getShellConfiguration();
+      expect(config.executable).toBe('cmd.exe');
+      expect(config.argsPrefix).toEqual(['/d', '/s', '/c']);
+      expect(config.shell).toBe('cmd');
+    });
+
+    it('should respect ComSpec for cmd.exe', () => {
+      const cmdPath = 'C:\\WINDOWS\\system32\\cmd.exe';
+      process.env['ComSpec'] = cmdPath;
+      const config = getShellConfiguration();
+      expect(config.executable).toBe(cmdPath);
+      expect(config.argsPrefix).toEqual(['/d', '/s', '/c']);
+      expect(config.shell).toBe('cmd');
+    });
+
+    it('should return PowerShell configuration if ComSpec points to powershell.exe', () => {
+      const psPath =
+        'C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+      process.env['ComSpec'] = psPath;
+      const config = getShellConfiguration();
+      expect(config.executable).toBe(psPath);
+      expect(config.argsPrefix).toEqual(['-NoProfile', '-Command']);
+      expect(config.shell).toBe('powershell');
+    });
+
+    it('should return PowerShell configuration if ComSpec points to pwsh.exe', () => {
+      const pwshPath = 'C:\\Program Files\\PowerShell\\7\\pwsh.exe';
+      process.env['ComSpec'] = pwshPath;
+      const config = getShellConfiguration();
+      expect(config.executable).toBe(pwshPath);
+      expect(config.argsPrefix).toEqual(['-NoProfile', '-Command']);
+      expect(config.shell).toBe('powershell');
+    });
+
+    it('should be case-insensitive when checking ComSpec', () => {
+      process.env['ComSpec'] = 'C:\\Path\\To\\POWERSHELL.EXE';
+      const config = getShellConfiguration();
+      expect(config.executable).toBe('C:\\Path\\To\\POWERSHELL.EXE');
+      expect(config.argsPrefix).toEqual(['-NoProfile', '-Command']);
+      expect(config.shell).toBe('powershell');
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/utils/shell-utils.ts

@@ -0,0 +1,457 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Config } from '../config/config.js';
+import os from 'os';
+import { quote } from 'shell-quote';
+
+/**
+ * An identifier for the shell type.
+ */
+export type ShellType = 'cmd' | 'powershell' | 'bash';
+
+/**
+ * Defines the configuration required to execute a command string within a specific shell.
+ */
+export interface ShellConfiguration {
+  /** The path or name of the shell executable (e.g., 'bash', 'cmd.exe'). */
+  executable: string;
+  /**
+   * The arguments required by the shell to execute a subsequent string argument.
+   */
+  argsPrefix: string[];
+  /** An identifier for the shell type. */
+  shell: ShellType;
+}
+
+/**
+ * Determines the appropriate shell configuration for the current platform.
+ *
+ * This ensures we can execute command strings predictably and securely across platforms
+ * using the `spawn(executable, [...argsPrefix, commandString], { shell: false })` pattern.
+ *
+ * @returns The ShellConfiguration for the current environment.
+ */
+export function getShellConfiguration(): ShellConfiguration {
+  if (isWindows()) {
+    const comSpec = process.env['ComSpec'] || 'cmd.exe';
+    const executable = comSpec.toLowerCase();
+
+    if (
+      executable.endsWith('powershell.exe') ||
+      executable.endsWith('pwsh.exe')
+    ) {
+      // For PowerShell, the arguments are different.
+      // -NoProfile: Speeds up startup.
+      // -Command: Executes the following command.
+      return {
+        executable: comSpec,
+        argsPrefix: ['-NoProfile', '-Command'],
+        shell: 'powershell',
+      };
+    }
+
+    // Default to cmd.exe for anything else on Windows.
+    // Flags for CMD:
+    // /d: Skip execution of AutoRun commands.
+    // /s: Modifies the treatment of the command string (important for quoting).
+    // /c: Carries out the command specified by the string and then terminates.
+    return {
+      executable: comSpec,
+      argsPrefix: ['/d', '/s', '/c'],
+      shell: 'cmd',
+    };
+  }
+
+  // Unix-like systems (Linux, macOS)
+  return { executable: 'bash', argsPrefix: ['-c'], shell: 'bash' };
+}
+
+/**
+ * Export the platform detection constant for use in process management (e.g., killing processes).
+ */
+export const isWindows = () => os.platform() === 'win32';
+
+/**
+ * Escapes a string so that it can be safely used as a single argument
+ * in a shell command, preventing command injection.
+ *
+ * @param arg The argument string to escape.
+ * @param shell The type of shell the argument is for.
+ * @returns The shell-escaped string.
+ */
+export function escapeShellArg(arg: string, shell: ShellType): string {
+  if (!arg) {
+    return '';
+  }
+
+  switch (shell) {
+    case 'powershell':
+      // For PowerShell, wrap in single quotes and escape internal single quotes by doubling them.
+      return `'${arg.replace(/'/g, "''")}'`;
+    case 'cmd':
+      // Simple Windows escaping for cmd.exe: wrap in double quotes and escape inner double quotes.
+      return `"${arg.replace(/"/g, '""')}"`;
+    case 'bash':
+    default:
+      // POSIX shell escaping using shell-quote.
+      return quote([arg]);
+  }
+}
+
+/**
+ * Splits a shell command into a list of individual commands, respecting quotes.
+ * This is used to separate chained commands (e.g., using &&, ||, ;).
+ * @param command The shell command string to parse
+ * @returns An array of individual command strings
+ */
+export function splitCommands(command: string): string[] {
+  const commands: string[] = [];
+  let currentCommand = '';
+  let inSingleQuotes = false;
+  let inDoubleQuotes = false;
+  let i = 0;
+
+  while (i < command.length) {
+    const char = command[i];
+    const nextChar = command[i + 1];
+
+    if (char === '\\' && i < command.length - 1) {
+      currentCommand += char + command[i + 1];
+      i += 2;
+      continue;
+    }
+
+    if (char === "'" && !inDoubleQuotes) {
+      inSingleQuotes = !inSingleQuotes;
+    } else if (char === '"' && !inSingleQuotes) {
+      inDoubleQuotes = !inDoubleQuotes;
+    }
+
+    if (!inSingleQuotes && !inDoubleQuotes) {
+      if (
+        (char === '&' && nextChar === '&') ||
+        (char === '|' && nextChar === '|')
+      ) {
+        commands.push(currentCommand.trim());
+        currentCommand = '';
+        i++; // Skip the next character
+      } else if (char === ';' || char === '&' || char === '|') {
+        commands.push(currentCommand.trim());
+        currentCommand = '';
+      } else {
+        currentCommand += char;
+      }
+    } else {
+      currentCommand += char;
+    }
+    i++;
+  }
+
+  if (currentCommand.trim()) {
+    commands.push(currentCommand.trim());
+  }
+
+  return commands.filter(Boolean); // Filter out any empty strings
+}
+
+/**
+ * Extracts the root command from a given shell command string.
+ * This is used to identify the base command for permission checks.
+ * @param command The shell command string to parse
+ * @returns The root command name, or undefined if it cannot be determined
+ * @example getCommandRoot("ls -la /tmp") returns "ls"
+ * @example getCommandRoot("git status && npm test") returns "git"
+ */
+export function getCommandRoot(command: string): string | undefined {
+  const trimmedCommand = command.trim();
+  if (!trimmedCommand) {
+    return undefined;
+  }
+
+  // This regex is designed to find the first "word" of a command,
+  // while respecting quotes. It looks for a sequence of non-whitespace
+  // characters that are not inside quotes.
+  const match = trimmedCommand.match(/^"([^"]+)"|^'([^']+)'|^(\S+)/);
+  if (match) {
+    // The first element in the match array is the full match.
+    // The subsequent elements are the capture groups.
+    // We prefer a captured group because it will be unquoted.
+    const commandRoot = match[1] || match[2] || match[3];
+    if (commandRoot) {
+      // If the command is a path, return the last component.
+      return commandRoot.split(/[\\/]/).pop();
+    }
+  }
+
+  return undefined;
+}
+
+export function getCommandRoots(command: string): string[] {
+  if (!command) {
+    return [];
+  }
+  return splitCommands(command)
+    .map((c) => getCommandRoot(c))
+    .filter((c): c is string => !!c);
+}
+
+export function stripShellWrapper(command: string): string {
+  const pattern = /^\s*(?:sh|bash|zsh|cmd.exe)\s+(?:\/c|-c)\s+/;
+  const match = command.match(pattern);
+  if (match) {
+    let newCommand = command.substring(match[0].length).trim();
+    if (
+      (newCommand.startsWith('"') && newCommand.endsWith('"')) ||
+      (newCommand.startsWith("'") && newCommand.endsWith("'"))
+    ) {
+      newCommand = newCommand.substring(1, newCommand.length - 1);
+    }
+    return newCommand;
+  }
+  return command.trim();
+}
+
+/**
+ * Detects command substitution patterns in a shell command, following bash quoting rules:
+ * - Single quotes ('): Everything literal, no substitution possible
+ * - Double quotes ("): Command substitution with $() and backticks unless escaped with \
+ * - No quotes: Command substitution with $(), <(), and backticks
+ * @param command The shell command string to check
+ * @returns true if command substitution would be executed by bash
+ */
+export function detectCommandSubstitution(command: string): boolean {
+  let inSingleQuotes = false;
+  let inDoubleQuotes = false;
+  let inBackticks = false;
+  let i = 0;
+
+  while (i < command.length) {
+    const char = command[i];
+    const nextChar = command[i + 1];
+
+    // Handle escaping - only works outside single quotes
+    if (char === '\\' && !inSingleQuotes) {
+      i += 2; // Skip the escaped character
+      continue;
+    }
+
+    // Handle quote state changes
+    if (char === "'" && !inDoubleQuotes && !inBackticks) {
+      inSingleQuotes = !inSingleQuotes;
+    } else if (char === '"' && !inSingleQuotes && !inBackticks) {
+      inDoubleQuotes = !inDoubleQuotes;
+    } else if (char === '`' && !inSingleQuotes) {
+      // Backticks work outside single quotes (including in double quotes)
+      inBackticks = !inBackticks;
+    }
+
+    // Check for command substitution patterns that would be executed
+    if (!inSingleQuotes) {
+      // $(...) command substitution - works in double quotes and unquoted
+      if (char === '$' && nextChar === '(') {
+        return true;
+      }
+
+      // <(...) process substitution - works unquoted only (not in double quotes)
+      if (char === '<' && nextChar === '(' && !inDoubleQuotes && !inBackticks) {
+        return true;
+      }
+
+      // Backtick command substitution - check for opening backtick
+      // (We track the state above, so this catches the start of backtick substitution)
+      if (char === '`' && !inBackticks) {
+        return true;
+      }
+    }
+
+    i++;
+  }
+
+  return false;
+}
+
+/**
+ * Checks a shell command against security policies and allowlists.
+ *
+ * This function operates in one of two modes depending on the presence of
+ * the `sessionAllowlist` parameter:
+ *
+ * 1.  **"Default Deny" Mode (sessionAllowlist is provided):** This is the
+ *     strictest mode, used for user-defined scripts like custom commands.
+ *     A command is only permitted if it is found on the global `coreTools`
+ *     allowlist OR the provided `sessionAllowlist`. It must not be on the
+ *     global `excludeTools` blocklist.
+ *
+ * 2.  **"Default Allow" Mode (sessionAllowlist is NOT provided):** This mode
+ *     is used for direct tool invocations (e.g., by the model). If a strict
+ *     global `coreTools` allowlist exists, commands must be on it. Otherwise,
+ *     any command is permitted as long as it is not on the `excludeTools`
+ *     blocklist.
+ *
+ * @param command The shell command string to validate.
+ * @param config The application configuration.
+ * @param sessionAllowlist A session-level list of approved commands. Its
+ *   presence activates "Default Deny" mode.
+ * @returns An object detailing which commands are not allowed.
+ */
+export function checkCommandPermissions(
+  command: string,
+  config: Config,
+  sessionAllowlist?: Set<string>,
+): {
+  allAllowed: boolean;
+  disallowedCommands: string[];
+  blockReason?: string;
+  isHardDenial?: boolean;
+} {
+  // Disallow command substitution for security.
+  if (detectCommandSubstitution(command)) {
+    return {
+      allAllowed: false,
+      disallowedCommands: [command],
+      blockReason:
+        'Command substitution using $(), <(), or >() is not allowed for security reasons',
+      isHardDenial: true,
+    };
+  }
+
+  const SHELL_TOOL_NAMES = ['run_shell_command', 'ShellTool'];
+  const normalize = (cmd: string): string => cmd.trim().replace(/\s+/g, ' ');
+
+  const isPrefixedBy = (cmd: string, prefix: string): boolean => {
+    if (!cmd.startsWith(prefix)) {
+      return false;
+    }
+    return cmd.length === prefix.length || cmd[prefix.length] === ' ';
+  };
+
+  const extractCommands = (tools: string[]): string[] =>
+    tools.flatMap((tool) => {
+      for (const toolName of SHELL_TOOL_NAMES) {
+        if (tool.startsWith(`${toolName}(`) && tool.endsWith(')')) {
+          return [normalize(tool.slice(toolName.length + 1, -1))];
+        }
+      }
+      return [];
+    });
+
+  const coreTools = config.getCoreTools() || [];
+  const excludeTools = config.getExcludeTools() || [];
+  const commandsToValidate = splitCommands(command).map(normalize);
+
+  // 1. Blocklist Check (Highest Priority)
+  if (SHELL_TOOL_NAMES.some((name) => excludeTools.includes(name))) {
+    return {
+      allAllowed: false,
+      disallowedCommands: commandsToValidate,
+      blockReason: 'Shell tool is globally disabled in configuration',
+      isHardDenial: true,
+    };
+  }
+  const blockedCommands = extractCommands(excludeTools);
+  for (const cmd of commandsToValidate) {
+    if (blockedCommands.some((blocked) => isPrefixedBy(cmd, blocked))) {
+      return {
+        allAllowed: false,
+        disallowedCommands: [cmd],
+        blockReason: `Command '${cmd}' is blocked by configuration`,
+        isHardDenial: true,
+      };
+    }
+  }
+
+  const globallyAllowedCommands = extractCommands(coreTools);
+  const isWildcardAllowed = SHELL_TOOL_NAMES.some((name) =>
+    coreTools.includes(name),
+  );
+
+  // If there's a global wildcard, all commands are allowed at this point
+  // because they have already passed the blocklist check.
+  if (isWildcardAllowed) {
+    return { allAllowed: true, disallowedCommands: [] };
+  }
+
+  if (sessionAllowlist) {
+    // "DEFAULT DENY" MODE: A session allowlist is provided.
+    // All commands must be in either the session or global allowlist.
+    const disallowedCommands: string[] = [];
+    for (const cmd of commandsToValidate) {
+      const isSessionAllowed = [...sessionAllowlist].some((allowed) =>
+        isPrefixedBy(cmd, normalize(allowed)),
+      );
+      if (isSessionAllowed) continue;
+
+      const isGloballyAllowed = globallyAllowedCommands.some((allowed) =>
+        isPrefixedBy(cmd, allowed),
+      );
+      if (isGloballyAllowed) continue;
+
+      disallowedCommands.push(cmd);
+    }
+
+    if (disallowedCommands.length > 0) {
+      return {
+        allAllowed: false,
+        disallowedCommands,
+        blockReason: `Command(s) not on the global or session allowlist. Disallowed commands: ${disallowedCommands
+          .map((c) => JSON.stringify(c))
+          .join(', ')}`,
+        isHardDenial: false, // This is a soft denial; confirmation is possible.
+      };
+    }
+  } else {
+    // "DEFAULT ALLOW" MODE: No session allowlist.
+    const hasSpecificAllowedCommands = globallyAllowedCommands.length > 0;
+    if (hasSpecificAllowedCommands) {
+      const disallowedCommands: string[] = [];
+      for (const cmd of commandsToValidate) {
+        const isGloballyAllowed = globallyAllowedCommands.some((allowed) =>
+          isPrefixedBy(cmd, allowed),
+        );
+        if (!isGloballyAllowed) {
+          disallowedCommands.push(cmd);
+        }
+      }
+      if (disallowedCommands.length > 0) {
+        return {
+          allAllowed: false,
+          disallowedCommands,
+          blockReason: `Command(s) not in the allowed commands list. Disallowed commands: ${disallowedCommands.map((c) => JSON.stringify(c)).join(', ')}`,
+          isHardDenial: false, // This is a soft denial.
+        };
+      }
+    }
+    // If no specific global allowlist exists, and it passed the blocklist,
+    // the command is allowed by default.
+  }
+
+  // If all checks for the current mode pass, the command is allowed.
+  return { allAllowed: true, disallowedCommands: [] };
+}
+
+/**
+ * Determines whether a given shell command is allowed to execute based on
+ * the tool's configuration including allowlists and blocklists.
+ *
+ * This function operates in "default allow" mode. It is a wrapper around
+ * `checkCommandPermissions`.
+ *
+ * @param command The shell command string to validate.
+ * @param config The application configuration.
+ * @returns An object with 'allowed' boolean and optional 'reason' string if not allowed.
+ */
+export function isCommandAllowed(
+  command: string,
+  config: Config,
+): { allowed: boolean; reason?: string } {
+  // By not providing a sessionAllowlist, we invoke "default allow" behavior.
+  const { allAllowed, blockReason } = checkCommandPermissions(command, config);
+  if (allAllowed) {
+    return { allowed: true };
+  }
+  return { allowed: false, reason: blockReason };
+}

projects/ui/qwen-code/packages/core/src/utils/summarizer.test.ts

@@ -0,0 +1,208 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach, Mock } from 'vitest';
+import { GeminiClient } from '../core/client.js';
+import { Config } from '../config/config.js';
+import {
+  summarizeToolOutput,
+  llmSummarizer,
+  defaultSummarizer,
+} from './summarizer.js';
+import { ToolResult } from '../tools/tools.js';
+
+// Mock GeminiClient and Config constructor
+vi.mock('../core/client.js');
+vi.mock('../config/config.js');
+
+describe('summarizers', () => {
+  let mockGeminiClient: GeminiClient;
+  let MockConfig: Mock;
+  const abortSignal = new AbortController().signal;
+
+  beforeEach(() => {
+    MockConfig = vi.mocked(Config);
+    const mockConfigInstance = new MockConfig(
+      'test-api-key',
+      'gemini-pro',
+      false,
+      '.',
+      false,
+      undefined,
+      false,
+      undefined,
+      undefined,
+      undefined,
+    );
+
+    mockGeminiClient = new GeminiClient(mockConfigInstance);
+    (mockGeminiClient.generateContent as Mock) = vi.fn();
+
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    (console.error as Mock).mockRestore();
+  });
+
+  describe('summarizeToolOutput', () => {
+    it('should return original text if it is shorter than maxLength', async () => {
+      const shortText = 'This is a short text.';
+      const result = await summarizeToolOutput(
+        shortText,
+        mockGeminiClient,
+        abortSignal,
+        2000,
+      );
+      expect(result).toBe(shortText);
+      expect(mockGeminiClient.generateContent).not.toHaveBeenCalled();
+    });
+
+    it('should return original text if it is empty', async () => {
+      const emptyText = '';
+      const result = await summarizeToolOutput(
+        emptyText,
+        mockGeminiClient,
+        abortSignal,
+        2000,
+      );
+      expect(result).toBe(emptyText);
+      expect(mockGeminiClient.generateContent).not.toHaveBeenCalled();
+    });
+
+    it('should call generateContent if text is longer than maxLength', async () => {
+      const longText = 'This is a very long text.'.repeat(200);
+      const summary = 'This is a summary.';
+      (mockGeminiClient.generateContent as Mock).mockResolvedValue({
+        candidates: [{ content: { parts: [{ text: summary }] } }],
+      });
+
+      const result = await summarizeToolOutput(
+        longText,
+        mockGeminiClient,
+        abortSignal,
+        2000,
+      );
+
+      expect(mockGeminiClient.generateContent).toHaveBeenCalledTimes(1);
+      expect(result).toBe(summary);
+    });
+
+    it('should return original text if generateContent throws an error', async () => {
+      const longText = 'This is a very long text.'.repeat(200);
+      const error = new Error('API Error');
+      (mockGeminiClient.generateContent as Mock).mockRejectedValue(error);
+
+      const result = await summarizeToolOutput(
+        longText,
+        mockGeminiClient,
+        abortSignal,
+        2000,
+      );
+
+      expect(mockGeminiClient.generateContent).toHaveBeenCalledTimes(1);
+      expect(result).toBe(longText);
+      expect(console.error).toHaveBeenCalledWith(
+        'Failed to summarize tool output.',
+        error,
+      );
+    });
+
+    it('should construct the correct prompt for summarization', async () => {
+      const longText = 'This is a very long text.'.repeat(200);
+      const summary = 'This is a summary.';
+      (mockGeminiClient.generateContent as Mock).mockResolvedValue({
+        candidates: [{ content: { parts: [{ text: summary }] } }],
+      });
+
+      await summarizeToolOutput(longText, mockGeminiClient, abortSignal, 1000);
+
+      const expectedPrompt = `Summarize the following tool output to be a maximum of 1000 tokens. The summary should be concise and capture the main points of the tool output.
+
+The summarization should be done based on the content that is provided. Here are the basic rules to follow:
+1. If the text is a directory listing or any output that is structural, use the history of the conversation to understand the context. Using this context try to understand what information we need from the tool output and return that as a response.
+2. If the text is text content and there is nothing structural that we need, summarize the text.
+3. If the text is the output of a shell command, use the history of the conversation to understand the context. Using this context try to understand what information we need from the tool output and return a summarization along with the stack trace of any error within the <error></error> tags. The stack trace should be complete and not truncated. If there are warnings, you should include them in the summary within <warning></warning> tags.
+
+
+Text to summarize:
+"${longText}"
+
+Return the summary string which should first contain an overall summarization of text followed by the full stack trace of errors and warnings in the tool output.
+`;
+      const calledWith = (mockGeminiClient.generateContent as Mock).mock
+        .calls[0];
+      const contents = calledWith[0];
+      expect(contents[0].parts[0].text).toBe(expectedPrompt);
+    });
+  });
+
+  describe('llmSummarizer', () => {
+    it('should summarize tool output using summarizeToolOutput', async () => {
+      const toolResult: ToolResult = {
+        llmContent: 'This is a very long text.'.repeat(200),
+        returnDisplay: '',
+      };
+      const summary = 'This is a summary.';
+      (mockGeminiClient.generateContent as Mock).mockResolvedValue({
+        candidates: [{ content: { parts: [{ text: summary }] } }],
+      });
+
+      const result = await llmSummarizer(
+        toolResult,
+        mockGeminiClient,
+        abortSignal,
+      );
+
+      expect(mockGeminiClient.generateContent).toHaveBeenCalledTimes(1);
+      expect(result).toBe(summary);
+    });
+
+    it('should handle different llmContent types', async () => {
+      const longText = 'This is a very long text.'.repeat(200);
+      const toolResult: ToolResult = {
+        llmContent: [{ text: longText }],
+        returnDisplay: '',
+      };
+      const summary = 'This is a summary.';
+      (mockGeminiClient.generateContent as Mock).mockResolvedValue({
+        candidates: [{ content: { parts: [{ text: summary }] } }],
+      });
+
+      const result = await llmSummarizer(
+        toolResult,
+        mockGeminiClient,
+        abortSignal,
+      );
+
+      expect(mockGeminiClient.generateContent).toHaveBeenCalledTimes(1);
+      const calledWith = (mockGeminiClient.generateContent as Mock).mock
+        .calls[0];
+      const contents = calledWith[0];
+      expect(contents[0].parts[0].text).toContain(`"${longText}"`);
+      expect(result).toBe(summary);
+    });
+  });
+
+  describe('defaultSummarizer', () => {
+    it('should stringify the llmContent', async () => {
+      const toolResult: ToolResult = {
+        llmContent: { text: 'some data' },
+        returnDisplay: '',
+      };
+
+      const result = await defaultSummarizer(
+        toolResult,
+        mockGeminiClient,
+        abortSignal,
+      );
+
+      expect(result).toBe(JSON.stringify({ text: 'some data' }));
+      expect(mockGeminiClient.generateContent).not.toHaveBeenCalled();
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/utils/summarizer.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ToolResult } from '../tools/tools.js';
+import {
+  Content,
+  GenerateContentConfig,
+  GenerateContentResponse,
+} from '@google/genai';
+import { GeminiClient } from '../core/client.js';
+import { DEFAULT_GEMINI_FLASH_LITE_MODEL } from '../config/models.js';
+import { getResponseText, partToString } from './partUtils.js';
+
+/**
+ * A function that summarizes the result of a tool execution.
+ *
+ * @param result The result of the tool execution.
+ * @returns The summary of the result.
+ */
+export type Summarizer = (
+  result: ToolResult,
+  geminiClient: GeminiClient,
+  abortSignal: AbortSignal,
+) => Promise<string>;
+
+/**
+ * The default summarizer for tool results.
+ *
+ * @param result The result of the tool execution.
+ * @param geminiClient The Gemini client to use for summarization.
+ * @param abortSignal The abort signal to use for summarization.
+ * @returns The summary of the result.
+ */
+export const defaultSummarizer: Summarizer = (
+  result: ToolResult,
+  _geminiClient: GeminiClient,
+  _abortSignal: AbortSignal,
+) => Promise.resolve(JSON.stringify(result.llmContent));
+
+const SUMMARIZE_TOOL_OUTPUT_PROMPT = `Summarize the following tool output to be a maximum of {maxOutputTokens} tokens. The summary should be concise and capture the main points of the tool output.
+
+The summarization should be done based on the content that is provided. Here are the basic rules to follow:
+1. If the text is a directory listing or any output that is structural, use the history of the conversation to understand the context. Using this context try to understand what information we need from the tool output and return that as a response.
+2. If the text is text content and there is nothing structural that we need, summarize the text.
+3. If the text is the output of a shell command, use the history of the conversation to understand the context. Using this context try to understand what information we need from the tool output and return a summarization along with the stack trace of any error within the <error></error> tags. The stack trace should be complete and not truncated. If there are warnings, you should include them in the summary within <warning></warning> tags.
+
+
+Text to summarize:
+"{textToSummarize}"
+
+Return the summary string which should first contain an overall summarization of text followed by the full stack trace of errors and warnings in the tool output.
+`;
+
+export const llmSummarizer: Summarizer = (result, geminiClient, abortSignal) =>
+  summarizeToolOutput(
+    partToString(result.llmContent),
+    geminiClient,
+    abortSignal,
+  );
+
+export async function summarizeToolOutput(
+  textToSummarize: string,
+  geminiClient: GeminiClient,
+  abortSignal: AbortSignal,
+  maxOutputTokens: number = 2000,
+): Promise<string> {
+  // There is going to be a slight difference here since we are comparing length of string with maxOutputTokens.
+  // This is meant to be a ballpark estimation of if we need to summarize the tool output.
+  if (!textToSummarize || textToSummarize.length < maxOutputTokens) {
+    return textToSummarize;
+  }
+  const prompt = SUMMARIZE_TOOL_OUTPUT_PROMPT.replace(
+    '{maxOutputTokens}',
+    String(maxOutputTokens),
+  ).replace('{textToSummarize}', textToSummarize);
+
+  const contents: Content[] = [{ role: 'user', parts: [{ text: prompt }] }];
+  const toolOutputSummarizerConfig: GenerateContentConfig = {
+    maxOutputTokens,
+  };
+  try {
+    const parsedResponse = (await geminiClient.generateContent(
+      contents,
+      toolOutputSummarizerConfig,
+      abortSignal,
+      DEFAULT_GEMINI_FLASH_LITE_MODEL,
+    )) as unknown as GenerateContentResponse;
+    return getResponseText(parsedResponse) || textToSummarize;
+  } catch (error) {
+    console.error('Failed to summarize tool output.', error);
+    return textToSummarize;
+  }
+}

projects/ui/qwen-code/packages/core/src/utils/systemEncoding.test.ts

@@ -0,0 +1,496 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execSync } from 'child_process';
+import * as os from 'os';
+import { detect as chardetDetect } from 'chardet';
+
+// Mock dependencies
+vi.mock('child_process');
+vi.mock('os');
+vi.mock('chardet');
+
+// Import the functions we want to test after refactoring
+import {
+  getCachedEncodingForBuffer,
+  getSystemEncoding,
+  windowsCodePageToEncoding,
+  detectEncodingFromBuffer,
+  resetEncodingCache,
+} from './systemEncoding.js';
+
+describe('Shell Command Processor - Encoding Functions', () => {
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+  let mockedExecSync: ReturnType<typeof vi.mocked<typeof execSync>>;
+  let mockedOsPlatform: ReturnType<typeof vi.mocked<() => string>>;
+  let mockedChardetDetect: ReturnType<typeof vi.mocked<typeof chardetDetect>>;
+
+  beforeEach(() => {
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    mockedExecSync = vi.mocked(execSync);
+    mockedOsPlatform = vi.mocked(os.platform);
+    mockedChardetDetect = vi.mocked(chardetDetect);
+
+    // Reset the encoding cache before each test
+    resetEncodingCache();
+
+    // Clear environment variables that might affect tests
+    delete process.env['LC_ALL'];
+    delete process.env['LC_CTYPE'];
+    delete process.env['LANG'];
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    resetEncodingCache();
+  });
+
+  describe('windowsCodePageToEncoding', () => {
+    it('should map common Windows code pages correctly', () => {
+      expect(windowsCodePageToEncoding(437)).toBe('cp437');
+      expect(windowsCodePageToEncoding(850)).toBe('cp850');
+      expect(windowsCodePageToEncoding(65001)).toBe('utf-8');
+      expect(windowsCodePageToEncoding(1252)).toBe('windows-1252');
+      expect(windowsCodePageToEncoding(932)).toBe('shift_jis');
+      expect(windowsCodePageToEncoding(936)).toBe('gb2312');
+      expect(windowsCodePageToEncoding(949)).toBe('euc-kr');
+      expect(windowsCodePageToEncoding(950)).toBe('big5');
+      expect(windowsCodePageToEncoding(1200)).toBe('utf-16le');
+      expect(windowsCodePageToEncoding(1201)).toBe('utf-16be');
+    });
+
+    it('should return null for unmapped code pages and warn', () => {
+      expect(windowsCodePageToEncoding(99999)).toBe(null);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Unable to determine encoding for windows code page 99999.',
+      );
+    });
+
+    it('should handle all Windows-specific code pages', () => {
+      expect(windowsCodePageToEncoding(874)).toBe('windows-874');
+      expect(windowsCodePageToEncoding(1250)).toBe('windows-1250');
+      expect(windowsCodePageToEncoding(1251)).toBe('windows-1251');
+      expect(windowsCodePageToEncoding(1253)).toBe('windows-1253');
+      expect(windowsCodePageToEncoding(1254)).toBe('windows-1254');
+      expect(windowsCodePageToEncoding(1255)).toBe('windows-1255');
+      expect(windowsCodePageToEncoding(1256)).toBe('windows-1256');
+      expect(windowsCodePageToEncoding(1257)).toBe('windows-1257');
+      expect(windowsCodePageToEncoding(1258)).toBe('windows-1258');
+    });
+  });
+
+  describe('detectEncodingFromBuffer', () => {
+    it('should detect encoding using chardet successfully', () => {
+      const buffer = Buffer.from('test content', 'utf8');
+      mockedChardetDetect.mockReturnValue('UTF-8');
+
+      const result = detectEncodingFromBuffer(buffer);
+      expect(result).toBe('utf-8');
+      expect(mockedChardetDetect).toHaveBeenCalledWith(buffer);
+    });
+
+    it('should handle chardet returning mixed case encoding', () => {
+      const buffer = Buffer.from('test content', 'utf8');
+      mockedChardetDetect.mockReturnValue('ISO-8859-1');
+
+      const result = detectEncodingFromBuffer(buffer);
+      expect(result).toBe('iso-8859-1');
+    });
+
+    it('should return null when chardet fails', () => {
+      const buffer = Buffer.from('test content', 'utf8');
+      mockedChardetDetect.mockImplementation(() => {
+        throw new Error('Detection failed');
+      });
+
+      const result = detectEncodingFromBuffer(buffer);
+      expect(result).toBe(null);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Failed to detect encoding with chardet:',
+        expect.any(Error),
+      );
+    });
+
+    it('should return null when chardet returns null', () => {
+      const buffer = Buffer.from('test content', 'utf8');
+      mockedChardetDetect.mockReturnValue(null);
+
+      const result = detectEncodingFromBuffer(buffer);
+      expect(result).toBe(null);
+    });
+
+    it('should return null when chardet returns non-string', () => {
+      const buffer = Buffer.from('test content', 'utf8');
+      mockedChardetDetect.mockReturnValue([
+        'utf-8',
+        'iso-8859-1',
+      ] as unknown as string);
+
+      const result = detectEncodingFromBuffer(buffer);
+      expect(result).toBe(null);
+    });
+  });
+
+  describe('getSystemEncoding - Windows', () => {
+    beforeEach(() => {
+      mockedOsPlatform.mockReturnValue('win32');
+    });
+
+    it('should parse Windows chcp output correctly', () => {
+      mockedExecSync.mockReturnValue('Active code page: 65001');
+
+      const result = getSystemEncoding();
+      expect(result).toBe('utf-8');
+      expect(mockedExecSync).toHaveBeenCalledWith('chcp', { encoding: 'utf8' });
+    });
+
+    it('should handle different chcp output formats', () => {
+      mockedExecSync.mockReturnValue('Current code page: 1252');
+
+      const result = getSystemEncoding();
+      expect(result).toBe('windows-1252');
+    });
+
+    it('should handle chcp output with extra whitespace', () => {
+      mockedExecSync.mockReturnValue('Active code page:   437   ');
+
+      const result = getSystemEncoding();
+      expect(result).toBe('cp437');
+    });
+
+    it('should return null when chcp command fails', () => {
+      mockedExecSync.mockImplementation(() => {
+        throw new Error('Command failed');
+      });
+
+      const result = getSystemEncoding();
+      expect(result).toBe(null);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "Failed to get Windows code page using 'chcp' command",
+        ),
+      );
+    });
+
+    it('should return null when chcp output cannot be parsed', () => {
+      mockedExecSync.mockReturnValue('Unexpected output format');
+
+      const result = getSystemEncoding();
+      expect(result).toBe(null);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "Failed to get Windows code page using 'chcp' command",
+        ),
+      );
+    });
+
+    it('should return null when code page is not a number', () => {
+      mockedExecSync.mockReturnValue('Active code page: abc');
+
+      const result = getSystemEncoding();
+      expect(result).toBe(null);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "Failed to get Windows code page using 'chcp' command",
+        ),
+      );
+    });
+
+    it('should return null when code page maps to null', () => {
+      mockedExecSync.mockReturnValue('Active code page: 99999');
+
+      const result = getSystemEncoding();
+      expect(result).toBe(null);
+      // Should warn about unknown code page from windowsCodePageToEncoding
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Unable to determine encoding for windows code page 99999.',
+      );
+    });
+  });
+
+  describe('getSystemEncoding - Unix-like', () => {
+    beforeEach(() => {
+      mockedOsPlatform.mockReturnValue('linux');
+    });
+
+    it('should parse locale from LC_ALL environment variable', () => {
+      process.env['LC_ALL'] = 'en_US.UTF-8';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('utf-8');
+    });
+
+    it('should parse locale from LC_CTYPE when LC_ALL is not set', () => {
+      process.env['LC_CTYPE'] = 'fr_FR.ISO-8859-1';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('iso-8859-1');
+    });
+
+    it('should parse locale from LANG when LC_ALL and LC_CTYPE are not set', () => {
+      process.env['LANG'] = 'de_DE.UTF-8';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('utf-8');
+    });
+
+    it('should handle locale charmap command when environment variables are empty', () => {
+      mockedExecSync.mockReturnValue('UTF-8\n');
+
+      const result = getSystemEncoding();
+      expect(result).toBe('utf-8');
+      expect(mockedExecSync).toHaveBeenCalledWith('locale charmap', {
+        encoding: 'utf8',
+      });
+    });
+
+    it('should handle locale charmap with mixed case', () => {
+      mockedExecSync.mockReturnValue('ISO-8859-1\n');
+
+      const result = getSystemEncoding();
+      expect(result).toBe('iso-8859-1');
+    });
+
+    it('should return null when locale charmap fails', () => {
+      mockedExecSync.mockImplementation(() => {
+        throw new Error('Command failed');
+      });
+
+      const result = getSystemEncoding();
+      expect(result).toBe(null);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Failed to get locale charmap.',
+      );
+    });
+
+    it('should handle locale without encoding (no dot)', () => {
+      process.env['LANG'] = 'C';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('c');
+    });
+
+    it('should handle empty locale environment variables', () => {
+      process.env['LC_ALL'] = '';
+      process.env['LC_CTYPE'] = '';
+      process.env['LANG'] = '';
+      mockedExecSync.mockReturnValue('UTF-8');
+
+      const result = getSystemEncoding();
+      expect(result).toBe('utf-8');
+    });
+
+    it('should return locale as-is when locale format has no dot', () => {
+      process.env['LANG'] = 'invalid_format';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('invalid_format');
+    });
+
+    it('should prioritize LC_ALL over other environment variables', () => {
+      process.env['LC_ALL'] = 'en_US.UTF-8';
+      process.env['LC_CTYPE'] = 'fr_FR.ISO-8859-1';
+      process.env['LANG'] = 'de_DE.CP1252';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('utf-8');
+    });
+
+    it('should prioritize LC_CTYPE over LANG', () => {
+      process.env['LC_CTYPE'] = 'fr_FR.ISO-8859-1';
+      process.env['LANG'] = 'de_DE.CP1252';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('iso-8859-1');
+    });
+  });
+
+  describe('getEncodingForBuffer', () => {
+    beforeEach(() => {
+      mockedOsPlatform.mockReturnValue('linux');
+    });
+
+    it('should use cached system encoding on subsequent calls', () => {
+      process.env['LANG'] = 'en_US.UTF-8';
+      const buffer = Buffer.from('test');
+
+      // First call
+      const result1 = getCachedEncodingForBuffer(buffer);
+      expect(result1).toBe('utf-8');
+
+      // Change environment (should not affect cached result)
+      process.env['LANG'] = 'fr_FR.ISO-8859-1';
+
+      // Second call should use cached value
+      const result2 = getCachedEncodingForBuffer(buffer);
+      expect(result2).toBe('utf-8');
+    });
+
+    it('should fall back to buffer detection when system encoding fails', () => {
+      // No environment variables set
+      mockedExecSync.mockImplementation(() => {
+        throw new Error('locale command failed');
+      });
+
+      const buffer = Buffer.from('test');
+      mockedChardetDetect.mockReturnValue('ISO-8859-1');
+
+      const result = getCachedEncodingForBuffer(buffer);
+      expect(result).toBe('iso-8859-1');
+      expect(mockedChardetDetect).toHaveBeenCalledWith(buffer);
+    });
+
+    it('should fall back to utf-8 when both system and buffer detection fail', () => {
+      // System encoding fails
+      mockedExecSync.mockImplementation(() => {
+        throw new Error('locale command failed');
+      });
+
+      // Buffer detection fails
+      mockedChardetDetect.mockImplementation(() => {
+        throw new Error('chardet failed');
+      });
+
+      const buffer = Buffer.from('test');
+      const result = getCachedEncodingForBuffer(buffer);
+      expect(result).toBe('utf-8');
+    });
+
+    it('should not cache buffer detection results', () => {
+      // System encoding fails initially
+      mockedExecSync.mockImplementation(() => {
+        throw new Error('locale command failed');
+      });
+
+      const buffer1 = Buffer.from('test1');
+      const buffer2 = Buffer.from('test2');
+
+      mockedChardetDetect
+        .mockReturnValueOnce('ISO-8859-1')
+        .mockReturnValueOnce('UTF-16');
+
+      const result1 = getCachedEncodingForBuffer(buffer1);
+      const result2 = getCachedEncodingForBuffer(buffer2);
+
+      expect(result1).toBe('iso-8859-1');
+      expect(result2).toBe('utf-16');
+      expect(mockedChardetDetect).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle Windows system encoding', () => {
+      mockedOsPlatform.mockReturnValue('win32');
+      mockedExecSync.mockReturnValue('Active code page: 1252');
+
+      const buffer = Buffer.from('test');
+      const result = getCachedEncodingForBuffer(buffer);
+
+      expect(result).toBe('windows-1252');
+    });
+
+    it('should cache null system encoding result', () => {
+      // Reset the cache specifically for this test
+      resetEncodingCache();
+
+      // Ensure we're on Unix-like for this test
+      mockedOsPlatform.mockReturnValue('linux');
+
+      // System encoding detection returns null
+      mockedExecSync.mockImplementation(() => {
+        throw new Error('locale command failed');
+      });
+
+      const buffer1 = Buffer.from('test1');
+      const buffer2 = Buffer.from('test2');
+
+      mockedChardetDetect
+        .mockReturnValueOnce('ISO-8859-1')
+        .mockReturnValueOnce('UTF-16');
+
+      // Clear any previous calls from beforeEach setup or previous tests
+      mockedExecSync.mockClear();
+
+      const result1 = getCachedEncodingForBuffer(buffer1);
+      const result2 = getCachedEncodingForBuffer(buffer2);
+
+      // Should call execSync only once due to caching (null result is cached)
+      expect(mockedExecSync).toHaveBeenCalledTimes(1);
+      expect(result1).toBe('iso-8859-1');
+      expect(result2).toBe('utf-16');
+
+      // Call a third time to verify cache is still used
+      const buffer3 = Buffer.from('test3');
+      mockedChardetDetect.mockReturnValueOnce('UTF-32');
+      const result3 = getCachedEncodingForBuffer(buffer3);
+
+      // Still should be only one call to execSync
+      expect(mockedExecSync).toHaveBeenCalledTimes(1);
+      expect(result3).toBe('utf-32');
+    });
+  });
+
+  describe('Cross-platform behavior', () => {
+    it('should work correctly on macOS', () => {
+      mockedOsPlatform.mockReturnValue('darwin');
+      process.env['LANG'] = 'en_US.UTF-8';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('utf-8');
+    });
+
+    it('should work correctly on other Unix-like systems', () => {
+      mockedOsPlatform.mockReturnValue('freebsd');
+      process.env['LANG'] = 'en_US.UTF-8';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('utf-8');
+    });
+
+    it('should handle unknown platforms as Unix-like', () => {
+      mockedOsPlatform.mockReturnValue('unknown' as NodeJS.Platform);
+      process.env['LANG'] = 'en_US.UTF-8';
+
+      const result = getSystemEncoding();
+      expect(result).toBe('utf-8');
+    });
+  });
+
+  describe('Edge cases and error handling', () => {
+    it('should handle empty buffer gracefully', () => {
+      mockedOsPlatform.mockReturnValue('linux');
+      process.env['LANG'] = 'en_US.UTF-8';
+
+      const buffer = Buffer.alloc(0);
+      const result = getCachedEncodingForBuffer(buffer);
+      expect(result).toBe('utf-8');
+    });
+
+    it('should handle very large buffers', () => {
+      mockedOsPlatform.mockReturnValue('linux');
+      process.env['LANG'] = 'en_US.UTF-8';
+
+      const buffer = Buffer.alloc(1024 * 1024, 'a');
+      const result = getCachedEncodingForBuffer(buffer);
+      expect(result).toBe('utf-8');
+    });
+
+    it('should handle Unicode content', () => {
+      mockedOsPlatform.mockReturnValue('linux');
+      const unicodeText = '你好世界 🌍 ñoño';
+
+      // System encoding fails
+      mockedExecSync.mockImplementation(() => {
+        throw new Error('locale command failed');
+      });
+
+      mockedChardetDetect.mockReturnValue('UTF-8');
+
+      const buffer = Buffer.from(unicodeText, 'utf8');
+      const result = getCachedEncodingForBuffer(buffer);
+      expect(result).toBe('utf-8');
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/utils/systemEncoding.ts

@@ -0,0 +1,166 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { execSync } from 'child_process';
+import os from 'os';
+import { detect as chardetDetect } from 'chardet';
+
+// Cache for system encoding to avoid repeated detection
+// Use undefined to indicate "not yet checked" vs null meaning "checked but failed"
+let cachedSystemEncoding: string | null | undefined = undefined;
+
+/**
+ * Reset the encoding cache - useful for testing
+ */
+export function resetEncodingCache(): void {
+  cachedSystemEncoding = undefined;
+}
+
+/**
+ * Returns the system encoding, caching the result to avoid repeated system calls.
+ * If system encoding detection fails, falls back to detecting from the provided buffer.
+ * Note: Only the system encoding is cached - buffer-based detection runs for each buffer
+ * since different buffers may have different encodings.
+ * @param buffer A buffer to use for detecting encoding if system detection fails.
+ */
+export function getCachedEncodingForBuffer(buffer: Buffer): string {
+  // Cache system encoding detection since it's system-wide
+  if (cachedSystemEncoding === undefined) {
+    cachedSystemEncoding = getSystemEncoding();
+  }
+
+  // If we have a cached system encoding, use it
+  if (cachedSystemEncoding) {
+    return cachedSystemEncoding;
+  }
+
+  // Otherwise, detect from this specific buffer (don't cache this result)
+  return detectEncodingFromBuffer(buffer) || 'utf-8';
+}
+
+/**
+ * Detects the system encoding based on the platform.
+ * For Windows, it uses the 'chcp' command to get the current code page.
+ * For Unix-like systems, it checks environment variables like LC_ALL, LC_CTYPE, and LANG.
+ * If those are not set, it tries to run 'locale charmap' to get the encoding.
+ * If detection fails, it returns null.
+ * @returns The system encoding as a string, or null if detection fails.
+ */
+export function getSystemEncoding(): string | null {
+  // Windows
+  if (os.platform() === 'win32') {
+    try {
+      const output = execSync('chcp', { encoding: 'utf8' });
+      const match = output.match(/:\s*(\d+)/);
+      if (match) {
+        const codePage = parseInt(match[1], 10);
+        if (!isNaN(codePage)) {
+          return windowsCodePageToEncoding(codePage);
+        }
+      }
+      // Only warn if we can't parse the output format, not if windowsCodePageToEncoding fails
+      throw new Error(
+        `Unable to parse Windows code page from 'chcp' output "${output.trim()}". `,
+      );
+    } catch (error) {
+      console.warn(
+        `Failed to get Windows code page using 'chcp' command: ${error instanceof Error ? error.message : String(error)}. ` +
+          `Will attempt to detect encoding from command output instead.`,
+      );
+    }
+    return null;
+  }
+
+  // Unix-like
+  // Use environment variables LC_ALL, LC_CTYPE, and LANG to determine the
+  // system encoding. However, these environment variables might not always
+  // be set or accurate. Handle cases where none of these variables are set.
+  const env = process.env;
+  let locale = env['LC_ALL'] || env['LC_CTYPE'] || env['LANG'] || '';
+
+  // Fallback to querying the system directly when environment variables are missing
+  if (!locale) {
+    try {
+      locale = execSync('locale charmap', { encoding: 'utf8' })
+        .toString()
+        .trim();
+    } catch (_e) {
+      console.warn('Failed to get locale charmap.');
+      return null;
+    }
+  }
+
+  const match = locale.match(/\.(.+)/); // e.g., "en_US.UTF-8"
+  if (match && match[1]) {
+    return match[1].toLowerCase();
+  }
+
+  // Handle cases where locale charmap returns just the encoding name (e.g., "UTF-8")
+  if (locale && !locale.includes('.')) {
+    return locale.toLowerCase();
+  }
+
+  return null;
+}
+
+/**
+ * Converts a Windows code page number to a corresponding encoding name.
+ * @param cp The Windows code page number (e.g., 437, 850, etc.)
+ * @returns The corresponding encoding name as a string, or null if no mapping exists.
+ */
+export function windowsCodePageToEncoding(cp: number): string | null {
+  // Most common mappings; extend as needed
+  const map: { [key: number]: string } = {
+    437: 'cp437',
+    850: 'cp850',
+    852: 'cp852',
+    866: 'cp866',
+    874: 'windows-874',
+    932: 'shift_jis',
+    936: 'gb2312',
+    949: 'euc-kr',
+    950: 'big5',
+    1200: 'utf-16le',
+    1201: 'utf-16be',
+    1250: 'windows-1250',
+    1251: 'windows-1251',
+    1252: 'windows-1252',
+    1253: 'windows-1253',
+    1254: 'windows-1254',
+    1255: 'windows-1255',
+    1256: 'windows-1256',
+    1257: 'windows-1257',
+    1258: 'windows-1258',
+    65001: 'utf-8',
+  };
+
+  if (map[cp]) {
+    return map[cp];
+  }
+
+  console.warn(`Unable to determine encoding for windows code page ${cp}.`);
+  return null; // Return null if no mapping found
+}
+
+/**
+ * Attempts to detect encoding from a buffer using chardet.
+ * This is useful when system encoding detection fails.
+ * Returns the detected encoding in lowercase, or null if detection fails.
+ * @param buffer The buffer to analyze for encoding.
+ * @return The detected encoding as a lowercase string, or null if detection fails.
+ */
+export function detectEncodingFromBuffer(buffer: Buffer): string | null {
+  try {
+    const detected = chardetDetect(buffer);
+    if (detected && typeof detected === 'string') {
+      return detected.toLowerCase();
+    }
+  } catch (error) {
+    console.warn('Failed to detect encoding with chardet:', error);
+  }
+
+  return null;
+}

projects/ui/qwen-code/packages/core/src/utils/testUtils.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Testing utilities for simulating 429 errors in unit tests
+ */
+
+let requestCounter = 0;
+let simulate429Enabled = false;
+let simulate429AfterRequests = 0;
+let simulate429ForAuthType: string | undefined;
+let fallbackOccurred = false;
+
+/**
+ * Check if we should simulate a 429 error for the current request
+ */
+export function shouldSimulate429(authType?: string): boolean {
+  if (!simulate429Enabled || fallbackOccurred) {
+    return false;
+  }
+
+  // If auth type filter is set, only simulate for that auth type
+  if (simulate429ForAuthType && authType !== simulate429ForAuthType) {
+    return false;
+  }
+
+  requestCounter++;
+
+  // If afterRequests is set, only simulate after that many requests
+  if (simulate429AfterRequests > 0) {
+    return requestCounter > simulate429AfterRequests;
+  }
+
+  // Otherwise, simulate for every request
+  return true;
+}
+
+/**
+ * Reset the request counter (useful for tests)
+ */
+export function resetRequestCounter(): void {
+  requestCounter = 0;
+}
+
+/**
+ * Disable 429 simulation after successful fallback
+ */
+export function disableSimulationAfterFallback(): void {
+  fallbackOccurred = true;
+}
+
+/**
+ * Create a simulated 429 error response
+ */
+export function createSimulated429Error(): Error {
+  const error = new Error('Rate limit exceeded (simulated)') as Error & {
+    status: number;
+  };
+  error.status = 429;
+  return error;
+}
+
+/**
+ * Reset simulation state when switching auth methods
+ */
+export function resetSimulationState(): void {
+  fallbackOccurred = false;
+  resetRequestCounter();
+}
+
+/**
+ * Enable/disable 429 simulation programmatically (for tests)
+ */
+export function setSimulate429(
+  enabled: boolean,
+  afterRequests = 0,
+  forAuthType?: string,
+): void {
+  simulate429Enabled = enabled;
+  simulate429AfterRequests = afterRequests;
+  simulate429ForAuthType = forAuthType;
+  fallbackOccurred = false; // Reset fallback state when simulation is re-enabled
+  resetRequestCounter();
+}

projects/ui/qwen-code/packages/core/src/utils/textUtils.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Checks if a Buffer is likely binary by testing for the presence of a NULL byte.
+ * The presence of a NULL byte is a strong indicator that the data is not plain text.
+ * @param data The Buffer to check.
+ * @param sampleSize The number of bytes from the start of the buffer to test.
+ * @returns True if a NULL byte is found, false otherwise.
+ */
+export function isBinary(
+  data: Buffer | null | undefined,
+  sampleSize = 512,
+): boolean {
+  if (!data) {
+    return false;
+  }
+
+  const sample = data.length > sampleSize ? data.subarray(0, sampleSize) : data;
+
+  for (const byte of sample) {
+    // The presence of a NULL byte (0x00) is one of the most reliable
+    // indicators of a binary file. Text files should not contain them.
+    if (byte === 0) {
+      return true;
+    }
+  }
+
+  // If no NULL bytes were found in the sample, we assume it's text.
+  return false;
+}

projects/ui/qwen-code/packages/core/src/utils/user_account.test.ts

@@ -0,0 +1,339 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach, Mock } from 'vitest';
+import {
+  cacheGoogleAccount,
+  getCachedGoogleAccount,
+  clearCachedGoogleAccount,
+  getLifetimeGoogleAccounts,
+} from './user_account.js';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import path from 'node:path';
+
+vi.mock('os', async (importOriginal) => {
+  const os = await importOriginal<typeof import('os')>();
+  return {
+    ...os,
+    homedir: vi.fn(),
+  };
+});
+
+describe('user_account', () => {
+  let tempHomeDir: string;
+  const accountsFile = () =>
+    path.join(tempHomeDir, '.qwen', 'google_accounts.json');
+  beforeEach(() => {
+    tempHomeDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'qwen-code-test-home-'),
+    );
+    (os.homedir as Mock).mockReturnValue(tempHomeDir);
+  });
+  afterEach(() => {
+    fs.rmSync(tempHomeDir, { recursive: true, force: true });
+    vi.clearAllMocks();
+  });
+
+  describe('cacheGoogleAccount', () => {
+    it('should create directory and write initial account file', async () => {
+      await cacheGoogleAccount('test1@google.com');
+
+      // Verify Google Account ID was cached
+      expect(fs.existsSync(accountsFile())).toBe(true);
+      expect(fs.readFileSync(accountsFile(), 'utf-8')).toBe(
+        JSON.stringify({ active: 'test1@google.com', old: [] }, null, 2),
+      );
+    });
+
+    it('should update active account and move previous to old', async () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify(
+          { active: 'test2@google.com', old: ['test1@google.com'] },
+          null,
+          2,
+        ),
+      );
+
+      await cacheGoogleAccount('test3@google.com');
+
+      expect(fs.readFileSync(accountsFile(), 'utf-8')).toBe(
+        JSON.stringify(
+          {
+            active: 'test3@google.com',
+            old: ['test1@google.com', 'test2@google.com'],
+          },
+          null,
+          2,
+        ),
+      );
+    });
+
+    it('should not add a duplicate to the old list', async () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify(
+          { active: 'test1@google.com', old: ['test2@google.com'] },
+          null,
+          2,
+        ),
+      );
+      await cacheGoogleAccount('test2@google.com');
+      await cacheGoogleAccount('test1@google.com');
+
+      expect(fs.readFileSync(accountsFile(), 'utf-8')).toBe(
+        JSON.stringify(
+          { active: 'test1@google.com', old: ['test2@google.com'] },
+          null,
+          2,
+        ),
+      );
+    });
+
+    it('should handle corrupted JSON by starting fresh', async () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(accountsFile(), 'not valid json');
+      const consoleLogSpy = vi
+        .spyOn(console, 'log')
+        .mockImplementation(() => {});
+
+      await cacheGoogleAccount('test1@google.com');
+
+      expect(consoleLogSpy).toHaveBeenCalled();
+      expect(JSON.parse(fs.readFileSync(accountsFile(), 'utf-8'))).toEqual({
+        active: 'test1@google.com',
+        old: [],
+      });
+    });
+
+    it('should handle valid JSON with incorrect schema by starting fresh', async () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify({ active: 'test1@google.com', old: 'not-an-array' }),
+      );
+      const consoleLogSpy = vi
+        .spyOn(console, 'log')
+        .mockImplementation(() => {});
+
+      await cacheGoogleAccount('test2@google.com');
+
+      expect(consoleLogSpy).toHaveBeenCalled();
+      expect(JSON.parse(fs.readFileSync(accountsFile(), 'utf-8'))).toEqual({
+        active: 'test2@google.com',
+        old: [],
+      });
+    });
+  });
+
+  describe('getCachedGoogleAccount', () => {
+    it('should return the active account if file exists and is valid', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify({ active: 'active@google.com', old: [] }, null, 2),
+      );
+      const account = getCachedGoogleAccount();
+      expect(account).toBe('active@google.com');
+    });
+
+    it('should return null if file does not exist', () => {
+      const account = getCachedGoogleAccount();
+      expect(account).toBeNull();
+    });
+
+    it('should return null if file is empty', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(accountsFile(), '');
+      const account = getCachedGoogleAccount();
+      expect(account).toBeNull();
+    });
+
+    it('should return null and log if file is corrupted', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(accountsFile(), '{ "active": "test@google.com"'); // Invalid JSON
+      const consoleLogSpy = vi
+        .spyOn(console, 'log')
+        .mockImplementation(() => {});
+
+      const account = getCachedGoogleAccount();
+
+      expect(account).toBeNull();
+      expect(consoleLogSpy).toHaveBeenCalled();
+    });
+
+    it('should return null if active key is missing', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(accountsFile(), JSON.stringify({ old: [] }));
+      const account = getCachedGoogleAccount();
+      expect(account).toBeNull();
+    });
+  });
+
+  describe('clearCachedGoogleAccount', () => {
+    it('should set active to null and move it to old', async () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify(
+          { active: 'active@google.com', old: ['old1@google.com'] },
+          null,
+          2,
+        ),
+      );
+
+      await clearCachedGoogleAccount();
+
+      const stored = JSON.parse(fs.readFileSync(accountsFile(), 'utf-8'));
+      expect(stored.active).toBeNull();
+      expect(stored.old).toEqual(['old1@google.com', 'active@google.com']);
+    });
+
+    it('should handle empty file gracefully', async () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(accountsFile(), '');
+      await clearCachedGoogleAccount();
+      const stored = JSON.parse(fs.readFileSync(accountsFile(), 'utf-8'));
+      expect(stored.active).toBeNull();
+      expect(stored.old).toEqual([]);
+    });
+
+    it('should handle corrupted JSON by creating a fresh file', async () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(accountsFile(), 'not valid json');
+      const consoleLogSpy = vi
+        .spyOn(console, 'log')
+        .mockImplementation(() => {});
+
+      await clearCachedGoogleAccount();
+
+      expect(consoleLogSpy).toHaveBeenCalled();
+      const stored = JSON.parse(fs.readFileSync(accountsFile(), 'utf-8'));
+      expect(stored.active).toBeNull();
+      expect(stored.old).toEqual([]);
+    });
+
+    it('should be idempotent if active account is already null', async () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify({ active: null, old: ['old1@google.com'] }, null, 2),
+      );
+
+      await clearCachedGoogleAccount();
+
+      const stored = JSON.parse(fs.readFileSync(accountsFile(), 'utf-8'));
+      expect(stored.active).toBeNull();
+      expect(stored.old).toEqual(['old1@google.com']);
+    });
+
+    it('should not add a duplicate to the old list', async () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify(
+          {
+            active: 'active@google.com',
+            old: ['active@google.com'],
+          },
+          null,
+          2,
+        ),
+      );
+
+      await clearCachedGoogleAccount();
+
+      const stored = JSON.parse(fs.readFileSync(accountsFile(), 'utf-8'));
+      expect(stored.active).toBeNull();
+      expect(stored.old).toEqual(['active@google.com']);
+    });
+  });
+
+  describe('getLifetimeGoogleAccounts', () => {
+    it('should return 0 if the file does not exist', () => {
+      expect(getLifetimeGoogleAccounts()).toBe(0);
+    });
+
+    it('should return 0 if the file is empty', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(accountsFile(), '');
+      expect(getLifetimeGoogleAccounts()).toBe(0);
+    });
+
+    it('should return 0 if the file is corrupted', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(accountsFile(), 'invalid json');
+      const consoleLogSpy = vi
+        .spyOn(console, 'log')
+        .mockImplementation(() => {});
+
+      expect(getLifetimeGoogleAccounts()).toBe(0);
+      expect(consoleLogSpy).toHaveBeenCalled();
+    });
+
+    it('should return 1 if there is only an active account', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify({ active: 'test1@google.com', old: [] }),
+      );
+      expect(getLifetimeGoogleAccounts()).toBe(1);
+    });
+
+    it('should correctly count old accounts when active is null', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify({
+          active: null,
+          old: ['test1@google.com', 'test2@google.com'],
+        }),
+      );
+      expect(getLifetimeGoogleAccounts()).toBe(2);
+    });
+
+    it('should correctly count both active and old accounts', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify({
+          active: 'test3@google.com',
+          old: ['test1@google.com', 'test2@google.com'],
+        }),
+      );
+      expect(getLifetimeGoogleAccounts()).toBe(3);
+    });
+
+    it('should handle valid JSON with incorrect schema by returning 0', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify({ active: null, old: 1 }),
+      );
+      const consoleLogSpy = vi
+        .spyOn(console, 'log')
+        .mockImplementation(() => {});
+
+      expect(getLifetimeGoogleAccounts()).toBe(0);
+      expect(consoleLogSpy).toHaveBeenCalled();
+    });
+
+    it('should not double count if active account is also in old list', () => {
+      fs.mkdirSync(path.dirname(accountsFile()), { recursive: true });
+      fs.writeFileSync(
+        accountsFile(),
+        JSON.stringify({
+          active: 'test1@google.com',
+          old: ['test1@google.com', 'test2@google.com'],
+        }),
+      );
+      expect(getLifetimeGoogleAccounts()).toBe(2);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/utils/user_account.ts

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import { promises as fsp, readFileSync } from 'node:fs';
+import * as os from 'os';
+import { QWEN_DIR, GOOGLE_ACCOUNTS_FILENAME } from './paths.js';
+
+interface UserAccounts {
+  active: string | null;
+  old: string[];
+}
+
+function getGoogleAccountsCachePath(): string {
+  return path.join(os.homedir(), QWEN_DIR, GOOGLE_ACCOUNTS_FILENAME);
+}
+
+/**
+ * Parses and validates the string content of an accounts file.
+ * @param content The raw string content from the file.
+ * @returns A valid UserAccounts object.
+ */
+function parseAndValidateAccounts(content: string): UserAccounts {
+  const defaultState = { active: null, old: [] };
+  if (!content.trim()) {
+    return defaultState;
+  }
+
+  const parsed = JSON.parse(content);
+
+  // Inlined validation logic
+  if (typeof parsed !== 'object' || parsed === null) {
+    console.log('Invalid accounts file schema, starting fresh.');
+    return defaultState;
+  }
+  const { active, old } = parsed as Partial<UserAccounts>;
+  const isValid =
+    (active === undefined || active === null || typeof active === 'string') &&
+    (old === undefined ||
+      (Array.isArray(old) && old.every((i) => typeof i === 'string')));
+
+  if (!isValid) {
+    console.log('Invalid accounts file schema, starting fresh.');
+    return defaultState;
+  }
+
+  return {
+    active: parsed.active ?? null,
+    old: parsed.old ?? [],
+  };
+}
+
+function readAccountsSync(filePath: string): UserAccounts {
+  const defaultState = { active: null, old: [] };
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    return parseAndValidateAccounts(content);
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      return defaultState;
+    }
+    console.log('Error during sync read of accounts, starting fresh.', error);
+    return defaultState;
+  }
+}
+
+async function readAccounts(filePath: string): Promise<UserAccounts> {
+  const defaultState = { active: null, old: [] };
+  try {
+    const content = await fsp.readFile(filePath, 'utf-8');
+    return parseAndValidateAccounts(content);
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      return defaultState;
+    }
+    console.log('Could not parse accounts file, starting fresh.', error);
+    return defaultState;
+  }
+}
+
+export async function cacheGoogleAccount(email: string): Promise<void> {
+  const filePath = getGoogleAccountsCachePath();
+  await fsp.mkdir(path.dirname(filePath), { recursive: true });
+
+  const accounts = await readAccounts(filePath);
+
+  if (accounts.active && accounts.active !== email) {
+    if (!accounts.old.includes(accounts.active)) {
+      accounts.old.push(accounts.active);
+    }
+  }
+
+  // If the new email was in the old list, remove it
+  accounts.old = accounts.old.filter((oldEmail) => oldEmail !== email);
+
+  accounts.active = email;
+  await fsp.writeFile(filePath, JSON.stringify(accounts, null, 2), 'utf-8');
+}
+
+export function getCachedGoogleAccount(): string | null {
+  const filePath = getGoogleAccountsCachePath();
+  const accounts = readAccountsSync(filePath);
+  return accounts.active;
+}
+
+export function getLifetimeGoogleAccounts(): number {
+  const filePath = getGoogleAccountsCachePath();
+  const accounts = readAccountsSync(filePath);
+  const allAccounts = new Set(accounts.old);
+  if (accounts.active) {
+    allAccounts.add(accounts.active);
+  }
+  return allAccounts.size;
+}
+
+export async function clearCachedGoogleAccount(): Promise<void> {
+  const filePath = getGoogleAccountsCachePath();
+  const accounts = await readAccounts(filePath);
+
+  if (accounts.active) {
+    if (!accounts.old.includes(accounts.active)) {
+      accounts.old.push(accounts.active);
+    }
+    accounts.active = null;
+  }
+
+  await fsp.writeFile(filePath, JSON.stringify(accounts, null, 2), 'utf-8');
+}

projects/ui/qwen-code/packages/core/src/utils/user_id.test.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { getInstallationId } from './user_id.js';
+
+describe('user_id', () => {
+  describe('getInstallationId', () => {
+    it('should return a valid UUID format string', () => {
+      const installationId = getInstallationId();
+
+      expect(installationId).toBeDefined();
+      expect(typeof installationId).toBe('string');
+      expect(installationId.length).toBeGreaterThan(0);
+
+      // Should return the same ID on subsequent calls (consistent)
+      const secondCall = getInstallationId();
+      expect(secondCall).toBe(installationId);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/utils/user_id.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as os from 'os';
+import * as fs from 'fs';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+import { QWEN_DIR } from './paths.js';
+
+const homeDir = os.homedir() ?? '';
+const geminiDir = path.join(homeDir, QWEN_DIR);
+const installationIdFile = path.join(geminiDir, 'installation_id');
+
+function ensureGeminiDirExists() {
+  if (!fs.existsSync(geminiDir)) {
+    fs.mkdirSync(geminiDir, { recursive: true });
+  }
+}
+
+function readInstallationIdFromFile(): string | null {
+  if (fs.existsSync(installationIdFile)) {
+    const installationid = fs.readFileSync(installationIdFile, 'utf-8').trim();
+    return installationid || null;
+  }
+  return null;
+}
+
+function writeInstallationIdToFile(installationId: string) {
+  fs.writeFileSync(installationIdFile, installationId, 'utf-8');
+}
+
+/**
+ * Retrieves the installation ID from a file, creating it if it doesn't exist.
+ * This ID is used for unique user installation tracking.
+ * @returns A UUID string for the user.
+ */
+export function getInstallationId(): string {
+  try {
+    ensureGeminiDirExists();
+    let installationId = readInstallationIdFromFile();
+
+    if (!installationId) {
+      installationId = randomUUID();
+      writeInstallationIdToFile(installationId);
+    }
+
+    return installationId;
+  } catch (error) {
+    console.error(
+      'Error accessing installation ID file, generating ephemeral ID:',
+      error,
+    );
+    return '123456789';
+  }
+}

projects/ui/qwen-code/packages/core/src/utils/workspaceContext.test.ts

@@ -0,0 +1,389 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { WorkspaceContext } from './workspaceContext.js';
+
+describe('WorkspaceContext with real filesystem', () => {
+  let tempDir: string;
+  let cwd: string;
+  let otherDir: string;
+
+  beforeEach(() => {
+    // os.tmpdir() can return a path using a symlink (this is standard on macOS)
+    // Use fs.realpathSync to fully resolve the absolute path.
+    tempDir = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), 'workspace-context-test-')),
+    );
+
+    cwd = path.join(tempDir, 'project');
+    otherDir = path.join(tempDir, 'other-project');
+
+    fs.mkdirSync(cwd, { recursive: true });
+    fs.mkdirSync(otherDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('initialization', () => {
+    it('should initialize with a single directory (cwd)', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      const directories = workspaceContext.getDirectories();
+
+      expect(directories).toEqual([cwd]);
+    });
+
+    it('should validate and resolve directories to absolute paths', () => {
+      const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+      const directories = workspaceContext.getDirectories();
+
+      expect(directories).toEqual([cwd, otherDir]);
+    });
+
+    it('should reject non-existent directories', () => {
+      const nonExistentDir = path.join(tempDir, 'does-not-exist');
+      expect(() => {
+        new WorkspaceContext(cwd, [nonExistentDir]);
+      }).toThrow('Directory does not exist');
+    });
+
+    it('should handle empty initialization', () => {
+      const workspaceContext = new WorkspaceContext(cwd, []);
+      const directories = workspaceContext.getDirectories();
+      expect(directories).toHaveLength(1);
+      expect(fs.realpathSync(directories[0])).toBe(cwd);
+    });
+  });
+
+  describe('adding directories', () => {
+    it('should add valid directories', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      workspaceContext.addDirectory(otherDir);
+      const directories = workspaceContext.getDirectories();
+
+      expect(directories).toEqual([cwd, otherDir]);
+    });
+
+    it('should resolve relative paths to absolute', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      const relativePath = path.relative(cwd, otherDir);
+      workspaceContext.addDirectory(relativePath, cwd);
+      const directories = workspaceContext.getDirectories();
+
+      expect(directories).toEqual([cwd, otherDir]);
+    });
+
+    it('should reject non-existent directories', () => {
+      const nonExistentDir = path.join(tempDir, 'does-not-exist');
+      const workspaceContext = new WorkspaceContext(cwd);
+
+      expect(() => {
+        workspaceContext.addDirectory(nonExistentDir);
+      }).toThrow('Directory does not exist');
+    });
+
+    it('should prevent duplicate directories', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      workspaceContext.addDirectory(otherDir);
+      workspaceContext.addDirectory(otherDir);
+      const directories = workspaceContext.getDirectories();
+
+      expect(directories).toHaveLength(2);
+    });
+
+    it('should handle symbolic links correctly', () => {
+      const realDir = path.join(tempDir, 'real');
+      fs.mkdirSync(realDir, { recursive: true });
+      const symlinkDir = path.join(tempDir, 'symlink-to-real');
+      fs.symlinkSync(realDir, symlinkDir, 'dir');
+      const workspaceContext = new WorkspaceContext(cwd);
+      workspaceContext.addDirectory(symlinkDir);
+
+      const directories = workspaceContext.getDirectories();
+
+      expect(directories).toEqual([cwd, realDir]);
+    });
+  });
+
+  describe('path validation', () => {
+    it('should accept paths within workspace directories', () => {
+      const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+      const validPath1 = path.join(cwd, 'src', 'file.ts');
+      const validPath2 = path.join(otherDir, 'lib', 'module.js');
+
+      fs.mkdirSync(path.dirname(validPath1), { recursive: true });
+      fs.writeFileSync(validPath1, 'content');
+      fs.mkdirSync(path.dirname(validPath2), { recursive: true });
+      fs.writeFileSync(validPath2, 'content');
+
+      expect(workspaceContext.isPathWithinWorkspace(validPath1)).toBe(true);
+      expect(workspaceContext.isPathWithinWorkspace(validPath2)).toBe(true);
+    });
+
+    it('should accept non-existent paths within workspace directories', () => {
+      const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+      const validPath1 = path.join(cwd, 'src', 'file.ts');
+      const validPath2 = path.join(otherDir, 'lib', 'module.js');
+
+      expect(workspaceContext.isPathWithinWorkspace(validPath1)).toBe(true);
+      expect(workspaceContext.isPathWithinWorkspace(validPath2)).toBe(true);
+    });
+
+    it('should reject paths outside workspace', () => {
+      const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+      const invalidPath = path.join(tempDir, 'outside-workspace', 'file.txt');
+
+      expect(workspaceContext.isPathWithinWorkspace(invalidPath)).toBe(false);
+    });
+
+    it('should reject non-existent paths outside workspace', () => {
+      const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+      const invalidPath = path.join(tempDir, 'outside-workspace', 'file.txt');
+
+      expect(workspaceContext.isPathWithinWorkspace(invalidPath)).toBe(false);
+    });
+
+    it('should handle nested directories correctly', () => {
+      const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+      const nestedPath = path.join(cwd, 'deeply', 'nested', 'path', 'file.txt');
+      expect(workspaceContext.isPathWithinWorkspace(nestedPath)).toBe(true);
+    });
+
+    it('should handle edge cases (root, parent references)', () => {
+      const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+      const rootPath = path.parse(tempDir).root;
+      const parentPath = path.dirname(cwd);
+
+      expect(workspaceContext.isPathWithinWorkspace(rootPath)).toBe(false);
+      expect(workspaceContext.isPathWithinWorkspace(parentPath)).toBe(false);
+    });
+
+    it('should handle non-existent paths correctly', () => {
+      const workspaceContext = new WorkspaceContext(cwd, [otherDir]);
+      const nonExistentPath = path.join(cwd, 'does-not-exist.txt');
+      expect(workspaceContext.isPathWithinWorkspace(nonExistentPath)).toBe(
+        true,
+      );
+    });
+
+    describe('with symbolic link', () => {
+      describe('in the workspace', () => {
+        let realDir: string;
+        let symlinkDir: string;
+        beforeEach(() => {
+          realDir = path.join(cwd, 'real-dir');
+          fs.mkdirSync(realDir, { recursive: true });
+
+          symlinkDir = path.join(cwd, 'symlink-file');
+          fs.symlinkSync(realDir, symlinkDir, 'dir');
+        });
+
+        it('should accept dir paths', () => {
+          const workspaceContext = new WorkspaceContext(cwd);
+
+          expect(workspaceContext.isPathWithinWorkspace(symlinkDir)).toBe(true);
+        });
+
+        it('should accept non-existent paths', () => {
+          const filePath = path.join(symlinkDir, 'does-not-exist.txt');
+
+          const workspaceContext = new WorkspaceContext(cwd);
+
+          expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(true);
+        });
+
+        it('should accept non-existent deep paths', () => {
+          const filePath = path.join(symlinkDir, 'deep', 'does-not-exist.txt');
+
+          const workspaceContext = new WorkspaceContext(cwd);
+
+          expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(true);
+        });
+      });
+
+      describe('outside the workspace', () => {
+        let realDir: string;
+        let symlinkDir: string;
+        beforeEach(() => {
+          realDir = path.join(tempDir, 'real-dir');
+          fs.mkdirSync(realDir, { recursive: true });
+
+          symlinkDir = path.join(cwd, 'symlink-file');
+          fs.symlinkSync(realDir, symlinkDir, 'dir');
+        });
+
+        it('should reject dir paths', () => {
+          const workspaceContext = new WorkspaceContext(cwd);
+
+          expect(workspaceContext.isPathWithinWorkspace(symlinkDir)).toBe(
+            false,
+          );
+        });
+
+        it('should reject non-existent paths', () => {
+          const filePath = path.join(symlinkDir, 'does-not-exist.txt');
+
+          const workspaceContext = new WorkspaceContext(cwd);
+
+          expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(false);
+        });
+
+        it('should reject non-existent deep paths', () => {
+          const filePath = path.join(symlinkDir, 'deep', 'does-not-exist.txt');
+
+          const workspaceContext = new WorkspaceContext(cwd);
+
+          expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(false);
+        });
+
+        it('should reject partially non-existent deep paths', () => {
+          const deepDir = path.join(symlinkDir, 'deep');
+          fs.mkdirSync(deepDir, { recursive: true });
+          const filePath = path.join(deepDir, 'does-not-exist.txt');
+
+          const workspaceContext = new WorkspaceContext(cwd);
+
+          expect(workspaceContext.isPathWithinWorkspace(filePath)).toBe(false);
+        });
+      });
+
+      it('should reject symbolic file links outside the workspace', () => {
+        const realFile = path.join(tempDir, 'real-file.txt');
+        fs.writeFileSync(realFile, 'content');
+
+        const symlinkFile = path.join(cwd, 'symlink-to-real-file');
+        fs.symlinkSync(realFile, symlinkFile, 'file');
+
+        const workspaceContext = new WorkspaceContext(cwd);
+
+        expect(workspaceContext.isPathWithinWorkspace(symlinkFile)).toBe(false);
+      });
+
+      it('should reject non-existent symbolic file links outside the workspace', () => {
+        const realFile = path.join(tempDir, 'real-file.txt');
+
+        const symlinkFile = path.join(cwd, 'symlink-to-real-file');
+        fs.symlinkSync(realFile, symlinkFile, 'file');
+
+        const workspaceContext = new WorkspaceContext(cwd);
+
+        expect(workspaceContext.isPathWithinWorkspace(symlinkFile)).toBe(false);
+      });
+
+      it('should handle circular symlinks gracefully', () => {
+        const workspaceContext = new WorkspaceContext(cwd);
+        const linkA = path.join(cwd, 'link-a');
+        const linkB = path.join(cwd, 'link-b');
+        // Create a circular dependency: linkA -> linkB -> linkA
+        fs.symlinkSync(linkB, linkA, 'dir');
+        fs.symlinkSync(linkA, linkB, 'dir');
+
+        // fs.realpathSync should throw ELOOP, and isPathWithinWorkspace should
+        // handle it gracefully and return false.
+        expect(workspaceContext.isPathWithinWorkspace(linkA)).toBe(false);
+        expect(workspaceContext.isPathWithinWorkspace(linkB)).toBe(false);
+      });
+    });
+  });
+
+  describe('onDirectoriesChanged', () => {
+    it('should call listener when adding a directory', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      const listener = vi.fn();
+      workspaceContext.onDirectoriesChanged(listener);
+
+      workspaceContext.addDirectory(otherDir);
+
+      expect(listener).toHaveBeenCalledOnce();
+    });
+
+    it('should not call listener when adding a duplicate directory', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      workspaceContext.addDirectory(otherDir);
+      const listener = vi.fn();
+      workspaceContext.onDirectoriesChanged(listener);
+
+      workspaceContext.addDirectory(otherDir);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it('should call listener when setting different directories', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      const listener = vi.fn();
+      workspaceContext.onDirectoriesChanged(listener);
+
+      workspaceContext.setDirectories([otherDir]);
+
+      expect(listener).toHaveBeenCalledOnce();
+    });
+
+    it('should not call listener when setting same directories', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      const listener = vi.fn();
+      workspaceContext.onDirectoriesChanged(listener);
+
+      workspaceContext.setDirectories([cwd]);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it('should support multiple listeners', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      const listener1 = vi.fn();
+      const listener2 = vi.fn();
+      workspaceContext.onDirectoriesChanged(listener1);
+      workspaceContext.onDirectoriesChanged(listener2);
+
+      workspaceContext.addDirectory(otherDir);
+
+      expect(listener1).toHaveBeenCalledOnce();
+      expect(listener2).toHaveBeenCalledOnce();
+    });
+
+    it('should allow unsubscribing a listener', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      const listener = vi.fn();
+      const unsubscribe = workspaceContext.onDirectoriesChanged(listener);
+
+      unsubscribe();
+      workspaceContext.addDirectory(otherDir);
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it('should not fail if a listener throws an error', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      const errorListener = () => {
+        throw new Error('test error');
+      };
+      const listener = vi.fn();
+      workspaceContext.onDirectoriesChanged(errorListener);
+      workspaceContext.onDirectoriesChanged(listener);
+
+      expect(() => {
+        workspaceContext.addDirectory(otherDir);
+      }).not.toThrow();
+      expect(listener).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('getDirectories', () => {
+    it('should return a copy of directories array', () => {
+      const workspaceContext = new WorkspaceContext(cwd);
+      const dirs1 = workspaceContext.getDirectories();
+      const dirs2 = workspaceContext.getDirectories();
+
+      expect(dirs1).not.toBe(dirs2);
+      expect(dirs1).toEqual(dirs2);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/utils/workspaceContext.ts

@@ -0,0 +1,193 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { isNodeError } from '../utils/errors.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export type Unsubscribe = () => void;
+
+/**
+ * WorkspaceContext manages multiple workspace directories and validates paths
+ * against them. This allows the CLI to operate on files from multiple directories
+ * in a single session.
+ */
+export class WorkspaceContext {
+  private directories = new Set<string>();
+  private initialDirectories: Set<string>;
+  private onDirectoriesChangedListeners = new Set<() => void>();
+
+  /**
+   * Creates a new WorkspaceContext with the given initial directory and optional additional directories.
+   * @param directory The initial working directory (usually cwd)
+   * @param additionalDirectories Optional array of additional directories to include
+   */
+  constructor(directory: string, additionalDirectories: string[] = []) {
+    this.addDirectory(directory);
+    for (const additionalDirectory of additionalDirectories) {
+      this.addDirectory(additionalDirectory);
+    }
+
+    this.initialDirectories = new Set(this.directories);
+  }
+
+  /**
+   * Registers a listener that is called when the workspace directories change.
+   * @param listener The listener to call.
+   * @returns A function to unsubscribe the listener.
+   */
+  onDirectoriesChanged(listener: () => void): Unsubscribe {
+    this.onDirectoriesChangedListeners.add(listener);
+    return () => {
+      this.onDirectoriesChangedListeners.delete(listener);
+    };
+  }
+
+  private notifyDirectoriesChanged() {
+    // Iterate over a copy of the set in case a listener unsubscribes itself or others.
+    for (const listener of [...this.onDirectoriesChangedListeners]) {
+      try {
+        listener();
+      } catch (e) {
+        // Don't let one listener break others.
+        console.error('Error in WorkspaceContext listener:', e);
+      }
+    }
+  }
+
+  /**
+   * Adds a directory to the workspace.
+   * @param directory The directory path to add (can be relative or absolute)
+   * @param basePath Optional base path for resolving relative paths (defaults to cwd)
+   */
+  addDirectory(directory: string, basePath: string = process.cwd()): void {
+    const resolved = this.resolveAndValidateDir(directory, basePath);
+    if (this.directories.has(resolved)) {
+      return;
+    }
+    this.directories.add(resolved);
+    this.notifyDirectoriesChanged();
+  }
+
+  private resolveAndValidateDir(
+    directory: string,
+    basePath: string = process.cwd(),
+  ): string {
+    const absolutePath = path.isAbsolute(directory)
+      ? directory
+      : path.resolve(basePath, directory);
+
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Directory does not exist: ${absolutePath}`);
+    }
+    const stats = fs.statSync(absolutePath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${absolutePath}`);
+    }
+
+    return fs.realpathSync(absolutePath);
+  }
+
+  /**
+   * Gets a copy of all workspace directories.
+   * @returns Array of absolute directory paths
+   */
+  getDirectories(): readonly string[] {
+    return Array.from(this.directories);
+  }
+
+  getInitialDirectories(): readonly string[] {
+    return Array.from(this.initialDirectories);
+  }
+
+  setDirectories(directories: readonly string[]): void {
+    const newDirectories = new Set<string>();
+    for (const dir of directories) {
+      newDirectories.add(this.resolveAndValidateDir(dir));
+    }
+
+    if (
+      newDirectories.size !== this.directories.size ||
+      ![...newDirectories].every((d) => this.directories.has(d))
+    ) {
+      this.directories = newDirectories;
+      this.notifyDirectoriesChanged();
+    }
+  }
+
+  /**
+   * Checks if a given path is within any of the workspace directories.
+   * @param pathToCheck The path to validate
+   * @returns True if the path is within the workspace, false otherwise
+   */
+  isPathWithinWorkspace(pathToCheck: string): boolean {
+    try {
+      const fullyResolvedPath = this.fullyResolvedPath(pathToCheck);
+
+      for (const dir of this.directories) {
+        if (this.isPathWithinRoot(fullyResolvedPath, dir)) {
+          return true;
+        }
+      }
+      return false;
+    } catch (_error) {
+      return false;
+    }
+  }
+
+  /**
+   * Fully resolves a path, including symbolic links.
+   * If the path does not exist, it returns the fully resolved path as it would be
+   * if it did exist.
+   */
+  private fullyResolvedPath(pathToCheck: string): string {
+    try {
+      return fs.realpathSync(pathToCheck);
+    } catch (e: unknown) {
+      if (
+        isNodeError(e) &&
+        e.code === 'ENOENT' &&
+        e.path &&
+        // realpathSync does not set e.path correctly for symlinks to
+        // non-existent files.
+        !this.isFileSymlink(e.path)
+      ) {
+        // If it doesn't exist, e.path contains the fully resolved path.
+        return e.path;
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Checks if a path is within a given root directory.
+   * @param pathToCheck The absolute path to check
+   * @param rootDirectory The absolute root directory
+   * @returns True if the path is within the root directory, false otherwise
+   */
+  private isPathWithinRoot(
+    pathToCheck: string,
+    rootDirectory: string,
+  ): boolean {
+    const relative = path.relative(rootDirectory, pathToCheck);
+    return (
+      !relative.startsWith(`..${path.sep}`) &&
+      relative !== '..' &&
+      !path.isAbsolute(relative)
+    );
+  }
+
+  /**
+   * Checks if a file path is a symbolic link that points to a file.
+   */
+  private isFileSymlink(filePath: string): boolean {
+    try {
+      return !fs.readlinkSync(filePath).endsWith('/');
+    } catch (_error) {
+      return false;
+    }
+  }
+}