Add files using upload-large-folder tool

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

@@ -0,0 +1,2277 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'events';
+import { type ChildProcess } from 'child_process';
+import type { Config } from '../config/config.js';
+import {
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generatePKCEPair,
+  isDeviceAuthorizationSuccess,
+  isDeviceTokenPending,
+  isDeviceTokenSuccess,
+  isErrorResponse,
+  QwenOAuth2Client,
+  type DeviceAuthorizationResponse,
+  type DeviceTokenResponse,
+  type ErrorData,
+  type QwenCredentials,
+} from './qwenOAuth2.js';
+import {
+  SharedTokenManager,
+  TokenManagerError,
+  TokenError,
+} from './sharedTokenManager.js';
+
+interface MockSharedTokenManager {
+  getValidCredentials(qwenClient: QwenOAuth2Client): Promise<QwenCredentials>;
+  getCurrentCredentials(): QwenCredentials | null;
+  clearCache(): void;
+}
+
+// Mock SharedTokenManager
+vi.mock('./sharedTokenManager.js', () => ({
+  SharedTokenManager: class {
+    private static instance: MockSharedTokenManager | null = null;
+
+    static getInstance() {
+      if (!this.instance) {
+        this.instance = new this();
+      }
+      return this.instance;
+    }
+
+    async getValidCredentials(
+      qwenClient: QwenOAuth2Client,
+    ): Promise<QwenCredentials> {
+      // Try to get credentials from the client first
+      const clientCredentials = qwenClient.getCredentials();
+      if (clientCredentials && clientCredentials.access_token) {
+        return clientCredentials;
+      }
+
+      // Fall back to default mock credentials if client has none
+      return {
+        access_token: 'new-access-token',
+        refresh_token: 'valid-refresh-token',
+        resource_url: undefined,
+        token_type: 'Bearer',
+        expiry_date: Date.now() + 3600000,
+      };
+    }
+
+    getCurrentCredentials(): QwenCredentials | null {
+      // Return null to let the client manage its own credentials
+      return null;
+    }
+
+    clearCache(): void {
+      // Do nothing in mock
+    }
+  },
+  TokenManagerError: class extends Error {
+    constructor(message: string) {
+      super(message);
+      this.name = 'TokenManagerError';
+    }
+  },
+  TokenError: {
+    REFRESH_FAILED: 'REFRESH_FAILED',
+    NO_REFRESH_TOKEN: 'NO_REFRESH_TOKEN',
+    LOCK_TIMEOUT: 'LOCK_TIMEOUT',
+    FILE_ACCESS_ERROR: 'FILE_ACCESS_ERROR',
+    NETWORK_ERROR: 'NETWORK_ERROR',
+  },
+}));
+
+// Mock qrcode-terminal
+vi.mock('qrcode-terminal', () => ({
+  default: {
+    generate: vi.fn(),
+  },
+}));
+
+// Mock open
+vi.mock('open', () => ({
+  default: vi.fn(),
+}));
+
+// Mock process.stdout.write
+vi.mock('process', () => ({
+  stdout: {
+    write: vi.fn(),
+  },
+}));
+
+// Mock file system operations
+vi.mock('node:fs', () => ({
+  promises: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    unlink: vi.fn(),
+    mkdir: vi.fn().mockResolvedValue(undefined),
+  },
+}));
+
+describe('PKCE Code Generation', () => {
+  describe('generateCodeVerifier', () => {
+    it('should generate a code verifier with correct length', () => {
+      const codeVerifier = generateCodeVerifier();
+      expect(codeVerifier).toMatch(/^[A-Za-z0-9_-]{43}$/);
+    });
+
+    it('should generate different verifiers on subsequent calls', () => {
+      const verifier1 = generateCodeVerifier();
+      const verifier2 = generateCodeVerifier();
+      expect(verifier1).not.toBe(verifier2);
+    });
+  });
+
+  describe('generateCodeChallenge', () => {
+    it('should generate code challenge from verifier', () => {
+      const verifier = 'test-verifier-1234567890abcdefghijklmnopqrst';
+      const challenge = generateCodeChallenge(verifier);
+
+      // Should be base64url encoded
+      expect(challenge).toMatch(/^[A-Za-z0-9_-]+$/);
+      expect(challenge).not.toBe(verifier);
+    });
+  });
+
+  describe('generatePKCEPair', () => {
+    it('should generate valid PKCE pair', () => {
+      const { code_verifier, code_challenge } = generatePKCEPair();
+
+      expect(code_verifier).toMatch(/^[A-Za-z0-9_-]{43}$/);
+      expect(code_challenge).toMatch(/^[A-Za-z0-9_-]+$/);
+      expect(code_verifier).not.toBe(code_challenge);
+    });
+  });
+});
+
+describe('Type Guards', () => {
+  describe('isDeviceAuthorizationSuccess', () => {
+    it('should return true for successful authorization response', () => {
+      const expectedBaseUrl = process.env['DEBUG']
+        ? 'https://pre4-chat.qwen.ai'
+        : 'https://chat.qwen.ai';
+
+      const successResponse: DeviceAuthorizationResponse = {
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: `${expectedBaseUrl}/device`,
+        verification_uri_complete: `${expectedBaseUrl}/device?code=TEST123`,
+        expires_in: 1800,
+      };
+
+      expect(isDeviceAuthorizationSuccess(successResponse)).toBe(true);
+    });
+
+    it('should return false for error response', () => {
+      const errorResponse: DeviceAuthorizationResponse = {
+        error: 'INVALID_REQUEST',
+        error_description: 'The request parameters are invalid',
+      };
+
+      expect(isDeviceAuthorizationSuccess(errorResponse)).toBe(false);
+    });
+  });
+
+  describe('isDeviceTokenPending', () => {
+    it('should return true for pending response', () => {
+      const pendingResponse: DeviceTokenResponse = {
+        status: 'pending',
+      };
+
+      expect(isDeviceTokenPending(pendingResponse)).toBe(true);
+    });
+
+    it('should return false for success response', () => {
+      const successResponse: DeviceTokenResponse = {
+        access_token: 'valid-access-token',
+        refresh_token: 'valid-refresh-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        scope: 'openid profile email model.completion',
+      };
+
+      expect(isDeviceTokenPending(successResponse)).toBe(false);
+    });
+
+    it('should return false for error response', () => {
+      const errorResponse: DeviceTokenResponse = {
+        error: 'ACCESS_DENIED',
+        error_description: 'User denied the authorization request',
+      };
+
+      expect(isDeviceTokenPending(errorResponse)).toBe(false);
+    });
+  });
+
+  describe('isDeviceTokenSuccess', () => {
+    it('should return true for successful token response', () => {
+      const successResponse: DeviceTokenResponse = {
+        access_token: 'valid-access-token',
+        refresh_token: 'valid-refresh-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        scope: 'openid profile email model.completion',
+      };
+
+      expect(isDeviceTokenSuccess(successResponse)).toBe(true);
+    });
+
+    it('should return false for pending response', () => {
+      const pendingResponse: DeviceTokenResponse = {
+        status: 'pending',
+      };
+
+      expect(isDeviceTokenSuccess(pendingResponse)).toBe(false);
+    });
+
+    it('should return false for error response', () => {
+      const errorResponse: DeviceTokenResponse = {
+        error: 'ACCESS_DENIED',
+        error_description: 'User denied the authorization request',
+      };
+
+      expect(isDeviceTokenSuccess(errorResponse)).toBe(false);
+    });
+
+    it('should return false for null access token', () => {
+      const nullTokenResponse: DeviceTokenResponse = {
+        access_token: null,
+        token_type: 'Bearer',
+        expires_in: 3600,
+      };
+
+      expect(isDeviceTokenSuccess(nullTokenResponse)).toBe(false);
+    });
+
+    it('should return false for empty access token', () => {
+      const emptyTokenResponse: DeviceTokenResponse = {
+        access_token: '',
+        token_type: 'Bearer',
+        expires_in: 3600,
+      };
+
+      expect(isDeviceTokenSuccess(emptyTokenResponse)).toBe(false);
+    });
+  });
+
+  describe('isErrorResponse', () => {
+    it('should return true for error responses', () => {
+      const errorResponse: ErrorData = {
+        error: 'INVALID_REQUEST',
+        error_description: 'The request parameters are invalid',
+      };
+
+      expect(isErrorResponse(errorResponse)).toBe(true);
+    });
+
+    it('should return false for successful responses', () => {
+      const successResponse: DeviceAuthorizationResponse = {
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      };
+
+      expect(isErrorResponse(successResponse)).toBe(false);
+    });
+  });
+});
+
+describe('QwenOAuth2Client', () => {
+  let client: QwenOAuth2Client;
+  let originalFetch: typeof global.fetch;
+
+  beforeEach(() => {
+    // Create client instance
+    client = new QwenOAuth2Client();
+
+    // Mock fetch
+    originalFetch = global.fetch;
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.clearAllMocks();
+  });
+
+  describe('requestDeviceAuthorization', () => {
+    it('should successfully request device authorization', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          device_code: 'test-device-code',
+          user_code: 'TEST123',
+          verification_uri: 'https://chat.qwen.ai/device',
+          verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+          expires_in: 1800,
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      const result = await client.requestDeviceAuthorization({
+        scope: 'openid profile email model.completion',
+        code_challenge: 'test-challenge',
+        code_challenge_method: 'S256',
+      });
+
+      expect(result).toEqual({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      });
+    });
+
+    it('should handle error response', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          error: 'INVALID_REQUEST',
+          error_description: 'The request parameters are invalid',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await expect(
+        client.requestDeviceAuthorization({
+          scope: 'openid profile email model.completion',
+          code_challenge: 'test-challenge',
+          code_challenge_method: 'S256',
+        }),
+      ).rejects.toThrow(
+        'Device authorization failed: INVALID_REQUEST - The request parameters are invalid',
+      );
+    });
+  });
+
+  describe('refreshAccessToken', () => {
+    beforeEach(() => {
+      // Set up client with credentials
+      client.setCredentials({
+        access_token: 'old-token',
+        refresh_token: 'test-refresh-token',
+        token_type: 'Bearer',
+      });
+    });
+
+    it('should successfully refresh access token', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-access-token',
+          token_type: 'Bearer',
+          expires_in: 3600,
+          resource_url: 'https://new-endpoint.com',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      const result = await client.refreshAccessToken();
+
+      expect(result).toEqual({
+        access_token: 'new-access-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        resource_url: 'https://new-endpoint.com',
+      });
+
+      // Verify credentials were updated
+      const credentials = client.getCredentials();
+      expect(credentials.access_token).toBe('new-access-token');
+    });
+
+    it('should handle refresh error', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          error: 'INVALID_GRANT',
+          error_description: 'The refresh token is invalid',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await expect(client.refreshAccessToken()).rejects.toThrow(
+        'Token refresh failed: INVALID_GRANT - The refresh token is invalid',
+      );
+    });
+
+    it('should successfully refresh access token and update credentials', async () => {
+      // Clear any previous calls
+      vi.clearAllMocks();
+
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-access-token',
+          token_type: 'Bearer',
+          expires_in: 3600,
+          resource_url: 'https://new-endpoint.com',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      const result = await client.refreshAccessToken();
+
+      // Verify the response
+      expect(result).toMatchObject({
+        access_token: 'new-access-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        resource_url: 'https://new-endpoint.com',
+      });
+
+      // Verify credentials were updated
+      const credentials = client.getCredentials();
+      expect(credentials).toMatchObject({
+        access_token: 'new-access-token',
+        token_type: 'Bearer',
+        refresh_token: 'test-refresh-token', // Should preserve existing refresh token
+        resource_url: 'https://new-endpoint.com',
+      });
+      expect(credentials.expiry_date).toBeDefined();
+    });
+
+    it('should use new refresh token if provided in response', async () => {
+      // Clear any previous calls
+      vi.clearAllMocks();
+
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-access-token',
+          token_type: 'Bearer',
+          expires_in: 3600,
+          refresh_token: 'new-refresh-token', // New refresh token provided
+          resource_url: 'https://new-endpoint.com',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await client.refreshAccessToken();
+
+      // Verify the credentials contain the new refresh token
+      const credentials = client.getCredentials();
+      expect(credentials.refresh_token).toBe('new-refresh-token');
+    });
+  });
+
+  describe('getAccessToken', () => {
+    it('should return access token if valid and not expired', async () => {
+      // Set valid credentials
+      client.setCredentials({
+        access_token: 'valid-token',
+        expiry_date: Date.now() + 60 * 60 * 1000, // 1 hour from now
+      });
+
+      const result = await client.getAccessToken();
+      expect(result.token).toBe('valid-token');
+    });
+
+    it('should refresh token if access token is expired', async () => {
+      // Set expired credentials with refresh token
+      client.setCredentials({
+        access_token: 'expired-token',
+        refresh_token: 'valid-refresh-token',
+        expiry_date: Date.now() - 1000, // 1 second ago
+      });
+
+      // Override the client's SharedTokenManager instance directly
+      (
+        client as unknown as {
+          sharedManager: {
+            getValidCredentials: () => Promise<QwenCredentials>;
+          };
+        }
+      ).sharedManager = {
+        getValidCredentials: vi.fn().mockResolvedValue({
+          access_token: 'new-access-token',
+          refresh_token: 'valid-refresh-token',
+          token_type: 'Bearer',
+          expiry_date: Date.now() + 3600000,
+        }),
+      };
+
+      const result = await client.getAccessToken();
+      expect(result.token).toBe('new-access-token');
+    });
+
+    it('should return undefined if no access token and no refresh token', async () => {
+      client.setCredentials({});
+
+      // Override the client's SharedTokenManager instance directly
+      (
+        client as unknown as {
+          sharedManager: {
+            getValidCredentials: () => Promise<QwenCredentials>;
+          };
+        }
+      ).sharedManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('No credentials available')),
+      };
+
+      const result = await client.getAccessToken();
+      expect(result.token).toBeUndefined();
+    });
+  });
+
+  describe('pollDeviceToken', () => {
+    it('should successfully poll for device token', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-access-token',
+          refresh_token: 'new-refresh-token',
+          token_type: 'Bearer',
+          expires_in: 3600,
+          scope: 'openid profile email model.completion',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      const result = await client.pollDeviceToken({
+        device_code: 'test-device-code',
+        code_verifier: 'test-code-verifier',
+      });
+
+      expect(result).toEqual({
+        access_token: 'new-access-token',
+        refresh_token: 'new-refresh-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        scope: 'openid profile email model.completion',
+      });
+    });
+
+    it('should return pending status when authorization is pending', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          status: 'pending',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      const result = await client.pollDeviceToken({
+        device_code: 'test-device-code',
+        code_verifier: 'test-code-verifier',
+      });
+
+      expect(result).toEqual({
+        status: 'pending',
+      });
+    });
+
+    it('should handle HTTP error responses', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        text: async () => 'Invalid device code',
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await expect(
+        client.pollDeviceToken({
+          device_code: 'invalid-device-code',
+          code_verifier: 'test-code-verifier',
+        }),
+      ).rejects.toThrow('Device token poll failed: 400 Bad Request');
+    });
+
+    it('should include status code in error for better handling', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 429,
+        statusText: 'Too Many Requests',
+        text: async () => 'Rate limited',
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      try {
+        await client.pollDeviceToken({
+          device_code: 'test-device-code',
+          code_verifier: 'test-code-verifier',
+        });
+      } catch (error) {
+        expect((error as Error & { status?: number }).status).toBe(429);
+      }
+    });
+
+    it('should handle authorization_pending with HTTP 400 according to RFC 8628', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        json: async () => ({
+          error: 'authorization_pending',
+          error_description: 'The authorization request is still pending',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      const result = await client.pollDeviceToken({
+        device_code: 'test-device-code',
+        code_verifier: 'test-code-verifier',
+      });
+
+      expect(result).toEqual({
+        status: 'pending',
+      });
+    });
+
+    it('should handle slow_down with HTTP 429 according to RFC 8628', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 429,
+        statusText: 'Too Many Requests',
+        json: async () => ({
+          error: 'slow_down',
+          error_description: 'The client is polling too frequently',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      const result = await client.pollDeviceToken({
+        device_code: 'test-device-code',
+        code_verifier: 'test-code-verifier',
+      });
+
+      expect(result).toEqual({
+        status: 'pending',
+        slowDown: true,
+      });
+    });
+  });
+
+  describe('refreshAccessToken error handling', () => {
+    beforeEach(() => {
+      client.setCredentials({
+        access_token: 'old-token',
+        refresh_token: 'test-refresh-token',
+        token_type: 'Bearer',
+      });
+    });
+
+    it('should throw error if no refresh token available', async () => {
+      client.setCredentials({ access_token: 'token' });
+
+      await expect(client.refreshAccessToken()).rejects.toThrow(
+        'No refresh token available',
+      );
+    });
+
+    it('should handle 400 status as expired refresh token', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        text: async () => 'Refresh token expired',
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await expect(client.refreshAccessToken()).rejects.toThrow(
+        "Refresh token expired or invalid. Please use '/auth' to re-authenticate.",
+      );
+    });
+
+    it('should handle other HTTP error statuses', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        text: async () => 'Server error',
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await expect(client.refreshAccessToken()).rejects.toThrow(
+        'Token refresh failed: 500 Internal Server Error',
+      );
+    });
+  });
+
+  describe('credentials management', () => {
+    it('should set and get credentials correctly', () => {
+      const credentials = {
+        access_token: 'test-token',
+        refresh_token: 'test-refresh',
+        token_type: 'Bearer',
+        expiry_date: Date.now() + 3600000,
+      };
+
+      client.setCredentials(credentials);
+      expect(client.getCredentials()).toEqual(credentials);
+    });
+
+    it('should handle empty credentials', () => {
+      client.setCredentials({});
+      expect(client.getCredentials()).toEqual({});
+    });
+  });
+});
+
+describe('getQwenOAuthClient', () => {
+  let mockConfig: Config;
+  let originalFetch: typeof global.fetch;
+
+  beforeEach(() => {
+    mockConfig = {
+      isBrowserLaunchSuppressed: vi.fn().mockReturnValue(false),
+    } as unknown as Config;
+
+    originalFetch = global.fetch;
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.clearAllMocks();
+  });
+
+  it('should load cached credentials if available', async () => {
+    const fs = await import('node:fs');
+    const mockCredentials = {
+      access_token: 'cached-token',
+      refresh_token: 'cached-refresh',
+      token_type: 'Bearer',
+      expiry_date: Date.now() + 3600000,
+    };
+
+    vi.mocked(fs.promises.readFile).mockResolvedValue(
+      JSON.stringify(mockCredentials),
+    );
+
+    // Mock SharedTokenManager to use cached credentials
+    const mockTokenManager = {
+      getValidCredentials: vi.fn().mockResolvedValue(mockCredentials),
+    };
+
+    const originalGetInstance = SharedTokenManager.getInstance;
+    SharedTokenManager.getInstance = vi.fn().mockReturnValue(mockTokenManager);
+
+    const client = await import('./qwenOAuth2.js').then((module) =>
+      module.getQwenOAuthClient(mockConfig),
+    );
+
+    expect(client).toBeInstanceOf(Object);
+    expect(mockTokenManager.getValidCredentials).toHaveBeenCalled();
+
+    SharedTokenManager.getInstance = originalGetInstance;
+  });
+
+  it('should handle cached credentials refresh failure', async () => {
+    const fs = await import('node:fs');
+    const mockCredentials = {
+      access_token: 'cached-token',
+      refresh_token: 'expired-refresh',
+      token_type: 'Bearer',
+      expiry_date: Date.now() + 3600000, // Valid expiry time so loadCachedQwenCredentials returns true
+    };
+
+    vi.mocked(fs.promises.readFile).mockResolvedValue(
+      JSON.stringify(mockCredentials),
+    );
+
+    // Mock SharedTokenManager to fail with a specific error
+    const mockTokenManager = {
+      getValidCredentials: vi
+        .fn()
+        .mockRejectedValue(new Error('Token refresh failed')),
+    };
+
+    const originalGetInstance = SharedTokenManager.getInstance;
+    SharedTokenManager.getInstance = vi.fn().mockReturnValue(mockTokenManager);
+
+    // Mock device flow to also fail
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        error: 'invalid_request',
+        error_description: 'Invalid request parameters',
+      }),
+    };
+    vi.mocked(global.fetch).mockResolvedValue(mockAuthResponse as Response);
+
+    // The function should handle the invalid cached credentials and throw the expected error
+    await expect(
+      import('./qwenOAuth2.js').then((module) =>
+        module.getQwenOAuthClient(mockConfig),
+      ),
+    ).rejects.toThrow('Qwen OAuth authentication failed');
+
+    SharedTokenManager.getInstance = originalGetInstance;
+  });
+});
+
+describe('clearQwenCredentials', () => {
+  it('should successfully clear credentials file', async () => {
+    const { promises: fs } = await import('node:fs');
+    const { clearQwenCredentials } = await import('./qwenOAuth2.js');
+
+    vi.mocked(fs.unlink).mockResolvedValue(undefined);
+
+    await expect(clearQwenCredentials()).resolves.not.toThrow();
+    expect(fs.unlink).toHaveBeenCalled();
+  });
+
+  it('should handle file not found error gracefully', async () => {
+    const { promises: fs } = await import('node:fs');
+    const { clearQwenCredentials } = await import('./qwenOAuth2.js');
+
+    const notFoundError = new Error('File not found');
+    (notFoundError as Error & { code: string }).code = 'ENOENT';
+    vi.mocked(fs.unlink).mockRejectedValue(notFoundError);
+
+    await expect(clearQwenCredentials()).resolves.not.toThrow();
+  });
+
+  it('should handle other file system errors gracefully', async () => {
+    const { promises: fs } = await import('node:fs');
+    const { clearQwenCredentials } = await import('./qwenOAuth2.js');
+
+    const permissionError = new Error('Permission denied');
+    vi.mocked(fs.unlink).mockRejectedValue(permissionError);
+
+    // Should not throw but may log warning
+    await expect(clearQwenCredentials()).resolves.not.toThrow();
+  });
+});
+
+describe('QwenOAuth2Client - Additional Error Scenarios', () => {
+  let client: QwenOAuth2Client;
+  let originalFetch: typeof global.fetch;
+
+  beforeEach(() => {
+    client = new QwenOAuth2Client();
+    originalFetch = global.fetch;
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.clearAllMocks();
+  });
+
+  describe('requestDeviceAuthorization HTTP errors', () => {
+    it('should handle HTTP error response with non-ok status', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        text: async () => 'Server error occurred',
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await expect(
+        client.requestDeviceAuthorization({
+          scope: 'openid profile email model.completion',
+          code_challenge: 'test-challenge',
+          code_challenge_method: 'S256',
+        }),
+      ).rejects.toThrow(
+        'Device authorization failed: 500 Internal Server Error. Response: Server error occurred',
+      );
+    });
+  });
+
+  describe('isTokenValid edge cases', () => {
+    it('should return false when expiry_date is undefined', () => {
+      client.setCredentials({
+        access_token: 'token',
+        // expiry_date is undefined
+      });
+
+      // Access private method for testing
+      const isValid = (
+        client as unknown as { isTokenValid(): boolean }
+      ).isTokenValid();
+      expect(isValid).toBe(false);
+    });
+  });
+});
+
+describe('getQwenOAuthClient - Enhanced Error Scenarios', () => {
+  let mockConfig: Config;
+  let originalFetch: typeof global.fetch;
+
+  beforeEach(() => {
+    mockConfig = {
+      isBrowserLaunchSuppressed: vi.fn().mockReturnValue(false),
+    } as unknown as Config;
+
+    originalFetch = global.fetch;
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.clearAllMocks();
+  });
+
+  it('should handle generic refresh token errors', async () => {
+    const { promises: fs } = await import('node:fs');
+    const mockCredentials = {
+      access_token: 'cached-token',
+      refresh_token: 'some-refresh-token',
+      token_type: 'Bearer',
+      expiry_date: Date.now() + 3600000,
+    };
+
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockCredentials));
+
+    // Mock SharedTokenManager to fail
+    const mockTokenManager = {
+      getValidCredentials: vi
+        .fn()
+        .mockRejectedValue(new Error('Refresh failed')),
+    };
+
+    const originalGetInstance = SharedTokenManager.getInstance;
+    SharedTokenManager.getInstance = vi.fn().mockReturnValue(mockTokenManager);
+
+    // Mock device flow to also fail
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        error: 'invalid_request',
+        error_description: 'Invalid request parameters',
+      }),
+    };
+    vi.mocked(global.fetch).mockResolvedValue(mockAuthResponse as Response);
+
+    await expect(
+      import('./qwenOAuth2.js').then((module) =>
+        module.getQwenOAuthClient(mockConfig),
+      ),
+    ).rejects.toThrow('Qwen OAuth authentication failed');
+
+    SharedTokenManager.getInstance = originalGetInstance;
+  });
+
+  it('should handle different authentication failure reasons - timeout', async () => {
+    const { promises: fs } = await import('node:fs');
+    vi.mocked(fs.readFile).mockRejectedValue(
+      new Error('No cached credentials'),
+    );
+
+    // Mock SharedTokenManager to fail
+    const mockTokenManager = {
+      getValidCredentials: vi
+        .fn()
+        .mockRejectedValue(new Error('No credentials')),
+    };
+
+    const originalGetInstance = SharedTokenManager.getInstance;
+    SharedTokenManager.getInstance = vi.fn().mockReturnValue(mockTokenManager);
+
+    // Mock device authorization to succeed but polling to timeout
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 0.1, // Very short timeout for testing
+      }),
+    };
+
+    const mockPendingResponse = {
+      ok: true,
+      json: async () => ({
+        status: 'pending',
+      }),
+    };
+
+    global.fetch = vi
+      .fn()
+      .mockResolvedValueOnce(mockAuthResponse as Response)
+      .mockResolvedValue(mockPendingResponse as Response);
+
+    await expect(
+      import('./qwenOAuth2.js').then((module) =>
+        module.getQwenOAuthClient(mockConfig),
+      ),
+    ).rejects.toThrow('Qwen OAuth authentication timed out');
+
+    SharedTokenManager.getInstance = originalGetInstance;
+  });
+
+  it('should handle authentication failure reason - rate limit', async () => {
+    const { promises: fs } = await import('node:fs');
+    vi.mocked(fs.readFile).mockRejectedValue(
+      new Error('No cached credentials'),
+    );
+
+    // Mock SharedTokenManager to fail
+    const mockTokenManager = {
+      getValidCredentials: vi
+        .fn()
+        .mockRejectedValue(new Error('No credentials')),
+    };
+
+    const originalGetInstance = SharedTokenManager.getInstance;
+    SharedTokenManager.getInstance = vi.fn().mockReturnValue(mockTokenManager);
+
+    // Mock device authorization to succeed but polling to get rate limited
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      }),
+    };
+
+    const mockRateLimitResponse = {
+      ok: false,
+      status: 429,
+      statusText: 'Too Many Requests',
+      text: async () => 'Rate limited',
+    };
+
+    global.fetch = vi
+      .fn()
+      .mockResolvedValueOnce(mockAuthResponse as Response)
+      .mockResolvedValue(mockRateLimitResponse as Response);
+
+    await expect(
+      import('./qwenOAuth2.js').then((module) =>
+        module.getQwenOAuthClient(mockConfig),
+      ),
+    ).rejects.toThrow(
+      'Too many request for Qwen OAuth authentication, please try again later.',
+    );
+
+    SharedTokenManager.getInstance = originalGetInstance;
+  });
+
+  it('should handle authentication failure reason - error', async () => {
+    const { promises: fs } = await import('node:fs');
+    vi.mocked(fs.readFile).mockRejectedValue(
+      new Error('No cached credentials'),
+    );
+
+    // Mock SharedTokenManager to fail
+    const mockTokenManager = {
+      getValidCredentials: vi
+        .fn()
+        .mockRejectedValue(new Error('No credentials')),
+    };
+
+    const originalGetInstance = SharedTokenManager.getInstance;
+    SharedTokenManager.getInstance = vi.fn().mockReturnValue(mockTokenManager);
+
+    // Mock device authorization to fail
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        error: 'invalid_request',
+        error_description: 'Invalid request parameters',
+      }),
+    };
+
+    global.fetch = vi.fn().mockResolvedValue(mockAuthResponse as Response);
+
+    await expect(
+      import('./qwenOAuth2.js').then((module) =>
+        module.getQwenOAuthClient(mockConfig),
+      ),
+    ).rejects.toThrow('Qwen OAuth authentication failed');
+
+    SharedTokenManager.getInstance = originalGetInstance;
+  });
+});
+
+describe('authWithQwenDeviceFlow - Comprehensive Testing', () => {
+  let mockConfig: Config;
+  let originalFetch: typeof global.fetch;
+
+  beforeEach(() => {
+    mockConfig = {
+      isBrowserLaunchSuppressed: vi.fn().mockReturnValue(false),
+    } as unknown as Config;
+
+    originalFetch = global.fetch;
+    global.fetch = vi.fn();
+
+    // Mock setTimeout to avoid real delays in tests
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.clearAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('should handle device authorization error response', async () => {
+    const { promises: fs } = await import('node:fs');
+    vi.mocked(fs.readFile).mockRejectedValue(
+      new Error('No cached credentials'),
+    );
+
+    // Mock SharedTokenManager to fail
+    const mockTokenManager = {
+      getValidCredentials: vi
+        .fn()
+        .mockRejectedValue(new Error('No credentials')),
+    };
+
+    const originalGetInstance = SharedTokenManager.getInstance;
+    SharedTokenManager.getInstance = vi.fn().mockReturnValue(mockTokenManager);
+
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        error: 'invalid_client',
+        error_description: 'Client authentication failed',
+      }),
+    };
+
+    global.fetch = vi.fn().mockResolvedValue(mockAuthResponse as Response);
+
+    await expect(
+      import('./qwenOAuth2.js').then((module) =>
+        module.getQwenOAuthClient(mockConfig),
+      ),
+    ).rejects.toThrow('Qwen OAuth authentication failed');
+
+    SharedTokenManager.getInstance = originalGetInstance;
+  });
+
+  it('should handle successful authentication flow', async () => {
+    const { promises: fs } = await import('node:fs');
+    vi.mocked(fs.readFile).mockRejectedValue(
+      new Error('No cached credentials'),
+    );
+
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      }),
+    };
+
+    const mockTokenResponse = {
+      ok: true,
+      json: async () => ({
+        access_token: 'new-access-token',
+        refresh_token: 'new-refresh-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        scope: 'openid profile email model.completion',
+      }),
+    };
+
+    vi.mocked(global.fetch)
+      .mockResolvedValueOnce(mockAuthResponse as Response)
+      .mockResolvedValue(mockTokenResponse as Response);
+
+    const client = await import('./qwenOAuth2.js').then((module) =>
+      module.getQwenOAuthClient(mockConfig),
+    );
+
+    expect(client).toBeInstanceOf(Object);
+  });
+
+  it('should handle 401 error during token polling', async () => {
+    const { promises: fs } = await import('node:fs');
+    vi.mocked(fs.readFile).mockRejectedValue(
+      new Error('No cached credentials'),
+    );
+
+    // Mock SharedTokenManager to fail
+    const mockTokenManager = {
+      getValidCredentials: vi
+        .fn()
+        .mockRejectedValue(new Error('No credentials')),
+    };
+
+    const originalGetInstance = SharedTokenManager.getInstance;
+    SharedTokenManager.getInstance = vi.fn().mockReturnValue(mockTokenManager);
+
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      }),
+    };
+
+    const mock401Response = {
+      ok: false,
+      status: 401,
+      statusText: 'Unauthorized',
+      text: async () => 'Device code expired',
+    };
+
+    global.fetch = vi
+      .fn()
+      .mockResolvedValueOnce(mockAuthResponse as Response)
+      .mockResolvedValue(mock401Response as Response);
+
+    await expect(
+      import('./qwenOAuth2.js').then((module) =>
+        module.getQwenOAuthClient(mockConfig),
+      ),
+    ).rejects.toThrow('Qwen OAuth authentication failed');
+
+    SharedTokenManager.getInstance = originalGetInstance;
+  });
+
+  it('should handle token polling with browser launch suppressed', async () => {
+    const { promises: fs } = await import('node:fs');
+    vi.mocked(fs.readFile).mockRejectedValue(
+      new Error('No cached credentials'),
+    );
+
+    // Mock SharedTokenManager to fail initially so device flow is used
+    const mockTokenManager = {
+      getValidCredentials: vi
+        .fn()
+        .mockRejectedValue(new Error('No credentials')),
+    };
+
+    const originalGetInstance = SharedTokenManager.getInstance;
+    SharedTokenManager.getInstance = vi.fn().mockReturnValue(mockTokenManager);
+
+    // Mock browser launch as suppressed
+    mockConfig.isBrowserLaunchSuppressed = vi.fn().mockReturnValue(true);
+
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      }),
+    };
+
+    const mockTokenResponse = {
+      ok: true,
+      json: async () => ({
+        access_token: 'new-access-token',
+        refresh_token: 'new-refresh-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        scope: 'openid profile email model.completion',
+      }),
+    };
+
+    global.fetch = vi
+      .fn()
+      .mockResolvedValueOnce(mockAuthResponse as Response)
+      .mockResolvedValue(mockTokenResponse as Response);
+
+    const client = await import('./qwenOAuth2.js').then((module) =>
+      module.getQwenOAuthClient(mockConfig),
+    );
+
+    expect(client).toBeInstanceOf(Object);
+    expect(mockConfig.isBrowserLaunchSuppressed).toHaveBeenCalled();
+
+    SharedTokenManager.getInstance = originalGetInstance;
+  });
+});
+
+describe('Browser Launch and Error Handling', () => {
+  let mockConfig: Config;
+  let originalFetch: typeof global.fetch;
+
+  beforeEach(() => {
+    mockConfig = {
+      isBrowserLaunchSuppressed: vi.fn().mockReturnValue(false),
+    } as unknown as Config;
+
+    originalFetch = global.fetch;
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.clearAllMocks();
+  });
+
+  it('should handle browser launch failure gracefully', async () => {
+    const { promises: fs } = await import('node:fs');
+    vi.mocked(fs.readFile).mockRejectedValue(
+      new Error('No cached credentials'),
+    );
+
+    // Mock open to throw error
+    const open = await import('open');
+    vi.mocked(open.default).mockRejectedValue(
+      new Error('Browser launch failed'),
+    );
+
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      }),
+    };
+
+    const mockTokenResponse = {
+      ok: true,
+      json: async () => ({
+        access_token: 'new-access-token',
+        refresh_token: 'new-refresh-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        scope: 'openid profile email model.completion',
+      }),
+    };
+
+    vi.mocked(global.fetch)
+      .mockResolvedValueOnce(mockAuthResponse as Response)
+      .mockResolvedValue(mockTokenResponse as Response);
+
+    const client = await import('./qwenOAuth2.js').then((module) =>
+      module.getQwenOAuthClient(mockConfig),
+    );
+
+    expect(client).toBeInstanceOf(Object);
+  });
+
+  it('should handle browser child process error gracefully', async () => {
+    const { promises: fs } = await import('node:fs');
+    vi.mocked(fs.readFile).mockRejectedValue(
+      new Error('No cached credentials'),
+    );
+
+    // Mock open to return a child process that will emit error
+    const open = await import('open');
+    const mockChildProcess = {
+      on: vi.fn((event: string, callback: (error: Error) => void) => {
+        if (event === 'error') {
+          // Call the error handler immediately for testing
+          setTimeout(() => callback(new Error('Process spawn failed')), 0);
+        }
+      }),
+    };
+    vi.mocked(open.default).mockResolvedValue(
+      mockChildProcess as unknown as ChildProcess,
+    );
+
+    const mockAuthResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      }),
+    };
+
+    const mockTokenResponse = {
+      ok: true,
+      json: async () => ({
+        access_token: 'new-access-token',
+        refresh_token: 'new-refresh-token',
+        token_type: 'Bearer',
+        expires_in: 3600,
+        scope: 'openid profile email model.completion',
+      }),
+    };
+
+    vi.mocked(global.fetch)
+      .mockResolvedValueOnce(mockAuthResponse as Response)
+      .mockResolvedValue(mockTokenResponse as Response);
+
+    const client = await import('./qwenOAuth2.js').then((module) =>
+      module.getQwenOAuthClient(mockConfig),
+    );
+
+    expect(client).toBeInstanceOf(Object);
+  });
+});
+
+describe('Event Emitter Integration', () => {
+  it('should export qwenOAuth2Events as EventEmitter', async () => {
+    const { qwenOAuth2Events } = await import('./qwenOAuth2.js');
+    expect(qwenOAuth2Events).toBeInstanceOf(EventEmitter);
+  });
+
+  it('should define correct event enum values', async () => {
+    const { QwenOAuth2Event } = await import('./qwenOAuth2.js');
+    expect(QwenOAuth2Event.AuthUri).toBe('auth-uri');
+    expect(QwenOAuth2Event.AuthProgress).toBe('auth-progress');
+    expect(QwenOAuth2Event.AuthCancel).toBe('auth-cancel');
+  });
+});
+
+describe('Utility Functions', () => {
+  describe('objectToUrlEncoded', () => {
+    it('should encode object properties to URL-encoded format', async () => {
+      // Since objectToUrlEncoded is private, we test it indirectly through the client
+      const objectToUrlEncoded = (data: Record<string, string>): string =>
+        Object.keys(data)
+          .map(
+            (key) =>
+              `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`,
+          )
+          .join('&');
+
+      const testData = {
+        client_id: 'test-client',
+        scope: 'openid profile',
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = objectToUrlEncoded(testData);
+
+      expect(result).toContain('client_id=test-client');
+      expect(result).toContain('scope=openid%20profile');
+      expect(result).toContain(
+        'redirect_uri=https%3A%2F%2Fexample.com%2Fcallback',
+      );
+    });
+
+    it('should handle special characters', async () => {
+      const objectToUrlEncoded = (data: Record<string, string>): string =>
+        Object.keys(data)
+          .map(
+            (key) =>
+              `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`,
+          )
+          .join('&');
+
+      const testData = {
+        'param with spaces': 'value with spaces',
+        'param&with&amps': 'value&with&amps',
+        'param=with=equals': 'value=with=equals',
+      };
+
+      const result = objectToUrlEncoded(testData);
+
+      expect(result).toContain('param%20with%20spaces=value%20with%20spaces');
+      expect(result).toContain('param%26with%26amps=value%26with%26amps');
+      expect(result).toContain('param%3Dwith%3Dequals=value%3Dwith%3Dequals');
+    });
+
+    it('should handle empty object', async () => {
+      const objectToUrlEncoded = (data: Record<string, string>): string =>
+        Object.keys(data)
+          .map(
+            (key) =>
+              `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`,
+          )
+          .join('&');
+
+      const result = objectToUrlEncoded({});
+      expect(result).toBe('');
+    });
+  });
+
+  describe('getQwenCachedCredentialPath', () => {
+    it('should return correct path to cached credentials', async () => {
+      const os = await import('os');
+      const path = await import('path');
+
+      const expectedPath = path.join(os.homedir(), '.qwen', 'oauth_creds.json');
+
+      // Since this is a private function, we test it indirectly through clearQwenCredentials
+      const { promises: fs } = await import('node:fs');
+      const { clearQwenCredentials } = await import('./qwenOAuth2.js');
+
+      vi.mocked(fs.unlink).mockResolvedValue(undefined);
+
+      await clearQwenCredentials();
+
+      expect(fs.unlink).toHaveBeenCalledWith(expectedPath);
+    });
+  });
+});
+
+describe('Credential Caching Functions', () => {
+  describe('cacheQwenCredentials', () => {
+    it('should create directory and write credentials to file', async () => {
+      // Mock the internal cacheQwenCredentials function by creating client and calling refresh
+      const client = new QwenOAuth2Client();
+      client.setCredentials({
+        refresh_token: 'test-refresh',
+      });
+
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-token',
+          token_type: 'Bearer',
+          expires_in: 3600,
+        }),
+      };
+
+      global.fetch = vi.fn().mockResolvedValue(mockResponse as Response);
+
+      await client.refreshAccessToken();
+
+      // Note: File caching is now handled by SharedTokenManager, so these calls won't happen
+      // This test verifies that refreshAccessToken works correctly
+      const updatedCredentials = client.getCredentials();
+      expect(updatedCredentials.access_token).toBe('new-token');
+    });
+  });
+
+  describe('loadCachedQwenCredentials', () => {
+    it('should load and validate cached credentials successfully', async () => {
+      const { promises: fs } = await import('node:fs');
+      const mockCredentials = {
+        access_token: 'cached-token',
+        refresh_token: 'cached-refresh',
+        token_type: 'Bearer',
+        expiry_date: Date.now() + 3600000,
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockCredentials));
+
+      // Test through getQwenOAuthClient which calls loadCachedQwenCredentials
+      const mockConfig = {
+        isBrowserLaunchSuppressed: vi.fn().mockReturnValue(true),
+      } as unknown as Config;
+
+      // Make SharedTokenManager fail to test the fallback
+      const mockTokenManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('No cached creds')),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      // Mock successful auth flow after cache load fails
+      const mockAuthResponse = {
+        ok: true,
+        json: async () => ({
+          device_code: 'test-device-code',
+          user_code: 'TEST123',
+          verification_uri: 'https://chat.qwen.ai/device',
+          verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+          expires_in: 1800,
+        }),
+      };
+
+      const mockTokenResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-access-token',
+          refresh_token: 'new-refresh-token',
+          token_type: 'Bearer',
+          expires_in: 3600,
+          scope: 'openid profile email model.completion',
+        }),
+      };
+
+      global.fetch = vi
+        .fn()
+        .mockResolvedValueOnce(mockAuthResponse as Response)
+        .mockResolvedValue(mockTokenResponse as Response);
+
+      try {
+        await import('./qwenOAuth2.js').then((module) =>
+          module.getQwenOAuthClient(mockConfig),
+        );
+      } catch {
+        // Expected to fail in test environment
+      }
+
+      expect(fs.readFile).toHaveBeenCalled();
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+
+    it('should handle invalid cached credentials gracefully', async () => {
+      const { promises: fs } = await import('node:fs');
+
+      // Mock file read to return invalid JSON
+      vi.mocked(fs.readFile).mockResolvedValue('invalid-json');
+
+      const mockConfig = {
+        isBrowserLaunchSuppressed: vi.fn().mockReturnValue(true),
+      } as unknown as Config;
+
+      const mockTokenManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('No cached creds')),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      // Mock auth flow
+      const mockAuthResponse = {
+        ok: true,
+        json: async () => ({
+          device_code: 'test-device-code',
+          user_code: 'TEST123',
+          verification_uri: 'https://chat.qwen.ai/device',
+          verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+          expires_in: 1800,
+        }),
+      };
+
+      const mockTokenResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-token',
+          refresh_token: 'new-refresh',
+          token_type: 'Bearer',
+          expires_in: 3600,
+        }),
+      };
+
+      global.fetch = vi
+        .fn()
+        .mockResolvedValueOnce(mockAuthResponse as Response)
+        .mockResolvedValue(mockTokenResponse as Response);
+
+      try {
+        await import('./qwenOAuth2.js').then((module) =>
+          module.getQwenOAuthClient(mockConfig),
+        );
+      } catch {
+        // Expected to fail in test environment
+      }
+
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+
+    it('should handle file access errors', async () => {
+      const { promises: fs } = await import('node:fs');
+
+      vi.mocked(fs.readFile).mockRejectedValue(new Error('File not found'));
+
+      const mockConfig = {
+        isBrowserLaunchSuppressed: vi.fn().mockReturnValue(true),
+      } as unknown as Config;
+
+      const mockTokenManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('No cached creds')),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      // Mock device flow to fail quickly
+      const mockAuthResponse = {
+        ok: true,
+        json: async () => ({
+          error: 'invalid_request',
+          error_description: 'Invalid request parameters',
+        }),
+      };
+
+      global.fetch = vi.fn().mockResolvedValue(mockAuthResponse as Response);
+
+      // Should proceed to device flow when cache loading fails
+      try {
+        await import('./qwenOAuth2.js').then((module) =>
+          module.getQwenOAuthClient(mockConfig),
+        );
+      } catch {
+        // Expected to fail in test environment
+      }
+
+      SharedTokenManager.getInstance = originalGetInstance;
+    });
+  });
+});
+
+describe('Enhanced Error Handling and Edge Cases', () => {
+  let client: QwenOAuth2Client;
+  let originalFetch: typeof global.fetch;
+
+  beforeEach(() => {
+    client = new QwenOAuth2Client();
+    originalFetch = global.fetch;
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.clearAllMocks();
+  });
+
+  describe('QwenOAuth2Client getAccessToken enhanced scenarios', () => {
+    it('should handle SharedTokenManager failure and fall back to cached token', async () => {
+      // Set up client with valid credentials
+      client.setCredentials({
+        access_token: 'fallback-token',
+        expiry_date: Date.now() + 3600000, // Valid for 1 hour
+      });
+
+      // Override the client's SharedTokenManager instance directly to ensure it fails
+      (
+        client as unknown as {
+          sharedManager: {
+            getValidCredentials: () => Promise<QwenCredentials>;
+          };
+        }
+      ).sharedManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('Manager failed')),
+      };
+
+      // Mock console.warn to avoid test noise
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const result = await client.getAccessToken();
+
+      expect(result.token).toBe('fallback-token');
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Failed to get access token from shared manager:',
+        expect.any(Error),
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should return undefined when both manager and cache fail', async () => {
+      // Set up client with expired credentials
+      client.setCredentials({
+        access_token: 'expired-token',
+        expiry_date: Date.now() - 1000, // Expired
+      });
+
+      // Override the client's SharedTokenManager instance directly to ensure it fails
+      (
+        client as unknown as {
+          sharedManager: {
+            getValidCredentials: () => Promise<QwenCredentials>;
+          };
+        }
+      ).sharedManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('Manager failed')),
+      };
+
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const result = await client.getAccessToken();
+
+      expect(result.token).toBeUndefined();
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should handle missing credentials gracefully', async () => {
+      // No credentials set
+      client.setCredentials({});
+
+      // Override the client's SharedTokenManager instance directly to ensure it fails
+      (
+        client as unknown as {
+          sharedManager: {
+            getValidCredentials: () => Promise<QwenCredentials>;
+          };
+        }
+      ).sharedManager = {
+        getValidCredentials: vi
+          .fn()
+          .mockRejectedValue(new Error('No credentials')),
+      };
+
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const result = await client.getAccessToken();
+
+      expect(result.token).toBeUndefined();
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('Enhanced requestDeviceAuthorization scenarios', () => {
+    it('should include x-request-id header', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          device_code: 'test-device-code',
+          user_code: 'TEST123',
+          verification_uri: 'https://chat.qwen.ai/device',
+          verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+          expires_in: 1800,
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await client.requestDeviceAuthorization({
+        scope: 'openid profile email model.completion',
+        code_challenge: 'test-challenge',
+        code_challenge_method: 'S256',
+      });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'x-request-id': expect.any(String),
+          }),
+        }),
+      );
+    });
+
+    it('should include correct Content-Type and Accept headers', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          device_code: 'test-device-code',
+          user_code: 'TEST123',
+          verification_uri: 'https://chat.qwen.ai/device',
+          verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+          expires_in: 1800,
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await client.requestDeviceAuthorization({
+        scope: 'openid profile email model.completion',
+        code_challenge: 'test-challenge',
+        code_challenge_method: 'S256',
+      });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: 'application/json',
+          }),
+        }),
+      );
+    });
+
+    it('should send correct form data', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          device_code: 'test-device-code',
+          user_code: 'TEST123',
+          verification_uri: 'https://chat.qwen.ai/device',
+          verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+          expires_in: 1800,
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await client.requestDeviceAuthorization({
+        scope: 'test-scope',
+        code_challenge: 'test-challenge',
+        code_challenge_method: 'S256',
+      });
+
+      const [, options] = vi.mocked(global.fetch).mock.calls[0];
+      expect(options?.body).toContain(
+        'client_id=f0304373b74a44d2b584a3fb70ca9e56',
+      );
+      expect(options?.body).toContain('scope=test-scope');
+      expect(options?.body).toContain('code_challenge=test-challenge');
+      expect(options?.body).toContain('code_challenge_method=S256');
+    });
+  });
+
+  describe('Enhanced pollDeviceToken scenarios', () => {
+    it('should handle JSON parsing error during error response', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        json: vi.fn().mockRejectedValue(new Error('Invalid JSON')),
+        text: vi.fn().mockResolvedValue('Invalid request format'),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(
+        mockResponse as unknown as Response,
+      );
+
+      await expect(
+        client.pollDeviceToken({
+          device_code: 'test-device-code',
+          code_verifier: 'test-verifier',
+        }),
+      ).rejects.toThrow('Device token poll failed: 400 Bad Request');
+    });
+
+    it('should include status code in thrown errors', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        json: vi.fn().mockRejectedValue(new Error('Invalid JSON')),
+        text: vi.fn().mockResolvedValue('Internal server error'),
+      };
+
+      global.fetch = vi
+        .fn()
+        .mockResolvedValue(mockResponse as unknown as Response);
+
+      await expect(
+        client.pollDeviceToken({
+          device_code: 'test-device-code',
+          code_verifier: 'test-verifier',
+        }),
+      ).rejects.toMatchObject({
+        message: expect.stringContaining(
+          'Device token poll failed: 500 Internal Server Error',
+        ),
+        status: 500,
+      });
+    });
+
+    it('should handle authorization_pending with correct status', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        json: vi.fn().mockResolvedValue({
+          error: 'authorization_pending',
+          error_description: 'Authorization request is pending',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(
+        mockResponse as unknown as Response,
+      );
+
+      const result = await client.pollDeviceToken({
+        device_code: 'test-device-code',
+        code_verifier: 'test-verifier',
+      });
+
+      expect(result).toEqual({ status: 'pending' });
+    });
+  });
+
+  describe('Enhanced refreshAccessToken scenarios', () => {
+    it('should call clearQwenCredentials on 400 error', async () => {
+      client.setCredentials({
+        refresh_token: 'expired-refresh',
+      });
+
+      const { promises: fs } = await import('node:fs');
+      vi.mocked(fs.unlink).mockResolvedValue(undefined);
+
+      const mockResponse = {
+        ok: false,
+        status: 400,
+        text: async () => 'Bad Request',
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await expect(client.refreshAccessToken()).rejects.toThrow(
+        "Refresh token expired or invalid. Please use '/auth' to re-authenticate.",
+      );
+
+      expect(fs.unlink).toHaveBeenCalled();
+    });
+
+    it('should preserve existing refresh token when new one not provided', async () => {
+      const originalRefreshToken = 'original-refresh-token';
+      client.setCredentials({
+        refresh_token: originalRefreshToken,
+      });
+
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-access-token',
+          token_type: 'Bearer',
+          expires_in: 3600,
+          // No refresh_token in response
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await client.refreshAccessToken();
+
+      const credentials = client.getCredentials();
+      expect(credentials.refresh_token).toBe(originalRefreshToken);
+    });
+
+    it('should include resource_url when provided in response', async () => {
+      client.setCredentials({
+        refresh_token: 'test-refresh',
+      });
+
+      const mockResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-access-token',
+          token_type: 'Bearer',
+          expires_in: 3600,
+          resource_url: 'https://new-resource-url.com',
+        }),
+      };
+
+      vi.mocked(global.fetch).mockResolvedValue(mockResponse as Response);
+
+      await client.refreshAccessToken();
+
+      const credentials = client.getCredentials();
+      expect(credentials.resource_url).toBe('https://new-resource-url.com');
+    });
+  });
+
+  describe('isTokenValid edge cases', () => {
+    it('should return false for tokens expiring within buffer time', () => {
+      const nearExpiryTime = Date.now() + 15000; // 15 seconds from now (within 30s buffer)
+
+      client.setCredentials({
+        access_token: 'test-token',
+        expiry_date: nearExpiryTime,
+      });
+
+      const isValid = (
+        client as unknown as { isTokenValid(): boolean }
+      ).isTokenValid();
+      expect(isValid).toBe(false);
+    });
+
+    it('should return true for tokens expiring well beyond buffer time', () => {
+      const futureExpiryTime = Date.now() + 120000; // 2 minutes from now (beyond 30s buffer)
+
+      client.setCredentials({
+        access_token: 'test-token',
+        expiry_date: futureExpiryTime,
+      });
+
+      const isValid = (
+        client as unknown as { isTokenValid(): boolean }
+      ).isTokenValid();
+      expect(isValid).toBe(true);
+    });
+  });
+});
+
+describe('SharedTokenManager Integration in QwenOAuth2Client', () => {
+  let client: QwenOAuth2Client;
+
+  beforeEach(() => {
+    client = new QwenOAuth2Client();
+  });
+
+  it('should use SharedTokenManager instance in constructor', () => {
+    const sharedManager = (
+      client as unknown as { sharedManager: MockSharedTokenManager }
+    ).sharedManager;
+    expect(sharedManager).toBeDefined();
+  });
+
+  it('should handle TokenManagerError types correctly in getQwenOAuthClient', async () => {
+    const mockConfig = {
+      isBrowserLaunchSuppressed: vi.fn().mockReturnValue(true),
+    } as unknown as Config;
+
+    // Test different TokenManagerError types
+    const tokenErrors = [
+      { type: TokenError.NO_REFRESH_TOKEN, message: 'No refresh token' },
+      { type: TokenError.REFRESH_FAILED, message: 'Token refresh failed' },
+      { type: TokenError.NETWORK_ERROR, message: 'Network error' },
+      { type: TokenError.REFRESH_FAILED, message: 'Refresh failed' },
+    ];
+
+    for (const errorInfo of tokenErrors) {
+      const tokenError = new TokenManagerError(
+        errorInfo.type,
+        errorInfo.message,
+      );
+
+      const mockTokenManager = {
+        getValidCredentials: vi.fn().mockRejectedValue(tokenError),
+      };
+
+      const originalGetInstance = SharedTokenManager.getInstance;
+      SharedTokenManager.getInstance = vi
+        .fn()
+        .mockReturnValue(mockTokenManager);
+
+      const { promises: fs } = await import('node:fs');
+      vi.mocked(fs.readFile).mockRejectedValue(new Error('No cached file'));
+
+      // Mock device flow to succeed
+      const mockAuthResponse = {
+        ok: true,
+        json: async () => ({
+          device_code: 'test-device-code',
+          user_code: 'TEST123',
+          verification_uri: 'https://chat.qwen.ai/device',
+          verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+          expires_in: 1800,
+        }),
+      };
+
+      const mockTokenResponse = {
+        ok: true,
+        json: async () => ({
+          access_token: 'new-token',
+          refresh_token: 'new-refresh',
+          token_type: 'Bearer',
+          expires_in: 3600,
+        }),
+      };
+
+      global.fetch = vi
+        .fn()
+        .mockResolvedValueOnce(mockAuthResponse as Response)
+        .mockResolvedValue(mockTokenResponse as Response);
+
+      try {
+        await import('./qwenOAuth2.js').then((module) =>
+          module.getQwenOAuthClient(mockConfig),
+        );
+      } catch {
+        // Expected to fail in test environment
+      }
+
+      SharedTokenManager.getInstance = originalGetInstance;
+      vi.clearAllMocks();
+    }
+  });
+});
+
+describe('Constants and Configuration', () => {
+  it('should have correct OAuth endpoints', async () => {
+    // Test that the constants are properly defined by checking they're used in requests
+    const client = new QwenOAuth2Client();
+
+    const mockResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      }),
+    };
+
+    global.fetch = vi.fn().mockResolvedValue(mockResponse as Response);
+
+    await client.requestDeviceAuthorization({
+      scope: 'test-scope',
+      code_challenge: 'test-challenge',
+      code_challenge_method: 'S256',
+    });
+
+    const [url] = vi.mocked(global.fetch).mock.calls[0];
+    expect(url).toBe('https://chat.qwen.ai/api/v1/oauth2/device/code');
+  });
+
+  it('should use correct client ID in requests', async () => {
+    const client = new QwenOAuth2Client();
+
+    const mockResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      }),
+    };
+
+    global.fetch = vi.fn().mockResolvedValue(mockResponse as Response);
+
+    await client.requestDeviceAuthorization({
+      scope: 'test-scope',
+      code_challenge: 'test-challenge',
+      code_challenge_method: 'S256',
+    });
+
+    const [, options] = vi.mocked(global.fetch).mock.calls[0];
+    expect(options?.body).toContain(
+      'client_id=f0304373b74a44d2b584a3fb70ca9e56',
+    );
+  });
+
+  it('should use correct default scope', async () => {
+    // Test the default scope constant by checking it's used in device flow
+    const client = new QwenOAuth2Client();
+
+    const mockResponse = {
+      ok: true,
+      json: async () => ({
+        device_code: 'test-device-code',
+        user_code: 'TEST123',
+        verification_uri: 'https://chat.qwen.ai/device',
+        verification_uri_complete: 'https://chat.qwen.ai/device?code=TEST123',
+        expires_in: 1800,
+      }),
+    };
+
+    global.fetch = vi.fn().mockResolvedValue(mockResponse as Response);
+
+    await client.requestDeviceAuthorization({
+      scope: 'openid profile email model.completion',
+      code_challenge: 'test-challenge',
+      code_challenge_method: 'S256',
+    });
+
+    const [, options] = vi.mocked(global.fetch).mock.calls[0];
+    expect(options?.body).toContain(
+      'scope=openid%20profile%20email%20model.completion',
+    );
+  });
+});

projects/ui/qwen-code/packages/core/src/qwen/qwenOAuth2.ts

@@ -0,0 +1,884 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import crypto from 'crypto';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import * as os from 'os';
+
+import open from 'open';
+import { EventEmitter } from 'events';
+import { Config } from '../config/config.js';
+import { randomUUID } from 'node:crypto';
+import {
+  SharedTokenManager,
+  TokenManagerError,
+  TokenError,
+} from './sharedTokenManager.js';
+
+// OAuth Endpoints
+const QWEN_OAUTH_BASE_URL = 'https://chat.qwen.ai';
+
+const QWEN_OAUTH_DEVICE_CODE_ENDPOINT = `${QWEN_OAUTH_BASE_URL}/api/v1/oauth2/device/code`;
+const QWEN_OAUTH_TOKEN_ENDPOINT = `${QWEN_OAUTH_BASE_URL}/api/v1/oauth2/token`;
+
+// OAuth Client Configuration
+const QWEN_OAUTH_CLIENT_ID = 'f0304373b74a44d2b584a3fb70ca9e56';
+
+const QWEN_OAUTH_SCOPE = 'openid profile email model.completion';
+const QWEN_OAUTH_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:device_code';
+
+// File System Configuration
+const QWEN_DIR = '.qwen';
+const QWEN_CREDENTIAL_FILENAME = 'oauth_creds.json';
+
+// Token Configuration
+const TOKEN_REFRESH_BUFFER_MS = 30 * 1000; // 30 seconds
+
+/**
+ * PKCE (Proof Key for Code Exchange) utilities
+ * Implements RFC 7636 - Proof Key for Code Exchange by OAuth Public Clients
+ */
+
+/**
+ * Generate a random code verifier for PKCE
+ * @returns A random string of 43-128 characters
+ */
+export function generateCodeVerifier(): string {
+  return crypto.randomBytes(32).toString('base64url');
+}
+
+/**
+ * Generate a code challenge from a code verifier using SHA-256
+ * @param codeVerifier The code verifier string
+ * @returns The code challenge string
+ */
+export function generateCodeChallenge(codeVerifier: string): string {
+  const hash = crypto.createHash('sha256');
+  hash.update(codeVerifier);
+  return hash.digest('base64url');
+}
+
+/**
+ * Generate PKCE code verifier and challenge pair
+ * @returns Object containing code_verifier and code_challenge
+ */
+export function generatePKCEPair(): {
+  code_verifier: string;
+  code_challenge: string;
+} {
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = generateCodeChallenge(codeVerifier);
+  return { code_verifier: codeVerifier, code_challenge: codeChallenge };
+}
+
+/**
+ * Convert object to URL-encoded form data
+ * @param data The object to convert
+ * @returns URL-encoded string
+ */
+function objectToUrlEncoded(data: Record<string, string>): string {
+  return Object.keys(data)
+    .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
+    .join('&');
+}
+
+/**
+ * Standard error response data
+ */
+export interface ErrorData {
+  error: string;
+  error_description: string;
+}
+
+/**
+ * Qwen OAuth2 credentials interface
+ */
+export interface QwenCredentials {
+  access_token?: string;
+  refresh_token?: string;
+  id_token?: string;
+  expiry_date?: number;
+  token_type?: string;
+  resource_url?: string;
+}
+
+/**
+ * Device authorization success data
+ */
+export interface DeviceAuthorizationData {
+  device_code: string;
+  user_code: string;
+  verification_uri: string;
+  verification_uri_complete: string;
+  expires_in: number;
+}
+
+/**
+ * Device authorization response interface
+ */
+export type DeviceAuthorizationResponse = DeviceAuthorizationData | ErrorData;
+
+/**
+ * Type guard to check if device authorization was successful
+ */
+export function isDeviceAuthorizationSuccess(
+  response: DeviceAuthorizationResponse,
+): response is DeviceAuthorizationData {
+  return 'device_code' in response;
+}
+
+/**
+ * Device token success data
+ */
+export interface DeviceTokenData {
+  access_token: string | null;
+  refresh_token?: string | null;
+  token_type: string;
+  expires_in: number | null;
+  scope?: string | null;
+  endpoint?: string;
+  resource_url?: string;
+}
+
+/**
+ * Device token pending response
+ */
+export interface DeviceTokenPendingData {
+  status: 'pending';
+  slowDown?: boolean; // Indicates if client should increase polling interval
+}
+
+/**
+ * Device token response interface
+ */
+export type DeviceTokenResponse =
+  | DeviceTokenData
+  | DeviceTokenPendingData
+  | ErrorData;
+
+/**
+ * Type guard to check if device token response was successful
+ */
+export function isDeviceTokenSuccess(
+  response: DeviceTokenResponse,
+): response is DeviceTokenData {
+  return (
+    'access_token' in response &&
+    response.access_token !== null &&
+    response.access_token !== undefined &&
+    typeof response.access_token === 'string' &&
+    response.access_token.length > 0
+  );
+}
+
+/**
+ * Type guard to check if device token response is pending
+ */
+export function isDeviceTokenPending(
+  response: DeviceTokenResponse,
+): response is DeviceTokenPendingData {
+  return (
+    'status' in response &&
+    (response as DeviceTokenPendingData).status === 'pending'
+  );
+}
+
+/**
+ * Type guard to check if response is an error
+ */
+export function isErrorResponse(
+  response:
+    | DeviceAuthorizationResponse
+    | DeviceTokenResponse
+    | TokenRefreshResponse,
+): response is ErrorData {
+  return 'error' in response;
+}
+
+/**
+ * Token refresh success data
+ */
+export interface TokenRefreshData {
+  access_token: string;
+  token_type: string;
+  expires_in: number;
+  refresh_token?: string; // Some OAuth servers may return a new refresh token
+  resource_url?: string;
+}
+
+/**
+ * Token refresh response interface
+ */
+export type TokenRefreshResponse = TokenRefreshData | ErrorData;
+
+/**
+ * Qwen OAuth2 client interface
+ */
+export interface IQwenOAuth2Client {
+  setCredentials(credentials: QwenCredentials): void;
+  getCredentials(): QwenCredentials;
+  getAccessToken(): Promise<{ token?: string }>;
+  requestDeviceAuthorization(options: {
+    scope: string;
+    code_challenge: string;
+    code_challenge_method: string;
+  }): Promise<DeviceAuthorizationResponse>;
+  pollDeviceToken(options: {
+    device_code: string;
+    code_verifier: string;
+  }): Promise<DeviceTokenResponse>;
+  refreshAccessToken(): Promise<TokenRefreshResponse>;
+}
+
+/**
+ * Qwen OAuth2 client implementation
+ */
+export class QwenOAuth2Client implements IQwenOAuth2Client {
+  private credentials: QwenCredentials = {};
+  private sharedManager: SharedTokenManager;
+
+  constructor() {
+    this.sharedManager = SharedTokenManager.getInstance();
+  }
+
+  setCredentials(credentials: QwenCredentials): void {
+    this.credentials = credentials;
+  }
+
+  getCredentials(): QwenCredentials {
+    return this.credentials;
+  }
+
+  async getAccessToken(): Promise<{ token?: string }> {
+    try {
+      // Use shared manager to get valid credentials with cross-session synchronization
+      const credentials = await this.sharedManager.getValidCredentials(this);
+      return { token: credentials.access_token };
+    } catch (error) {
+      console.warn('Failed to get access token from shared manager:', error);
+
+      // Only return cached token if it's still valid, don't refresh uncoordinated
+      // This prevents the cross-session token invalidation issue
+      if (this.credentials.access_token && this.isTokenValid()) {
+        return { token: this.credentials.access_token };
+      }
+
+      // If we can't get valid credentials through shared manager, fail gracefully
+      // All token refresh operations should go through the SharedTokenManager
+      return { token: undefined };
+    }
+  }
+
+  async requestDeviceAuthorization(options: {
+    scope: string;
+    code_challenge: string;
+    code_challenge_method: string;
+  }): Promise<DeviceAuthorizationResponse> {
+    const bodyData = {
+      client_id: QWEN_OAUTH_CLIENT_ID,
+      scope: options.scope,
+      code_challenge: options.code_challenge,
+      code_challenge_method: options.code_challenge_method,
+    };
+
+    const response = await fetch(QWEN_OAUTH_DEVICE_CODE_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Accept: 'application/json',
+        'x-request-id': randomUUID(),
+      },
+      body: objectToUrlEncoded(bodyData),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.text();
+      throw new Error(
+        `Device authorization failed: ${response.status} ${response.statusText}. Response: ${errorData}`,
+      );
+    }
+
+    const result = (await response.json()) as DeviceAuthorizationResponse;
+    console.debug('Device authorization result:', result);
+
+    // Check if the response indicates success
+    if (!isDeviceAuthorizationSuccess(result)) {
+      const errorData = result as ErrorData;
+      throw new Error(
+        `Device authorization failed: ${errorData?.error || 'Unknown error'} - ${errorData?.error_description || 'No details provided'}`,
+      );
+    }
+
+    return result;
+  }
+
+  async pollDeviceToken(options: {
+    device_code: string;
+    code_verifier: string;
+  }): Promise<DeviceTokenResponse> {
+    const bodyData = {
+      grant_type: QWEN_OAUTH_GRANT_TYPE,
+      client_id: QWEN_OAUTH_CLIENT_ID,
+      device_code: options.device_code,
+      code_verifier: options.code_verifier,
+    };
+
+    const response = await fetch(QWEN_OAUTH_TOKEN_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Accept: 'application/json',
+      },
+      body: objectToUrlEncoded(bodyData),
+    });
+
+    if (!response.ok) {
+      // Parse the response as JSON to check for OAuth RFC 8628 standard errors
+      try {
+        const errorData = (await response.json()) as ErrorData;
+
+        // According to OAuth RFC 8628, handle standard polling responses
+        if (
+          response.status === 400 &&
+          errorData.error === 'authorization_pending'
+        ) {
+          // User has not yet approved the authorization request. Continue polling.
+          return { status: 'pending' } as DeviceTokenPendingData;
+        }
+
+        if (response.status === 429 && errorData.error === 'slow_down') {
+          // Client is polling too frequently. Return pending with slowDown flag.
+          return {
+            status: 'pending',
+            slowDown: true,
+          } as DeviceTokenPendingData;
+        }
+
+        // Handle other 400 errors (access_denied, expired_token, etc.) as real errors
+
+        // For other errors, throw with proper error information
+        const error = new Error(
+          `Device token poll failed: ${errorData.error || 'Unknown error'} - ${errorData.error_description || 'No details provided'}`,
+        );
+        (error as Error & { status?: number }).status = response.status;
+        throw error;
+      } catch (_parseError) {
+        // If JSON parsing fails, fall back to text response
+        const errorData = await response.text();
+        const error = new Error(
+          `Device token poll failed: ${response.status} ${response.statusText}. Response: ${errorData}`,
+        );
+        (error as Error & { status?: number }).status = response.status;
+        throw error;
+      }
+    }
+
+    return (await response.json()) as DeviceTokenResponse;
+  }
+
+  async refreshAccessToken(): Promise<TokenRefreshResponse> {
+    if (!this.credentials.refresh_token) {
+      throw new Error('No refresh token available');
+    }
+
+    const bodyData = {
+      grant_type: 'refresh_token',
+      refresh_token: this.credentials.refresh_token,
+      client_id: QWEN_OAUTH_CLIENT_ID,
+    };
+
+    const response = await fetch(QWEN_OAUTH_TOKEN_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Accept: 'application/json',
+      },
+      body: objectToUrlEncoded(bodyData),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.text();
+      // Handle 401 errors which might indicate refresh token expiry
+      if (response.status === 400) {
+        await clearQwenCredentials();
+        throw new Error(
+          "Refresh token expired or invalid. Please use '/auth' to re-authenticate.",
+        );
+      }
+      throw new Error(
+        `Token refresh failed: ${response.status} ${response.statusText}. Response: ${errorData}`,
+      );
+    }
+
+    const responseData = (await response.json()) as TokenRefreshResponse;
+
+    // Check if the response indicates success
+    if (isErrorResponse(responseData)) {
+      const errorData = responseData as ErrorData;
+      throw new Error(
+        `Token refresh failed: ${errorData?.error || 'Unknown error'} - ${errorData?.error_description || 'No details provided'}`,
+      );
+    }
+
+    // Handle successful response
+    const tokenData = responseData as TokenRefreshData;
+    const tokens: QwenCredentials = {
+      access_token: tokenData.access_token,
+      token_type: tokenData.token_type,
+      // Use new refresh token if provided, otherwise preserve existing one
+      refresh_token: tokenData.refresh_token || this.credentials.refresh_token,
+      resource_url: tokenData.resource_url, // Include resource_url if provided
+      expiry_date: Date.now() + tokenData.expires_in * 1000,
+    };
+
+    this.setCredentials(tokens);
+
+    // Note: File caching is now handled by SharedTokenManager
+    // to prevent cross-session token invalidation issues
+
+    return responseData;
+  }
+
+  private isTokenValid(): boolean {
+    if (!this.credentials.expiry_date) {
+      return false;
+    }
+    // Check if token expires within the refresh buffer time
+    return Date.now() < this.credentials.expiry_date - TOKEN_REFRESH_BUFFER_MS;
+  }
+}
+
+export enum QwenOAuth2Event {
+  AuthUri = 'auth-uri',
+  AuthProgress = 'auth-progress',
+  AuthCancel = 'auth-cancel',
+}
+
+/**
+ * Authentication result types to distinguish different failure reasons
+ */
+export type AuthResult =
+  | { success: true }
+  | {
+      success: false;
+      reason: 'timeout' | 'cancelled' | 'error' | 'rate_limit';
+    };
+
+/**
+ * Global event emitter instance for QwenOAuth2 authentication events
+ */
+export const qwenOAuth2Events = new EventEmitter();
+
+export async function getQwenOAuthClient(
+  config: Config,
+): Promise<QwenOAuth2Client> {
+  const client = new QwenOAuth2Client();
+
+  // Use shared token manager to get valid credentials with cross-session synchronization
+  const sharedManager = SharedTokenManager.getInstance();
+
+  try {
+    // Try to get valid credentials from shared cache first
+    const credentials = await sharedManager.getValidCredentials(client);
+    client.setCredentials(credentials);
+    return client;
+  } catch (error: unknown) {
+    console.debug(
+      'Shared token manager failed, attempting device flow:',
+      error,
+    );
+
+    // Handle specific token manager errors
+    if (error instanceof TokenManagerError) {
+      switch (error.type) {
+        case TokenError.NO_REFRESH_TOKEN:
+          console.debug(
+            'No refresh token available, proceeding with device flow',
+          );
+          break;
+        case TokenError.REFRESH_FAILED:
+          console.debug('Token refresh failed, proceeding with device flow');
+          break;
+        case TokenError.NETWORK_ERROR:
+          console.warn(
+            'Network error during token refresh, trying device flow',
+          );
+          break;
+        default:
+          console.warn('Token manager error:', (error as Error).message);
+      }
+    }
+
+    // If shared manager fails, check if we have cached credentials for device flow
+    if (await loadCachedQwenCredentials(client)) {
+      // We have cached credentials but they might be expired
+      // Try device flow instead of forcing refresh
+      const result = await authWithQwenDeviceFlow(client, config);
+      if (!result.success) {
+        throw new Error('Qwen OAuth authentication failed');
+      }
+      return client;
+    }
+
+    // No cached credentials, use device authorization flow for authentication
+    const result = await authWithQwenDeviceFlow(client, config);
+    if (!result.success) {
+      // Only emit timeout event if the failure reason is actually timeout
+      // Other error types (401, 429, etc.) have already emitted their specific events
+      if (result.reason === 'timeout') {
+        qwenOAuth2Events.emit(
+          QwenOAuth2Event.AuthProgress,
+          'timeout',
+          'Authentication timed out. Please try again or select a different authentication method.',
+        );
+      }
+
+      // Throw error with appropriate message based on failure reason
+      switch (result.reason) {
+        case 'timeout':
+          throw new Error('Qwen OAuth authentication timed out');
+        case 'cancelled':
+          throw new Error('Qwen OAuth authentication was cancelled by user');
+        case 'rate_limit':
+          throw new Error(
+            'Too many request for Qwen OAuth authentication, please try again later.',
+          );
+        case 'error':
+        default:
+          throw new Error('Qwen OAuth authentication failed');
+      }
+    }
+
+    return client;
+  }
+}
+
+async function authWithQwenDeviceFlow(
+  client: QwenOAuth2Client,
+  config: Config,
+): Promise<AuthResult> {
+  let isCancelled = false;
+
+  // Set up cancellation listener
+  const cancelHandler = () => {
+    isCancelled = true;
+  };
+  qwenOAuth2Events.once(QwenOAuth2Event.AuthCancel, cancelHandler);
+
+  try {
+    // Generate PKCE code verifier and challenge
+    const { code_verifier, code_challenge } = generatePKCEPair();
+
+    // Request device authorization
+    const deviceAuth = await client.requestDeviceAuthorization({
+      scope: QWEN_OAUTH_SCOPE,
+      code_challenge,
+      code_challenge_method: 'S256',
+    });
+
+    // Ensure we have a successful authorization response
+    if (!isDeviceAuthorizationSuccess(deviceAuth)) {
+      const errorData = deviceAuth as ErrorData;
+      throw new Error(
+        `Device authorization failed: ${errorData?.error || 'Unknown error'} - ${errorData?.error_description || 'No details provided'}`,
+      );
+    }
+
+    // Emit device authorization event for UI integration immediately
+    qwenOAuth2Events.emit(QwenOAuth2Event.AuthUri, deviceAuth);
+
+    const showFallbackMessage = () => {
+      console.log('\n=== Qwen OAuth Device Authorization ===');
+      console.log(
+        'Please visit the following URL in your browser to authorize:',
+      );
+      console.log(`\n${deviceAuth.verification_uri_complete}\n`);
+      console.log('Waiting for authorization to complete...\n');
+    };
+
+    // If browser launch is not suppressed, try to open the URL
+    if (!config.isBrowserLaunchSuppressed()) {
+      try {
+        const childProcess = await open(deviceAuth.verification_uri_complete);
+
+        // IMPORTANT: Attach an error handler to the returned child process.
+        // Without this, if `open` fails to spawn a process (e.g., `xdg-open` is not found
+        // in a minimal Docker container), it will emit an unhandled 'error' event,
+        // causing the entire Node.js process to crash.
+        if (childProcess) {
+          childProcess.on('error', () => {
+            console.debug(
+              'Failed to open browser. Visit this URL to authorize:',
+            );
+            showFallbackMessage();
+          });
+        }
+      } catch (_err) {
+        showFallbackMessage();
+      }
+    } else {
+      // Browser launch is suppressed, show fallback message
+      showFallbackMessage();
+    }
+
+    // Emit auth progress event
+    qwenOAuth2Events.emit(
+      QwenOAuth2Event.AuthProgress,
+      'polling',
+      'Waiting for authorization...',
+    );
+
+    console.debug('Waiting for authorization...\n');
+
+    // Poll for the token
+    let pollInterval = 2000; // 2 seconds, can be increased if slow_down is received
+    const maxAttempts = Math.ceil(
+      deviceAuth.expires_in / (pollInterval / 1000),
+    );
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      // Check if authentication was cancelled
+      if (isCancelled) {
+        console.debug('\nAuthentication cancelled by user.');
+        qwenOAuth2Events.emit(
+          QwenOAuth2Event.AuthProgress,
+          'error',
+          'Authentication cancelled by user.',
+        );
+        return { success: false, reason: 'cancelled' };
+      }
+
+      try {
+        console.debug('polling for token...');
+        const tokenResponse = await client.pollDeviceToken({
+          device_code: deviceAuth.device_code,
+          code_verifier,
+        });
+
+        // Check if the response is successful and contains token data
+        if (isDeviceTokenSuccess(tokenResponse)) {
+          const tokenData = tokenResponse as DeviceTokenData;
+
+          // Convert to QwenCredentials format
+          const credentials: QwenCredentials = {
+            access_token: tokenData.access_token!, // Safe to assert as non-null due to isDeviceTokenSuccess check
+            refresh_token: tokenData.refresh_token || undefined,
+            token_type: tokenData.token_type,
+            resource_url: tokenData.resource_url,
+            expiry_date: tokenData.expires_in
+              ? Date.now() + tokenData.expires_in * 1000
+              : undefined,
+          };
+
+          client.setCredentials(credentials);
+
+          // Cache the new tokens
+          await cacheQwenCredentials(credentials);
+
+          // Emit auth progress success event
+          qwenOAuth2Events.emit(
+            QwenOAuth2Event.AuthProgress,
+            'success',
+            'Authentication successful! Access token obtained.',
+          );
+
+          console.debug('Authentication successful! Access token obtained.');
+          return { success: true };
+        }
+
+        // Check if the response is pending
+        if (isDeviceTokenPending(tokenResponse)) {
+          const pendingData = tokenResponse as DeviceTokenPendingData;
+
+          // Handle slow_down error by increasing poll interval
+          if (pendingData.slowDown) {
+            pollInterval = Math.min(pollInterval * 1.5, 10000); // Increase by 50%, max 10 seconds
+            console.debug(
+              `\nServer requested to slow down, increasing poll interval to ${pollInterval}ms'`,
+            );
+          } else {
+            pollInterval = 2000; // Reset to default interval
+          }
+
+          // Emit polling progress event
+          qwenOAuth2Events.emit(
+            QwenOAuth2Event.AuthProgress,
+            'polling',
+            `Polling... (attempt ${attempt + 1}/${maxAttempts})`,
+          );
+
+          process.stdout.write('.');
+
+          // Wait with cancellation check every 100ms
+          await new Promise<void>((resolve) => {
+            const checkInterval = 100; // Check every 100ms
+            let elapsedTime = 0;
+
+            const intervalId = setInterval(() => {
+              elapsedTime += checkInterval;
+
+              // Check for cancellation during wait
+              if (isCancelled) {
+                clearInterval(intervalId);
+                resolve();
+                return;
+              }
+
+              // Complete wait when interval is reached
+              if (elapsedTime >= pollInterval) {
+                clearInterval(intervalId);
+                resolve();
+                return;
+              }
+            }, checkInterval);
+          });
+
+          // Check for cancellation after waiting
+          if (isCancelled) {
+            console.debug('\nAuthentication cancelled by user.');
+            qwenOAuth2Events.emit(
+              QwenOAuth2Event.AuthProgress,
+              'error',
+              'Authentication cancelled by user.',
+            );
+            return { success: false, reason: 'cancelled' };
+          }
+
+          continue;
+        }
+
+        // Handle error response
+        if (isErrorResponse(tokenResponse)) {
+          const errorData = tokenResponse as ErrorData;
+          throw new Error(
+            `Token polling failed: ${errorData?.error || 'Unknown error'} - ${errorData?.error_description || 'No details provided'}`,
+          );
+        }
+      } catch (error: unknown) {
+        // Handle specific error cases
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        const statusCode =
+          error instanceof Error
+            ? (error as Error & { status?: number }).status
+            : null;
+
+        if (errorMessage.includes('401') || statusCode === 401) {
+          const message =
+            'Device code expired or invalid, please restart the authorization process.';
+
+          // Emit error event
+          qwenOAuth2Events.emit(QwenOAuth2Event.AuthProgress, 'error', message);
+
+          return { success: false, reason: 'error' };
+        }
+
+        // Handle 429 Too Many Requests error
+        if (errorMessage.includes('429') || statusCode === 429) {
+          const message =
+            'Too many requests. The server is rate limiting our requests. Please select a different authentication method or try again later.';
+
+          // Emit rate limit event to notify user
+          qwenOAuth2Events.emit(
+            QwenOAuth2Event.AuthProgress,
+            'rate_limit',
+            message,
+          );
+
+          console.log('\n' + message);
+
+          // Return false to stop polling and go back to auth selection
+          return { success: false, reason: 'rate_limit' };
+        }
+
+        const message = `Error polling for token: ${errorMessage}`;
+
+        // Emit error event
+        qwenOAuth2Events.emit(QwenOAuth2Event.AuthProgress, 'error', message);
+
+        // Check for cancellation before waiting
+        if (isCancelled) {
+          return { success: false, reason: 'cancelled' };
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      }
+    }
+
+    const timeoutMessage = 'Authorization timeout, please restart the process.';
+
+    // Emit timeout error event
+    qwenOAuth2Events.emit(
+      QwenOAuth2Event.AuthProgress,
+      'timeout',
+      timeoutMessage,
+    );
+
+    console.error('\n' + timeoutMessage);
+    return { success: false, reason: 'timeout' };
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error('Device authorization flow failed:', errorMessage);
+    return { success: false, reason: 'error' };
+  } finally {
+    // Clean up event listener
+    qwenOAuth2Events.off(QwenOAuth2Event.AuthCancel, cancelHandler);
+  }
+}
+
+async function loadCachedQwenCredentials(
+  client: QwenOAuth2Client,
+): Promise<boolean> {
+  try {
+    const keyFile = getQwenCachedCredentialPath();
+    const creds = await fs.readFile(keyFile, 'utf-8');
+    const credentials = JSON.parse(creds) as QwenCredentials;
+    client.setCredentials(credentials);
+
+    // Verify that the credentials are still valid
+    const { token } = await client.getAccessToken();
+    if (!token) {
+      return false;
+    }
+
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+async function cacheQwenCredentials(credentials: QwenCredentials) {
+  const filePath = getQwenCachedCredentialPath();
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+
+  const credString = JSON.stringify(credentials, null, 2);
+  await fs.writeFile(filePath, credString);
+}
+
+/**
+ * Clear cached Qwen credentials from disk
+ * This is useful when credentials have expired or need to be reset
+ */
+export async function clearQwenCredentials(): Promise<void> {
+  try {
+    const filePath = getQwenCachedCredentialPath();
+    await fs.unlink(filePath);
+    console.debug('Cached Qwen credentials cleared successfully.');
+  } catch (error: unknown) {
+    // If file doesn't exist or can't be deleted, we consider it cleared
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      // File doesn't exist, already cleared
+      return;
+    }
+    // Log other errors but don't throw - clearing credentials should be non-critical
+    console.warn('Warning: Failed to clear cached Qwen credentials:', error);
+  }
+}
+
+function getQwenCachedCredentialPath(): string {
+  return path.join(os.homedir(), QWEN_DIR, QWEN_CREDENTIAL_FILENAME);
+}

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

@@ -0,0 +1,758 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { promises as fs, unlinkSync, type Stats } from 'node:fs';
+import * as os from 'os';
+import path from 'node:path';
+
+import {
+  SharedTokenManager,
+  TokenManagerError,
+  TokenError,
+} from './sharedTokenManager.js';
+import type {
+  IQwenOAuth2Client,
+  QwenCredentials,
+  TokenRefreshData,
+  ErrorData,
+} from './qwenOAuth2.js';
+
+// Mock external dependencies
+vi.mock('node:fs', () => ({
+  promises: {
+    stat: vi.fn(),
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+    unlink: vi.fn(),
+  },
+  unlinkSync: vi.fn(),
+}));
+
+vi.mock('node:os', () => ({
+  homedir: vi.fn(),
+}));
+
+vi.mock('node:path', () => ({
+  default: {
+    join: vi.fn(),
+    dirname: vi.fn(),
+  },
+}));
+
+/**
+ * Helper to access private properties for testing
+ */
+function getPrivateProperty<T>(obj: unknown, property: string): T {
+  return (obj as Record<string, T>)[property];
+}
+
+/**
+ * Helper to set private properties for testing
+ */
+function setPrivateProperty<T>(obj: unknown, property: string, value: T): void {
+  (obj as Record<string, T>)[property] = value;
+}
+
+/**
+ * Creates a mock QwenOAuth2Client for testing
+ */
+function createMockQwenClient(
+  initialCredentials: Partial<QwenCredentials> = {},
+): IQwenOAuth2Client {
+  let credentials: QwenCredentials = {
+    access_token: 'mock_access_token',
+    refresh_token: 'mock_refresh_token',
+    token_type: 'Bearer',
+    expiry_date: Date.now() + 3600000, // 1 hour from now
+    resource_url: 'https://api.example.com',
+    ...initialCredentials,
+  };
+
+  return {
+    setCredentials: vi.fn((creds: QwenCredentials) => {
+      credentials = { ...credentials, ...creds };
+    }),
+    getCredentials: vi.fn(() => credentials),
+    getAccessToken: vi.fn(),
+    requestDeviceAuthorization: vi.fn(),
+    pollDeviceToken: vi.fn(),
+    refreshAccessToken: vi.fn(),
+  };
+}
+
+/**
+ * Creates valid mock credentials
+ */
+function createValidCredentials(
+  overrides: Partial<QwenCredentials> = {},
+): QwenCredentials {
+  return {
+    access_token: 'valid_access_token',
+    refresh_token: 'valid_refresh_token',
+    token_type: 'Bearer',
+    expiry_date: Date.now() + 3600000, // 1 hour from now
+    resource_url: 'https://api.example.com',
+    ...overrides,
+  };
+}
+
+/**
+ * Creates expired mock credentials
+ */
+function createExpiredCredentials(
+  overrides: Partial<QwenCredentials> = {},
+): QwenCredentials {
+  return {
+    access_token: 'expired_access_token',
+    refresh_token: 'expired_refresh_token',
+    token_type: 'Bearer',
+    expiry_date: Date.now() - 3600000, // 1 hour ago
+    resource_url: 'https://api.example.com',
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a successful token refresh response
+ */
+function createSuccessfulRefreshResponse(
+  overrides: Partial<TokenRefreshData> = {},
+): TokenRefreshData {
+  return {
+    access_token: 'fresh_access_token',
+    token_type: 'Bearer',
+    expires_in: 3600,
+    refresh_token: 'new_refresh_token',
+    resource_url: 'https://api.example.com',
+    ...overrides,
+  };
+}
+
+/**
+ * Creates an error response
+ */
+function createErrorResponse(
+  error = 'invalid_grant',
+  description = 'Token expired',
+): ErrorData {
+  return {
+    error,
+    error_description: description,
+  };
+}
+
+describe('SharedTokenManager', () => {
+  let tokenManager: SharedTokenManager;
+
+  // Get mocked modules
+  const mockFs = vi.mocked(fs);
+  const mockOs = vi.mocked(os);
+  const mockPath = vi.mocked(path);
+  const mockUnlinkSync = vi.mocked(unlinkSync);
+
+  beforeEach(() => {
+    // Clean up any existing instance's listeners first
+    const existingInstance = getPrivateProperty(
+      SharedTokenManager,
+      'instance',
+    ) as SharedTokenManager;
+    if (existingInstance) {
+      existingInstance.cleanup();
+    }
+
+    // Reset all mocks
+    vi.clearAllMocks();
+
+    // Setup default mock implementations
+    mockOs.homedir.mockReturnValue('/home/user');
+    mockPath.join.mockImplementation((...args) => args.join('/'));
+    mockPath.dirname.mockImplementation((filePath) => {
+      // Handle undefined/null input gracefully
+      if (!filePath || typeof filePath !== 'string') {
+        return '/home/user/.qwen'; // Return the expected directory path
+      }
+      const parts = filePath.split('/');
+      const result = parts.slice(0, -1).join('/');
+      return result || '/';
+    });
+
+    // Reset singleton instance for each test
+    setPrivateProperty(SharedTokenManager, 'instance', null);
+    tokenManager = SharedTokenManager.getInstance();
+  });
+
+  afterEach(() => {
+    // Clean up listeners after each test
+    if (tokenManager) {
+      tokenManager.cleanup();
+    }
+  });
+
+  describe('Singleton Pattern', () => {
+    it('should return the same instance when called multiple times', () => {
+      const instance1 = SharedTokenManager.getInstance();
+      const instance2 = SharedTokenManager.getInstance();
+
+      expect(instance1).toBe(instance2);
+      expect(instance1).toBe(tokenManager);
+    });
+
+    it('should create a new instance after reset', () => {
+      const instance1 = SharedTokenManager.getInstance();
+
+      // Reset singleton for testing
+      setPrivateProperty(SharedTokenManager, 'instance', null);
+      const instance2 = SharedTokenManager.getInstance();
+
+      expect(instance1).not.toBe(instance2);
+    });
+  });
+
+  describe('getValidCredentials', () => {
+    it('should return valid cached credentials without refresh', async () => {
+      const mockClient = createMockQwenClient();
+      const validCredentials = createValidCredentials();
+
+      // Mock file operations to indicate no file changes
+      mockFs.stat.mockResolvedValue({ mtimeMs: 1000 } as Stats);
+
+      // Manually set cached credentials
+      tokenManager.clearCache();
+      const memoryCache = getPrivateProperty<{
+        credentials: QwenCredentials | null;
+        fileModTime: number;
+        lastCheck: number;
+      }>(tokenManager, 'memoryCache');
+      memoryCache.credentials = validCredentials;
+      memoryCache.fileModTime = 1000;
+      memoryCache.lastCheck = Date.now();
+
+      const result = await tokenManager.getValidCredentials(mockClient);
+
+      expect(result).toEqual(validCredentials);
+      expect(mockClient.refreshAccessToken).not.toHaveBeenCalled();
+    });
+
+    it('should refresh expired credentials', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+      const refreshResponse = createSuccessfulRefreshResponse();
+
+      mockClient.refreshAccessToken = vi
+        .fn()
+        .mockResolvedValue(refreshResponse);
+
+      // Mock file operations
+      mockFs.stat.mockResolvedValue({ mtimeMs: 1000 } as Stats);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockFs.mkdir.mockResolvedValue(undefined);
+
+      const result = await tokenManager.getValidCredentials(mockClient);
+
+      expect(result.access_token).toBe(refreshResponse.access_token);
+      expect(mockClient.refreshAccessToken).toHaveBeenCalled();
+      expect(mockClient.setCredentials).toHaveBeenCalled();
+    });
+
+    it('should force refresh when forceRefresh is true', async () => {
+      const mockClient = createMockQwenClient(createValidCredentials());
+      const refreshResponse = createSuccessfulRefreshResponse();
+
+      mockClient.refreshAccessToken = vi
+        .fn()
+        .mockResolvedValue(refreshResponse);
+
+      // Mock file operations
+      mockFs.stat.mockResolvedValue({ mtimeMs: 1000 } as Stats);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockFs.mkdir.mockResolvedValue(undefined);
+
+      const result = await tokenManager.getValidCredentials(mockClient, true);
+
+      expect(result.access_token).toBe(refreshResponse.access_token);
+      expect(mockClient.refreshAccessToken).toHaveBeenCalled();
+    });
+
+    it('should throw TokenManagerError when refresh token is missing', async () => {
+      const mockClient = createMockQwenClient({
+        access_token: 'expired_token',
+        refresh_token: undefined, // No refresh token
+        expiry_date: Date.now() - 3600000,
+      });
+
+      await expect(
+        tokenManager.getValidCredentials(mockClient),
+      ).rejects.toThrow(TokenManagerError);
+
+      await expect(
+        tokenManager.getValidCredentials(mockClient),
+      ).rejects.toThrow('No refresh token available');
+    });
+
+    it('should throw TokenManagerError when refresh fails', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+      const errorResponse = createErrorResponse();
+
+      mockClient.refreshAccessToken = vi.fn().mockResolvedValue(errorResponse);
+
+      // Mock file operations
+      mockFs.stat.mockResolvedValue({ mtimeMs: 1000 } as Stats);
+
+      await expect(
+        tokenManager.getValidCredentials(mockClient),
+      ).rejects.toThrow(TokenManagerError);
+    });
+
+    it('should handle network errors during refresh', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+      const networkError = new Error('Network request failed');
+
+      mockClient.refreshAccessToken = vi.fn().mockRejectedValue(networkError);
+
+      // Mock file operations
+      mockFs.stat.mockResolvedValue({ mtimeMs: 1000 } as Stats);
+
+      await expect(
+        tokenManager.getValidCredentials(mockClient),
+      ).rejects.toThrow(TokenManagerError);
+    });
+
+    it('should wait for ongoing refresh and return same result', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+      const refreshResponse = createSuccessfulRefreshResponse();
+
+      // Create a delayed refresh response
+      let resolveRefresh: (value: TokenRefreshData) => void;
+      const refreshPromise = new Promise<TokenRefreshData>((resolve) => {
+        resolveRefresh = resolve;
+      });
+
+      mockClient.refreshAccessToken = vi.fn().mockReturnValue(refreshPromise);
+
+      // Mock file operations
+      mockFs.stat.mockResolvedValue({ mtimeMs: 1000 } as Stats);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockFs.mkdir.mockResolvedValue(undefined);
+
+      // Start two concurrent refresh operations
+      const promise1 = tokenManager.getValidCredentials(mockClient);
+      const promise2 = tokenManager.getValidCredentials(mockClient);
+
+      // Resolve the refresh
+      resolveRefresh!(refreshResponse);
+
+      const [result1, result2] = await Promise.all([promise1, promise2]);
+
+      expect(result1).toEqual(result2);
+      expect(mockClient.refreshAccessToken).toHaveBeenCalledTimes(1);
+    });
+
+    it('should reload credentials from file when file is modified', async () => {
+      const mockClient = createMockQwenClient();
+      const fileCredentials = createValidCredentials({
+        access_token: 'file_access_token',
+      });
+
+      // Mock file operations to simulate file modification
+      mockFs.stat.mockResolvedValue({ mtimeMs: 2000 } as Stats);
+      mockFs.readFile.mockResolvedValue(JSON.stringify(fileCredentials));
+
+      // Set initial cache state
+      tokenManager.clearCache();
+      const memoryCache = getPrivateProperty<{ fileModTime: number }>(
+        tokenManager,
+        'memoryCache',
+      );
+      memoryCache.fileModTime = 1000; // Older than file
+
+      const result = await tokenManager.getValidCredentials(mockClient);
+
+      expect(result.access_token).toBe('file_access_token');
+      expect(mockFs.readFile).toHaveBeenCalled();
+    });
+  });
+
+  describe('Cache Management', () => {
+    it('should clear cache', () => {
+      // Set some cache data
+      tokenManager.clearCache();
+      const memoryCache = getPrivateProperty<{
+        credentials: QwenCredentials | null;
+      }>(tokenManager, 'memoryCache');
+      memoryCache.credentials = createValidCredentials();
+
+      tokenManager.clearCache();
+
+      expect(tokenManager.getCurrentCredentials()).toBeNull();
+    });
+
+    it('should return current credentials from cache', () => {
+      const credentials = createValidCredentials();
+
+      tokenManager.clearCache();
+      const memoryCache = getPrivateProperty<{
+        credentials: QwenCredentials | null;
+      }>(tokenManager, 'memoryCache');
+      memoryCache.credentials = credentials;
+
+      expect(tokenManager.getCurrentCredentials()).toEqual(credentials);
+    });
+
+    it('should return null when no credentials are cached', () => {
+      tokenManager.clearCache();
+
+      expect(tokenManager.getCurrentCredentials()).toBeNull();
+    });
+  });
+
+  describe('Refresh Status', () => {
+    it('should return false when no refresh is in progress', () => {
+      expect(tokenManager.isRefreshInProgress()).toBe(false);
+    });
+
+    it('should return true when refresh is in progress', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+
+      // Clear cache to ensure refresh is triggered
+      tokenManager.clearCache();
+
+      // Mock stat for file check to fail (no file initially)
+      mockFs.stat.mockRejectedValueOnce(
+        Object.assign(new Error('ENOENT'), { code: 'ENOENT' }),
+      );
+
+      // Create a delayed refresh response
+      let resolveRefresh: (value: TokenRefreshData) => void;
+      const refreshPromise = new Promise<TokenRefreshData>((resolve) => {
+        resolveRefresh = resolve;
+      });
+
+      mockClient.refreshAccessToken = vi.fn().mockReturnValue(refreshPromise);
+
+      // Mock file operations for lock and save
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.stat.mockResolvedValue({ mtimeMs: 1000 } as Stats);
+
+      // Start refresh
+      const refreshOperation = tokenManager.getValidCredentials(mockClient);
+
+      // Wait a tick to ensure the refresh promise is set
+      await new Promise((resolve) => setImmediate(resolve));
+
+      expect(tokenManager.isRefreshInProgress()).toBe(true);
+
+      // Complete refresh
+      resolveRefresh!(createSuccessfulRefreshResponse());
+      await refreshOperation;
+
+      expect(tokenManager.isRefreshInProgress()).toBe(false);
+    });
+  });
+
+  describe('Debug Info', () => {
+    it('should return complete debug information', () => {
+      const credentials = createValidCredentials();
+
+      tokenManager.clearCache();
+      const memoryCache = getPrivateProperty<{
+        credentials: QwenCredentials | null;
+      }>(tokenManager, 'memoryCache');
+      memoryCache.credentials = credentials;
+
+      const debugInfo = tokenManager.getDebugInfo();
+
+      expect(debugInfo).toHaveProperty('hasCredentials', true);
+      expect(debugInfo).toHaveProperty('credentialsExpired', false);
+      expect(debugInfo).toHaveProperty('isRefreshing', false);
+      expect(debugInfo).toHaveProperty('cacheAge');
+      expect(typeof debugInfo.cacheAge).toBe('number');
+    });
+
+    it('should indicate expired credentials in debug info', () => {
+      const expiredCredentials = createExpiredCredentials();
+
+      tokenManager.clearCache();
+      const memoryCache = getPrivateProperty<{
+        credentials: QwenCredentials | null;
+      }>(tokenManager, 'memoryCache');
+      memoryCache.credentials = expiredCredentials;
+
+      const debugInfo = tokenManager.getDebugInfo();
+
+      expect(debugInfo.hasCredentials).toBe(true);
+      expect(debugInfo.credentialsExpired).toBe(true);
+    });
+
+    it('should indicate no credentials in debug info', () => {
+      tokenManager.clearCache();
+
+      const debugInfo = tokenManager.getDebugInfo();
+
+      expect(debugInfo.hasCredentials).toBe(false);
+      expect(debugInfo.credentialsExpired).toBe(false);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should create TokenManagerError with correct type and message', () => {
+      const error = new TokenManagerError(
+        TokenError.REFRESH_FAILED,
+        'Token refresh failed',
+        new Error('Original error'),
+      );
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(TokenManagerError);
+      expect(error.type).toBe(TokenError.REFRESH_FAILED);
+      expect(error.message).toBe('Token refresh failed');
+      expect(error.name).toBe('TokenManagerError');
+      expect(error.originalError).toBeInstanceOf(Error);
+    });
+
+    it('should handle file access errors gracefully', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+
+      // Mock file stat to throw access error
+      const accessError = new Error(
+        'Permission denied',
+      ) as NodeJS.ErrnoException;
+      accessError.code = 'EACCES';
+      mockFs.stat.mockRejectedValue(accessError);
+
+      await expect(
+        tokenManager.getValidCredentials(mockClient),
+      ).rejects.toThrow(TokenManagerError);
+    });
+
+    it('should handle missing file gracefully', async () => {
+      const mockClient = createMockQwenClient();
+      const validCredentials = createValidCredentials();
+
+      // Mock file stat to throw file not found error
+      const notFoundError = new Error(
+        'File not found',
+      ) as NodeJS.ErrnoException;
+      notFoundError.code = 'ENOENT';
+      mockFs.stat.mockRejectedValue(notFoundError);
+
+      // Set valid credentials in cache
+      const memoryCache = getPrivateProperty<{
+        credentials: QwenCredentials | null;
+      }>(tokenManager, 'memoryCache');
+      memoryCache.credentials = validCredentials;
+
+      const result = await tokenManager.getValidCredentials(mockClient);
+
+      expect(result).toEqual(validCredentials);
+    });
+
+    it('should handle lock timeout scenarios', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+
+      // Configure shorter timeouts for testing
+      tokenManager.setLockConfig({
+        maxAttempts: 3,
+        attemptInterval: 50,
+      });
+
+      // Mock stat for file check to pass (no file initially)
+      mockFs.stat.mockRejectedValueOnce(
+        Object.assign(new Error('ENOENT'), { code: 'ENOENT' }),
+      );
+
+      // Mock writeFile to always throw EEXIST for lock file writes (flag: 'wx')
+      // but succeed for regular file writes
+      const lockError = new Error('File exists') as NodeJS.ErrnoException;
+      lockError.code = 'EEXIST';
+
+      mockFs.writeFile.mockImplementation((path, data, options) => {
+        if (typeof options === 'object' && options?.flag === 'wx') {
+          return Promise.reject(lockError);
+        }
+        return Promise.resolve(undefined);
+      });
+
+      // Mock stat to return recent lock file (not stale) when checking lock age
+      mockFs.stat.mockResolvedValue({ mtimeMs: Date.now() } as Stats);
+
+      // Mock unlink to simulate lock file removal attempts
+      mockFs.unlink.mockResolvedValue(undefined);
+
+      await expect(
+        tokenManager.getValidCredentials(mockClient),
+      ).rejects.toThrow(TokenManagerError);
+    }, 500); // 500ms timeout for lock test (3 attempts × 50ms = ~150ms + buffer)
+
+    it('should handle refresh response without access token', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+      const invalidResponse = {
+        token_type: 'Bearer',
+        expires_in: 3600,
+        // access_token is missing, so we use undefined explicitly
+        access_token: undefined,
+      } as Partial<TokenRefreshData>;
+
+      mockClient.refreshAccessToken = vi
+        .fn()
+        .mockResolvedValue(invalidResponse);
+
+      // Mock stat for file check to pass (no file initially)
+      mockFs.stat.mockRejectedValueOnce(
+        Object.assign(new Error('ENOENT'), { code: 'ENOENT' }),
+      );
+
+      // Mock file operations for lock acquisition
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockFs.mkdir.mockResolvedValue(undefined);
+
+      // Clear cache to force refresh
+      tokenManager.clearCache();
+
+      await expect(
+        tokenManager.getValidCredentials(mockClient),
+      ).rejects.toThrow(TokenManagerError);
+
+      await expect(
+        tokenManager.getValidCredentials(mockClient),
+      ).rejects.toThrow('no token returned');
+    });
+  });
+
+  describe('File System Operations', () => {
+    it('should handle file reload failures gracefully', async () => {
+      const mockClient = createMockQwenClient();
+
+      // Mock successful refresh for when cache is cleared
+      mockClient.refreshAccessToken = vi
+        .fn()
+        .mockResolvedValue(createSuccessfulRefreshResponse());
+
+      // Mock file operations
+      mockFs.stat
+        .mockResolvedValueOnce({ mtimeMs: 2000 } as Stats) // For checkAndReloadIfNeeded
+        .mockResolvedValue({ mtimeMs: 1000 } as Stats); // For later operations
+      mockFs.readFile.mockRejectedValue(new Error('Read failed'));
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockFs.mkdir.mockResolvedValue(undefined);
+
+      // Set initial cache state to trigger reload
+      tokenManager.clearCache();
+      const memoryCache = getPrivateProperty<{ fileModTime: number }>(
+        tokenManager,
+        'memoryCache',
+      );
+      memoryCache.fileModTime = 1000;
+
+      // Should not throw error, should refresh and get new credentials
+      const result = await tokenManager.getValidCredentials(mockClient);
+
+      expect(result).toBeDefined();
+      expect(result.access_token).toBe('fresh_access_token');
+    });
+
+    it('should handle invalid JSON in credentials file', async () => {
+      const mockClient = createMockQwenClient();
+
+      // Mock successful refresh for when cache is cleared
+      mockClient.refreshAccessToken = vi
+        .fn()
+        .mockResolvedValue(createSuccessfulRefreshResponse());
+
+      // Mock file operations with invalid JSON
+      mockFs.stat
+        .mockResolvedValueOnce({ mtimeMs: 2000 } as Stats) // For checkAndReloadIfNeeded
+        .mockResolvedValue({ mtimeMs: 1000 } as Stats); // For later operations
+      mockFs.readFile.mockResolvedValue('invalid json content');
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockFs.mkdir.mockResolvedValue(undefined);
+
+      // Set initial cache state to trigger reload
+      tokenManager.clearCache();
+      const memoryCache = getPrivateProperty<{ fileModTime: number }>(
+        tokenManager,
+        'memoryCache',
+      );
+      memoryCache.fileModTime = 1000;
+
+      // Should handle JSON parse error gracefully, then refresh and get new credentials
+      const result = await tokenManager.getValidCredentials(mockClient);
+
+      expect(result).toBeDefined();
+      expect(result.access_token).toBe('fresh_access_token');
+    });
+
+    it('should handle directory creation during save', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+      const refreshResponse = createSuccessfulRefreshResponse();
+
+      mockClient.refreshAccessToken = vi
+        .fn()
+        .mockResolvedValue(refreshResponse);
+
+      // Mock file operations
+      mockFs.stat.mockResolvedValue({ mtimeMs: 1000 } as Stats);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockFs.mkdir.mockResolvedValue(undefined);
+
+      await tokenManager.getValidCredentials(mockClient);
+
+      expect(mockFs.mkdir).toHaveBeenCalledWith(expect.any(String), {
+        recursive: true,
+        mode: 0o700,
+      });
+      expect(mockFs.writeFile).toHaveBeenCalled();
+    });
+  });
+
+  describe('Lock File Management', () => {
+    it('should clean up lock file during process cleanup', () => {
+      // Create a new instance to trigger cleanup handler registration
+      SharedTokenManager.getInstance();
+
+      // Access the private cleanup method for testing
+      const cleanupHandlers = process.listeners('exit');
+      const cleanup = cleanupHandlers[cleanupHandlers.length - 1] as () => void;
+
+      // Should not throw when lock file doesn't exist
+      expect(() => cleanup()).not.toThrow();
+      expect(mockUnlinkSync).toHaveBeenCalled();
+    });
+
+    it('should handle stale lock cleanup', async () => {
+      const mockClient = createMockQwenClient(createExpiredCredentials());
+      const refreshResponse = createSuccessfulRefreshResponse();
+
+      mockClient.refreshAccessToken = vi
+        .fn()
+        .mockResolvedValue(refreshResponse);
+
+      // First writeFile call throws EEXIST (lock exists)
+      // Second writeFile call succeeds (after stale lock cleanup)
+      const lockError = new Error('File exists') as NodeJS.ErrnoException;
+      lockError.code = 'EEXIST';
+      mockFs.writeFile
+        .mockRejectedValueOnce(lockError)
+        .mockResolvedValue(undefined);
+
+      // Mock stat to return stale lock (old timestamp)
+      mockFs.stat
+        .mockResolvedValueOnce({ mtimeMs: Date.now() - 20000 } as Stats) // Stale lock
+        .mockResolvedValueOnce({ mtimeMs: 1000 } as Stats); // Credentials file
+
+      // Mock unlink to succeed
+      mockFs.unlink.mockResolvedValue(undefined);
+      mockFs.mkdir.mockResolvedValue(undefined);
+
+      const result = await tokenManager.getValidCredentials(mockClient);
+
+      expect(result.access_token).toBe(refreshResponse.access_token);
+      expect(mockFs.unlink).toHaveBeenCalled(); // Stale lock removed
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/qwen/sharedTokenManager.ts

@@ -0,0 +1,662 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import { promises as fs, unlinkSync } from 'node:fs';
+import * as os from 'os';
+import { randomUUID } from 'node:crypto';
+
+import {
+  IQwenOAuth2Client,
+  type QwenCredentials,
+  type TokenRefreshData,
+  type ErrorData,
+  isErrorResponse,
+} from './qwenOAuth2.js';
+
+// File System Configuration
+const QWEN_DIR = '.qwen';
+const QWEN_CREDENTIAL_FILENAME = 'oauth_creds.json';
+const QWEN_LOCK_FILENAME = 'oauth_creds.lock';
+
+// Token and Cache Configuration
+const TOKEN_REFRESH_BUFFER_MS = 30 * 1000; // 30 seconds
+const LOCK_TIMEOUT_MS = 10000; // 10 seconds lock timeout
+const CACHE_CHECK_INTERVAL_MS = 1000; // 1 second cache check interval
+
+// Lock acquisition configuration (can be overridden for testing)
+interface LockConfig {
+  maxAttempts: number;
+  attemptInterval: number;
+}
+
+const DEFAULT_LOCK_CONFIG: LockConfig = {
+  maxAttempts: 50,
+  attemptInterval: 200,
+};
+
+/**
+ * Token manager error types for better error classification
+ */
+export enum TokenError {
+  REFRESH_FAILED = 'REFRESH_FAILED',
+  NO_REFRESH_TOKEN = 'NO_REFRESH_TOKEN',
+  LOCK_TIMEOUT = 'LOCK_TIMEOUT',
+  FILE_ACCESS_ERROR = 'FILE_ACCESS_ERROR',
+  NETWORK_ERROR = 'NETWORK_ERROR',
+}
+
+/**
+ * Custom error class for token manager operations
+ */
+export class TokenManagerError extends Error {
+  constructor(
+    public type: TokenError,
+    message: string,
+    public originalError?: unknown,
+  ) {
+    super(message);
+    this.name = 'TokenManagerError';
+  }
+}
+
+/**
+ * Interface for the memory cache state
+ */
+interface MemoryCache {
+  credentials: QwenCredentials | null;
+  fileModTime: number;
+  lastCheck: number;
+}
+
+/**
+ * Validates that the given data is a valid QwenCredentials object
+ *
+ * @param data - The data to validate
+ * @returns The validated credentials object
+ * @throws Error if the data is invalid
+ */
+function validateCredentials(data: unknown): QwenCredentials {
+  if (!data || typeof data !== 'object') {
+    throw new Error('Invalid credentials format');
+  }
+
+  const creds = data as Partial<QwenCredentials>;
+  const requiredFields = [
+    'access_token',
+    'refresh_token',
+    'token_type',
+  ] as const;
+
+  // Check required string fields
+  for (const field of requiredFields) {
+    if (!creds[field] || typeof creds[field] !== 'string') {
+      throw new Error(`Invalid credentials: missing ${field}`);
+    }
+  }
+
+  // Check expiry_date
+  if (!creds.expiry_date || typeof creds.expiry_date !== 'number') {
+    throw new Error('Invalid credentials: missing expiry_date');
+  }
+
+  return creds as QwenCredentials;
+}
+
+/**
+ * Manages OAuth tokens across multiple processes using file-based caching and locking
+ */
+export class SharedTokenManager {
+  private static instance: SharedTokenManager | null = null;
+
+  /**
+   * In-memory cache for credentials and file state tracking
+   */
+  private memoryCache: MemoryCache = {
+    credentials: null,
+    fileModTime: 0,
+    lastCheck: 0,
+  };
+
+  /**
+   * Promise tracking any ongoing token refresh operation
+   */
+  private refreshPromise: Promise<QwenCredentials> | null = null;
+
+  /**
+   * Whether cleanup handlers have been registered
+   */
+  private cleanupHandlersRegistered = false;
+
+  /**
+   * Reference to cleanup functions for proper removal
+   */
+  private cleanupFunction: (() => void) | null = null;
+
+  /**
+   * Lock configuration for testing purposes
+   */
+  private lockConfig: LockConfig = DEFAULT_LOCK_CONFIG;
+
+  /**
+   * Private constructor for singleton pattern
+   */
+  private constructor() {
+    this.registerCleanupHandlers();
+  }
+
+  /**
+   * Get the singleton instance
+   * @returns The shared token manager instance
+   */
+  static getInstance(): SharedTokenManager {
+    if (!SharedTokenManager.instance) {
+      SharedTokenManager.instance = new SharedTokenManager();
+    }
+    return SharedTokenManager.instance;
+  }
+
+  /**
+   * Set up handlers to clean up lock files when the process exits
+   */
+  private registerCleanupHandlers(): void {
+    if (this.cleanupHandlersRegistered) {
+      return;
+    }
+
+    this.cleanupFunction = () => {
+      try {
+        const lockPath = this.getLockFilePath();
+        // Use synchronous unlink for process exit handlers
+        unlinkSync(lockPath);
+      } catch (_error) {
+        // Ignore cleanup errors - lock file might not exist or already be cleaned up
+      }
+    };
+
+    process.on('exit', this.cleanupFunction);
+    process.on('SIGINT', this.cleanupFunction);
+    process.on('SIGTERM', this.cleanupFunction);
+    process.on('uncaughtException', this.cleanupFunction);
+    process.on('unhandledRejection', this.cleanupFunction);
+
+    this.cleanupHandlersRegistered = true;
+  }
+
+  /**
+   * Get valid OAuth credentials, refreshing them if necessary
+   *
+   * @param qwenClient - The OAuth2 client instance
+   * @param forceRefresh - If true, refresh token even if current one is still valid
+   * @returns Promise resolving to valid credentials
+   * @throws TokenManagerError if unable to obtain valid credentials
+   */
+  async getValidCredentials(
+    qwenClient: IQwenOAuth2Client,
+    forceRefresh = false,
+  ): Promise<QwenCredentials> {
+    try {
+      // Check if credentials file has been updated by other sessions
+      await this.checkAndReloadIfNeeded();
+
+      // Return valid cached credentials if available (unless force refresh is requested)
+      if (
+        !forceRefresh &&
+        this.memoryCache.credentials &&
+        this.isTokenValid(this.memoryCache.credentials)
+      ) {
+        return this.memoryCache.credentials;
+      }
+
+      // If refresh is already in progress, wait for it to complete
+      if (this.refreshPromise) {
+        return this.refreshPromise;
+      }
+
+      // Start new refresh operation with distributed locking
+      this.refreshPromise = this.performTokenRefresh(qwenClient, forceRefresh);
+
+      try {
+        const credentials = await this.refreshPromise;
+        return credentials;
+      } catch (error) {
+        // Ensure refreshPromise is cleared on error before re-throwing
+        this.refreshPromise = null;
+        throw error;
+      } finally {
+        this.refreshPromise = null;
+      }
+    } catch (error) {
+      // Convert generic errors to TokenManagerError for better error handling
+      if (error instanceof TokenManagerError) {
+        throw error;
+      }
+
+      throw new TokenManagerError(
+        TokenError.REFRESH_FAILED,
+        `Failed to get valid credentials: ${error instanceof Error ? error.message : String(error)}`,
+        error,
+      );
+    }
+  }
+
+  /**
+   * Check if the credentials file was updated by another process and reload if so
+   */
+  private async checkAndReloadIfNeeded(): Promise<void> {
+    const now = Date.now();
+
+    // Limit check frequency to avoid excessive disk I/O
+    if (now - this.memoryCache.lastCheck < CACHE_CHECK_INTERVAL_MS) {
+      return;
+    }
+
+    this.memoryCache.lastCheck = now;
+
+    try {
+      const filePath = this.getCredentialFilePath();
+      const stats = await fs.stat(filePath);
+      const fileModTime = stats.mtimeMs;
+
+      // Reload credentials if file has been modified since last cache
+      if (fileModTime > this.memoryCache.fileModTime) {
+        await this.reloadCredentialsFromFile();
+        this.memoryCache.fileModTime = fileModTime;
+      }
+    } catch (error) {
+      // Handle file access errors
+      if (
+        error instanceof Error &&
+        'code' in error &&
+        error.code !== 'ENOENT'
+      ) {
+        // Clear cache for non-missing file errors
+        this.memoryCache.credentials = null;
+        this.memoryCache.fileModTime = 0;
+
+        throw new TokenManagerError(
+          TokenError.FILE_ACCESS_ERROR,
+          `Failed to access credentials file: ${error.message}`,
+          error,
+        );
+      }
+
+      // For missing files (ENOENT), just reset file modification time
+      // but keep existing valid credentials in memory if they exist
+      this.memoryCache.fileModTime = 0;
+    }
+  }
+
+  /**
+   * Load credentials from the file system into memory cache
+   */
+  private async reloadCredentialsFromFile(): Promise<void> {
+    try {
+      const filePath = this.getCredentialFilePath();
+      const content = await fs.readFile(filePath, 'utf-8');
+      const parsedData = JSON.parse(content);
+      const credentials = validateCredentials(parsedData);
+      this.memoryCache.credentials = credentials;
+    } catch (error) {
+      // Log validation errors for debugging but don't throw
+      if (
+        error instanceof Error &&
+        error.message.includes('Invalid credentials')
+      ) {
+        console.warn(`Failed to validate credentials file: ${error.message}`);
+      }
+      this.memoryCache.credentials = null;
+    }
+  }
+
+  /**
+   * Refresh the OAuth token using file locking to prevent concurrent refreshes
+   *
+   * @param qwenClient - The OAuth2 client instance
+   * @param forceRefresh - If true, skip checking if token is already valid after getting lock
+   * @returns Promise resolving to refreshed credentials
+   * @throws TokenManagerError if refresh fails or lock cannot be acquired
+   */
+  private async performTokenRefresh(
+    qwenClient: IQwenOAuth2Client,
+    forceRefresh = false,
+  ): Promise<QwenCredentials> {
+    const lockPath = this.getLockFilePath();
+
+    try {
+      // Check if we have a refresh token before attempting refresh
+      const currentCredentials = qwenClient.getCredentials();
+      if (!currentCredentials.refresh_token) {
+        throw new TokenManagerError(
+          TokenError.NO_REFRESH_TOKEN,
+          'No refresh token available for token refresh',
+        );
+      }
+
+      // Acquire distributed file lock
+      await this.acquireLock(lockPath);
+
+      // Double-check if another process already refreshed the token (unless force refresh is requested)
+      await this.checkAndReloadIfNeeded();
+
+      // Use refreshed credentials if they're now valid (unless force refresh is requested)
+      if (
+        !forceRefresh &&
+        this.memoryCache.credentials &&
+        this.isTokenValid(this.memoryCache.credentials)
+      ) {
+        qwenClient.setCredentials(this.memoryCache.credentials);
+        return this.memoryCache.credentials;
+      }
+
+      // Perform the actual token refresh
+      const response = await qwenClient.refreshAccessToken();
+
+      if (!response || isErrorResponse(response)) {
+        const errorData = response as ErrorData;
+        throw new TokenManagerError(
+          TokenError.REFRESH_FAILED,
+          `Token refresh failed: ${errorData?.error || 'Unknown error'} - ${errorData?.error_description || 'No details provided'}`,
+        );
+      }
+
+      const tokenData = response as TokenRefreshData;
+
+      if (!tokenData.access_token) {
+        throw new TokenManagerError(
+          TokenError.REFRESH_FAILED,
+          'Failed to refresh access token: no token returned',
+        );
+      }
+
+      // Create updated credentials object
+      const credentials: QwenCredentials = {
+        access_token: tokenData.access_token,
+        token_type: tokenData.token_type,
+        refresh_token:
+          tokenData.refresh_token || currentCredentials.refresh_token,
+        resource_url: tokenData.resource_url,
+        expiry_date: Date.now() + tokenData.expires_in * 1000,
+      };
+
+      // Update memory cache and client credentials
+      this.memoryCache.credentials = credentials;
+      qwenClient.setCredentials(credentials);
+
+      // Persist to file and update modification time
+      await this.saveCredentialsToFile(credentials);
+
+      return credentials;
+    } catch (error) {
+      if (error instanceof TokenManagerError) {
+        throw error;
+      }
+
+      // Handle network-related errors
+      if (
+        error instanceof Error &&
+        (error.message.includes('fetch') ||
+          error.message.includes('network') ||
+          error.message.includes('timeout'))
+      ) {
+        throw new TokenManagerError(
+          TokenError.NETWORK_ERROR,
+          `Network error during token refresh: ${error.message}`,
+          error,
+        );
+      }
+
+      throw new TokenManagerError(
+        TokenError.REFRESH_FAILED,
+        `Unexpected error during token refresh: ${error instanceof Error ? error.message : String(error)}`,
+        error,
+      );
+    } finally {
+      // Always release the file lock
+      await this.releaseLock(lockPath);
+    }
+  }
+
+  /**
+   * Save credentials to file and update the cached file modification time
+   *
+   * @param credentials - The credentials to save
+   */
+  private async saveCredentialsToFile(
+    credentials: QwenCredentials,
+  ): Promise<void> {
+    const filePath = this.getCredentialFilePath();
+    const dirPath = path.dirname(filePath);
+
+    // Create directory with restricted permissions
+    try {
+      await fs.mkdir(dirPath, { recursive: true, mode: 0o700 });
+    } catch (error) {
+      throw new TokenManagerError(
+        TokenError.FILE_ACCESS_ERROR,
+        `Failed to create credentials directory: ${error instanceof Error ? error.message : String(error)}`,
+        error,
+      );
+    }
+
+    const credString = JSON.stringify(credentials, null, 2);
+
+    try {
+      // Write file with restricted permissions (owner read/write only)
+      await fs.writeFile(filePath, credString, { mode: 0o600 });
+    } catch (error) {
+      throw new TokenManagerError(
+        TokenError.FILE_ACCESS_ERROR,
+        `Failed to write credentials file: ${error instanceof Error ? error.message : String(error)}`,
+        error,
+      );
+    }
+
+    // Update cached file modification time to avoid unnecessary reloads
+    try {
+      const stats = await fs.stat(filePath);
+      this.memoryCache.fileModTime = stats.mtimeMs;
+    } catch (error) {
+      // Non-fatal error, just log it
+      console.warn(
+        `Failed to update file modification time: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  /**
+   * Check if the token is valid and not expired
+   *
+   * @param credentials - The credentials to validate
+   * @returns true if token is valid and not expired, false otherwise
+   */
+  private isTokenValid(credentials: QwenCredentials): boolean {
+    if (!credentials.expiry_date || !credentials.access_token) {
+      return false;
+    }
+    return Date.now() < credentials.expiry_date - TOKEN_REFRESH_BUFFER_MS;
+  }
+
+  /**
+   * Get the full path to the credentials file
+   *
+   * @returns The absolute path to the credentials file
+   */
+  private getCredentialFilePath(): string {
+    return path.join(os.homedir(), QWEN_DIR, QWEN_CREDENTIAL_FILENAME);
+  }
+
+  /**
+   * Get the full path to the lock file
+   *
+   * @returns The absolute path to the lock file
+   */
+  private getLockFilePath(): string {
+    return path.join(os.homedir(), QWEN_DIR, QWEN_LOCK_FILENAME);
+  }
+
+  /**
+   * Acquire a file lock to prevent other processes from refreshing tokens simultaneously
+   *
+   * @param lockPath - Path to the lock file
+   * @throws TokenManagerError if lock cannot be acquired within timeout period
+   */
+  private async acquireLock(lockPath: string): Promise<void> {
+    const { maxAttempts, attemptInterval } = this.lockConfig;
+    const lockId = randomUUID(); // Use random UUID instead of PID for security
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        // Attempt to create lock file atomically (exclusive mode)
+        await fs.writeFile(lockPath, lockId, { flag: 'wx' });
+        return; // Successfully acquired lock
+      } catch (error: unknown) {
+        if ((error as NodeJS.ErrnoException).code === 'EEXIST') {
+          // Lock file already exists, check if it's stale
+          try {
+            const stats = await fs.stat(lockPath);
+            const lockAge = Date.now() - stats.mtimeMs;
+
+            // Remove stale locks that exceed timeout
+            if (lockAge > LOCK_TIMEOUT_MS) {
+              try {
+                await fs.unlink(lockPath);
+                console.warn(
+                  `Removed stale lock file: ${lockPath} (age: ${lockAge}ms)`,
+                );
+                continue; // Retry lock acquisition
+              } catch (unlinkError) {
+                // Log the error but continue trying - another process might have removed it
+                console.warn(
+                  `Failed to remove stale lock file ${lockPath}: ${unlinkError instanceof Error ? unlinkError.message : String(unlinkError)}`,
+                );
+                // Still continue - the lock might have been removed by another process
+              }
+            }
+          } catch (statError) {
+            // Can't stat lock file, it might have been removed, continue trying
+            console.warn(
+              `Failed to stat lock file ${lockPath}: ${statError instanceof Error ? statError.message : String(statError)}`,
+            );
+          }
+
+          // Wait before retrying
+          await new Promise((resolve) => setTimeout(resolve, attemptInterval));
+        } else {
+          throw new TokenManagerError(
+            TokenError.FILE_ACCESS_ERROR,
+            `Failed to create lock file: ${error instanceof Error ? error.message : String(error)}`,
+            error,
+          );
+        }
+      }
+    }
+
+    throw new TokenManagerError(
+      TokenError.LOCK_TIMEOUT,
+      'Failed to acquire file lock for token refresh: timeout exceeded',
+    );
+  }
+
+  /**
+   * Release the file lock
+   *
+   * @param lockPath - Path to the lock file
+   */
+  private async releaseLock(lockPath: string): Promise<void> {
+    try {
+      await fs.unlink(lockPath);
+    } catch (error) {
+      // Lock file might already be removed by another process or timeout cleanup
+      // This is not an error condition, but log for debugging
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        console.warn(
+          `Failed to release lock file ${lockPath}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+  }
+
+  /**
+   * Clear all cached data and reset the manager to initial state
+   */
+  clearCache(): void {
+    this.memoryCache = {
+      credentials: null,
+      fileModTime: 0,
+      lastCheck: 0,
+    };
+    this.refreshPromise = null;
+  }
+
+  /**
+   * Get the current cached credentials (may be expired)
+   *
+   * @returns The currently cached credentials or null
+   */
+  getCurrentCredentials(): QwenCredentials | null {
+    return this.memoryCache.credentials;
+  }
+
+  /**
+   * Check if there's an ongoing refresh operation
+   *
+   * @returns true if refresh is in progress, false otherwise
+   */
+  isRefreshInProgress(): boolean {
+    return this.refreshPromise !== null;
+  }
+
+  /**
+   * Set lock configuration for testing purposes
+   * @param config - Lock configuration
+   */
+  setLockConfig(config: Partial<LockConfig>): void {
+    this.lockConfig = { ...DEFAULT_LOCK_CONFIG, ...config };
+  }
+
+  /**
+   * Clean up event listeners (primarily for testing)
+   */
+  cleanup(): void {
+    if (this.cleanupFunction && this.cleanupHandlersRegistered) {
+      this.cleanupFunction();
+
+      process.removeListener('exit', this.cleanupFunction);
+      process.removeListener('SIGINT', this.cleanupFunction);
+      process.removeListener('SIGTERM', this.cleanupFunction);
+      process.removeListener('uncaughtException', this.cleanupFunction);
+      process.removeListener('unhandledRejection', this.cleanupFunction);
+
+      this.cleanupHandlersRegistered = false;
+      this.cleanupFunction = null;
+    }
+  }
+
+  /**
+   * Get a summary of the current state for debugging
+   *
+   * @returns Object containing current state information
+   */
+  getDebugInfo(): {
+    hasCredentials: boolean;
+    credentialsExpired: boolean;
+    isRefreshing: boolean;
+    cacheAge: number;
+  } {
+    const hasCredentials = !!this.memoryCache.credentials;
+    const credentialsExpired = hasCredentials
+      ? !this.isTokenValid(this.memoryCache.credentials!)
+      : false;
+
+    return {
+      hasCredentials,
+      credentialsExpired,
+      isRefreshing: this.isRefreshInProgress(),
+      cacheAge: Date.now() - this.memoryCache.lastCheck,
+    };
+  }
+}

projects/ui/qwen-code/packages/core/src/services/chatRecordingService.test.ts

@@ -0,0 +1,367 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  expect,
+  it,
+  describe,
+  vi,
+  beforeEach,
+  afterEach,
+  MockInstance,
+} from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import {
+  ChatRecordingService,
+  ConversationRecord,
+  ToolCallRecord,
+} from './chatRecordingService.js';
+import { Config } from '../config/config.js';
+import { getProjectHash } from '../utils/paths.js';
+
+vi.mock('node:fs');
+vi.mock('node:path');
+vi.mock('node:crypto');
+vi.mock('../utils/paths.js');
+
+describe('ChatRecordingService', () => {
+  let chatRecordingService: ChatRecordingService;
+  let mockConfig: Config;
+
+  let mkdirSyncSpy: MockInstance<typeof fs.mkdirSync>;
+  let writeFileSyncSpy: MockInstance<typeof fs.writeFileSync>;
+
+  beforeEach(() => {
+    mockConfig = {
+      getSessionId: vi.fn().mockReturnValue('test-session-id'),
+      getProjectRoot: vi.fn().mockReturnValue('/test/project/root'),
+      getProjectTempDir: vi
+        .fn()
+        .mockReturnValue('/test/project/root/.gemini/tmp'),
+      getModel: vi.fn().mockReturnValue('gemini-pro'),
+      getDebugMode: vi.fn().mockReturnValue(false),
+    } as unknown as Config;
+
+    vi.mocked(getProjectHash).mockReturnValue('test-project-hash');
+    vi.mocked(randomUUID).mockReturnValue('this-is-a-test-uuid');
+    vi.mocked(path.join).mockImplementation((...args) => args.join('/'));
+
+    chatRecordingService = new ChatRecordingService(mockConfig);
+
+    mkdirSyncSpy = vi
+      .spyOn(fs, 'mkdirSync')
+      .mockImplementation(() => undefined);
+
+    writeFileSyncSpy = vi
+      .spyOn(fs, 'writeFileSync')
+      .mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('initialize', () => {
+    it('should create a new session if none is provided', () => {
+      chatRecordingService.initialize();
+
+      expect(mkdirSyncSpy).toHaveBeenCalledWith(
+        '/test/project/root/.gemini/tmp/chats',
+        { recursive: true },
+      );
+      expect(writeFileSyncSpy).not.toHaveBeenCalled();
+    });
+
+    it('should resume from an existing session if provided', () => {
+      const readFileSyncSpy = vi.spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify({
+          sessionId: 'old-session-id',
+          projectHash: 'test-project-hash',
+          messages: [],
+        }),
+      );
+      const writeFileSyncSpy = vi
+        .spyOn(fs, 'writeFileSync')
+        .mockImplementation(() => undefined);
+
+      chatRecordingService.initialize({
+        filePath: '/test/project/root/.gemini/tmp/chats/session.json',
+        conversation: {
+          sessionId: 'old-session-id',
+        } as ConversationRecord,
+      });
+
+      expect(mkdirSyncSpy).not.toHaveBeenCalled();
+      expect(readFileSyncSpy).toHaveBeenCalled();
+      expect(writeFileSyncSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('recordMessage', () => {
+    beforeEach(() => {
+      chatRecordingService.initialize();
+      vi.spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify({
+          sessionId: 'test-session-id',
+          projectHash: 'test-project-hash',
+          messages: [],
+        }),
+      );
+    });
+
+    it('should record a new message', () => {
+      const writeFileSyncSpy = vi
+        .spyOn(fs, 'writeFileSync')
+        .mockImplementation(() => undefined);
+      chatRecordingService.recordMessage({ type: 'user', content: 'Hello' });
+      expect(mkdirSyncSpy).toHaveBeenCalled();
+      expect(writeFileSyncSpy).toHaveBeenCalled();
+      const conversation = JSON.parse(
+        writeFileSyncSpy.mock.calls[0][1] as string,
+      ) as ConversationRecord;
+      expect(conversation.messages).toHaveLength(1);
+      expect(conversation.messages[0].content).toBe('Hello');
+      expect(conversation.messages[0].type).toBe('user');
+    });
+
+    it('should append to the last message if append is true and types match', () => {
+      const writeFileSyncSpy = vi
+        .spyOn(fs, 'writeFileSync')
+        .mockImplementation(() => undefined);
+      const initialConversation = {
+        sessionId: 'test-session-id',
+        projectHash: 'test-project-hash',
+        messages: [
+          {
+            id: '1',
+            type: 'user',
+            content: 'Hello',
+            timestamp: new Date().toISOString(),
+          },
+        ],
+      };
+      vi.spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify(initialConversation),
+      );
+
+      chatRecordingService.recordMessage({
+        type: 'user',
+        content: ' World',
+        append: true,
+      });
+
+      expect(mkdirSyncSpy).toHaveBeenCalled();
+      expect(writeFileSyncSpy).toHaveBeenCalled();
+      const conversation = JSON.parse(
+        writeFileSyncSpy.mock.calls[0][1] as string,
+      ) as ConversationRecord;
+      expect(conversation.messages).toHaveLength(1);
+      expect(conversation.messages[0].content).toBe('Hello World');
+    });
+  });
+
+  describe('recordThought', () => {
+    it('should queue a thought', () => {
+      chatRecordingService.initialize();
+      chatRecordingService.recordThought({
+        subject: 'Thinking',
+        description: 'Thinking...',
+      });
+      // @ts-expect-error private property
+      expect(chatRecordingService.queuedThoughts).toHaveLength(1);
+      // @ts-expect-error private property
+      expect(chatRecordingService.queuedThoughts[0].subject).toBe('Thinking');
+      // @ts-expect-error private property
+      expect(chatRecordingService.queuedThoughts[0].description).toBe(
+        'Thinking...',
+      );
+    });
+  });
+
+  describe('recordMessageTokens', () => {
+    beforeEach(() => {
+      chatRecordingService.initialize();
+    });
+
+    it('should update the last message with token info', () => {
+      const writeFileSyncSpy = vi
+        .spyOn(fs, 'writeFileSync')
+        .mockImplementation(() => undefined);
+      const initialConversation = {
+        sessionId: 'test-session-id',
+        projectHash: 'test-project-hash',
+        messages: [
+          {
+            id: '1',
+            type: 'gemini',
+            content: 'Response',
+            timestamp: new Date().toISOString(),
+          },
+        ],
+      };
+      vi.spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify(initialConversation),
+      );
+
+      chatRecordingService.recordMessageTokens({
+        input: 1,
+        output: 2,
+        total: 3,
+        cached: 0,
+      });
+
+      expect(mkdirSyncSpy).toHaveBeenCalled();
+      expect(writeFileSyncSpy).toHaveBeenCalled();
+      const conversation = JSON.parse(
+        writeFileSyncSpy.mock.calls[0][1] as string,
+      ) as ConversationRecord;
+      expect(conversation.messages[0]).toEqual({
+        ...initialConversation.messages[0],
+        tokens: { input: 1, output: 2, total: 3, cached: 0 },
+      });
+    });
+
+    it('should queue token info if the last message already has tokens', () => {
+      const initialConversation = {
+        sessionId: 'test-session-id',
+        projectHash: 'test-project-hash',
+        messages: [
+          {
+            id: '1',
+            type: 'gemini',
+            content: 'Response',
+            timestamp: new Date().toISOString(),
+            tokens: { input: 1, output: 1, total: 2, cached: 0 },
+          },
+        ],
+      };
+      vi.spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify(initialConversation),
+      );
+
+      chatRecordingService.recordMessageTokens({
+        input: 2,
+        output: 2,
+        total: 4,
+        cached: 0,
+      });
+
+      // @ts-expect-error private property
+      expect(chatRecordingService.queuedTokens).toEqual({
+        input: 2,
+        output: 2,
+        total: 4,
+        cached: 0,
+      });
+    });
+  });
+
+  describe('recordToolCalls', () => {
+    beforeEach(() => {
+      chatRecordingService.initialize();
+    });
+
+    it('should add new tool calls to the last message', () => {
+      const writeFileSyncSpy = vi
+        .spyOn(fs, 'writeFileSync')
+        .mockImplementation(() => undefined);
+      const initialConversation = {
+        sessionId: 'test-session-id',
+        projectHash: 'test-project-hash',
+        messages: [
+          {
+            id: '1',
+            type: 'gemini',
+            content: '',
+            timestamp: new Date().toISOString(),
+          },
+        ],
+      };
+      vi.spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify(initialConversation),
+      );
+
+      const toolCall: ToolCallRecord = {
+        id: 'tool-1',
+        name: 'testTool',
+        args: {},
+        status: 'awaiting_approval',
+        timestamp: new Date().toISOString(),
+      };
+      chatRecordingService.recordToolCalls([toolCall]);
+
+      expect(mkdirSyncSpy).toHaveBeenCalled();
+      expect(writeFileSyncSpy).toHaveBeenCalled();
+      const conversation = JSON.parse(
+        writeFileSyncSpy.mock.calls[0][1] as string,
+      ) as ConversationRecord;
+      expect(conversation.messages[0]).toEqual({
+        ...initialConversation.messages[0],
+        toolCalls: [toolCall],
+      });
+    });
+
+    it('should create a new message if the last message is not from gemini', () => {
+      const writeFileSyncSpy = vi
+        .spyOn(fs, 'writeFileSync')
+        .mockImplementation(() => undefined);
+      const initialConversation = {
+        sessionId: 'test-session-id',
+        projectHash: 'test-project-hash',
+        messages: [
+          {
+            id: 'a-uuid',
+            type: 'user',
+            content: 'call a tool',
+            timestamp: new Date().toISOString(),
+          },
+        ],
+      };
+      vi.spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify(initialConversation),
+      );
+
+      const toolCall: ToolCallRecord = {
+        id: 'tool-1',
+        name: 'testTool',
+        args: {},
+        status: 'awaiting_approval',
+        timestamp: new Date().toISOString(),
+      };
+      chatRecordingService.recordToolCalls([toolCall]);
+
+      expect(mkdirSyncSpy).toHaveBeenCalled();
+      expect(writeFileSyncSpy).toHaveBeenCalled();
+      const conversation = JSON.parse(
+        writeFileSyncSpy.mock.calls[0][1] as string,
+      ) as ConversationRecord;
+      expect(conversation.messages).toHaveLength(2);
+      expect(conversation.messages[1]).toEqual({
+        ...conversation.messages[1],
+        id: 'this-is-a-test-uuid',
+        model: 'gemini-pro',
+        type: 'gemini',
+        thoughts: [],
+        content: '',
+        toolCalls: [toolCall],
+      });
+    });
+  });
+
+  describe('deleteSession', () => {
+    it('should delete the session file', () => {
+      const unlinkSyncSpy = vi
+        .spyOn(fs, 'unlinkSync')
+        .mockImplementation(() => undefined);
+      chatRecordingService.deleteSession('test-session-id');
+      expect(unlinkSyncSpy).toHaveBeenCalledWith(
+        '/test/project/root/.gemini/tmp/chats/test-session-id.json',
+      );
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/services/chatRecordingService.ts

@@ -0,0 +1,433 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { type Config } from '../config/config.js';
+import { type Status } from '../core/coreToolScheduler.js';
+import { type ThoughtSummary } from '../core/turn.js';
+import { getProjectHash } from '../utils/paths.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { PartListUnion } from '@google/genai';
+
+/**
+ * Token usage summary for a message or conversation.
+ */
+export interface TokensSummary {
+  input: number; // promptTokenCount
+  output: number; // candidatesTokenCount
+  cached: number; // cachedContentTokenCount
+  thoughts?: number; // thoughtsTokenCount
+  tool?: number; // toolUsePromptTokenCount
+  total: number; // totalTokenCount
+}
+
+/**
+ * Base fields common to all messages.
+ */
+export interface BaseMessageRecord {
+  id: string;
+  timestamp: string;
+  content: string;
+}
+
+/**
+ * Record of a tool call execution within a conversation.
+ */
+export interface ToolCallRecord {
+  id: string;
+  name: string;
+  args: Record<string, unknown>;
+  result?: PartListUnion | null;
+  status: Status;
+  timestamp: string;
+  // UI-specific fields for display purposes
+  displayName?: string;
+  description?: string;
+  resultDisplay?: string;
+  renderOutputAsMarkdown?: boolean;
+}
+
+/**
+ * Message type and message type-specific fields.
+ */
+export type ConversationRecordExtra =
+  | {
+      type: 'user';
+    }
+  | {
+      type: 'gemini';
+      toolCalls?: ToolCallRecord[];
+      thoughts?: Array<ThoughtSummary & { timestamp: string }>;
+      tokens?: TokensSummary | null;
+      model?: string;
+    };
+
+/**
+ * A single message record in a conversation.
+ */
+export type MessageRecord = BaseMessageRecord & ConversationRecordExtra;
+
+/**
+ * Complete conversation record stored in session files.
+ */
+export interface ConversationRecord {
+  sessionId: string;
+  projectHash: string;
+  startTime: string;
+  lastUpdated: string;
+  messages: MessageRecord[];
+}
+
+/**
+ * Data structure for resuming an existing session.
+ */
+export interface ResumedSessionData {
+  conversation: ConversationRecord;
+  filePath: string;
+}
+
+/**
+ * Service for automatically recording chat conversations to disk.
+ *
+ * This service provides comprehensive conversation recording that captures:
+ * - All user and assistant messages
+ * - Tool calls and their execution results
+ * - Token usage statistics
+ * - Assistant thoughts and reasoning
+ *
+ * Sessions are stored as JSON files in ~/.gemini/tmp/<project_hash>/chats/
+ */
+export class ChatRecordingService {
+  private conversationFile: string | null = null;
+  private cachedLastConvData: string | null = null;
+  private sessionId: string;
+  private projectHash: string;
+  private queuedThoughts: Array<ThoughtSummary & { timestamp: string }> = [];
+  private queuedTokens: TokensSummary | null = null;
+  private config: Config;
+
+  constructor(config: Config) {
+    this.config = config;
+    this.sessionId = config.getSessionId();
+    this.projectHash = getProjectHash(config.getProjectRoot());
+  }
+
+  /**
+   * Initializes the chat recording service: creates a new conversation file and associates it with
+   * this service instance, or resumes from an existing session if resumedSessionData is provided.
+   */
+  initialize(resumedSessionData?: ResumedSessionData): void {
+    try {
+      if (resumedSessionData) {
+        // Resume from existing session
+        this.conversationFile = resumedSessionData.filePath;
+        this.sessionId = resumedSessionData.conversation.sessionId;
+
+        // Update the session ID in the existing file
+        this.updateConversation((conversation) => {
+          conversation.sessionId = this.sessionId;
+        });
+
+        // Clear any cached data to force fresh reads
+        this.cachedLastConvData = null;
+      } else {
+        // Create new session
+        const chatsDir = path.join(this.config.getProjectTempDir(), 'chats');
+        fs.mkdirSync(chatsDir, { recursive: true });
+
+        const timestamp = new Date()
+          .toISOString()
+          .slice(0, 16)
+          .replace(/:/g, '-');
+        const filename = `session-${timestamp}-${this.sessionId.slice(
+          0,
+          8,
+        )}.json`;
+        this.conversationFile = path.join(chatsDir, filename);
+
+        this.writeConversation({
+          sessionId: this.sessionId,
+          projectHash: this.projectHash,
+          startTime: new Date().toISOString(),
+          lastUpdated: new Date().toISOString(),
+          messages: [],
+        });
+      }
+
+      // Clear any queued data since this is a fresh start
+      this.queuedThoughts = [];
+      this.queuedTokens = null;
+    } catch (error) {
+      console.error('Error initializing chat recording service:', error);
+      throw error;
+    }
+  }
+
+  private getLastMessage(
+    conversation: ConversationRecord,
+  ): MessageRecord | undefined {
+    return conversation.messages.at(-1);
+  }
+
+  private newMessage(
+    type: ConversationRecordExtra['type'],
+    content: string,
+  ): MessageRecord {
+    return {
+      id: randomUUID(),
+      timestamp: new Date().toISOString(),
+      type,
+      content,
+    };
+  }
+
+  /**
+   * Records a message in the conversation.
+   */
+  recordMessage(message: {
+    type: ConversationRecordExtra['type'];
+    content: string;
+    append?: boolean;
+  }): void {
+    if (!this.conversationFile) return;
+
+    try {
+      this.updateConversation((conversation) => {
+        if (message.append) {
+          const lastMsg = this.getLastMessage(conversation);
+          if (lastMsg && lastMsg.type === message.type) {
+            lastMsg.content += message.content;
+            return;
+          }
+        }
+        // We're not appending, or we are appending but the last message's type is not the same as
+        // the specified type, so just create a new message.
+        const msg = this.newMessage(message.type, message.content);
+        if (msg.type === 'gemini') {
+          // If it's a new Gemini message then incorporate any queued thoughts.
+          conversation.messages.push({
+            ...msg,
+            thoughts: this.queuedThoughts,
+            tokens: this.queuedTokens,
+            model: this.config.getModel(),
+          });
+          this.queuedThoughts = [];
+          this.queuedTokens = null;
+        } else {
+          // Or else just add it.
+          conversation.messages.push(msg);
+        }
+      });
+    } catch (error) {
+      console.error('Error saving message:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Records a thought from the assistant's reasoning process.
+   */
+  recordThought(thought: ThoughtSummary): void {
+    if (!this.conversationFile) return;
+
+    try {
+      this.queuedThoughts.push({
+        ...thought,
+        timestamp: new Date().toISOString(),
+      });
+    } catch (error) {
+      if (this.config.getDebugMode()) {
+        console.error('Error saving thought:', error);
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Updates the tokens for the last message in the conversation (which should be by Gemini).
+   */
+  recordMessageTokens(tokens: {
+    input: number;
+    output: number;
+    cached: number;
+    thoughts?: number;
+    tool?: number;
+    total: number;
+  }): void {
+    if (!this.conversationFile) return;
+
+    try {
+      this.updateConversation((conversation) => {
+        const lastMsg = this.getLastMessage(conversation);
+        // If the last message already has token info, it's because this new token info is for a
+        // new message that hasn't been recorded yet.
+        if (lastMsg && lastMsg.type === 'gemini' && !lastMsg.tokens) {
+          lastMsg.tokens = tokens;
+          this.queuedTokens = null;
+        } else {
+          this.queuedTokens = tokens;
+        }
+      });
+    } catch (error) {
+      console.error('Error updating message tokens:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Adds tool calls to the last message in the conversation (which should be by Gemini).
+   */
+  recordToolCalls(toolCalls: ToolCallRecord[]): void {
+    if (!this.conversationFile) return;
+
+    try {
+      this.updateConversation((conversation) => {
+        const lastMsg = this.getLastMessage(conversation);
+        // If a tool call was made, but the last message isn't from Gemini, it's because Gemini is
+        // calling tools without starting the message with text.  So the user submits a prompt, and
+        // Gemini immediately calls a tool (maybe with some thinking first).  In that case, create
+        // a new empty Gemini message.
+        // Also if there are any queued thoughts, it means this tool call(s) is from a new Gemini
+        // message--because it's thought some more since we last, if ever, created a new Gemini
+        // message from tool calls, when we dequeued the thoughts.
+        if (
+          !lastMsg ||
+          lastMsg.type !== 'gemini' ||
+          this.queuedThoughts.length > 0
+        ) {
+          const newMsg: MessageRecord = {
+            ...this.newMessage('gemini' as const, ''),
+            // This isn't strictly necessary, but TypeScript apparently can't
+            // tell that the first parameter to newMessage() becomes the
+            // resulting message's type, and so it thinks that toolCalls may
+            // not be present.  Confirming the type here satisfies it.
+            type: 'gemini' as const,
+            toolCalls,
+            thoughts: this.queuedThoughts,
+            model: this.config.getModel(),
+          };
+          // If there are any queued thoughts join them to this message.
+          if (this.queuedThoughts.length > 0) {
+            newMsg.thoughts = this.queuedThoughts;
+            this.queuedThoughts = [];
+          }
+          // If there's any queued tokens info join it to this message.
+          if (this.queuedTokens) {
+            newMsg.tokens = this.queuedTokens;
+            this.queuedTokens = null;
+          }
+          conversation.messages.push(newMsg);
+        } else {
+          // The last message is an existing Gemini message that we need to update.
+
+          // Update any existing tool call entries.
+          if (!lastMsg.toolCalls) {
+            lastMsg.toolCalls = [];
+          }
+          lastMsg.toolCalls = lastMsg.toolCalls.map((toolCall) => {
+            // If there are multiple tool calls with the same ID, this will take the first one.
+            const incomingToolCall = toolCalls.find(
+              (tc) => tc.id === toolCall.id,
+            );
+            if (incomingToolCall) {
+              // Merge in the new data to keep preserve thoughts, etc., that were assigned to older
+              // versions of the tool call.
+              return { ...toolCall, ...incomingToolCall };
+            } else {
+              return toolCall;
+            }
+          });
+
+          // Add any new tools calls that aren't in the message yet.
+          for (const toolCall of toolCalls) {
+            const existingToolCall = lastMsg.toolCalls.find(
+              (tc) => tc.id === toolCall.id,
+            );
+            if (!existingToolCall) {
+              lastMsg.toolCalls.push(toolCall);
+            }
+          }
+        }
+      });
+    } catch (error) {
+      console.error('Error adding tool call to message:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Loads up the conversation record from disk.
+   */
+  private readConversation(): ConversationRecord {
+    try {
+      this.cachedLastConvData = fs.readFileSync(this.conversationFile!, 'utf8');
+      return JSON.parse(this.cachedLastConvData);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        console.error('Error reading conversation file:', error);
+        throw error;
+      }
+
+      // Placeholder empty conversation if file doesn't exist.
+      return {
+        sessionId: this.sessionId,
+        projectHash: this.projectHash,
+        startTime: new Date().toISOString(),
+        lastUpdated: new Date().toISOString(),
+        messages: [],
+      };
+    }
+  }
+
+  /**
+   * Saves the conversation record; overwrites the file.
+   */
+  private writeConversation(conversation: ConversationRecord): void {
+    try {
+      if (!this.conversationFile) return;
+      // Don't write the file yet until there's at least one message.
+      if (conversation.messages.length === 0) return;
+
+      // Only write the file if this change would change the file.
+      if (this.cachedLastConvData !== JSON.stringify(conversation, null, 2)) {
+        conversation.lastUpdated = new Date().toISOString();
+        const newContent = JSON.stringify(conversation, null, 2);
+        this.cachedLastConvData = newContent;
+        fs.writeFileSync(this.conversationFile, newContent);
+      }
+    } catch (error) {
+      console.error('Error writing conversation file:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Convenient helper for updating the conversation without file reading and writing and time
+   * updating boilerplate.
+   */
+  private updateConversation(
+    updateFn: (conversation: ConversationRecord) => void,
+  ) {
+    const conversation = this.readConversation();
+    updateFn(conversation);
+    this.writeConversation(conversation);
+  }
+
+  /**
+   * Deletes a session file by session ID.
+   */
+  deleteSession(sessionId: string): void {
+    try {
+      const chatsDir = path.join(this.config.getProjectTempDir(), 'chats');
+      const sessionPath = path.join(chatsDir, `${sessionId}.json`);
+      fs.unlinkSync(sessionPath);
+    } catch (error) {
+      console.error('Error deleting session:', error);
+      throw error;
+    }
+  }
+}

projects/ui/qwen-code/packages/core/src/services/fileDiscoveryService.test.ts

@@ -0,0 +1,211 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { FileDiscoveryService } from './fileDiscoveryService.js';
+
+describe('FileDiscoveryService', () => {
+  let testRootDir: string;
+  let projectRoot: string;
+
+  async function createTestFile(filePath: string, content = '') {
+    const fullPath = path.join(projectRoot, filePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content);
+    return fullPath;
+  }
+
+  beforeEach(async () => {
+    testRootDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'file-discovery-test-'),
+    );
+    projectRoot = path.join(testRootDir, 'project');
+    await fs.mkdir(projectRoot, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(testRootDir, { recursive: true, force: true });
+  });
+
+  describe('initialization', () => {
+    it('should initialize git ignore parser by default in a git repo', async () => {
+      await fs.mkdir(path.join(projectRoot, '.git'));
+      await createTestFile('.gitignore', 'node_modules/');
+
+      const service = new FileDiscoveryService(projectRoot);
+      // Let's check the effect of the parser instead of mocking it.
+      expect(service.shouldGitIgnoreFile('node_modules/foo.js')).toBe(true);
+      expect(service.shouldGitIgnoreFile('src/foo.js')).toBe(false);
+    });
+
+    it('should not load git repo patterns when not in a git repo', async () => {
+      // No .git directory
+      await createTestFile('.gitignore', 'node_modules/');
+      const service = new FileDiscoveryService(projectRoot);
+
+      // .gitignore is not loaded in non-git repos
+      expect(service.shouldGitIgnoreFile('node_modules/foo.js')).toBe(false);
+    });
+
+    it('should load .geminiignore patterns even when not in a git repo', async () => {
+      await createTestFile('.geminiignore', 'secrets.txt');
+      const service = new FileDiscoveryService(projectRoot);
+
+      expect(service.shouldGeminiIgnoreFile('secrets.txt')).toBe(true);
+      expect(service.shouldGeminiIgnoreFile('src/index.js')).toBe(false);
+    });
+  });
+
+  describe('filterFiles', () => {
+    beforeEach(async () => {
+      await fs.mkdir(path.join(projectRoot, '.git'));
+      await createTestFile('.gitignore', 'node_modules/\n.git/\ndist');
+      await createTestFile('.geminiignore', 'logs/');
+    });
+
+    it('should filter out git-ignored and gemini-ignored files by default', () => {
+      const files = [
+        'src/index.ts',
+        'node_modules/package/index.js',
+        'README.md',
+        '.git/config',
+        'dist/bundle.js',
+        'logs/latest.log',
+      ].map((f) => path.join(projectRoot, f));
+
+      const service = new FileDiscoveryService(projectRoot);
+
+      expect(service.filterFiles(files)).toEqual(
+        ['src/index.ts', 'README.md'].map((f) => path.join(projectRoot, f)),
+      );
+    });
+
+    it('should not filter files when respectGitIgnore is false', () => {
+      const files = [
+        'src/index.ts',
+        'node_modules/package/index.js',
+        '.git/config',
+        'logs/latest.log',
+      ].map((f) => path.join(projectRoot, f));
+
+      const service = new FileDiscoveryService(projectRoot);
+
+      const filtered = service.filterFiles(files, {
+        respectGitIgnore: false,
+        respectGeminiIgnore: true, // still respect this one
+      });
+
+      expect(filtered).toEqual(
+        ['src/index.ts', 'node_modules/package/index.js', '.git/config'].map(
+          (f) => path.join(projectRoot, f),
+        ),
+      );
+    });
+
+    it('should not filter files when respectGeminiIgnore is false', () => {
+      const files = [
+        'src/index.ts',
+        'node_modules/package/index.js',
+        'logs/latest.log',
+      ].map((f) => path.join(projectRoot, f));
+
+      const service = new FileDiscoveryService(projectRoot);
+
+      const filtered = service.filterFiles(files, {
+        respectGitIgnore: true,
+        respectGeminiIgnore: false,
+      });
+
+      expect(filtered).toEqual(
+        ['src/index.ts', 'logs/latest.log'].map((f) =>
+          path.join(projectRoot, f),
+        ),
+      );
+    });
+
+    it('should handle empty file list', () => {
+      const service = new FileDiscoveryService(projectRoot);
+
+      expect(service.filterFiles([])).toEqual([]);
+    });
+  });
+
+  describe('shouldGitIgnoreFile & shouldGeminiIgnoreFile', () => {
+    beforeEach(async () => {
+      await fs.mkdir(path.join(projectRoot, '.git'));
+      await createTestFile('.gitignore', 'node_modules/');
+      await createTestFile('.geminiignore', '*.log');
+    });
+
+    it('should return true for git-ignored files', () => {
+      const service = new FileDiscoveryService(projectRoot);
+
+      expect(
+        service.shouldGitIgnoreFile(
+          path.join(projectRoot, 'node_modules/package/index.js'),
+        ),
+      ).toBe(true);
+    });
+
+    it('should return false for non-git-ignored files', () => {
+      const service = new FileDiscoveryService(projectRoot);
+
+      expect(
+        service.shouldGitIgnoreFile(path.join(projectRoot, 'src/index.ts')),
+      ).toBe(false);
+    });
+
+    it('should return true for gemini-ignored files', () => {
+      const service = new FileDiscoveryService(projectRoot);
+
+      expect(
+        service.shouldGeminiIgnoreFile(path.join(projectRoot, 'debug.log')),
+      ).toBe(true);
+    });
+
+    it('should return false for non-gemini-ignored files', () => {
+      const service = new FileDiscoveryService(projectRoot);
+
+      expect(
+        service.shouldGeminiIgnoreFile(path.join(projectRoot, 'src/index.ts')),
+      ).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle relative project root paths', async () => {
+      await fs.mkdir(path.join(projectRoot, '.git'));
+      await createTestFile('.gitignore', 'ignored.txt');
+      const service = new FileDiscoveryService(
+        path.relative(process.cwd(), projectRoot),
+      );
+
+      expect(
+        service.shouldGitIgnoreFile(path.join(projectRoot, 'ignored.txt')),
+      ).toBe(true);
+      expect(
+        service.shouldGitIgnoreFile(path.join(projectRoot, 'not-ignored.txt')),
+      ).toBe(false);
+    });
+
+    it('should handle filterFiles with undefined options', async () => {
+      await fs.mkdir(path.join(projectRoot, '.git'));
+      await createTestFile('.gitignore', 'ignored.txt');
+      const service = new FileDiscoveryService(projectRoot);
+
+      const files = ['src/index.ts', 'ignored.txt'].map((f) =>
+        path.join(projectRoot, f),
+      );
+
+      expect(service.filterFiles(files, undefined)).toEqual([
+        path.join(projectRoot, 'src/index.ts'),
+      ]);
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/services/fileDiscoveryService.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { GitIgnoreParser, GitIgnoreFilter } from '../utils/gitIgnoreParser.js';
+import { isGitRepository } from '../utils/gitUtils.js';
+import * as path from 'path';
+
+const GEMINI_IGNORE_FILE_NAME = '.geminiignore';
+
+export interface FilterFilesOptions {
+  respectGitIgnore?: boolean;
+  respectGeminiIgnore?: boolean;
+}
+
+export class FileDiscoveryService {
+  private gitIgnoreFilter: GitIgnoreFilter | null = null;
+  private geminiIgnoreFilter: GitIgnoreFilter | null = null;
+  private projectRoot: string;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = path.resolve(projectRoot);
+    if (isGitRepository(this.projectRoot)) {
+      const parser = new GitIgnoreParser(this.projectRoot);
+      try {
+        parser.loadGitRepoPatterns();
+      } catch (_error) {
+        // ignore file not found
+      }
+      this.gitIgnoreFilter = parser;
+    }
+    const gParser = new GitIgnoreParser(this.projectRoot);
+    try {
+      gParser.loadPatterns(GEMINI_IGNORE_FILE_NAME);
+    } catch (_error) {
+      // ignore file not found
+    }
+    this.geminiIgnoreFilter = gParser;
+  }
+
+  /**
+   * Filters a list of file paths based on git ignore rules
+   */
+  filterFiles(
+    filePaths: string[],
+    options: FilterFilesOptions = {
+      respectGitIgnore: true,
+      respectGeminiIgnore: true,
+    },
+  ): string[] {
+    return filePaths.filter((filePath) => {
+      if (options.respectGitIgnore && this.shouldGitIgnoreFile(filePath)) {
+        return false;
+      }
+      if (
+        options.respectGeminiIgnore &&
+        this.shouldGeminiIgnoreFile(filePath)
+      ) {
+        return false;
+      }
+      return true;
+    });
+  }
+
+  /**
+   * Checks if a single file should be git-ignored
+   */
+  shouldGitIgnoreFile(filePath: string): boolean {
+    if (this.gitIgnoreFilter) {
+      return this.gitIgnoreFilter.isIgnored(filePath);
+    }
+    return false;
+  }
+
+  /**
+   * Checks if a single file should be gemini-ignored
+   */
+  shouldGeminiIgnoreFile(filePath: string): boolean {
+    if (this.geminiIgnoreFilter) {
+      return this.geminiIgnoreFilter.isIgnored(filePath);
+    }
+    return false;
+  }
+
+  /**
+   * Unified method to check if a file should be ignored based on filtering options
+   */
+  shouldIgnoreFile(
+    filePath: string,
+    options: FilterFilesOptions = {},
+  ): boolean {
+    const { respectGitIgnore = true, respectGeminiIgnore = true } = options;
+
+    if (respectGitIgnore && this.shouldGitIgnoreFile(filePath)) {
+      return true;
+    }
+    if (respectGeminiIgnore && this.shouldGeminiIgnoreFile(filePath)) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Returns loaded patterns from .geminiignore
+   */
+  getGeminiIgnorePatterns(): string[] {
+    return this.geminiIgnoreFilter?.getPatterns() ?? [];
+  }
+}

projects/ui/qwen-code/packages/core/src/services/fileSystemService.test.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs/promises';
+import { StandardFileSystemService } from './fileSystemService.js';
+
+vi.mock('fs/promises');
+
+describe('StandardFileSystemService', () => {
+  let fileSystem: StandardFileSystemService;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    fileSystem = new StandardFileSystemService();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('readTextFile', () => {
+    it('should read file content using fs', async () => {
+      const testContent = 'Hello, World!';
+      vi.mocked(fs.readFile).mockResolvedValue(testContent);
+
+      const result = await fileSystem.readTextFile('/test/file.txt');
+
+      expect(fs.readFile).toHaveBeenCalledWith('/test/file.txt', 'utf-8');
+      expect(result).toBe(testContent);
+    });
+
+    it('should propagate fs.readFile errors', async () => {
+      const error = new Error('ENOENT: File not found');
+      vi.mocked(fs.readFile).mockRejectedValue(error);
+
+      await expect(fileSystem.readTextFile('/test/file.txt')).rejects.toThrow(
+        'ENOENT: File not found',
+      );
+    });
+  });
+
+  describe('writeTextFile', () => {
+    it('should write file content using fs', async () => {
+      vi.mocked(fs.writeFile).mockResolvedValue();
+
+      await fileSystem.writeTextFile('/test/file.txt', 'Hello, World!');
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        '/test/file.txt',
+        'Hello, World!',
+        'utf-8',
+      );
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/services/fileSystemService.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs/promises';
+
+/**
+ * Interface for file system operations that may be delegated to different implementations
+ */
+export interface FileSystemService {
+  /**
+   * Read text content from a file
+   *
+   * @param filePath - The path to the file to read
+   * @returns The file content as a string
+   */
+  readTextFile(filePath: string): Promise<string>;
+
+  /**
+   * Write text content to a file
+   *
+   * @param filePath - The path to the file to write
+   * @param content - The content to write
+   */
+  writeTextFile(filePath: string, content: string): Promise<void>;
+}
+
+/**
+ * Standard file system implementation
+ */
+export class StandardFileSystemService implements FileSystemService {
+  async readTextFile(filePath: string): Promise<string> {
+    return fs.readFile(filePath, 'utf-8');
+  }
+
+  async writeTextFile(filePath: string, content: string): Promise<void> {
+    await fs.writeFile(filePath, content, 'utf-8');
+  }
+}

projects/ui/qwen-code/packages/core/src/services/gitService.test.ts

@@ -0,0 +1,247 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { GitService } from './gitService.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import type { ChildProcess } from 'node:child_process';
+import { getProjectHash, QWEN_DIR } from '../utils/paths.js';
+
+const hoistedMockExec = vi.hoisted(() => vi.fn());
+vi.mock('node:child_process', () => ({
+  exec: hoistedMockExec,
+}));
+
+const hoistedMockEnv = vi.hoisted(() => vi.fn());
+const hoistedMockSimpleGit = vi.hoisted(() => vi.fn());
+const hoistedMockCheckIsRepo = vi.hoisted(() => vi.fn());
+const hoistedMockInit = vi.hoisted(() => vi.fn());
+const hoistedMockRaw = vi.hoisted(() => vi.fn());
+const hoistedMockAdd = vi.hoisted(() => vi.fn());
+const hoistedMockCommit = vi.hoisted(() => vi.fn());
+vi.mock('simple-git', () => ({
+  simpleGit: hoistedMockSimpleGit.mockImplementation(() => ({
+    checkIsRepo: hoistedMockCheckIsRepo,
+    init: hoistedMockInit,
+    raw: hoistedMockRaw,
+    add: hoistedMockAdd,
+    commit: hoistedMockCommit,
+    env: hoistedMockEnv,
+  })),
+  CheckRepoActions: { IS_REPO_ROOT: 'is-repo-root' },
+}));
+
+const hoistedIsGitRepositoryMock = vi.hoisted(() => vi.fn());
+vi.mock('../utils/gitUtils.js', () => ({
+  isGitRepository: hoistedIsGitRepositoryMock,
+}));
+
+const hoistedMockHomedir = vi.hoisted(() => vi.fn());
+vi.mock('os', async (importOriginal) => {
+  const actual = await importOriginal<typeof os>();
+  return {
+    ...actual,
+    homedir: hoistedMockHomedir,
+  };
+});
+
+describe('GitService', () => {
+  let testRootDir: string;
+  let projectRoot: string;
+  let homedir: string;
+  let hash: string;
+
+  beforeEach(async () => {
+    testRootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'git-service-test-'));
+    projectRoot = path.join(testRootDir, 'project');
+    homedir = path.join(testRootDir, 'home');
+    await fs.mkdir(projectRoot, { recursive: true });
+    await fs.mkdir(homedir, { recursive: true });
+
+    hash = getProjectHash(projectRoot);
+
+    vi.clearAllMocks();
+    hoistedIsGitRepositoryMock.mockReturnValue(true);
+    hoistedMockExec.mockImplementation((command, callback) => {
+      if (command === 'git --version') {
+        callback(null, 'git version 2.0.0');
+      } else {
+        callback(new Error('Command not mocked'));
+      }
+      return {};
+    });
+
+    hoistedMockHomedir.mockReturnValue(homedir);
+
+    hoistedMockEnv.mockImplementation(() => ({
+      checkIsRepo: hoistedMockCheckIsRepo,
+      init: hoistedMockInit,
+      raw: hoistedMockRaw,
+      add: hoistedMockAdd,
+      commit: hoistedMockCommit,
+    }));
+    hoistedMockSimpleGit.mockImplementation(() => ({
+      checkIsRepo: hoistedMockCheckIsRepo,
+      init: hoistedMockInit,
+      raw: hoistedMockRaw,
+      add: hoistedMockAdd,
+      commit: hoistedMockCommit,
+      env: hoistedMockEnv,
+    }));
+    hoistedMockCheckIsRepo.mockResolvedValue(false);
+    hoistedMockInit.mockResolvedValue(undefined);
+    hoistedMockRaw.mockResolvedValue('');
+    hoistedMockAdd.mockResolvedValue(undefined);
+    hoistedMockCommit.mockResolvedValue({
+      commit: 'initial',
+    });
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    await fs.rm(testRootDir, { recursive: true, force: true });
+  });
+
+  describe('constructor', () => {
+    it('should successfully create an instance', () => {
+      expect(() => new GitService(projectRoot)).not.toThrow();
+    });
+  });
+
+  describe('verifyGitAvailability', () => {
+    it('should resolve true if git --version command succeeds', async () => {
+      const service = new GitService(projectRoot);
+      await expect(service.verifyGitAvailability()).resolves.toBe(true);
+    });
+
+    it('should resolve false if git --version command fails', async () => {
+      hoistedMockExec.mockImplementation((command, callback) => {
+        callback(new Error('git not found'));
+        return {} as ChildProcess;
+      });
+      const service = new GitService(projectRoot);
+      await expect(service.verifyGitAvailability()).resolves.toBe(false);
+    });
+  });
+
+  describe('initialize', () => {
+    it('should throw an error if Git is not available', async () => {
+      hoistedMockExec.mockImplementation((command, callback) => {
+        callback(new Error('git not found'));
+        return {} as ChildProcess;
+      });
+      const service = new GitService(projectRoot);
+      await expect(service.initialize()).rejects.toThrow(
+        'Checkpointing is enabled, but Git is not installed. Please install Git or disable checkpointing to continue.',
+      );
+    });
+
+    it('should call setupShadowGitRepository if Git is available', async () => {
+      const service = new GitService(projectRoot);
+      const setupSpy = vi
+        .spyOn(service, 'setupShadowGitRepository')
+        .mockResolvedValue(undefined);
+
+      await service.initialize();
+      expect(setupSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('setupShadowGitRepository', () => {
+    let repoDir: string;
+    let gitConfigPath: string;
+
+    beforeEach(() => {
+      repoDir = path.join(homedir, QWEN_DIR, 'history', hash);
+      gitConfigPath = path.join(repoDir, '.gitconfig');
+    });
+
+    it('should create history and repository directories', async () => {
+      const service = new GitService(projectRoot);
+      await service.setupShadowGitRepository();
+      const stats = await fs.stat(repoDir);
+      expect(stats.isDirectory()).toBe(true);
+    });
+
+    it('should create a .gitconfig file with the correct content', async () => {
+      const service = new GitService(projectRoot);
+      await service.setupShadowGitRepository();
+
+      const expectedConfigContent =
+        '[user]\n  name = Gemini CLI\n  email = gemini-cli@google.com\n[commit]\n  gpgsign = false\n';
+      const actualConfigContent = await fs.readFile(gitConfigPath, 'utf-8');
+      expect(actualConfigContent).toBe(expectedConfigContent);
+    });
+
+    it('should initialize git repo in historyDir if not already initialized', async () => {
+      hoistedMockCheckIsRepo.mockResolvedValue(false);
+      const service = new GitService(projectRoot);
+      await service.setupShadowGitRepository();
+      expect(hoistedMockSimpleGit).toHaveBeenCalledWith(repoDir);
+      expect(hoistedMockInit).toHaveBeenCalled();
+    });
+
+    it('should not initialize git repo if already initialized', async () => {
+      hoistedMockCheckIsRepo.mockResolvedValue(true);
+      const service = new GitService(projectRoot);
+      await service.setupShadowGitRepository();
+      expect(hoistedMockInit).not.toHaveBeenCalled();
+    });
+
+    it('should copy .gitignore from projectRoot if it exists', async () => {
+      const gitignoreContent = 'node_modules/\n.env';
+      const visibleGitIgnorePath = path.join(projectRoot, '.gitignore');
+      await fs.writeFile(visibleGitIgnorePath, gitignoreContent);
+
+      const service = new GitService(projectRoot);
+      await service.setupShadowGitRepository();
+
+      const hiddenGitIgnorePath = path.join(repoDir, '.gitignore');
+      const copiedContent = await fs.readFile(hiddenGitIgnorePath, 'utf-8');
+      expect(copiedContent).toBe(gitignoreContent);
+    });
+
+    it('should not create a .gitignore in shadow repo if project .gitignore does not exist', async () => {
+      const service = new GitService(projectRoot);
+      await service.setupShadowGitRepository();
+
+      const hiddenGitIgnorePath = path.join(repoDir, '.gitignore');
+      // An empty string is written if the file doesn't exist.
+      const content = await fs.readFile(hiddenGitIgnorePath, 'utf-8');
+      expect(content).toBe('');
+    });
+
+    it('should throw an error if reading projectRoot .gitignore fails with other errors', async () => {
+      const visibleGitIgnorePath = path.join(projectRoot, '.gitignore');
+      // Create a directory instead of a file to cause a read error
+      await fs.mkdir(visibleGitIgnorePath);
+
+      const service = new GitService(projectRoot);
+      // EISDIR is the expected error code on Unix-like systems
+      await expect(service.setupShadowGitRepository()).rejects.toThrow(
+        /EISDIR: illegal operation on a directory, read|EBUSY: resource busy or locked, read/,
+      );
+    });
+
+    it('should make an initial commit if no commits exist in history repo', async () => {
+      hoistedMockCheckIsRepo.mockResolvedValue(false);
+      const service = new GitService(projectRoot);
+      await service.setupShadowGitRepository();
+      expect(hoistedMockCommit).toHaveBeenCalledWith('Initial commit', {
+        '--allow-empty': null,
+      });
+    });
+
+    it('should not make an initial commit if commits already exist', async () => {
+      hoistedMockCheckIsRepo.mockResolvedValue(true);
+      const service = new GitService(projectRoot);
+      await service.setupShadowGitRepository();
+      expect(hoistedMockCommit).not.toHaveBeenCalled();
+    });
+  });
+});

projects/ui/qwen-code/packages/core/src/services/gitService.ts

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { isNodeError } from '../utils/errors.js';
+import { exec } from 'node:child_process';
+import { simpleGit, SimpleGit, CheckRepoActions } from 'simple-git';
+import { getProjectHash, QWEN_DIR } from '../utils/paths.js';
+
+export class GitService {
+  private projectRoot: string;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = path.resolve(projectRoot);
+  }
+
+  private getHistoryDir(): string {
+    const hash = getProjectHash(this.projectRoot);
+    return path.join(os.homedir(), QWEN_DIR, 'history', hash);
+  }
+
+  async initialize(): Promise<void> {
+    const gitAvailable = await this.verifyGitAvailability();
+    if (!gitAvailable) {
+      throw new Error(
+        'Checkpointing is enabled, but Git is not installed. Please install Git or disable checkpointing to continue.',
+      );
+    }
+    this.setupShadowGitRepository();
+  }
+
+  verifyGitAvailability(): Promise<boolean> {
+    return new Promise((resolve) => {
+      exec('git --version', (error) => {
+        if (error) {
+          resolve(false);
+        } else {
+          resolve(true);
+        }
+      });
+    });
+  }
+
+  /**
+   * Creates a hidden git repository in the project root.
+   * The Git repository is used to support checkpointing.
+   */
+  async setupShadowGitRepository() {
+    const repoDir = this.getHistoryDir();
+    const gitConfigPath = path.join(repoDir, '.gitconfig');
+
+    await fs.mkdir(repoDir, { recursive: true });
+
+    // We don't want to inherit the user's name, email, or gpg signing
+    // preferences for the shadow repository, so we create a dedicated gitconfig.
+    const gitConfigContent =
+      '[user]\n  name = Gemini CLI\n  email = gemini-cli@google.com\n[commit]\n  gpgsign = false\n';
+    await fs.writeFile(gitConfigPath, gitConfigContent);
+
+    const repo = simpleGit(repoDir);
+    const isRepoDefined = await repo.checkIsRepo(CheckRepoActions.IS_REPO_ROOT);
+
+    if (!isRepoDefined) {
+      await repo.init(false, {
+        '--initial-branch': 'main',
+      });
+
+      await repo.commit('Initial commit', { '--allow-empty': null });
+    }
+
+    const userGitIgnorePath = path.join(this.projectRoot, '.gitignore');
+    const shadowGitIgnorePath = path.join(repoDir, '.gitignore');
+
+    let userGitIgnoreContent = '';
+    try {
+      userGitIgnoreContent = await fs.readFile(userGitIgnorePath, 'utf-8');
+    } catch (error) {
+      if (isNodeError(error) && error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+
+    await fs.writeFile(shadowGitIgnorePath, userGitIgnoreContent);
+  }
+
+  private get shadowGitRepository(): SimpleGit {
+    const repoDir = this.getHistoryDir();
+    return simpleGit(this.projectRoot).env({
+      GIT_DIR: path.join(repoDir, '.git'),
+      GIT_WORK_TREE: this.projectRoot,
+      // Prevent git from using the user's global git config.
+      HOME: repoDir,
+      XDG_CONFIG_HOME: repoDir,
+    });
+  }
+
+  async getCurrentCommitHash(): Promise<string> {
+    const hash = await this.shadowGitRepository.raw('rev-parse', 'HEAD');
+    return hash.trim();
+  }
+
+  async createFileSnapshot(message: string): Promise<string> {
+    const repo = this.shadowGitRepository;
+    await repo.add('.');
+    const commitResult = await repo.commit(message);
+    return commitResult.commit;
+  }
+
+  async restoreProjectFromSnapshot(commitHash: string): Promise<void> {
+    const repo = this.shadowGitRepository;
+    await repo.raw(['restore', '--source', commitHash, '.']);
+    // Removes any untracked files that were introduced post snapshot.
+    await repo.clean('f', ['-d']);
+  }
+}

projects/ui/qwen-code/packages/core/src/services/loopDetectionService.test.ts

@@ -0,0 +1,700 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Config } from '../config/config.js';
+import { GeminiClient } from '../core/client.js';
+import {
+  GeminiEventType,
+  ServerGeminiContentEvent,
+  ServerGeminiStreamEvent,
+  ServerGeminiToolCallRequestEvent,
+} from '../core/turn.js';
+import * as loggers from '../telemetry/loggers.js';
+import { LoopType } from '../telemetry/types.js';
+import { LoopDetectionService } from './loopDetectionService.js';
+
+vi.mock('../telemetry/loggers.js', () => ({
+  logLoopDetected: vi.fn(),
+  logApiError: vi.fn(),
+  logApiResponse: vi.fn(),
+}));
+
+const TOOL_CALL_LOOP_THRESHOLD = 5;
+const CONTENT_LOOP_THRESHOLD = 10;
+const CONTENT_CHUNK_SIZE = 50;
+
+describe('LoopDetectionService', () => {
+  let service: LoopDetectionService;
+  let mockConfig: Config;
+
+  beforeEach(() => {
+    mockConfig = {
+      getTelemetryEnabled: () => true,
+    } as unknown as Config;
+    service = new LoopDetectionService(mockConfig);
+    vi.clearAllMocks();
+  });
+
+  const createToolCallRequestEvent = (
+    name: string,
+    args: Record<string, unknown>,
+  ): ServerGeminiToolCallRequestEvent => ({
+    type: GeminiEventType.ToolCallRequest,
+    value: {
+      name,
+      args,
+      callId: 'test-id',
+      isClientInitiated: false,
+      prompt_id: 'test-prompt-id',
+    },
+  });
+
+  const createContentEvent = (content: string): ServerGeminiContentEvent => ({
+    type: GeminiEventType.Content,
+    value: content,
+  });
+
+  const createRepetitiveContent = (id: number, length: number): string => {
+    const baseString = `This is a unique sentence, id=${id}. `;
+    let content = '';
+    while (content.length < length) {
+      content += baseString;
+    }
+    return content.slice(0, length);
+  };
+
+  describe('Tool Call Loop Detection', () => {
+    it(`should not detect a loop for fewer than TOOL_CALL_LOOP_THRESHOLD identical calls`, () => {
+      const event = createToolCallRequestEvent('testTool', { param: 'value' });
+      for (let i = 0; i < TOOL_CALL_LOOP_THRESHOLD - 1; i++) {
+        expect(service.addAndCheck(event)).toBe(false);
+      }
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it(`should detect a loop on the TOOL_CALL_LOOP_THRESHOLD-th identical call`, () => {
+      const event = createToolCallRequestEvent('testTool', { param: 'value' });
+      for (let i = 0; i < TOOL_CALL_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(event);
+      }
+      expect(service.addAndCheck(event)).toBe(true);
+      expect(loggers.logLoopDetected).toHaveBeenCalledTimes(1);
+    });
+
+    it('should detect a loop on subsequent identical calls', () => {
+      const event = createToolCallRequestEvent('testTool', { param: 'value' });
+      for (let i = 0; i < TOOL_CALL_LOOP_THRESHOLD; i++) {
+        service.addAndCheck(event);
+      }
+      expect(service.addAndCheck(event)).toBe(true);
+      expect(loggers.logLoopDetected).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not detect a loop for different tool calls', () => {
+      const event1 = createToolCallRequestEvent('testTool', {
+        param: 'value1',
+      });
+      const event2 = createToolCallRequestEvent('testTool', {
+        param: 'value2',
+      });
+      const event3 = createToolCallRequestEvent('anotherTool', {
+        param: 'value1',
+      });
+
+      for (let i = 0; i < TOOL_CALL_LOOP_THRESHOLD - 2; i++) {
+        expect(service.addAndCheck(event1)).toBe(false);
+        expect(service.addAndCheck(event2)).toBe(false);
+        expect(service.addAndCheck(event3)).toBe(false);
+      }
+    });
+
+    it('should not reset tool call counter for other event types', () => {
+      const toolCallEvent = createToolCallRequestEvent('testTool', {
+        param: 'value',
+      });
+      const otherEvent = {
+        type: 'thought',
+      } as unknown as ServerGeminiStreamEvent;
+
+      // Send events just below the threshold
+      for (let i = 0; i < TOOL_CALL_LOOP_THRESHOLD - 1; i++) {
+        expect(service.addAndCheck(toolCallEvent)).toBe(false);
+      }
+
+      // Send a different event type
+      expect(service.addAndCheck(otherEvent)).toBe(false);
+
+      // Send the tool call event again, which should now trigger the loop
+      expect(service.addAndCheck(toolCallEvent)).toBe(true);
+      expect(loggers.logLoopDetected).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Content Loop Detection', () => {
+    const generateRandomString = (length: number) => {
+      let result = '';
+      const characters =
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+      const charactersLength = characters.length;
+      for (let i = 0; i < length; i++) {
+        result += characters.charAt(
+          Math.floor(Math.random() * charactersLength),
+        );
+      }
+      return result;
+    };
+
+    it('should not detect a loop for random content', () => {
+      service.reset('');
+      for (let i = 0; i < 1000; i++) {
+        const content = generateRandomString(10);
+        const isLoop = service.addAndCheck(createContentEvent(content));
+        expect(isLoop).toBe(false);
+      }
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should detect a loop when a chunk of content repeats consecutively', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      let isLoop = false;
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD; i++) {
+        isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+      }
+      expect(isLoop).toBe(true);
+      expect(loggers.logLoopDetected).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not detect a loop if repetitions are very far apart', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+      const fillerContent = generateRandomString(500);
+
+      let isLoop = false;
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD; i++) {
+        isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        isLoop = service.addAndCheck(createContentEvent(fillerContent));
+      }
+      expect(isLoop).toBe(false);
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Content Loop Detection with Code Blocks', () => {
+    it('should not detect a loop when repetitive content is inside a code block', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      service.addAndCheck(createContentEvent('```\n'));
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      const isLoop = service.addAndCheck(createContentEvent('\n```'));
+      expect(isLoop).toBe(false);
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should not detect loops when content transitions into a code block', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      // Add some repetitive content outside of code block
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 2; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // Now transition into a code block - this should prevent loop detection
+      // even though we were already close to the threshold
+      const codeBlockStart = '```javascript\n';
+      const isLoop = service.addAndCheck(createContentEvent(codeBlockStart));
+      expect(isLoop).toBe(false);
+
+      // Continue adding repetitive content inside the code block - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD; i++) {
+        const isLoopInside = service.addAndCheck(
+          createContentEvent(repeatedContent),
+        );
+        expect(isLoopInside).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should skip loop detection when already inside a code block (this.inCodeBlock)', () => {
+      service.reset('');
+
+      // Start with content that puts us inside a code block
+      service.addAndCheck(createContentEvent('Here is some code:\n```\n'));
+
+      // Verify we are now inside a code block and any content should be ignored for loop detection
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD + 5; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should correctly track inCodeBlock state with multiple fence transitions', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      // Outside code block - should track content
+      service.addAndCheck(createContentEvent('Normal text '));
+
+      // Enter code block (1 fence) - should stop tracking
+      const enterResult = service.addAndCheck(createContentEvent('```\n'));
+      expect(enterResult).toBe(false);
+
+      // Inside code block - should not track loops
+      for (let i = 0; i < 5; i++) {
+        const insideResult = service.addAndCheck(
+          createContentEvent(repeatedContent),
+        );
+        expect(insideResult).toBe(false);
+      }
+
+      // Exit code block (2nd fence) - should reset tracking but still return false
+      const exitResult = service.addAndCheck(createContentEvent('```\n'));
+      expect(exitResult).toBe(false);
+
+      // Enter code block again (3rd fence) - should stop tracking again
+      const reenterResult = service.addAndCheck(
+        createContentEvent('```python\n'),
+      );
+      expect(reenterResult).toBe(false);
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should detect a loop when repetitive content is outside a code block', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      service.addAndCheck(createContentEvent('```'));
+      service.addAndCheck(createContentEvent('\nsome code\n'));
+      service.addAndCheck(createContentEvent('```'));
+
+      let isLoop = false;
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD; i++) {
+        isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+      }
+      expect(isLoop).toBe(true);
+      expect(loggers.logLoopDetected).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle content with multiple code blocks and no loops', () => {
+      service.reset('');
+      service.addAndCheck(createContentEvent('```\ncode1\n```'));
+      service.addAndCheck(createContentEvent('\nsome text\n'));
+      const isLoop = service.addAndCheck(createContentEvent('```\ncode2\n```'));
+
+      expect(isLoop).toBe(false);
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should handle content with mixed code blocks and looping text', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      service.addAndCheck(createContentEvent('```'));
+      service.addAndCheck(createContentEvent('\ncode1\n'));
+      service.addAndCheck(createContentEvent('```'));
+
+      let isLoop = false;
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD; i++) {
+        isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      expect(isLoop).toBe(true);
+      expect(loggers.logLoopDetected).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not detect a loop for a long code block with some repeating tokens', () => {
+      service.reset('');
+      const repeatingTokens =
+        'for (let i = 0; i < 10; i++) { console.log(i); }';
+
+      service.addAndCheck(createContentEvent('```\n'));
+
+      for (let i = 0; i < 20; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatingTokens));
+        expect(isLoop).toBe(false);
+      }
+
+      const isLoop = service.addAndCheck(createContentEvent('\n```'));
+      expect(isLoop).toBe(false);
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking when a code fence is found', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // This should not trigger a loop because of the reset
+      service.addAndCheck(createContentEvent('```'));
+
+      // We are now in a code block, so loop detection should be off.
+      // Let's add the repeated content again, it should not trigger a loop.
+      let isLoop = false;
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD; i++) {
+        isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+    it('should reset tracking when a table is detected', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // This should reset tracking and not trigger a loop
+      service.addAndCheck(createContentEvent('| Column 1 | Column 2 |'));
+
+      // Add more repeated content after table - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking when a list item is detected', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // This should reset tracking and not trigger a loop
+      service.addAndCheck(createContentEvent('* List item'));
+
+      // Add more repeated content after list - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking when a heading is detected', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // This should reset tracking and not trigger a loop
+      service.addAndCheck(createContentEvent('## Heading'));
+
+      // Add more repeated content after heading - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking when a blockquote is detected', () => {
+      service.reset('');
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        service.addAndCheck(createContentEvent(repeatedContent));
+      }
+
+      // This should reset tracking and not trigger a loop
+      service.addAndCheck(createContentEvent('> Quote text'));
+
+      // Add more repeated content after blockquote - should not trigger loop
+      for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+        const isLoop = service.addAndCheck(createContentEvent(repeatedContent));
+        expect(isLoop).toBe(false);
+      }
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking for various list item formats', () => {
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      // Test different list formats - make sure they start at beginning of line
+      const listFormats = [
+        '* Bullet item',
+        '- Dash item',
+        '+ Plus item',
+        '1. Numbered item',
+        '42. Another numbered item',
+      ];
+
+      listFormats.forEach((listFormat, index) => {
+        service.reset('');
+
+        // Build up to near threshold
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          service.addAndCheck(createContentEvent(repeatedContent));
+        }
+
+        // Reset should occur with list item - add newline to ensure it starts at beginning
+        service.addAndCheck(createContentEvent('\n' + listFormat));
+
+        // Should not trigger loop after reset - use different content to avoid any cached state issues
+        const newRepeatedContent = createRepetitiveContent(
+          index + 100,
+          CONTENT_CHUNK_SIZE,
+        );
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          const isLoop = service.addAndCheck(
+            createContentEvent(newRepeatedContent),
+          );
+          expect(isLoop).toBe(false);
+        }
+      });
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking for various table formats', () => {
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      const tableFormats = [
+        '| Column 1 | Column 2 |',
+        '|---|---|',
+        '|++|++|',
+        '+---+---+',
+      ];
+
+      tableFormats.forEach((tableFormat, index) => {
+        service.reset('');
+
+        // Build up to near threshold
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          service.addAndCheck(createContentEvent(repeatedContent));
+        }
+
+        // Reset should occur with table format - add newline to ensure it starts at beginning
+        service.addAndCheck(createContentEvent('\n' + tableFormat));
+
+        // Should not trigger loop after reset - use different content to avoid any cached state issues
+        const newRepeatedContent = createRepetitiveContent(
+          index + 200,
+          CONTENT_CHUNK_SIZE,
+        );
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          const isLoop = service.addAndCheck(
+            createContentEvent(newRepeatedContent),
+          );
+          expect(isLoop).toBe(false);
+        }
+      });
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+
+    it('should reset tracking for various heading levels', () => {
+      const repeatedContent = createRepetitiveContent(1, CONTENT_CHUNK_SIZE);
+
+      const headingFormats = [
+        '# H1 Heading',
+        '## H2 Heading',
+        '### H3 Heading',
+        '#### H4 Heading',
+        '##### H5 Heading',
+        '###### H6 Heading',
+      ];
+
+      headingFormats.forEach((headingFormat, index) => {
+        service.reset('');
+
+        // Build up to near threshold
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          service.addAndCheck(createContentEvent(repeatedContent));
+        }
+
+        // Reset should occur with heading - add newline to ensure it starts at beginning
+        service.addAndCheck(createContentEvent('\n' + headingFormat));
+
+        // Should not trigger loop after reset - use different content to avoid any cached state issues
+        const newRepeatedContent = createRepetitiveContent(
+          index + 300,
+          CONTENT_CHUNK_SIZE,
+        );
+        for (let i = 0; i < CONTENT_LOOP_THRESHOLD - 1; i++) {
+          const isLoop = service.addAndCheck(
+            createContentEvent(newRepeatedContent),
+          );
+          expect(isLoop).toBe(false);
+        }
+      });
+
+      expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty content', () => {
+      const event = createContentEvent('');
+      expect(service.addAndCheck(event)).toBe(false);
+    });
+  });
+
+  describe('Reset Functionality', () => {
+    it('tool call should reset content count', () => {
+      const contentEvent = createContentEvent('Some content.');
+      const toolEvent = createToolCallRequestEvent('testTool', {
+        param: 'value',
+      });
+      for (let i = 0; i < 9; i++) {
+        service.addAndCheck(contentEvent);
+      }
+
+      service.addAndCheck(toolEvent);
+
+      // Should start fresh
+      expect(service.addAndCheck(createContentEvent('Fresh content.'))).toBe(
+        false,
+      );
+    });
+  });
+
+  describe('General Behavior', () => {
+    it('should return false for unhandled event types', () => {
+      const otherEvent = {
+        type: 'unhandled_event',
+      } as unknown as ServerGeminiStreamEvent;
+      expect(service.addAndCheck(otherEvent)).toBe(false);
+      expect(service.addAndCheck(otherEvent)).toBe(false);
+    });
+  });
+});
+
+describe('LoopDetectionService LLM Checks', () => {
+  let service: LoopDetectionService;
+  let mockConfig: Config;
+  let mockGeminiClient: GeminiClient;
+  let abortController: AbortController;
+
+  beforeEach(() => {
+    mockGeminiClient = {
+      getHistory: vi.fn().mockReturnValue([]),
+      generateJson: vi.fn(),
+    } as unknown as GeminiClient;
+
+    mockConfig = {
+      getGeminiClient: () => mockGeminiClient,
+      getDebugMode: () => false,
+      getTelemetryEnabled: () => true,
+    } as unknown as Config;
+
+    service = new LoopDetectionService(mockConfig);
+    abortController = new AbortController();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const advanceTurns = async (count: number) => {
+    for (let i = 0; i < count; i++) {
+      await service.turnStarted(abortController.signal);
+    }
+  };
+
+  it('should not trigger LLM check before LLM_CHECK_AFTER_TURNS', async () => {
+    await advanceTurns(29);
+    expect(mockGeminiClient.generateJson).not.toHaveBeenCalled();
+  });
+
+  it('should trigger LLM check on the 30th turn', async () => {
+    mockGeminiClient.generateJson = vi
+      .fn()
+      .mockResolvedValue({ confidence: 0.1 });
+    await advanceTurns(30);
+    expect(mockGeminiClient.generateJson).toHaveBeenCalledTimes(1);
+  });
+
+  it('should detect a cognitive loop when confidence is high', async () => {
+    // First check at turn 30
+    mockGeminiClient.generateJson = vi
+      .fn()
+      .mockResolvedValue({ confidence: 0.85, reasoning: 'Repetitive actions' });
+    await advanceTurns(30);
+    expect(mockGeminiClient.generateJson).toHaveBeenCalledTimes(1);
+
+    // The confidence of 0.85 will result in a low interval.
+    // The interval will be: 5 + (15 - 5) * (1 - 0.85) = 5 + 10 * 0.15 = 6.5 -> rounded to 7
+    await advanceTurns(6); // advance to turn 36
+
+    mockGeminiClient.generateJson = vi
+      .fn()
+      .mockResolvedValue({ confidence: 0.95, reasoning: 'Repetitive actions' });
+    const finalResult = await service.turnStarted(abortController.signal); // This is turn 37
+
+    expect(finalResult).toBe(true);
+    expect(loggers.logLoopDetected).toHaveBeenCalledWith(
+      mockConfig,
+      expect.objectContaining({
+        'event.name': 'loop_detected',
+        loop_type: LoopType.LLM_DETECTED_LOOP,
+      }),
+    );
+  });
+
+  it('should not detect a loop when confidence is low', async () => {
+    mockGeminiClient.generateJson = vi
+      .fn()
+      .mockResolvedValue({ confidence: 0.5, reasoning: 'Looks okay' });
+    await advanceTurns(30);
+    const result = await service.turnStarted(abortController.signal);
+    expect(result).toBe(false);
+    expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+  });
+
+  it('should adjust the check interval based on confidence', async () => {
+    // Confidence is 0.0, so interval should be MAX_LLM_CHECK_INTERVAL (15)
+    mockGeminiClient.generateJson = vi
+      .fn()
+      .mockResolvedValue({ confidence: 0.0 });
+    await advanceTurns(30); // First check at turn 30
+    expect(mockGeminiClient.generateJson).toHaveBeenCalledTimes(1);
+
+    await advanceTurns(14); // Advance to turn 44
+    expect(mockGeminiClient.generateJson).toHaveBeenCalledTimes(1);
+
+    await service.turnStarted(abortController.signal); // Turn 45
+    expect(mockGeminiClient.generateJson).toHaveBeenCalledTimes(2);
+  });
+
+  it('should handle errors from generateJson gracefully', async () => {
+    mockGeminiClient.generateJson = vi
+      .fn()
+      .mockRejectedValue(new Error('API error'));
+    await advanceTurns(30);
+    const result = await service.turnStarted(abortController.signal);
+    expect(result).toBe(false);
+    expect(loggers.logLoopDetected).not.toHaveBeenCalled();
+  });
+});

projects/ui/qwen-code/packages/core/src/services/loopDetectionService.ts

@@ -0,0 +1,420 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { createHash } from 'crypto';
+import { GeminiEventType, ServerGeminiStreamEvent } from '../core/turn.js';
+import { logLoopDetected } from '../telemetry/loggers.js';
+import { LoopDetectedEvent, LoopType } from '../telemetry/types.js';
+import { Config, DEFAULT_GEMINI_FLASH_MODEL } from '../config/config.js';
+
+const TOOL_CALL_LOOP_THRESHOLD = 5;
+const CONTENT_LOOP_THRESHOLD = 10;
+const CONTENT_CHUNK_SIZE = 50;
+const MAX_HISTORY_LENGTH = 1000;
+
+/**
+ * The number of recent conversation turns to include in the history when asking the LLM to check for a loop.
+ */
+const LLM_LOOP_CHECK_HISTORY_COUNT = 20;
+
+/**
+ * The number of turns that must pass in a single prompt before the LLM-based loop check is activated.
+ */
+const LLM_CHECK_AFTER_TURNS = 30;
+
+/**
+ * The default interval, in number of turns, at which the LLM-based loop check is performed.
+ * This value is adjusted dynamically based on the LLM's confidence.
+ */
+const DEFAULT_LLM_CHECK_INTERVAL = 3;
+
+/**
+ * The minimum interval for LLM-based loop checks.
+ * This is used when the confidence of a loop is high, to check more frequently.
+ */
+const MIN_LLM_CHECK_INTERVAL = 5;
+
+/**
+ * The maximum interval for LLM-based loop checks.
+ * This is used when the confidence of a loop is low, to check less frequently.
+ */
+const MAX_LLM_CHECK_INTERVAL = 15;
+
+/**
+ * Service for detecting and preventing infinite loops in AI responses.
+ * Monitors tool call repetitions and content sentence repetitions.
+ */
+export class LoopDetectionService {
+  private readonly config: Config;
+  private promptId = '';
+
+  // Tool call tracking
+  private lastToolCallKey: string | null = null;
+  private toolCallRepetitionCount: number = 0;
+
+  // Content streaming tracking
+  private streamContentHistory = '';
+  private contentStats = new Map<string, number[]>();
+  private lastContentIndex = 0;
+  private loopDetected = false;
+  private inCodeBlock = false;
+
+  // LLM loop track tracking
+  private turnsInCurrentPrompt = 0;
+  private llmCheckInterval = DEFAULT_LLM_CHECK_INTERVAL;
+  private lastCheckTurn = 0;
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  private getToolCallKey(toolCall: { name: string; args: object }): string {
+    const argsString = JSON.stringify(toolCall.args);
+    const keyString = `${toolCall.name}:${argsString}`;
+    return createHash('sha256').update(keyString).digest('hex');
+  }
+
+  /**
+   * Processes a stream event and checks for loop conditions.
+   * @param event - The stream event to process
+   * @returns true if a loop is detected, false otherwise
+   */
+  addAndCheck(event: ServerGeminiStreamEvent): boolean {
+    if (this.loopDetected) {
+      return true;
+    }
+
+    switch (event.type) {
+      case GeminiEventType.ToolCallRequest:
+        // content chanting only happens in one single stream, reset if there
+        // is a tool call in between
+        this.resetContentTracking();
+        this.loopDetected = this.checkToolCallLoop(event.value);
+        break;
+      case GeminiEventType.Content:
+        this.loopDetected = this.checkContentLoop(event.value);
+        break;
+      default:
+        break;
+    }
+    return this.loopDetected;
+  }
+
+  /**
+   * Signals the start of a new turn in the conversation.
+   *
+   * This method increments the turn counter and, if specific conditions are met,
+   * triggers an LLM-based check to detect potential conversation loops. The check
+   * is performed periodically based on the `llmCheckInterval`.
+   *
+   * @param signal - An AbortSignal to allow for cancellation of the asynchronous LLM check.
+   * @returns A promise that resolves to `true` if a loop is detected, and `false` otherwise.
+   */
+  async turnStarted(signal: AbortSignal) {
+    this.turnsInCurrentPrompt++;
+
+    if (
+      this.turnsInCurrentPrompt >= LLM_CHECK_AFTER_TURNS &&
+      this.turnsInCurrentPrompt - this.lastCheckTurn >= this.llmCheckInterval
+    ) {
+      this.lastCheckTurn = this.turnsInCurrentPrompt;
+      return await this.checkForLoopWithLLM(signal);
+    }
+
+    return false;
+  }
+
+  private checkToolCallLoop(toolCall: { name: string; args: object }): boolean {
+    const key = this.getToolCallKey(toolCall);
+    if (this.lastToolCallKey === key) {
+      this.toolCallRepetitionCount++;
+    } else {
+      this.lastToolCallKey = key;
+      this.toolCallRepetitionCount = 1;
+    }
+    if (this.toolCallRepetitionCount >= TOOL_CALL_LOOP_THRESHOLD) {
+      logLoopDetected(
+        this.config,
+        new LoopDetectedEvent(
+          LoopType.CONSECUTIVE_IDENTICAL_TOOL_CALLS,
+          this.promptId,
+        ),
+      );
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Detects content loops by analyzing streaming text for repetitive patterns.
+   *
+   * The algorithm works by:
+   * 1. Appending new content to the streaming history
+   * 2. Truncating history if it exceeds the maximum length
+   * 3. Analyzing content chunks for repetitive patterns using hashing
+   * 4. Detecting loops when identical chunks appear frequently within a short distance
+   * 5. Disabling loop detection within code blocks to prevent false positives,
+   *    as repetitive code structures are common and not necessarily loops.
+   */
+  private checkContentLoop(content: string): boolean {
+    // Different content elements can often contain repetitive syntax that is not indicative of a loop.
+    // To avoid false positives, we detect when we encounter different content types and
+    // reset tracking to avoid analyzing content that spans across different element boundaries.
+    const numFences = (content.match(/```/g) ?? []).length;
+    const hasTable = /(^|\n)\s*(\|.*\||[|+-]{3,})/.test(content);
+    const hasListItem =
+      /(^|\n)\s*[*-+]\s/.test(content) || /(^|\n)\s*\d+\.\s/.test(content);
+    const hasHeading = /(^|\n)#+\s/.test(content);
+    const hasBlockquote = /(^|\n)>\s/.test(content);
+
+    if (numFences || hasTable || hasListItem || hasHeading || hasBlockquote) {
+      // Reset tracking when different content elements are detected to avoid analyzing content
+      // that spans across different element boundaries.
+      this.resetContentTracking();
+    }
+
+    const wasInCodeBlock = this.inCodeBlock;
+    this.inCodeBlock =
+      numFences % 2 === 0 ? this.inCodeBlock : !this.inCodeBlock;
+    if (wasInCodeBlock || this.inCodeBlock) {
+      return false;
+    }
+
+    this.streamContentHistory += content;
+
+    this.truncateAndUpdate();
+    return this.analyzeContentChunksForLoop();
+  }
+
+  /**
+   * Truncates the content history to prevent unbounded memory growth.
+   * When truncating, adjusts all stored indices to maintain their relative positions.
+   */
+  private truncateAndUpdate(): void {
+    if (this.streamContentHistory.length <= MAX_HISTORY_LENGTH) {
+      return;
+    }
+
+    // Calculate how much content to remove from the beginning
+    const truncationAmount =
+      this.streamContentHistory.length - MAX_HISTORY_LENGTH;
+    this.streamContentHistory =
+      this.streamContentHistory.slice(truncationAmount);
+    this.lastContentIndex = Math.max(
+      0,
+      this.lastContentIndex - truncationAmount,
+    );
+
+    // Update all stored chunk indices to account for the truncation
+    for (const [hash, oldIndices] of this.contentStats.entries()) {
+      const adjustedIndices = oldIndices
+        .map((index) => index - truncationAmount)
+        .filter((index) => index >= 0);
+
+      if (adjustedIndices.length > 0) {
+        this.contentStats.set(hash, adjustedIndices);
+      } else {
+        this.contentStats.delete(hash);
+      }
+    }
+  }
+
+  /**
+   * Analyzes content in fixed-size chunks to detect repetitive patterns.
+   *
+   * Uses a sliding window approach:
+   * 1. Extract chunks of fixed size (CONTENT_CHUNK_SIZE)
+   * 2. Hash each chunk for efficient comparison
+   * 3. Track positions where identical chunks appear
+   * 4. Detect loops when chunks repeat frequently within a short distance
+   */
+  private analyzeContentChunksForLoop(): boolean {
+    while (this.hasMoreChunksToProcess()) {
+      // Extract current chunk of text
+      const currentChunk = this.streamContentHistory.substring(
+        this.lastContentIndex,
+        this.lastContentIndex + CONTENT_CHUNK_SIZE,
+      );
+      const chunkHash = createHash('sha256').update(currentChunk).digest('hex');
+
+      if (this.isLoopDetectedForChunk(currentChunk, chunkHash)) {
+        logLoopDetected(
+          this.config,
+          new LoopDetectedEvent(
+            LoopType.CHANTING_IDENTICAL_SENTENCES,
+            this.promptId,
+          ),
+        );
+        return true;
+      }
+
+      // Move to next position in the sliding window
+      this.lastContentIndex++;
+    }
+
+    return false;
+  }
+
+  private hasMoreChunksToProcess(): boolean {
+    return (
+      this.lastContentIndex + CONTENT_CHUNK_SIZE <=
+      this.streamContentHistory.length
+    );
+  }
+
+  /**
+   * Determines if a content chunk indicates a loop pattern.
+   *
+   * Loop detection logic:
+   * 1. Check if we've seen this hash before (new chunks are stored for future comparison)
+   * 2. Verify actual content matches to prevent hash collisions
+   * 3. Track all positions where this chunk appears
+   * 4. A loop is detected when the same chunk appears CONTENT_LOOP_THRESHOLD times
+   *    within a small average distance (≤ 1.5 * chunk size)
+   */
+  private isLoopDetectedForChunk(chunk: string, hash: string): boolean {
+    const existingIndices = this.contentStats.get(hash);
+
+    if (!existingIndices) {
+      this.contentStats.set(hash, [this.lastContentIndex]);
+      return false;
+    }
+
+    if (!this.isActualContentMatch(chunk, existingIndices[0])) {
+      return false;
+    }
+
+    existingIndices.push(this.lastContentIndex);
+
+    if (existingIndices.length < CONTENT_LOOP_THRESHOLD) {
+      return false;
+    }
+
+    // Analyze the most recent occurrences to see if they're clustered closely together
+    const recentIndices = existingIndices.slice(-CONTENT_LOOP_THRESHOLD);
+    const totalDistance =
+      recentIndices[recentIndices.length - 1] - recentIndices[0];
+    const averageDistance = totalDistance / (CONTENT_LOOP_THRESHOLD - 1);
+    const maxAllowedDistance = CONTENT_CHUNK_SIZE * 1.5;
+
+    return averageDistance <= maxAllowedDistance;
+  }
+
+  /**
+   * Verifies that two chunks with the same hash actually contain identical content.
+   * This prevents false positives from hash collisions.
+   */
+  private isActualContentMatch(
+    currentChunk: string,
+    originalIndex: number,
+  ): boolean {
+    const originalChunk = this.streamContentHistory.substring(
+      originalIndex,
+      originalIndex + CONTENT_CHUNK_SIZE,
+    );
+    return originalChunk === currentChunk;
+  }
+
+  private async checkForLoopWithLLM(signal: AbortSignal) {
+    const recentHistory = this.config
+      .getGeminiClient()
+      .getHistory()
+      .slice(-LLM_LOOP_CHECK_HISTORY_COUNT);
+
+    const prompt = `You are a sophisticated AI diagnostic agent specializing in identifying when a conversational AI is stuck in an unproductive state. Your task is to analyze the provided conversation history and determine if the assistant has ceased to make meaningful progress.
+
+An unproductive state is characterized by one or more of the following patterns over the last 5 or more assistant turns:
+
+Repetitive Actions: The assistant repeats the same tool calls or conversational responses a decent number of times. This includes simple loops (e.g., tool_A, tool_A, tool_A) and alternating patterns (e.g., tool_A, tool_B, tool_A, tool_B, ...).
+
+Cognitive Loop: The assistant seems unable to determine the next logical step. It might express confusion, repeatedly ask the same questions, or generate responses that don't logically follow from the previous turns, indicating it's stuck and not advancing the task.
+
+Crucially, differentiate between a true unproductive state and legitimate, incremental progress.
+For example, a series of 'tool_A' or 'tool_B' tool calls that make small, distinct changes to the same file (like adding docstrings to functions one by one) is considered forward progress and is NOT a loop. A loop would be repeatedly replacing the same text with the same content, or cycling between a small set of files with no net change.
+
+Please analyze the conversation history to determine the possibility that the conversation is stuck in a repetitive, non-productive state.`;
+    const contents = [
+      ...recentHistory,
+      { role: 'user', parts: [{ text: prompt }] },
+    ];
+    const schema: Record<string, unknown> = {
+      type: 'object',
+      properties: {
+        reasoning: {
+          type: 'string',
+          description:
+            'Your reasoning on if the conversation is looping without forward progress.',
+        },
+        confidence: {
+          type: 'number',
+          description:
+            'A number between 0.0 and 1.0 representing your confidence that the conversation is in an unproductive state.',
+        },
+      },
+      required: ['reasoning', 'confidence'],
+    };
+    let result;
+    try {
+      result = await this.config
+        .getGeminiClient()
+        .generateJson(contents, schema, signal, DEFAULT_GEMINI_FLASH_MODEL);
+    } catch (e) {
+      // Do nothing, treat it as a non-loop.
+      this.config.getDebugMode() ? console.error(e) : console.debug(e);
+      return false;
+    }
+
+    if (typeof result['confidence'] === 'number') {
+      if (result['confidence'] > 0.9) {
+        if (typeof result['reasoning'] === 'string' && result['reasoning']) {
+          console.warn(result['reasoning']);
+        }
+        logLoopDetected(
+          this.config,
+          new LoopDetectedEvent(LoopType.LLM_DETECTED_LOOP, this.promptId),
+        );
+        return true;
+      } else {
+        this.llmCheckInterval = Math.round(
+          MIN_LLM_CHECK_INTERVAL +
+            (MAX_LLM_CHECK_INTERVAL - MIN_LLM_CHECK_INTERVAL) *
+              (1 - result['confidence']),
+        );
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Resets all loop detection state.
+   */
+  reset(promptId: string): void {
+    this.promptId = promptId;
+    this.resetToolCallCount();
+    this.resetContentTracking();
+    this.resetLlmCheckTracking();
+    this.loopDetected = false;
+  }
+
+  private resetToolCallCount(): void {
+    this.lastToolCallKey = null;
+    this.toolCallRepetitionCount = 0;
+  }
+
+  private resetContentTracking(resetHistory = true): void {
+    if (resetHistory) {
+      this.streamContentHistory = '';
+    }
+    this.contentStats.clear();
+    this.lastContentIndex = 0;
+  }
+
+  private resetLlmCheckTracking(): void {
+    this.turnsInCurrentPrompt = 0;
+    this.llmCheckInterval = DEFAULT_LLM_CHECK_INTERVAL;
+    this.lastCheckTurn = 0;
+  }
+}

projects/ui/qwen-code/packages/core/src/services/shellExecutionService.test.ts

@@ -0,0 +1,750 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, type Mock } from 'vitest';
+import EventEmitter from 'events';
+import { Readable } from 'stream';
+import { type ChildProcess } from 'child_process';
+import {
+  ShellExecutionService,
+  ShellOutputEvent,
+} from './shellExecutionService.js';
+
+// Hoisted Mocks
+const mockPtySpawn = vi.hoisted(() => vi.fn());
+const mockCpSpawn = vi.hoisted(() => vi.fn());
+const mockIsBinary = vi.hoisted(() => vi.fn());
+const mockPlatform = vi.hoisted(() => vi.fn());
+const mockGetPty = vi.hoisted(() => vi.fn());
+
+// Top-level Mocks
+vi.mock('@lydell/node-pty', () => ({
+  spawn: mockPtySpawn,
+}));
+vi.mock('child_process', () => ({
+  spawn: mockCpSpawn,
+}));
+vi.mock('../utils/textUtils.js', () => ({
+  isBinary: mockIsBinary,
+}));
+vi.mock('os', () => ({
+  default: {
+    platform: mockPlatform,
+    constants: {
+      signals: {
+        SIGTERM: 15,
+        SIGKILL: 9,
+      },
+    },
+  },
+  platform: mockPlatform,
+  constants: {
+    signals: {
+      SIGTERM: 15,
+      SIGKILL: 9,
+    },
+  },
+}));
+vi.mock('../utils/getPty.js', () => ({
+  getPty: mockGetPty,
+}));
+
+const mockProcessKill = vi
+  .spyOn(process, 'kill')
+  .mockImplementation(() => true);
+
+describe('ShellExecutionService', () => {
+  let mockPtyProcess: EventEmitter & {
+    pid: number;
+    kill: Mock;
+    onData: Mock;
+    onExit: Mock;
+  };
+  let onOutputEventMock: Mock<(event: ShellOutputEvent) => void>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockIsBinary.mockReturnValue(false);
+    mockPlatform.mockReturnValue('linux');
+    mockGetPty.mockResolvedValue({
+      module: { spawn: mockPtySpawn },
+      name: 'mock-pty',
+    });
+
+    onOutputEventMock = vi.fn();
+
+    mockPtyProcess = new EventEmitter() as EventEmitter & {
+      pid: number;
+      kill: Mock;
+      onData: Mock;
+      onExit: Mock;
+    };
+    mockPtyProcess.pid = 12345;
+    mockPtyProcess.kill = vi.fn();
+    mockPtyProcess.onData = vi.fn();
+    mockPtyProcess.onExit = vi.fn();
+
+    mockPtySpawn.mockReturnValue(mockPtyProcess);
+  });
+
+  // Helper function to run a standard execution simulation
+  const simulateExecution = async (
+    command: string,
+    simulation: (
+      ptyProcess: typeof mockPtyProcess,
+      ac: AbortController,
+    ) => void,
+  ) => {
+    const abortController = new AbortController();
+    const handle = await ShellExecutionService.execute(
+      command,
+      '/test/dir',
+      onOutputEventMock,
+      abortController.signal,
+      true,
+    );
+
+    await new Promise((resolve) => setImmediate(resolve));
+    simulation(mockPtyProcess, abortController);
+    const result = await handle.result;
+    return { result, handle, abortController };
+  };
+
+  describe('Successful Execution', () => {
+    it('should execute a command and capture output', async () => {
+      const { result, handle } = await simulateExecution('ls -l', (pty) => {
+        pty.onData.mock.calls[0][0]('file1.txt\n');
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      });
+
+      expect(mockPtySpawn).toHaveBeenCalledWith(
+        'bash',
+        ['-c', 'ls -l'],
+        expect.any(Object),
+      );
+      expect(result.exitCode).toBe(0);
+      expect(result.signal).toBeNull();
+      expect(result.error).toBeNull();
+      expect(result.aborted).toBe(false);
+      expect(result.output).toBe('file1.txt');
+      expect(handle.pid).toBe(12345);
+
+      expect(onOutputEventMock).toHaveBeenCalledWith({
+        type: 'data',
+        chunk: 'file1.txt',
+      });
+    });
+
+    it('should strip ANSI codes from output', async () => {
+      const { result } = await simulateExecution('ls --color=auto', (pty) => {
+        pty.onData.mock.calls[0][0]('a\u001b[31mred\u001b[0mword');
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      });
+
+      expect(result.output).toBe('aredword');
+      expect(onOutputEventMock).toHaveBeenCalledWith({
+        type: 'data',
+        chunk: 'aredword',
+      });
+    });
+
+    it('should correctly decode multi-byte characters split across chunks', async () => {
+      const { result } = await simulateExecution('echo "你好"', (pty) => {
+        const multiByteChar = '你好';
+        pty.onData.mock.calls[0][0](multiByteChar.slice(0, 1));
+        pty.onData.mock.calls[0][0](multiByteChar.slice(1));
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      });
+      expect(result.output).toBe('你好');
+    });
+
+    it('should handle commands with no output', async () => {
+      const { result } = await simulateExecution('touch file', (pty) => {
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      });
+
+      expect(result.output).toBe('');
+      expect(onOutputEventMock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Failed Execution', () => {
+    it('should capture a non-zero exit code', async () => {
+      const { result } = await simulateExecution('a-bad-command', (pty) => {
+        pty.onData.mock.calls[0][0]('command not found');
+        pty.onExit.mock.calls[0][0]({ exitCode: 127, signal: null });
+      });
+
+      expect(result.exitCode).toBe(127);
+      expect(result.output).toBe('command not found');
+      expect(result.error).toBeNull();
+    });
+
+    it('should capture a termination signal', async () => {
+      const { result } = await simulateExecution('long-process', (pty) => {
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: 15 });
+      });
+
+      expect(result.exitCode).toBe(0);
+      expect(result.signal).toBe(15);
+    });
+
+    it('should handle a synchronous spawn error', async () => {
+      mockGetPty.mockImplementation(() => null);
+
+      mockCpSpawn.mockImplementation(() => {
+        throw new Error('Simulated PTY spawn error');
+      });
+
+      const handle = await ShellExecutionService.execute(
+        'any-command',
+        '/test/dir',
+        onOutputEventMock,
+        new AbortController().signal,
+        true,
+      );
+      const result = await handle.result;
+
+      expect(result.error).toBeInstanceOf(Error);
+      expect(result.error?.message).toContain('Simulated PTY spawn error');
+      expect(result.exitCode).toBe(1);
+      expect(result.output).toBe('');
+      expect(handle.pid).toBeUndefined();
+    });
+  });
+
+  describe('Aborting Commands', () => {
+    it('should abort a running process and set the aborted flag', async () => {
+      const { result } = await simulateExecution(
+        'sleep 10',
+        (pty, abortController) => {
+          abortController.abort();
+          pty.onExit.mock.calls[0][0]({ exitCode: 1, signal: null });
+        },
+      );
+
+      expect(result.aborted).toBe(true);
+      expect(mockPtyProcess.kill).toHaveBeenCalled();
+    });
+  });
+
+  describe('Binary Output', () => {
+    it('should detect binary output and switch to progress events', async () => {
+      mockIsBinary.mockReturnValueOnce(true);
+      const binaryChunk1 = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+      const binaryChunk2 = Buffer.from([0x0d, 0x0a, 0x1a, 0x0a]);
+
+      const { result } = await simulateExecution('cat image.png', (pty) => {
+        pty.onData.mock.calls[0][0](binaryChunk1);
+        pty.onData.mock.calls[0][0](binaryChunk2);
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      });
+
+      expect(result.rawOutput).toEqual(
+        Buffer.concat([binaryChunk1, binaryChunk2]),
+      );
+      expect(onOutputEventMock).toHaveBeenCalledTimes(3);
+      expect(onOutputEventMock.mock.calls[0][0]).toEqual({
+        type: 'binary_detected',
+      });
+      expect(onOutputEventMock.mock.calls[1][0]).toEqual({
+        type: 'binary_progress',
+        bytesReceived: 4,
+      });
+      expect(onOutputEventMock.mock.calls[2][0]).toEqual({
+        type: 'binary_progress',
+        bytesReceived: 8,
+      });
+    });
+
+    it('should not emit data events after binary is detected', async () => {
+      mockIsBinary.mockImplementation((buffer) => buffer.includes(0x00));
+
+      await simulateExecution('cat mixed_file', (pty) => {
+        pty.onData.mock.calls[0][0](Buffer.from('some text'));
+        pty.onData.mock.calls[0][0](Buffer.from([0x00, 0x01, 0x02]));
+        pty.onData.mock.calls[0][0](Buffer.from('more text'));
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      });
+
+      const eventTypes = onOutputEventMock.mock.calls.map(
+        (call: [ShellOutputEvent]) => call[0].type,
+      );
+      expect(eventTypes).toEqual([
+        'data',
+        'binary_detected',
+        'binary_progress',
+        'binary_progress',
+      ]);
+    });
+  });
+
+  describe('Platform-Specific Behavior', () => {
+    it('should use cmd.exe on Windows', async () => {
+      mockPlatform.mockReturnValue('win32');
+      await simulateExecution('dir "foo bar"', (pty) =>
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null }),
+      );
+
+      expect(mockPtySpawn).toHaveBeenCalledWith(
+        'cmd.exe',
+        ['/c', 'dir "foo bar"'],
+        expect.any(Object),
+      );
+    });
+
+    it('should use bash on Linux', async () => {
+      mockPlatform.mockReturnValue('linux');
+      await simulateExecution('ls "foo bar"', (pty) =>
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null }),
+      );
+
+      expect(mockPtySpawn).toHaveBeenCalledWith(
+        'bash',
+        ['-c', 'ls "foo bar"'],
+        expect.any(Object),
+      );
+    });
+  });
+});
+
+describe('ShellExecutionService child_process fallback', () => {
+  let mockChildProcess: EventEmitter & Partial<ChildProcess>;
+  let onOutputEventMock: Mock<(event: ShellOutputEvent) => void>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockIsBinary.mockReturnValue(false);
+    mockPlatform.mockReturnValue('linux');
+    mockGetPty.mockResolvedValue(null);
+
+    onOutputEventMock = vi.fn();
+
+    mockChildProcess = new EventEmitter() as EventEmitter &
+      Partial<ChildProcess>;
+    mockChildProcess.stdout = new EventEmitter() as Readable;
+    mockChildProcess.stderr = new EventEmitter() as Readable;
+    mockChildProcess.kill = vi.fn();
+
+    Object.defineProperty(mockChildProcess, 'pid', {
+      value: 12345,
+      configurable: true,
+    });
+
+    mockCpSpawn.mockReturnValue(mockChildProcess);
+  });
+
+  // Helper function to run a standard execution simulation
+  const simulateExecution = async (
+    command: string,
+    simulation: (cp: typeof mockChildProcess, ac: AbortController) => void,
+  ) => {
+    const abortController = new AbortController();
+    const handle = await ShellExecutionService.execute(
+      command,
+      '/test/dir',
+      onOutputEventMock,
+      abortController.signal,
+      true,
+    );
+
+    await new Promise((resolve) => setImmediate(resolve));
+    simulation(mockChildProcess, abortController);
+    const result = await handle.result;
+    return { result, handle, abortController };
+  };
+
+  describe('Successful Execution', () => {
+    it('should execute a command and capture stdout and stderr', async () => {
+      const { result, handle } = await simulateExecution('ls -l', (cp) => {
+        cp.stdout?.emit('data', Buffer.from('file1.txt\n'));
+        cp.stderr?.emit('data', Buffer.from('a warning'));
+        cp.emit('exit', 0, null);
+      });
+
+      expect(mockCpSpawn).toHaveBeenCalledWith(
+        'ls -l',
+        [],
+        expect.objectContaining({ shell: 'bash' }),
+      );
+      expect(result.exitCode).toBe(0);
+      expect(result.signal).toBeNull();
+      expect(result.error).toBeNull();
+      expect(result.aborted).toBe(false);
+      expect(result.output).toBe('file1.txt\na warning');
+      expect(handle.pid).toBe(12345);
+
+      expect(onOutputEventMock).toHaveBeenCalledWith({
+        type: 'data',
+        chunk: 'file1.txt\n',
+      });
+      expect(onOutputEventMock).toHaveBeenCalledWith({
+        type: 'data',
+        chunk: 'a warning',
+      });
+    });
+
+    it('should strip ANSI codes from output', async () => {
+      const { result } = await simulateExecution('ls --color=auto', (cp) => {
+        cp.stdout?.emit('data', Buffer.from('a\u001b[31mred\u001b[0mword'));
+        cp.emit('exit', 0, null);
+      });
+
+      expect(result.output).toBe('aredword');
+      expect(onOutputEventMock).toHaveBeenCalledWith({
+        type: 'data',
+        chunk: 'aredword',
+      });
+    });
+
+    it('should correctly decode multi-byte characters split across chunks', async () => {
+      const { result } = await simulateExecution('echo "你好"', (cp) => {
+        const multiByteChar = Buffer.from('你好', 'utf-8');
+        cp.stdout?.emit('data', multiByteChar.slice(0, 2));
+        cp.stdout?.emit('data', multiByteChar.slice(2));
+        cp.emit('exit', 0, null);
+      });
+      expect(result.output).toBe('你好');
+    });
+
+    it('should handle commands with no output', async () => {
+      const { result } = await simulateExecution('touch file', (cp) => {
+        cp.emit('exit', 0, null);
+      });
+
+      expect(result.output).toBe('');
+      expect(onOutputEventMock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Failed Execution', () => {
+    it('should capture a non-zero exit code and format output correctly', async () => {
+      const { result } = await simulateExecution('a-bad-command', (cp) => {
+        cp.stderr?.emit('data', Buffer.from('command not found'));
+        cp.emit('exit', 127, null);
+      });
+
+      expect(result.exitCode).toBe(127);
+      expect(result.output).toBe('command not found');
+      expect(result.error).toBeNull();
+    });
+
+    it('should capture a termination signal', async () => {
+      const { result } = await simulateExecution('long-process', (cp) => {
+        cp.emit('exit', null, 'SIGTERM');
+      });
+
+      expect(result.exitCode).toBeNull();
+      expect(result.signal).toBe(15);
+    });
+
+    it('should handle a spawn error', async () => {
+      const spawnError = new Error('spawn EACCES');
+      const { result } = await simulateExecution('protected-cmd', (cp) => {
+        cp.emit('error', spawnError);
+        cp.emit('exit', 1, null);
+      });
+
+      expect(result.error).toBe(spawnError);
+      expect(result.exitCode).toBe(1);
+    });
+
+    it('handles errors that do not fire the exit event', async () => {
+      const error = new Error('spawn abc ENOENT');
+      const { result } = await simulateExecution('touch cat.jpg', (cp) => {
+        cp.emit('error', error); // No exit event is fired.
+      });
+
+      expect(result.error).toBe(error);
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe('Aborting Commands', () => {
+    describe.each([
+      {
+        platform: 'linux',
+        expectedSignal: 'SIGTERM',
+        expectedExit: { signal: 'SIGKILL' as const },
+      },
+      {
+        platform: 'win32',
+        expectedCommand: 'taskkill',
+        expectedExit: { code: 1 },
+      },
+    ])(
+      'on $platform',
+      ({ platform, expectedSignal, expectedCommand, expectedExit }) => {
+        it('should abort a running process and set the aborted flag', async () => {
+          mockPlatform.mockReturnValue(platform);
+
+          const { result } = await simulateExecution(
+            'sleep 10',
+            (cp, abortController) => {
+              abortController.abort();
+              if (expectedExit.signal)
+                cp.emit('exit', null, expectedExit.signal);
+              if (typeof expectedExit.code === 'number')
+                cp.emit('exit', expectedExit.code, null);
+            },
+          );
+
+          expect(result.aborted).toBe(true);
+
+          if (platform === 'linux') {
+            expect(mockProcessKill).toHaveBeenCalledWith(
+              -mockChildProcess.pid!,
+              expectedSignal,
+            );
+          } else {
+            expect(mockCpSpawn).toHaveBeenCalledWith(expectedCommand, [
+              '/pid',
+              String(mockChildProcess.pid),
+              '/f',
+              '/t',
+            ]);
+          }
+        });
+      },
+    );
+
+    it('should gracefully attempt SIGKILL on linux if SIGTERM fails', async () => {
+      mockPlatform.mockReturnValue('linux');
+      vi.useFakeTimers();
+
+      // Don't await the result inside the simulation block for this specific test.
+      // We need to control the timeline manually.
+      const abortController = new AbortController();
+      const handle = await ShellExecutionService.execute(
+        'unresponsive_process',
+        '/test/dir',
+        onOutputEventMock,
+        abortController.signal,
+        true,
+      );
+
+      abortController.abort();
+
+      // Check the first kill signal
+      expect(mockProcessKill).toHaveBeenCalledWith(
+        -mockChildProcess.pid!,
+        'SIGTERM',
+      );
+
+      // Now, advance time past the timeout
+      await vi.advanceTimersByTimeAsync(250);
+
+      // Check the second kill signal
+      expect(mockProcessKill).toHaveBeenCalledWith(
+        -mockChildProcess.pid!,
+        'SIGKILL',
+      );
+
+      // Finally, simulate the process exiting and await the result
+      mockChildProcess.emit('exit', null, 'SIGKILL');
+      const result = await handle.result;
+
+      vi.useRealTimers();
+
+      expect(result.aborted).toBe(true);
+      expect(result.signal).toBe(9);
+      // The individual kill calls were already asserted above.
+      expect(mockProcessKill).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('Binary Output', () => {
+    it('should detect binary output and switch to progress events', async () => {
+      mockIsBinary.mockReturnValueOnce(true);
+      const binaryChunk1 = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+      const binaryChunk2 = Buffer.from([0x0d, 0x0a, 0x1a, 0x0a]);
+
+      const { result } = await simulateExecution('cat image.png', (cp) => {
+        cp.stdout?.emit('data', binaryChunk1);
+        cp.stdout?.emit('data', binaryChunk2);
+        cp.emit('exit', 0, null);
+      });
+
+      expect(result.rawOutput).toEqual(
+        Buffer.concat([binaryChunk1, binaryChunk2]),
+      );
+      expect(onOutputEventMock).toHaveBeenCalledTimes(3);
+      expect(onOutputEventMock.mock.calls[0][0]).toEqual({
+        type: 'binary_detected',
+      });
+      expect(onOutputEventMock.mock.calls[1][0]).toEqual({
+        type: 'binary_progress',
+        bytesReceived: 4,
+      });
+      expect(onOutputEventMock.mock.calls[2][0]).toEqual({
+        type: 'binary_progress',
+        bytesReceived: 8,
+      });
+    });
+
+    it('should not emit data events after binary is detected', async () => {
+      mockIsBinary.mockImplementation((buffer) => buffer.includes(0x00));
+
+      await simulateExecution('cat mixed_file', (cp) => {
+        cp.stdout?.emit('data', Buffer.from('some text'));
+        cp.stdout?.emit('data', Buffer.from([0x00, 0x01, 0x02]));
+        cp.stdout?.emit('data', Buffer.from('more text'));
+        cp.emit('exit', 0, null);
+      });
+
+      const eventTypes = onOutputEventMock.mock.calls.map(
+        (call: [ShellOutputEvent]) => call[0].type,
+      );
+      expect(eventTypes).toEqual([
+        'data',
+        'binary_detected',
+        'binary_progress',
+        'binary_progress',
+      ]);
+    });
+  });
+
+  describe('Platform-Specific Behavior', () => {
+    it('should use cmd.exe on Windows', async () => {
+      mockPlatform.mockReturnValue('win32');
+      await simulateExecution('dir "foo bar"', (cp) =>
+        cp.emit('exit', 0, null),
+      );
+
+      expect(mockCpSpawn).toHaveBeenCalledWith(
+        'dir "foo bar"',
+        [],
+        expect.objectContaining({
+          shell: true,
+          detached: false,
+        }),
+      );
+    });
+
+    it('should use bash and detached process group on Linux', async () => {
+      mockPlatform.mockReturnValue('linux');
+      await simulateExecution('ls "foo bar"', (cp) => cp.emit('exit', 0, null));
+
+      expect(mockCpSpawn).toHaveBeenCalledWith(
+        'ls "foo bar"',
+        [],
+        expect.objectContaining({
+          shell: 'bash',
+          detached: true,
+        }),
+      );
+    });
+  });
+});
+
+describe('ShellExecutionService execution method selection', () => {
+  let onOutputEventMock: Mock<(event: ShellOutputEvent) => void>;
+  let mockPtyProcess: EventEmitter & {
+    pid: number;
+    kill: Mock;
+    onData: Mock;
+    onExit: Mock;
+  };
+  let mockChildProcess: EventEmitter & Partial<ChildProcess>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    onOutputEventMock = vi.fn();
+
+    // Mock for pty
+    mockPtyProcess = new EventEmitter() as EventEmitter & {
+      pid: number;
+      kill: Mock;
+      onData: Mock;
+      onExit: Mock;
+    };
+    mockPtyProcess.pid = 12345;
+    mockPtyProcess.kill = vi.fn();
+    mockPtyProcess.onData = vi.fn();
+    mockPtyProcess.onExit = vi.fn();
+    mockPtySpawn.mockReturnValue(mockPtyProcess);
+    mockGetPty.mockResolvedValue({
+      module: { spawn: mockPtySpawn },
+      name: 'mock-pty',
+    });
+
+    // Mock for child_process
+    mockChildProcess = new EventEmitter() as EventEmitter &
+      Partial<ChildProcess>;
+    mockChildProcess.stdout = new EventEmitter() as Readable;
+    mockChildProcess.stderr = new EventEmitter() as Readable;
+    mockChildProcess.kill = vi.fn();
+    Object.defineProperty(mockChildProcess, 'pid', {
+      value: 54321,
+      configurable: true,
+    });
+    mockCpSpawn.mockReturnValue(mockChildProcess);
+  });
+
+  it('should use node-pty when shouldUseNodePty is true and pty is available', async () => {
+    const abortController = new AbortController();
+    const handle = await ShellExecutionService.execute(
+      'test command',
+      '/test/dir',
+      onOutputEventMock,
+      abortController.signal,
+      true, // shouldUseNodePty
+    );
+
+    // Simulate exit to allow promise to resolve
+    mockPtyProcess.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+    const result = await handle.result;
+
+    expect(mockGetPty).toHaveBeenCalled();
+    expect(mockPtySpawn).toHaveBeenCalled();
+    expect(mockCpSpawn).not.toHaveBeenCalled();
+    expect(result.executionMethod).toBe('mock-pty');
+  });
+
+  it('should use child_process when shouldUseNodePty is false', async () => {
+    const abortController = new AbortController();
+    const handle = await ShellExecutionService.execute(
+      'test command',
+      '/test/dir',
+      onOutputEventMock,
+      abortController.signal,
+      false, // shouldUseNodePty
+    );
+
+    // Simulate exit to allow promise to resolve
+    mockChildProcess.emit('exit', 0, null);
+    const result = await handle.result;
+
+    expect(mockGetPty).not.toHaveBeenCalled();
+    expect(mockPtySpawn).not.toHaveBeenCalled();
+    expect(mockCpSpawn).toHaveBeenCalled();
+    expect(result.executionMethod).toBe('child_process');
+  });
+
+  it('should fall back to child_process if pty is not available even if shouldUseNodePty is true', async () => {
+    mockGetPty.mockResolvedValue(null);
+
+    const abortController = new AbortController();
+    const handle = await ShellExecutionService.execute(
+      'test command',
+      '/test/dir',
+      onOutputEventMock,
+      abortController.signal,
+      true, // shouldUseNodePty
+    );
+
+    // Simulate exit to allow promise to resolve
+    mockChildProcess.emit('exit', 0, null);
+    const result = await handle.result;
+
+    expect(mockGetPty).toHaveBeenCalled();
+    expect(mockPtySpawn).not.toHaveBeenCalled();
+    expect(mockCpSpawn).toHaveBeenCalled();
+    expect(result.executionMethod).toBe('child_process');
+  });
+});

projects/ui/qwen-code/packages/core/src/services/shellExecutionService.ts

@@ -0,0 +1,460 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { getPty, PtyImplementation } from '../utils/getPty.js';
+import { spawn as cpSpawn } from 'child_process';
+import { TextDecoder } from 'util';
+import os from 'os';
+import { getCachedEncodingForBuffer } from '../utils/systemEncoding.js';
+import { isBinary } from '../utils/textUtils.js';
+import pkg from '@xterm/headless';
+import stripAnsi from 'strip-ansi';
+const { Terminal } = pkg;
+
+const SIGKILL_TIMEOUT_MS = 200;
+
+// @ts-expect-error getFullText is not a public API.
+const getFullText = (terminal: Terminal) => {
+  const buffer = terminal.buffer.active;
+  const lines: string[] = [];
+  for (let i = 0; i < buffer.length; i++) {
+    const line = buffer.getLine(i);
+    lines.push(line ? line.translateToString(true) : '');
+  }
+  return lines.join('\n').trim();
+};
+
+/** A structured result from a shell command execution. */
+export interface ShellExecutionResult {
+  /** The raw, unprocessed output buffer. */
+  rawOutput: Buffer;
+  /** The combined, decoded output as a string. */
+  output: string;
+  /** The process exit code, or null if terminated by a signal. */
+  exitCode: number | null;
+  /** The signal that terminated the process, if any. */
+  signal: number | null;
+  /** An error object if the process failed to spawn. */
+  error: Error | null;
+  /** A boolean indicating if the command was aborted by the user. */
+  aborted: boolean;
+  /** The process ID of the spawned shell. */
+  pid: number | undefined;
+  /** The method used to execute the shell command. */
+  executionMethod: 'lydell-node-pty' | 'node-pty' | 'child_process' | 'none';
+}
+
+/** A handle for an ongoing shell execution. */
+export interface ShellExecutionHandle {
+  /** The process ID of the spawned shell. */
+  pid: number | undefined;
+  /** A promise that resolves with the complete execution result. */
+  result: Promise<ShellExecutionResult>;
+}
+
+/**
+ * Describes a structured event emitted during shell command execution.
+ */
+export type ShellOutputEvent =
+  | {
+      /** The event contains a chunk of output data. */
+      type: 'data';
+      /** The decoded string chunk. */
+      chunk: string;
+    }
+  | {
+      /** Signals that the output stream has been identified as binary. */
+      type: 'binary_detected';
+    }
+  | {
+      /** Provides progress updates for a binary stream. */
+      type: 'binary_progress';
+      /** The total number of bytes received so far. */
+      bytesReceived: number;
+    };
+
+/**
+ * A centralized service for executing shell commands with robust process
+ * management, cross-platform compatibility, and streaming output capabilities.
+ *
+ */
+export class ShellExecutionService {
+  /**
+   * Executes a shell command using `node-pty`, capturing all output and lifecycle events.
+   *
+   * @param commandToExecute The exact command string to run.
+   * @param cwd The working directory to execute the command in.
+   * @param onOutputEvent A callback for streaming structured events about the execution, including data chunks and status updates.
+   * @param abortSignal An AbortSignal to terminate the process and its children.
+   * @returns An object containing the process ID (pid) and a promise that
+   *          resolves with the complete execution result.
+   */
+  static async execute(
+    commandToExecute: string,
+    cwd: string,
+    onOutputEvent: (event: ShellOutputEvent) => void,
+    abortSignal: AbortSignal,
+    shouldUseNodePty: boolean,
+    terminalColumns?: number,
+    terminalRows?: number,
+  ): Promise<ShellExecutionHandle> {
+    if (shouldUseNodePty) {
+      const ptyInfo = await getPty();
+      if (ptyInfo) {
+        try {
+          return this.executeWithPty(
+            commandToExecute,
+            cwd,
+            onOutputEvent,
+            abortSignal,
+            terminalColumns,
+            terminalRows,
+            ptyInfo,
+          );
+        } catch (_e) {
+          // Fallback to child_process
+        }
+      }
+    }
+
+    return this.childProcessFallback(
+      commandToExecute,
+      cwd,
+      onOutputEvent,
+      abortSignal,
+    );
+  }
+
+  private static childProcessFallback(
+    commandToExecute: string,
+    cwd: string,
+    onOutputEvent: (event: ShellOutputEvent) => void,
+    abortSignal: AbortSignal,
+  ): ShellExecutionHandle {
+    try {
+      const isWindows = os.platform() === 'win32';
+
+      const child = cpSpawn(commandToExecute, [], {
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: isWindows ? true : 'bash',
+        detached: !isWindows,
+        env: {
+          ...process.env,
+          QWEN_CODE: '1',
+          TERM: 'xterm-256color',
+          PAGER: 'cat',
+        },
+      });
+
+      const result = new Promise<ShellExecutionResult>((resolve) => {
+        let stdoutDecoder: TextDecoder | null = null;
+        let stderrDecoder: TextDecoder | null = null;
+
+        let stdout = '';
+        let stderr = '';
+        const outputChunks: Buffer[] = [];
+        let error: Error | null = null;
+        let exited = false;
+
+        let isStreamingRawContent = true;
+        const MAX_SNIFF_SIZE = 4096;
+        let sniffedBytes = 0;
+
+        const handleOutput = (data: Buffer, stream: 'stdout' | 'stderr') => {
+          if (!stdoutDecoder || !stderrDecoder) {
+            const encoding = getCachedEncodingForBuffer(data);
+            try {
+              stdoutDecoder = new TextDecoder(encoding);
+              stderrDecoder = new TextDecoder(encoding);
+            } catch {
+              stdoutDecoder = new TextDecoder('utf-8');
+              stderrDecoder = new TextDecoder('utf-8');
+            }
+          }
+
+          outputChunks.push(data);
+
+          if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
+            const sniffBuffer = Buffer.concat(outputChunks.slice(0, 20));
+            sniffedBytes = sniffBuffer.length;
+
+            if (isBinary(sniffBuffer)) {
+              isStreamingRawContent = false;
+              onOutputEvent({ type: 'binary_detected' });
+            }
+          }
+
+          const decoder = stream === 'stdout' ? stdoutDecoder : stderrDecoder;
+          const decodedChunk = decoder.decode(data, { stream: true });
+          const strippedChunk = stripAnsi(decodedChunk);
+
+          if (stream === 'stdout') {
+            stdout += strippedChunk;
+          } else {
+            stderr += strippedChunk;
+          }
+
+          if (isStreamingRawContent) {
+            onOutputEvent({ type: 'data', chunk: strippedChunk });
+          } else {
+            const totalBytes = outputChunks.reduce(
+              (sum, chunk) => sum + chunk.length,
+              0,
+            );
+            onOutputEvent({
+              type: 'binary_progress',
+              bytesReceived: totalBytes,
+            });
+          }
+        };
+
+        const handleExit = (
+          code: number | null,
+          signal: NodeJS.Signals | null,
+        ) => {
+          const { finalBuffer } = cleanup();
+          // Ensure we don't add an extra newline if stdout already ends with one.
+          const separator = stdout.endsWith('\n') ? '' : '\n';
+          const combinedOutput =
+            stdout + (stderr ? (stdout ? separator : '') + stderr : '');
+
+          resolve({
+            rawOutput: finalBuffer,
+            output: combinedOutput.trim(),
+            exitCode: code,
+            signal: signal ? os.constants.signals[signal] : null,
+            error,
+            aborted: abortSignal.aborted,
+            pid: child.pid,
+            executionMethod: 'child_process',
+          });
+        };
+
+        child.stdout.on('data', (data) => handleOutput(data, 'stdout'));
+        child.stderr.on('data', (data) => handleOutput(data, 'stderr'));
+        child.on('error', (err) => {
+          error = err;
+          handleExit(1, null);
+        });
+
+        const abortHandler = async () => {
+          if (child.pid && !exited) {
+            if (isWindows) {
+              cpSpawn('taskkill', ['/pid', child.pid.toString(), '/f', '/t']);
+            } else {
+              try {
+                process.kill(-child.pid, 'SIGTERM');
+                await new Promise((res) => setTimeout(res, SIGKILL_TIMEOUT_MS));
+                if (!exited) {
+                  process.kill(-child.pid, 'SIGKILL');
+                }
+              } catch (_e) {
+                if (!exited) child.kill('SIGKILL');
+              }
+            }
+          }
+        };
+
+        abortSignal.addEventListener('abort', abortHandler, { once: true });
+
+        child.on('exit', (code, signal) => {
+          handleExit(code, signal);
+        });
+
+        function cleanup() {
+          exited = true;
+          abortSignal.removeEventListener('abort', abortHandler);
+          if (stdoutDecoder) {
+            const remaining = stdoutDecoder.decode();
+            if (remaining) {
+              stdout += stripAnsi(remaining);
+            }
+          }
+          if (stderrDecoder) {
+            const remaining = stderrDecoder.decode();
+            if (remaining) {
+              stderr += stripAnsi(remaining);
+            }
+          }
+
+          const finalBuffer = Buffer.concat(outputChunks);
+
+          return { stdout, stderr, finalBuffer };
+        }
+      });
+
+      return { pid: child.pid, result };
+    } catch (e) {
+      const error = e as Error;
+      return {
+        pid: undefined,
+        result: Promise.resolve({
+          error,
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 1,
+          signal: null,
+          aborted: false,
+          pid: undefined,
+          executionMethod: 'none',
+        }),
+      };
+    }
+  }
+
+  private static executeWithPty(
+    commandToExecute: string,
+    cwd: string,
+    onOutputEvent: (event: ShellOutputEvent) => void,
+    abortSignal: AbortSignal,
+    terminalColumns: number | undefined,
+    terminalRows: number | undefined,
+    ptyInfo: PtyImplementation | undefined,
+  ): ShellExecutionHandle {
+    try {
+      const cols = terminalColumns ?? 80;
+      const rows = terminalRows ?? 30;
+      const isWindows = os.platform() === 'win32';
+      const shell = isWindows ? 'cmd.exe' : 'bash';
+      const args = isWindows
+        ? ['/c', commandToExecute]
+        : ['-c', commandToExecute];
+
+      const ptyProcess = ptyInfo?.module.spawn(shell, args, {
+        cwd,
+        name: 'xterm-color',
+        cols,
+        rows,
+        env: {
+          ...process.env,
+          QWEN_CODE: '1',
+          TERM: 'xterm-256color',
+          PAGER: 'cat',
+        },
+        handleFlowControl: true,
+      });
+
+      const result = new Promise<ShellExecutionResult>((resolve) => {
+        const headlessTerminal = new Terminal({
+          allowProposedApi: true,
+          cols,
+          rows,
+        });
+        let processingChain = Promise.resolve();
+        let decoder: TextDecoder | null = null;
+        let output = '';
+        const outputChunks: Buffer[] = [];
+        const error: Error | null = null;
+        let exited = false;
+
+        let isStreamingRawContent = true;
+        const MAX_SNIFF_SIZE = 4096;
+        let sniffedBytes = 0;
+
+        const handleOutput = (data: Buffer) => {
+          processingChain = processingChain.then(
+            () =>
+              new Promise<void>((resolve) => {
+                if (!decoder) {
+                  const encoding = getCachedEncodingForBuffer(data);
+                  try {
+                    decoder = new TextDecoder(encoding);
+                  } catch {
+                    decoder = new TextDecoder('utf-8');
+                  }
+                }
+
+                outputChunks.push(data);
+
+                if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
+                  const sniffBuffer = Buffer.concat(outputChunks.slice(0, 20));
+                  sniffedBytes = sniffBuffer.length;
+
+                  if (isBinary(sniffBuffer)) {
+                    isStreamingRawContent = false;
+                    onOutputEvent({ type: 'binary_detected' });
+                  }
+                }
+
+                if (isStreamingRawContent) {
+                  const decodedChunk = decoder.decode(data, { stream: true });
+                  headlessTerminal.write(decodedChunk, () => {
+                    const newStrippedOutput = getFullText(headlessTerminal);
+                    output = newStrippedOutput;
+                    onOutputEvent({ type: 'data', chunk: newStrippedOutput });
+                    resolve();
+                  });
+                } else {
+                  const totalBytes = outputChunks.reduce(
+                    (sum, chunk) => sum + chunk.length,
+                    0,
+                  );
+                  onOutputEvent({
+                    type: 'binary_progress',
+                    bytesReceived: totalBytes,
+                  });
+                  resolve();
+                }
+              }),
+          );
+        };
+
+        ptyProcess.onData((data: string) => {
+          const bufferData = Buffer.from(data, 'utf-8');
+          handleOutput(bufferData);
+        });
+
+        ptyProcess.onExit(
+          ({ exitCode, signal }: { exitCode: number; signal?: number }) => {
+            exited = true;
+            abortSignal.removeEventListener('abort', abortHandler);
+
+            processingChain.then(() => {
+              const finalBuffer = Buffer.concat(outputChunks);
+
+              resolve({
+                rawOutput: finalBuffer,
+                output,
+                exitCode,
+                signal: signal ?? null,
+                error,
+                aborted: abortSignal.aborted,
+                pid: ptyProcess.pid,
+                executionMethod: ptyInfo?.name ?? 'node-pty',
+              });
+            });
+          },
+        );
+
+        const abortHandler = async () => {
+          if (ptyProcess.pid && !exited) {
+            ptyProcess.kill('SIGHUP');
+          }
+        };
+
+        abortSignal.addEventListener('abort', abortHandler, { once: true });
+      });
+
+      return { pid: ptyProcess.pid, result };
+    } catch (e) {
+      const error = e as Error;
+      return {
+        pid: undefined,
+        result: Promise.resolve({
+          error,
+          rawOutput: Buffer.from(''),
+          output: '',
+          exitCode: 1,
+          signal: null,
+          aborted: false,
+          pid: undefined,
+          executionMethod: 'none',
+        }),
+      };
+    }
+  }
+}

projects/ui/qwen-code/packages/core/src/telemetry/constants.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const SERVICE_NAME = 'qwen-code';
+
+export const EVENT_USER_PROMPT = 'qwen-code.user_prompt';
+export const EVENT_TOOL_CALL = 'qwen-code.tool_call';
+export const EVENT_API_REQUEST = 'qwen-code.api_request';
+export const EVENT_API_ERROR = 'qwen-code.api_error';
+export const EVENT_API_RESPONSE = 'qwen-code.api_response';
+export const EVENT_CLI_CONFIG = 'qwen-code.config';
+export const EVENT_FLASH_FALLBACK = 'qwen-code.flash_fallback';
+export const EVENT_NEXT_SPEAKER_CHECK = 'qwen-code.next_speaker_check';
+export const EVENT_SLASH_COMMAND = 'qwen-code.slash_command';
+export const EVENT_IDE_CONNECTION = 'qwen-code.ide_connection';
+export const EVENT_CHAT_COMPRESSION = 'qwen-code.chat_compression';
+export const EVENT_INVALID_CHUNK = 'qwen-code.chat.invalid_chunk';
+export const EVENT_CONTENT_RETRY = 'qwen-code.chat.content_retry';
+export const EVENT_CONTENT_RETRY_FAILURE =
+  'qwen-code.chat.content_retry_failure';
+
+export const METRIC_TOOL_CALL_COUNT = 'qwen-code.tool.call.count';
+export const METRIC_TOOL_CALL_LATENCY = 'qwen-code.tool.call.latency';
+export const METRIC_API_REQUEST_COUNT = 'qwen-code.api.request.count';
+export const METRIC_API_REQUEST_LATENCY = 'qwen-code.api.request.latency';
+export const METRIC_TOKEN_USAGE = 'qwen-code.token.usage';
+export const METRIC_SESSION_COUNT = 'qwen-code.session.count';
+export const METRIC_FILE_OPERATION_COUNT = 'qwen-code.file.operation.count';
+export const METRIC_INVALID_CHUNK_COUNT = 'qwen-code.chat.invalid_chunk.count';
+export const METRIC_CONTENT_RETRY_COUNT = 'qwen-code.chat.content_retry.count';
+export const METRIC_CONTENT_RETRY_FAILURE_COUNT =
+  'qwen-code.chat.content_retry_failure.count';

projects/ui/qwen-code/packages/core/src/telemetry/file-exporters.ts

@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'node:fs';
+import { ExportResult, ExportResultCode } from '@opentelemetry/core';
+import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { ReadableLogRecord, LogRecordExporter } from '@opentelemetry/sdk-logs';
+import {
+  ResourceMetrics,
+  PushMetricExporter,
+  AggregationTemporality,
+} from '@opentelemetry/sdk-metrics';
+
+class FileExporter {
+  protected writeStream: fs.WriteStream;
+
+  constructor(filePath: string) {
+    this.writeStream = fs.createWriteStream(filePath, { flags: 'a' });
+  }
+
+  protected serialize(data: unknown): string {
+    return JSON.stringify(data, null, 2) + '\n';
+  }
+
+  shutdown(): Promise<void> {
+    return new Promise((resolve) => {
+      this.writeStream.end(resolve);
+    });
+  }
+}
+
+export class FileSpanExporter extends FileExporter implements SpanExporter {
+  export(
+    spans: ReadableSpan[],
+    resultCallback: (result: ExportResult) => void,
+  ): void {
+    const data = spans.map((span) => this.serialize(span)).join('');
+    this.writeStream.write(data, (err) => {
+      resultCallback({
+        code: err ? ExportResultCode.FAILED : ExportResultCode.SUCCESS,
+        error: err || undefined,
+      });
+    });
+  }
+}
+
+export class FileLogExporter extends FileExporter implements LogRecordExporter {
+  export(
+    logs: ReadableLogRecord[],
+    resultCallback: (result: ExportResult) => void,
+  ): void {
+    const data = logs.map((log) => this.serialize(log)).join('');
+    this.writeStream.write(data, (err) => {
+      resultCallback({
+        code: err ? ExportResultCode.FAILED : ExportResultCode.SUCCESS,
+        error: err || undefined,
+      });
+    });
+  }
+}
+
+export class FileMetricExporter
+  extends FileExporter
+  implements PushMetricExporter
+{
+  export(
+    metrics: ResourceMetrics,
+    resultCallback: (result: ExportResult) => void,
+  ): void {
+    const data = this.serialize(metrics);
+    this.writeStream.write(data, (err) => {
+      resultCallback({
+        code: err ? ExportResultCode.FAILED : ExportResultCode.SUCCESS,
+        error: err || undefined,
+      });
+    });
+  }
+
+  getPreferredAggregationTemporality(): AggregationTemporality {
+    return AggregationTemporality.CUMULATIVE;
+  }
+
+  async forceFlush(): Promise<void> {
+    return Promise.resolve();
+  }
+}

projects/ui/qwen-code/packages/core/src/telemetry/index.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export enum TelemetryTarget {
+  GCP = 'gcp',
+  LOCAL = 'local',
+  QWEN = 'qwen',
+}
+
+const DEFAULT_TELEMETRY_TARGET = TelemetryTarget.LOCAL;
+const DEFAULT_OTLP_ENDPOINT = 'http://localhost:4317';
+
+export { DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT };
+export {
+  initializeTelemetry,
+  shutdownTelemetry,
+  isTelemetrySdkInitialized,
+} from './sdk.js';
+export {
+  logCliConfiguration,
+  logUserPrompt,
+  logToolCall,
+  logApiRequest,
+  logApiError,
+  logApiResponse,
+  logFlashFallback,
+  logSlashCommand,
+  logKittySequenceOverflow,
+  logChatCompression,
+} from './loggers.js';
+export {
+  StartSessionEvent,
+  EndSessionEvent,
+  UserPromptEvent,
+  ToolCallEvent,
+  ApiRequestEvent,
+  ApiErrorEvent,
+  ApiResponseEvent,
+  TelemetryEvent,
+  FlashFallbackEvent,
+  KittySequenceOverflowEvent,
+  SlashCommandEvent,
+  makeSlashCommandEvent,
+  SlashCommandStatus,
+  ChatCompressionEvent,
+  makeChatCompressionEvent,
+} from './types.js';
+export { SpanStatusCode, ValueType } from '@opentelemetry/api';
+export { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+export * from './uiTelemetry.js';

projects/ui/qwen-code/packages/core/src/telemetry/integration.test.circular.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Integration test to verify circular reference handling with proxy agents
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { QwenLogger } from './qwen-logger/qwen-logger.js';
+import { RumEvent } from './qwen-logger/event-types.js';
+import { Config } from '../config/config.js';
+
+describe('Circular Reference Integration Test', () => {
+  beforeEach(() => {
+    // Clear singleton instance before each test
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (QwenLogger as any).instance = undefined;
+  });
+
+  afterEach(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (QwenLogger as any).instance = undefined;
+  });
+
+  it('should handle HttpsProxyAgent-like circular references in qwen logging', () => {
+    // Create a mock config with proxy
+    const mockConfig = {
+      getTelemetryEnabled: () => true,
+      getUsageStatisticsEnabled: () => true,
+      getSessionId: () => 'test-session',
+      getModel: () => 'test-model',
+      getEmbeddingModel: () => 'test-embedding',
+      getDebugMode: () => false,
+      getProxy: () => 'http://proxy.example.com:8080',
+    } as unknown as Config;
+
+    // Simulate the structure that causes the circular reference error
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const proxyAgentLike: any = {
+      sockets: {},
+      options: { proxy: 'http://proxy.example.com:8080' },
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const socketLike: any = {
+      _httpMessage: {
+        agent: proxyAgentLike,
+        socket: null,
+      },
+    };
+
+    socketLike._httpMessage.socket = socketLike; // Create circular reference
+    proxyAgentLike.sockets['cloudcode-pa.googleapis.com:443'] = [socketLike];
+
+    // Create an event that would contain this circular structure
+    const problematicEvent: RumEvent = {
+      timestamp: Date.now(),
+      event_type: 'exception',
+      type: 'error',
+      name: 'api_error',
+      error: new Error('Network error'),
+      function_args: {
+        filePath: '/test/file.txt',
+        httpAgent: proxyAgentLike, // This would cause the circular reference
+      },
+    } as RumEvent;
+
+    // Test that QwenLogger can handle this
+    const logger = QwenLogger.getInstance(mockConfig);
+
+    expect(() => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      logger?.enqueueLogEvent(problematicEvent as any);
+    }).not.toThrow();
+  });
+
+  it('should handle event overflow without memory leaks', () => {
+    const mockConfig = {
+      getTelemetryEnabled: () => true,
+      getUsageStatisticsEnabled: () => true,
+      getSessionId: () => 'test-session',
+      getDebugMode: () => true,
+    } as unknown as Config;
+
+    const logger = QwenLogger.getInstance(mockConfig);
+
+    // Add more events than the maximum capacity
+    for (let i = 0; i < 1100; i++) {
+      logger?.enqueueLogEvent({
+        timestamp: Date.now(),
+        event_type: 'action',
+        type: 'test',
+        name: `overflow-test-${i}`,
+      });
+    }
+
+    // Logger should still be functional
+    expect(logger).toBeDefined();
+    expect(() => {
+      logger?.enqueueLogEvent({
+        timestamp: Date.now(),
+        event_type: 'action',
+        type: 'test',
+        name: 'final-test',
+      });
+    }).not.toThrow();
+  });
+});