@pedrofariasx/qwenproxy 1.2.1 → 1.2.3

package/src/services/playwright.ts

@@ -11,11 +11,27 @@
 import { chromium, firefox, webkit, BrowserContext, Page } from 'playwright';
 import path from 'path';
 import crypto from 'crypto';
-import { QwenAccount } from '../core/accounts.ts';
-import { config } from '../core/config.ts';
+import { QwenAccount } from '../core/accounts.js';
+import { config } from '../core/config.js';
 
 export type BrowserType = 'chromium' | 'firefox' | 'webkit' | 'chrome' | 'edge';
 
+interface BrowserEngineConfig {
+  engine: typeof chromium | typeof firefox | typeof webkit;
+  channel?: string;
+}
+
+function resolveBrowserEngine(browserType: BrowserType): BrowserEngineConfig {
+  switch (browserType) {
+    case 'firefox': return { engine: firefox };
+    case 'webkit': return { engine: webkit };
+    case 'chrome': return { engine: chromium, channel: 'chrome' };
+    case 'edge': return { engine: chromium, channel: 'msedge' };
+    case 'chromium':
+    default: return { engine: chromium };
+  }
+}
+
 let context: BrowserContext | null = null;
 export let activePage: Page | null = null;
 const accountContexts = new Map<string, BrowserContext>();
@@ -29,6 +45,7 @@ interface AccountHeaderCache {
 }
 
 const accountHeaderCaches = new Map<string, AccountHeaderCache>();
+const cachedUserAgents = new Map<string, string>();
 
 function getAccountHeaderCache(accountId: string): AccountHeaderCache {
   let cache = accountHeaderCaches.get(accountId);
@@ -119,9 +136,14 @@ export async function getBasicHeaders(accountId?: string): Promise<{ cookie: str
   if (!page) throw new Error('Playwright not initialized');
   
   const cookie = await getCookies(accountId);
-  const userAgent = await page.evaluate(() => navigator.userAgent);
-  
   const cacheKey = accountId || 'global';
+  
+  let userAgent = cachedUserAgents.get(cacheKey);
+  if (!userAgent) {
+    userAgent = await page.evaluate(() => navigator.userAgent);
+    cachedUserAgents.set(cacheKey, userAgent);
+  }
+  
   const cache = getAccountHeaderCache(cacheKey);
   const bxV = cache.currentHeaders['bx-v'] || '2.5.36';
   const bxUa = cache.currentHeaders['bx-ua'];
@@ -137,34 +159,11 @@ export async function initPlaywright(headless = true, browserType: BrowserType =
   }
 
   const profilePath = path.resolve('qwen_profiles', '_default');
-  
-  let browserEngine;
-  let channel: string | undefined;
-
-  switch (browserType) {
-    case 'firefox':
-      browserEngine = firefox;
-      break;
-    case 'webkit':
-      browserEngine = webkit;
-      break;
-    case 'chrome':
-      browserEngine = chromium;
-      channel = 'chrome';
-      break;
-    case 'edge':
-      browserEngine = chromium;
-      channel = 'msedge';
-      break;
-    case 'chromium':
-    default:
-      browserEngine = chromium;
-      break;
-  }
+  const { engine, channel } = resolveBrowserEngine(browserType);
 
   console.log(`[Playwright] Launching ${browserType}...`);
 
-  context = await browserEngine.launchPersistentContext(profilePath, {
+  context = await engine.launchPersistentContext(profilePath, {
     headless,
     channel,
     userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
@@ -248,45 +247,8 @@ export async function closePlaywright() {
 
 export async function loginToQwen(email: string, password: string): Promise<boolean> {
   if (!activePage) throw new Error('Playwright not initialized');
-
   console.log(`[Playwright] Attempting API login for ${email}...`);
-  
-  await activePage.goto('https://chat.qwen.ai/auth', { waitUntil: 'domcontentloaded' });
-
-  const hashedPassword = crypto.createHash('sha256').update(password).digest('hex');
-
-  const result = await activePage.evaluate(async ({ email, password }) => {
-    try {
-      const response = await fetch("https://chat.qwen.ai/api/v2/auths/signin", {
-        method: "POST",
-        headers: {
-          "accept": "application/json, text/plain, */*",
-          "content-type": "application/json",
-          "source": "web",
-          "timezone": new Date().toString().split(' (')[0],
-          "x-request-id": crypto.randomUUID()
-        },
-        body: JSON.stringify({ email, password, login_type: "email" })
-      });
-      const data = await response.json();
-      return { ok: response.ok, data };
-    } catch (e: any) {
-      return { ok: false, error: e.message };
-    }
-  }, { email, password: hashedPassword });
-
-  if (result.ok) {
-    console.log('[Playwright] API login request successful.');
-    await activePage.goto('https://chat.qwen.ai/', { waitUntil: 'domcontentloaded' });
-    const isLogged = !(activePage.url().includes('auth') || activePage.url().includes('login'));
-    if (isLogged) {
-       console.log('[Playwright] Login confirmed.');
-       return true;
-    }
-  }
-
-  console.error('[Playwright] Login failed:', result.data || result.error);
-  return false;
+  return loginToQwenWithContext(activePage.context(), activePage, email, password);
 }
 
 async function loginToQwenUI(email: string, password: string): Promise<boolean> {
@@ -373,7 +335,11 @@ async function tryLightweightCookieRefresh(accountId?: string): Promise<{ header
   try {
     const cookies = await page.context().cookies();
     const cookieStr = cookies.map(c => `${c.name}=${c.value}`).join('; ');
-    const userAgent = await page.evaluate(() => navigator.userAgent);
+    let userAgent = cachedUserAgents.get(cacheKey);
+    if (!userAgent) {
+      userAgent = await page.evaluate(() => navigator.userAgent);
+      cachedUserAgents.set(cacheKey, userAgent);
+    }
 
     const now = Date.now();
     cookieCaches.set(cacheKey, { cookie: cookieStr, timestamp: now });
@@ -472,7 +438,7 @@ async function _getQwenHeadersInternal(forceNew = false, accountId?: string): Pr
         console.warn('[Playwright] Detected login page but QWEN_EMAIL/PASSWORD not provided in .env');
       }
     } else {
-      const { getAccountCredentials } = await import('../core/accounts.ts');
+      const { getAccountCredentials } = await import('../core/accounts.js');
       const creds = getAccountCredentials(accountId);
       if (creds && creds.email && creds.password) {
         console.log(`[Playwright] Detected login page for account ${creds.email}. Attempting login...`);
@@ -547,7 +513,7 @@ async function _getQwenHeadersInternal(forceNew = false, accountId?: string): Pr
       cache.lastHeadersTime = Date.now();
       cache.refreshInProgress = false;
 
-      import('./qwen.ts').then(m => m.disableNativeTools(accountId).catch(() => {}));
+      import('./qwen.js').then(m => m.disableNativeTools(accountId).catch(() => {}));
 
       await route.abort('aborted');
 
@@ -608,34 +574,11 @@ async function _getQwenHeadersInternal(forceNew = false, accountId?: string): Pr
 
 export async function initPlaywrightForAccount(account: QwenAccount, headless = true, browserType: BrowserType = 'chromium') {
   const profilePath = path.resolve('qwen_profiles', account.id);
-  
-  let browserEngine;
-  let channel: string | undefined;
-
-  switch (browserType) {
-    case 'firefox':
-      browserEngine = firefox;
-      break;
-    case 'webkit':
-      browserEngine = webkit;
-      break;
-    case 'chrome':
-      browserEngine = chromium;
-      channel = 'chrome';
-      break;
-    case 'edge':
-      browserEngine = chromium;
-      channel = 'msedge';
-      break;
-    case 'chromium':
-    default:
-      browserEngine = chromium;
-      break;
-  }
+  const { engine, channel } = resolveBrowserEngine(browserType);
 
   console.log(`[Playwright] Launching ${browserType} for account ${account.email}...`);
 
-  const acctContext = await browserEngine.launchPersistentContext(profilePath, {
+  const acctContext = await engine.launchPersistentContext(profilePath, {
     headless,
     channel,
     userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
@@ -665,32 +608,9 @@ export async function initPlaywrightForAccount(account: QwenAccount, headless =
 
 export async function launchManualLoginAccount(accountId: string, browserType: BrowserType = 'chromium'): Promise<{ context: BrowserContext, page: Page }> {
   const profilePath = path.resolve('qwen_profiles', accountId);
-  
-  let browserEngine;
-  let channel: string | undefined;
-
-  switch (browserType) {
-    case 'firefox':
-      browserEngine = firefox;
-      break;
-    case 'webkit':
-      browserEngine = webkit;
-      break;
-    case 'chrome':
-      browserEngine = chromium;
-      channel = 'chrome';
-      break;
-    case 'edge':
-      browserEngine = chromium;
-      channel = 'msedge';
-      break;
-    case 'chromium':
-    default:
-      browserEngine = chromium;
-      break;
-  }
+  const { engine, channel } = resolveBrowserEngine(browserType);
 
-  const acctContext = await browserEngine.launchPersistentContext(profilePath, {
+  const acctContext = await engine.launchPersistentContext(profilePath, {
     headless: false,
     channel,
     userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',

package/src/services/qwen.ts

@@ -1,5 +1,7 @@
-import { getQwenHeaders, getBasicHeaders } from './playwright.ts';
-import { v4 as uuidv4 } from 'uuid';
+import { getQwenHeaders, getBasicHeaders } from './playwright.js';
+import crypto from 'crypto';
+
+const CACHED_TIMEZONE = new Date().toString().split(' (')[0];
 
 export class RetryableQwenStreamError extends Error {
   readonly retryAfterMs: number;
@@ -26,8 +28,7 @@ interface SessionEntry {
   timestamp: number;
 }
 
-const sessionStates: Map<string, SessionEntry> = (globalThis as any)._sessionStates || new Map();
-(globalThis as any)._sessionStates = sessionStates;
+const sessionStates: Map<string, SessionEntry> = new Map();
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
 
 function cleanupStaleSessions() {
@@ -63,11 +64,9 @@ interface WarmPoolEntry {
   timestamp: number;
 }
 
-const warmPool: Map<string, WarmPoolEntry[]> = (globalThis as any)._warmPool || new Map();
-(globalThis as any)._warmPool = warmPool;
+const warmPool: Map<string, WarmPoolEntry[]> = new Map();
 
-const refillPromises: Map<string, Promise<void>> = (globalThis as any)._refillPromises || new Map();
-(globalThis as any)._refillPromises = refillPromises;
+const refillPromises: Map<string, Promise<void>> = new Map();
 
 const WARM_POOL_SIZE = 5;
 const WARM_POOL_TTL_MS = 10 * 60 * 1000;
@@ -76,13 +75,11 @@ function cleanupStalePool(accountId: string) {
   const pool = warmPool.get(accountId);
   if (!pool) return;
   const now = Date.now();
-  for (let i = pool.length - 1; i >= 0; i--) {
-    if (now - pool[i].timestamp > WARM_POOL_TTL_MS) pool.splice(i, 1);
-  }
+  const filtered = pool.filter(e => now - e.timestamp <= WARM_POOL_TTL_MS);
+  if (filtered.length !== pool.length) warmPool.set(accountId, filtered);
 }
 
 async function getBasicQwenHeaders(accountId?: string): Promise<Record<string, string>> {
-  const { getBasicHeaders } = await import('./playwright.ts');
   const { cookie, userAgent, bxV } = await getBasicHeaders(accountId);
   return {
     cookie,
@@ -92,8 +89,6 @@ async function getBasicQwenHeaders(accountId?: string): Promise<Record<string, s
 }
 
 async function createRealQwenChat(header: Record<string, string>): Promise<string> {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 30000);
   const response = await fetch('https://chat.qwen.ai/api/v2/chats/new', {
     method: 'POST',
     headers: {
@@ -104,7 +99,7 @@ async function createRealQwenChat(header: Record<string, string>): Promise<strin
       origin: 'https://chat.qwen.ai',
       referer: 'https://chat.qwen.ai/c/new-chat',
       'user-agent': header['user-agent'],
-      'x-request-id': uuidv4(),
+      'x-request-id': crypto.randomUUID(),
       'bx-v': header['bx-v'],
     },
     body: JSON.stringify({
@@ -115,9 +110,8 @@ async function createRealQwenChat(header: Record<string, string>): Promise<strin
       timestamp: Date.now(),
       project_id: '',
     }),
-    signal: controller.signal,
+    signal: AbortSignal.timeout(30000),
   });
-  clearTimeout(timeoutId);
 
   if (!response.ok) throw new Error(`Failed to create chat: ${response.status}`);
   const json = await response.json();
@@ -131,18 +125,26 @@ async function refillPoolForAccount(accountId: string) {
   if (!pool) { pool = []; warmPool.set(accountId, pool); }
   cleanupStalePool(accountId);
   const need = Math.max(0, WARM_POOL_SIZE - pool.length);
-  
+  if (need === 0) return;
+
+  let headers: Record<string, string>;
+  try {
+    headers = await getBasicQwenHeaders(accountId === 'global' ? undefined : accountId);
+  } catch (err) {
+    console.error(`[WarmPool] header fetch failed for ${accountId}:`, (err as Error).message);
+    return;
+  }
+
   const creationPromises = Array.from({ length: need }, async () => {
     try {
-      const headers = await getBasicQwenHeaders(accountId === 'global' ? undefined : accountId);
       const chatId = await createRealQwenChat(headers);
       return { chatId, headers, accountId, timestamp: Date.now() };
     } catch (err) {
-      console.error(`[WarmPool] refill failed for ${accountId}:`, (err as Error).message);
+      console.error(`[WarmPool] chat creation failed for ${accountId}:`, (err as Error).message);
       return null;
     }
   });
-  
+
   const results = await Promise.all(creationPromises);
   for (const entry of results) {
     if (entry) pool.push(entry);
@@ -252,7 +254,7 @@ export async function disableNativeTools(accountId?: string): Promise<void> {
         'origin': 'https://chat.qwen.ai',
         'referer': 'https://chat.qwen.ai/',
         'user-agent': headers['user-agent'],
-        'x-request-id': uuidv4(),
+        'x-request-id': crypto.randomUUID(),
         'bx-ua': headers['bx-ua'],
         'bx-umidtoken': headers['bx-umidtoken'],
         'bx-v': headers['bx-v']
@@ -291,9 +293,9 @@ export async function fetchQwenModels(accountId?: string): Promise<any[]> {
       'cookie': cookie,
       'referer': 'https://chat.qwen.ai/',
       'user-agent': userAgent,
-      'x-request-id': uuidv4(),
+      'x-request-id': crypto.randomUUID(),
       'bx-v': bxV,
-      'timezone': new Date().toString(),
+      'timezone': CACHED_TIMEZONE,
       'source': 'web'
     }
   });
@@ -397,7 +399,7 @@ export async function createQwenStream(
   }
 
   const timestamp = Math.floor(Date.now() / 1000);
-  const fid = uuidv4();
+  const fid = crypto.randomUUID();
   const model = modelId.replace('-no-thinking', '');
 
   const payload: QwenPayload = {
@@ -456,10 +458,10 @@ export async function createQwenStream(
       'sec-fetch-dest': 'empty',
       'sec-fetch-mode': 'cors',
       'sec-fetch-site': 'same-origin',
-      'timezone': new Date().toString().split(' (')[0],
+      'timezone': CACHED_TIMEZONE,
       'user-agent': chatHeaders['user-agent'],
       'x-accel-buffering': 'no',
-      'x-request-id': uuidv4(),
+      'x-request-id': crypto.randomUUID(),
       'bx-v': chatHeaders['bx-v'],
     },
     body: JSON.stringify(payload),

package/src/tests/concurrency.test.ts

@@ -4,7 +4,7 @@ import assert from 'node:assert';
 process.env.TEST_MOCK_PLAYWRIGHT = 'true';
 
 import { app } from '../api/server.js';
-import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+import { initPlaywright, closePlaywright } from '../services/playwright.js';
 
 test('Concurrent requests are serialized by mutex', async () => {
   const originalFetch = globalThis.fetch;

package/src/tests/concurrentChat.test.ts

@@ -3,7 +3,7 @@ import assert from 'node:assert';
 import net from 'node:net';
 import { serve } from '@hono/node-server';
 import { app } from '../api/server.js';
-import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+import { initPlaywright, closePlaywright } from '../services/playwright.js';
 
 function isPortAvailable(port: number): Promise<boolean> {
   return new Promise((resolve) => {

package/src/tests/contextTruncation.test.ts

@@ -0,0 +1,142 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { estimateTokenCount, truncateMessages } from '../utils/context-truncation.js';
+
+test('estimateTokenCount: returns 0 for empty string', () => {
+  assert.strictEqual(estimateTokenCount(''), 0);
+});
+
+test('estimateTokenCount: estimates tokens conservatively using 2.5 divisor', () => {
+  assert.strictEqual(estimateTokenCount('hello'), 2);
+  assert.strictEqual(estimateTokenCount('a'.repeat(100)), 40);
+  assert.strictEqual(estimateTokenCount('a'.repeat(250)), 100);
+  assert.strictEqual(estimateTokenCount('a'.repeat(2500)), 1000);
+});
+
+test('estimateTokenCount: handles single character', () => {
+  assert.strictEqual(estimateTokenCount('x'), 1);
+});
+
+test('estimateTokenCount: rounds up for non-multiples of 2.5', () => {
+  assert.strictEqual(estimateTokenCount('ab'), 1);
+  assert.strictEqual(estimateTokenCount('abc'), 2);
+  assert.strictEqual(estimateTokenCount('abcd'), 2);
+});
+
+test('truncateMessages: returns all messages when within context window', () => {
+  const messages = [
+    { role: 'system', content: 'You are helpful.' },
+    { role: 'user', content: 'Hello' },
+    { role: 'assistant', content: 'Hi there!' },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 3);
+  assert.strictEqual(result[0].content, 'You are helpful.');
+  assert.strictEqual(result[1].content, 'Hello');
+  assert.strictEqual(result[2].content, 'Hi there!');
+});
+
+test('truncateMessages: preserves chronological order', () => {
+  const messages = [
+    { role: 'user', content: 'first' },
+    { role: 'assistant', content: 'second' },
+    { role: 'user', content: 'third' },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result[0].role, 'user');
+  assert.strictEqual(result[0].content, 'first');
+  assert.strictEqual(result[1].role, 'assistant');
+  assert.strictEqual(result[2].role, 'user');
+  assert.strictEqual(result[2].content, 'third');
+});
+
+test('truncateMessages: drops oldest messages first when exceeding context', () => {
+  const largeContent = 'x'.repeat(5000);
+  const messages = [
+    { role: 'user', content: largeContent },
+    { role: 'assistant', content: largeContent },
+    { role: 'user', content: 'latest message' },
+  ];
+  const result = truncateMessages(messages, 2000);
+  const lastMsg = result[result.length - 1];
+  assert.ok(lastMsg.content.includes('latest message') || lastMsg.content.includes('[Truncated]'));
+});
+
+test('truncateMessages: returns system prompt as fallback when context is extremely small', () => {
+  const messages = [
+    { role: 'user', content: 'some content' },
+  ];
+  const systemPrompt = 'system instructions';
+  const result = truncateMessages(messages, 10, systemPrompt);
+  assert.strictEqual(result.length, 1);
+  assert.strictEqual(result[0].role, 'user');
+  assert.strictEqual(result[0].content, systemPrompt);
+});
+
+test('truncateMessages: handles array content in messages', () => {
+  const messages = [
+    {
+      role: 'user',
+      content: [
+        { type: 'text', text: 'hello' },
+        { type: 'image_url', image_url: { url: 'data:image/png;base64,...' } },
+      ],
+    },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 1);
+  assert.ok(result[0].content.includes('hello'));
+});
+
+test('truncateMessages: handles null content', () => {
+  const messages = [
+    { role: 'user', content: null },
+    { role: 'assistant', content: 'response' },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 2);
+  assert.strictEqual(result[0].content, '');
+  assert.strictEqual(result[1].content, 'response');
+});
+
+test('truncateMessages: handles object content', () => {
+  const messages = [
+    { role: 'user', content: { structured: 'data', value: 42 } },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 1);
+  assert.ok(result[0].content.includes('structured'));
+});
+
+test('truncateMessages: truncates partially fitting message with marker', () => {
+  const messages = [
+    { role: 'user', content: 'a'.repeat(10000) },
+  ];
+  const result = truncateMessages(messages, 1000);
+  assert.strictEqual(result.length, 1);
+  assert.ok(
+    result[0].content.includes('[Truncated]') || result[0].content.length < 10000,
+    'Should truncate or mark as truncated'
+  );
+});
+
+test('truncateMessages: accounts for system prompt in available tokens', () => {
+  const systemPrompt = 'x'.repeat(2000);
+  const messages = [
+    { role: 'user', content: 'short' },
+  ];
+  const withSystem = truncateMessages(messages, 2000, systemPrompt);
+  const withoutSystem = truncateMessages(messages, 2000);
+  assert.ok(withSystem.length <= withoutSystem.length);
+});
+
+test('truncateMessages: handles empty messages array', () => {
+  const result = truncateMessages([], 100000);
+  assert.strictEqual(result.length, 0);
+});
+
+test('truncateMessages: handles empty messages with system prompt fallback', () => {
+  const result = truncateMessages([], 5, 'fallback');
+  assert.strictEqual(result.length, 1);
+  assert.strictEqual(result[0].content, 'fallback');
+});