qwenproxy-cli 1.0.3 → 1.0.5

package/README.md

@@ -7,9 +7,10 @@
 Gateway e API de alta performance compatível com **OpenAI** e **Anthropic** que conecta clientes e agentes (Codex, Claude Code CLI, Grok, Cursor) ao **Qwen (`chat.qwen.ai`)** com suporte a múltiplas contas, failover inteligente, tool calling robusto, thread-native, geração de fotos e vídeos, **Responses API completa com memória persistente** e sessões persistentes. Inclui Playwright com stealth, retries para erros transitórios, variantes públicas base/`-fast`/`-thinking`, cache comprimido, registro de capabilities por modelo e observabilidade.
 
 [![CI](https://github.com/johngbl/QwenProxy/actions/workflows/ci.yml/badge.svg)](https://github.com/johngbl/QwenProxy/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/qwenproxy-cli.svg)](https://www.npmjs.com/package/qwenproxy-cli)
 [![TypeScript](https://img.shields.io/badge/TypeScript-7.0-blue)](https://www.typescriptlang.org/)
 [![Hono](https://img.shields.io/badge/Hono-4.13-green)](https://hono.dev/)
-[![Playwright](https://img.shields.io/badge/Playwright-1.62-blueviolet)](https://playwright.dev/)
+[![Patchright](https://img.shields.io/badge/Patchright-Stealth-blueviolet)](https://github.com/kaliiiiiiiiii/patchright)
 [![License: ISC](https://img.shields.io/badge/License-ISC-yellow.svg)](LICENSE)
 [![GitHub Sponsors](https://img.shields.io/badge/sponsor-GitHub%20Sponsors-ea4aaa?logo=githubsponsors&logoColor=white)](https://github.com/sponsors/johngbl)
 [![Ko-fi](https://img.shields.io/badge/Donate-Ko--fi-ff5e5b?logo=kofi&logoColor=white)](https://ko-fi.com/johngbl)
@@ -29,10 +30,11 @@ Toda contribuição é muito bem-vinda e ajuda a cobrir custos de infraestrutura
 - **Compatibilidade OpenAI & Anthropic** — `/v1/chat/completions`, `/v1/completions` (legado), `/v1/models`, `/v1/messages` (**Anthropic Messages API** nativa com suporte total a **Claude Code CLI** e `@anthropic-ai/sdk`), `/v1/messages/count_tokens` e **Responses API** `/v1/responses`.
 - **Responses API completa** — SSE com `event:` + `data:` + `sequence_number`, memória persistente via `previous_response_id` (SQLite durável), `last_response_id`, multimodal (`input_image`/`input_file`), reasoning effort normalization, lifecycle events de reasoning e usage real do upstream.
 - **Thread-native** — Reutiliza sessão/pai no Qwen; preservação de contexto entre turns
-- **Dois modos de conversa** — `thread` (default, reutiliza chat e envia delta) e `temp` (novo chat temporário `chat_mode:"local"` por request, envia histórico completo; zero `chat_in_progress` e zero chats órfãos)
-- **Playwright + stealth** — Headers reais (`bx-ua`, `bx-umidtoken`, `bx-v`) por conta; fingerprint estável e cleanup de processos.
-- **Transporte Qwen via Chromium** — No fluxo principal de chat, modelos, criação de sessão, personalização, completion e stop usam o contexto Playwright; o completion lê o `ReadableStream` incrementalmente e preserva o SSE sem bufferizar a resposta inteira.
-- **Startup rápido multi-conta** — Sobe com a **primeira conta pronta**; as demais continuam preparando em background.
+- **Três modos de conversa** — `thread` (default, encadeamento nativo e delta de turns), `temp-thread` (recomendado para chat/TUI, efêmero `chat_mode:"local"` com contexto contínuo, zero poluição no `chat.qwen.ai`), e `temp` (stateless padrão OpenAI, novo chat efêmero por requisição).
+- **Instância única de Chromium ultra-leve** — 1 único processo de navegador compartilhado para todas as contas com isolamento seguro de `BrowserContext` e `storageState` JSON, consumindo ~200MB de RAM (economia de >65%).
+- **Dashboard TUI completo & responsivo** — Interface visual interativa no terminal (`qpx`) com monitoramento em tempo real, abas dedicadas para Chat, Sincronização de Agentes, Diagnóstico de Armazenamento, Gerenciamento de Contas e Logs, com confirmações de segurança para ações irreversíveis.
+- **Atualizador inteligente embutido** — Comando `qpx update` que detecta automaticamente seu gerenciador de pacotes (`npm`, `pnpm`, `bun`, `yarn`) e atualiza com um único comando.
+- **Startup sob demanda e multi-conta** — Sobe instantaneamente com a **primeira conta pronta**; as contas reservas ficam em repouso (*Standby*) e inicializam sem esforço apenas sob demanda.
 - **Retries resilientes** — 502/503/504, erros de rede (`fetch failed`), anti-bot, quota e `invalid_input` com recriação de chat.
 - **Parser de tools robusto** — stream fragmentado, JSON malformado, fuzzy de nomes (`readFile` → `read_file`), JSON duplamente escapado e `</tool_call>` case-insensitive.
 - **Personalization sync** — system + tools completos são sincronizados em `/settings/personalization` via `POST /api/v2/users/user/settings/update`; o cache por conteúdo evita updates repetidos e instruções acima do limite seguem inline; aplica settings seguras (`largeTextAsFile=false`, memory off, tools internas off).
@@ -86,19 +88,19 @@ Se `API_KEY` estiver definido, as rotas `/v1/*` (e `/metrics`) exigem uma das fo
 - `Authorization: Bearer <API_KEY>` (OpenAI / Responses)
 - `x-api-key: <API_KEY>` (clients bearer-style)
 
-QwenProxy usa **Playwright por padrão**. Cada conta abre uma sessão real de browser para capturar cookies e headers anti-bot.
+QwenProxy utiliza **Patchright com arquitetura de navegador compartilhado**. Um único processo Chromium é mantido aberto com aceleração WebGL ativa, enquanto cada conta opera em um `BrowserContext` isolado com persistência leve em `storage_state.json` (~200MB de RAM para todas as contas).
 
 ```env
 PLAYWRIGHT_HEADLESS=true
 PLAYWRIGHT_BROWSER=chromium
 ```
 
-**Requisitos:**
+**Instalação do navegador:**
+O Chromium é instalado automaticamente na primeira execução de `qpx`. Se desejar instalar manualmente:
 
 ```bash
-npx playwright install chromium
+npx patchright install chromium
 ```
-
 Senhas das contas são armazenadas **criptografadas** no SQLite (`data/`).
 
 ### Transporte upstream e streaming
@@ -272,6 +274,19 @@ qpx
 ```
 *(Abre diretamente o dashboard interativo da TUI com o servidor e proxy integrados).*
 
+#### Comandos Rápidos do CLI (`qpx`)
+
+| Comando | Descrição |
+| :--- | :--- |
+| `qpx` *(ou `qwenproxy`)* | Abre o dashboard visual interativo da TUI com servidor proxy integrado |
+| `qpx start` *(ou `--server`)* | Inicia apenas o servidor HTTP/SSE em modo headless (sem interface gráfica) |
+| `qpx update` | Verifica e atualiza o QwenProxy automaticamente via npm/pnpm/bun |
+| `qpx login` | Abre navegador visível para autenticar novas contas interativamente |
+| `qpx sync` | Configura e sincroniza clientes (Claude Code, Codex, OpenCode, OMP) |
+| `qpx clean` | Limpa caches temporários dos perfis Chromium (~4.5MB por conta) |
+| `qpx clean:all` | Limpa caches e remove versões antigas de navegadores órfãos em disco |
+| `qpx purge` | Limpa o histórico de conversas remotas no Qwen de todas as contas |
+| `qpx reset` | Reseta cooldowns e rate limits salvos no banco de dados |
 ### Opção 2: Execução Instantânea (Zero Instalação)
 Experimente ou execute pontualmente sem instalar nada permanentemente:
 ```bash
@@ -317,14 +332,10 @@ npm start
 
 > **Nota:** o servidor não inicia sem pelo menos uma conta configurada (via `.env`/`QWEN_ACCOUNTS`, `npm run login` ou banco de contas).
 
-### Startup multi-conta
-
-1. Prepara as contas em sequência, reutilizando o profile persistente quando ele já está autenticado.
-2. Se o profile não tiver uma sessão válida, autentica com as credenciais da conta e salva a sessão em `data/qwen_profiles/<accountId>`.
-3. O servidor sobe após a primeira conta ficar pronta e continua preparando as demais em background.
-4. Com `PLAYWRIGHT_MAX_ACTIVE_CONTEXTS=2` (padrão), 2 contextos ficam abertos após o warmup ({principal + reserva}, cobrindo o failover comum); contextos extras (uso simultâneo ou failover) fecham ao ficar idle. O watchdog RSS fecha contextos idle sob pressão de RAM.
-5. Use `PLAYWRIGHT_PREPARE_ALL_ON_STARTUP=false` para voltar ao modo econômico, preparando as contas adicionais somente quando forem necessárias.
-
+1. O servidor inicia instantaneamente com a **primeira conta pronta** para responder requisições imediatamente.
+2. Com `PLAYWRIGHT_PREPARE_ALL_ON_STARTUP=false` (padrão econômico), as contas adicionais permanecem em **Standby**, com credenciais validadas no banco, sendo inicializadas apenas sob demanda (failover ou rotação), poupando RAM e CPU.
+3. Todas as contas ativas compartilham a mesma instância Chromium única, mantendo sessões isoladas via `BrowserContext` e arquivos leves de estado `storage_state.json`.
+4. O watchdog RSS do sistema monitora a pressão de memória e fecha contextos ociosos automaticamente.
 Exemplo de log:
 
 ```text
@@ -379,7 +390,7 @@ npm run typecheck  # tipos
 | `QWEN_MAX_PERSONALIZATION_BYTES`    | `200000`       | Teto UTF-8 para personalization por request; acima disso as instruções seguem inline                                                                                                                                                                             |
 | `QWEN_CHAT_POOL_SIZE`               | `1`            | Warm pool de chats por modelo; fica desativado quando personalization por request está ativa                                                                                                                                                                     |
 | `QWEN_CHAT_POOL_MODELS`             | `qwen3.7-plus` | Modelos aquecidos no warm pool                                                                                                                                                                                                                                   |
-| `QWEN_CHAT_MODE`                    | `thread`       | Modo de conversa: `thread` (reutiliza o chat upstream via `parent_id` e envia o delta) ou `temp` (cria um chat temporário `chat_mode:"local"` a cada request e envia o histórico completo). Override por request via header `X-QwenProxy-Chat-Mode: thread/temp` |
+| `QWEN_CHAT_MODE`                    | `thread`       | Modo de conversa: `thread` (reutiliza o chat upstream via `parent_id` e envia o delta), `temp-thread` (chat efêmero `chat_mode:"local"` com contexto contínuo, zero poluição no Qwen Web) ou `temp` (stateless padrão OpenAI, novo chat efêmero por requisição). Override por request via header `X-QwenProxy-Chat-Mode: thread/temp/temp-thread` |
 
 
 ### Playwright / processos
@@ -390,14 +401,14 @@ npm run typecheck  # tipos
 | `PLAYWRIGHT_HEADLESS`                       | `true`     | Browser sem janela                                                                                                                                                               |
 | `PLAYWRIGHT_BROWSER`                        | `chromium` | `chromium` / `chrome` / `edge`                                                                                                                                                   |
 | `PLAYWRIGHT_INIT_BATCH_SIZE`                | `1`        | Contas em paralelo no background init                                                                                                                                            |
-| `PLAYWRIGHT_PREPARE_ALL_ON_STARTUP`         | `true`     | Prepara todas as contas no boot (`false` = só quando necessárias)                                                                                                                |
+| `PLAYWRIGHT_PREPARE_ALL_ON_STARTUP`         | `false`    | Prepara somente a primeira conta no boot (`false` = modo econômico sob demanda; `true` = aquece todas)                                                                           |
 | `PLAYWRIGHT_MAX_ACTIVE_CONTEXTS`            | `2`        | Contextos idle mantidos quentes ({principal + reserva}); streams ativos nunca são fechados; uso simultâneo abre mais. Contas em cooldown (rate limit) ficam idle e são evictadas |
 | `PLAYWRIGHT_CONTEXT_CLOSE_TIMEOUT_MS`       | `10000`    | Timeout de close antes do kill                                                                                                                                                   |
 | `PLAYWRIGHT_IDLE_CONTEXT_TTL_MS`            | `60000`    | Fecha contextos idle acima do cap (`0` desativa)                                                                                                                                 |
 | `PLAYWRIGHT_JS_HEAP_MB`                     | `256`      | Cap V8 do Chromium (`--max-old-space-size`)                                                                                                                                      |
 | `PLAYWRIGHT_LOW_MEMORY_FLAGS`               | `true`     | Flags de baixa RAM (heap cap, cache mínimo, renderer limit)                                                                                                                      |
 | `OSS_MULTIPART_THRESHOLD_MB`                | `5`        | Acima disso usa multipart OSS; abaixo `putStream`                                                                                                                                |
-| `SESSION_KEEP_ALIVE_ENABLED`                | `false`    | Keep-alive opt-in (evita Chromes permanentes)                                                                                                                                    |
+| `SESSION_KEEP_ALIVE_ENABLED`                | `true`     | Simula navegações leves periódicas a cada 3min para manter sessões ativas sem desconectar                                                                                        |
 | `SESSION_KEEP_ALIVE_INTERVAL_MS`            | `180000`   | Intervalo do ciclo de keep-alive/cleanup                                                                                                                                         |
 | `SESSION_KEEP_ALIVE_IDLE_MS`                | `120000`   | Idle mínimo para keep-alive                                                                                                                                                      |
 | `SESSION_KEEP_ALIVE_NAVIGATION_INTERVAL_MS` | `480000`   | Intervalo de navegação leve                                                                                                                                                      |
@@ -830,16 +841,16 @@ QwenProxy/
 
 | Comando             | Descrição                                                               |
 | ------------------- | ----------------------------------------------------------------------- |
-| `npm start`         | Iniciar o servidor QwenProxy                                            |
+| `npm run tui`       | Abrir o dashboard interativo da TUI com proxy embutido                  |
+| `npm start`         | Iniciar apenas o servidor QwenProxy em modo headless                    |
 | `npm run sync`      | Sincronizar clientes (Claude Code, Codex, OpenCode, OMP) com backup     |
 | `npm run clean`     | Limpar caches temporários dos perfis Chromium (~4.5MB por conta)        |
-| `npm run clean:all` | Limpar caches + remover navegadores órfãos e versões antigas no SSD     |
+| `npm run clean:all` | Limpar caches + remover navegadores órfãos e versões antigas em disco   |
 | `npm run reset`     | Zerar cooldowns de contas no banco de dados                             |
 | `npm run login`     | Adicionar/autenticar novas contas visualmente no navegador              |
 | `npm run purge`     | Limpar chats remotos do Qwen nas contas configuradas                    |
 | `npm test`          | Executar suíte de testes completa                                       |
 | `npm run typecheck` | Checagem estrita de tipos do TypeScript                                 |
-
 ---
 
 ## Scripts de instalação, início e atualização

package/bin/qwenproxy.js

@@ -115,19 +115,40 @@ try {
   tsxLoaderArg = pathToFileURL(tsxEntry).href;
 } catch {}
 
-// Ensure Playwright Chromium is installed for first-time global users
-try {
-  const { chromium } = await import("patchright");
-  const execPath = chromium.executablePath();
-  if (!fs.existsSync(execPath)) {
-    console.log("⏳ [QwenProxy] Instalando o navegador Chromium pela primeira vez...");
-    spawnSync("npx", ["patchright", "install", "chromium"], {
-      stdio: "inherit",
-      shell: true,
-    });
-    console.log("✓ [QwenProxy] Navegador instalado com sucesso!\n");
-  }
-} catch {}
+// Ensure Playwright Chromium is installed only for commands that need the browser
+const browserCommands = ["start", "tui", "login"];
+const isBrowserCommand =
+  !firstArg ||
+  browserCommands.includes(firstArg) ||
+  rawArgs.includes("--tui") ||
+  rawArgs.includes("--server");
+
+if (isBrowserCommand) {
+  try {
+    const { chromium } = await import("patchright");
+    const execPath = chromium.executablePath();
+    if (!fs.existsSync(execPath)) {
+      console.log("⏳ [QwenProxy] Instalando o navegador Chromium pela primeira vez...");
+      let cliPath = "";
+      try {
+        const patchrightEntry = require.resolve("patchright");
+        cliPath = path.join(path.dirname(patchrightEntry), "cli.js");
+      } catch {}
+
+      if (cliPath && fs.existsSync(cliPath)) {
+        spawnSync(process.execPath, [cliPath, "install", "chromium"], {
+          stdio: "inherit",
+        });
+      } else {
+        const cmd = process.platform === "win32" ? "npx.cmd" : "npx";
+        spawnSync(cmd, ["--yes", "patchright", "install", "chromium"], {
+          stdio: "inherit",
+        });
+      }
+      console.log("✓ [QwenProxy] Navegador instalado com sucesso!\n");
+    }
+  } catch {}
+}
 
 const child = spawn(process.execPath, ["--import", tsxLoaderArg, targetPath, ...scriptArgs], {
   stdio: "inherit",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "High-performance OpenAI & Anthropic compatible API gateway for Qwen with multi-account rotation, interactive TUI, and resilient tool calling.",
   "main": "src/index.ts",
   "bin": {

package/src/api/server.ts

@@ -597,6 +597,7 @@ export async function stopServer(): Promise<void> {
 
 export async function startServer(options?: {
   installSignalHandlers?: boolean;
+  showBanner?: boolean;
 }): Promise<StartedServerInfo> {
   if (server) {
     if (options?.installSignalHandlers !== false) installSignalHandlers();
@@ -829,7 +830,8 @@ export async function startServer(options?: {
 
     const endpoint = `${started.url}/v1`;
 
-    console.log(`
+    if (options?.showBanner !== false) {
+      console.log(`
 +${"-".repeat(W)}+
 |${blank()}|
 |${center("QwenProxy")}|
@@ -845,6 +847,7 @@ export async function startServer(options?: {
 |${blank()}|
 +${"-".repeat(W)}+
 `);
+    }
     return started;
   })();
 

package/src/clean-cache.ts

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { chromium } from "patchright";
-import { pruneAllPlaywrightProfiles } from "./services/playwright.ts";
+import { pruneAllPlaywrightProfiles, cleanupOrphanProfiles } from "./services/playwright.ts";
 
 export function formatBytes(bytes: number): string {
   if (bytes < 1024) return `${bytes} B`;
@@ -141,13 +141,19 @@ async function main() {
   // 1. Profile Transient Cache Pruning (V8 Code Cache, GPU Cache)
   console.log("1. Limpando caches transitórios dos perfis (data/qwen_profiles/)...");
   const profileResult = pruneAllPlaywrightProfiles();
-  if (profileResult.totalFreedFiles > 0) {
-    console.log(
-      `   [OK] Perfis limpos com sucesso!`,
-    );
-    console.log(
-      `   Espaço liberado: ${formatBytes(profileResult.totalFreedBytes)} em ${profileResult.totalFreedFiles} arquivos (${profileResult.profilesCleaned} perfil(is)).`,
-    );
+  const orphanResult = cleanupOrphanProfiles();
+  if (profileResult.totalFreedFiles > 0 || orphanResult.removedCount > 0) {
+    console.log(`   [OK] Perfis limpos com sucesso!`);
+    if (profileResult.totalFreedFiles > 0) {
+      console.log(
+        `   Espaço liberado: ${formatBytes(profileResult.totalFreedBytes)} em ${profileResult.totalFreedFiles} arquivos (${profileResult.profilesCleaned} perfil(is)).`,
+      );
+    }
+    if (orphanResult.removedCount > 0) {
+      console.log(
+        `   Perfis órfãos removidos: ${orphanResult.removedCount} (${formatBytes(orphanResult.freedBytes)} liberados).`,
+      );
+    }
     console.log(
       `   (Todos os cookies, sessões e logins foram 100% preservados!)`,
     );
@@ -172,13 +178,13 @@ async function main() {
       for (const d of browserResult.unusedDirs) {
         console.log(`     - ${d.name} (${d.size})`);
       }
-      console.log(`   Total recuperado no SSD: ${formatBytes(browserResult.freedBytes)}!`);
+      console.log(`   Total recuperado em disco: ${formatBytes(browserResult.freedBytes)}!`);
     } else {
-      console.log(`   [INFO] Encontrados ${browserResult.unusedDirs.length} navegador(es) legados/não utilizados no seu SSD:`);
+      console.log(`   [INFO] Encontrados ${browserResult.unusedDirs.length} navegador(es) legados/não utilizados em disco:`);
       for (const d of browserResult.unusedDirs) {
         console.log(`     - ${d.name} (${d.size})`);
       }
-      console.log(`   Espaço recuperável no SSD: ${formatBytes(totalReclaimable)}.`);
+      console.log(`   Espaço recuperável em disco: ${formatBytes(totalReclaimable)}.`);
       console.log(`   Para liberar esse espaço automaticamente, execute:`);
       console.log(`   npm run clean:all\n`);
     }

package/src/core/config.ts

@@ -34,7 +34,7 @@ const envSchema = z
     // temp chat (chat_mode:"local") for every request and sends the full
     // history inline (OpenAI standard). Temp chats are ephemeral and never
     // appear in the account's chat list (live-probed).
-    QWEN_CHAT_MODE: z.enum(["thread", "temp"]).default("thread"),
+    QWEN_CHAT_MODE: z.enum(["thread", "temp", "temp-thread"]).default("thread"),
     PLAYWRIGHT_HEADLESS: z.string().default("true"),
     PLAYWRIGHT_BROWSER: z
       .enum(["chromium", "chrome", "edge"])
@@ -379,5 +379,5 @@ export const config = {
 
 export type Config = typeof config;
 
-/** Conversation mode: thread-native reuse vs ephemeral temp chat per request. */
-export type ChatMode = "thread" | "temp";
+/** Conversation mode: thread-native reuse vs ephemeral temp chat per request vs temp-thread (ephemeral continuous session). */
+export type ChatMode = "thread" | "temp" | "temp-thread";

package/src/index.ts

@@ -55,7 +55,11 @@ if (isTui) {
     const message = error instanceof Error ? error.message : String(error)
     // Expected configuration errors are already formatted with an emoji and
     // actionable guidance; print only the message to avoid leaking stack traces.
-    if (message.includes('[Server]')) {
+    if (message.includes('No Qwen accounts configured')) {
+      console.error(message)
+      console.log('\n👉 Dica: Execute a interface interativa com "qpx" (ou "npm run tui") para gerenciar contas,')
+      console.log('   ou configure a variável QWEN_ACCOUNTS no seu arquivo .env.\n')
+    } else if (message.includes('[Server]')) {
       console.error(message)
     } else {
       console.error('❌ [Server] Failed to start:', message)

package/src/login.ts

@@ -130,6 +130,11 @@ async function removeAccountFlow() {
   const confirm = await askQuestion(`\nRemove ${account.email}? (y/N): `);
   if (confirm.toLowerCase() === "y") {
     if (removeAccount(account.id)) {
+      try {
+        const { removePlaywrightProfile } = await import("./services/playwright.ts");
+        const { getAccountProfilePath } = await import("./core/paths.ts");
+        removePlaywrightProfile(getAccountProfilePath(account.id));
+      } catch {}
       console.log(`Account ${maskEmail(account.email)} removed.`);
     } else {
       console.log("Failed to remove account.");

package/src/routes/chat/index.ts

@@ -49,7 +49,12 @@ function formatTimingHeader(timings: Record<string, number>): string {
  * else silently uses the configured default.
  */
 function resolveChatMode(headerValue: string | undefined): ChatMode {
-  if (headerValue === "thread" || headerValue === "temp") return headerValue;
+  if (headerValue === "thread" || headerValue === "temp" || headerValue === "temp-thread") {
+    return headerValue;
+  }
+  if (headerValue === "temp_thread") {
+    return "temp-thread";
+  }
   return config.qwen.chatMode;
 }
 

package/src/services/chat-cleanup.ts

@@ -9,7 +9,7 @@ import {
   isPlaywrightInitialized,
   closeAllPlaywright,
 } from "./playwright.ts";
-
+import { isAuthMockEnabled } from "./auth-playwright.ts";
 export interface DeleteChatsResult {
   attempted: number;
   succeeded: number;
@@ -17,7 +17,7 @@ export interface DeleteChatsResult {
 }
 
 async function ensurePlaywrightSession(account: QwenAccount): Promise<void> {
-  if (isPlaywrightInitialized(account.id)) return;
+  if (isPlaywrightInitialized(account.id) || isAuthMockEnabled()) return;
 
   const credentials = getAccountCredentials(account.id);
   if (!credentials) {
@@ -33,12 +33,25 @@ async function ensurePlaywrightSession(account: QwenAccount): Promise<void> {
   );
 }
 
-async function deleteChatsForAccount(account: QwenAccount): Promise<boolean> {
+export async function deleteChatsForAccount(account: QwenAccount): Promise<boolean> {
   await ensurePlaywrightSession(account);
   return deleteAllQwenChats(account.id);
 }
 
-export async function deleteChatsForConfiguredAccounts(): Promise<DeleteChatsResult> {
+export async function deleteChatsForAccountId(accountId: string): Promise<boolean> {
+  const accounts = loadAccounts();
+  const account = accounts.find((a) => a.id === accountId);
+  if (!account) {
+    throw new Error(`Conta ${accountId} não encontrada.`);
+  }
+  const credentials = getAccountCredentials(account.id);
+  if (!credentials) {
+    throw new Error(`Credenciais da conta ${account.email} não encontradas.`);
+  }
+  return deleteChatsForAccount(credentials);
+}
+
+export async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false): Promise<DeleteChatsResult> {
   // Playwright requests are account-scoped. Use every account persisted in the
   // database, including accounts created through `npm run login`, instead of
   // falling back to a global request without an account context.
@@ -64,12 +77,14 @@ export async function deleteChatsForConfiguredAccounts(): Promise<DeleteChatsRes
       }
     }
   } finally {
-    await closeAllPlaywright().catch((error) => {
-      console.warn(
-        `[DeleteChats] Failed to close Playwright sessions:`,
-        error instanceof Error ? error.message : String(error),
-      );
-    });
+    if (!keepBrowserOpen) {
+      await closeAllPlaywright().catch((error) => {
+        console.warn(
+          `[DeleteChats] Failed to close Playwright sessions:`,
+          error instanceof Error ? error.message : String(error),
+        );
+      });
+    }
   }
 
   return {

package/src/services/playwright.ts

@@ -7,7 +7,31 @@ import { chromium, type Browser, type BrowserContext, type Page } from "patchrig
 import path from "path";
 import fs from "fs";
 import crypto from "crypto";
-import type { QwenAccount } from "../core/accounts.ts";
+import { spawnSync } from "child_process";
+import { createRequire } from "module";
+
+const requireLocal = createRequire(import.meta.url);
+
+function autoInstallPlaywrightChromium(): void {
+  try {
+    const patchrightEntry = requireLocal.resolve("patchright");
+    const cliPath = path.join(path.dirname(patchrightEntry), "cli.js");
+    if (fs.existsSync(cliPath)) {
+      console.log("⏳ [Playwright] Navegador Chromium não encontrado. Instalando automaticamente...");
+      spawnSync(process.execPath, [cliPath, "install", "chromium"], {
+        stdio: "inherit",
+      });
+      return;
+    }
+  } catch {}
+
+  console.log("⏳ [Playwright] Navegador Chromium não encontrado. Instalando via npx...");
+  const cmd = process.platform === "win32" ? "npx.cmd" : "npx";
+  spawnSync(cmd, ["--yes", "patchright", "install", "chromium"], {
+    stdio: "inherit",
+  });
+}
+import { loadAccounts, type QwenAccount } from "../core/accounts.ts";
 // Imported here rather than injected from session-keeper.ts: account-concurrency
 // only depends on config/logger, so playwright -> account-concurrency stays
 // acyclic, while the reverse direction would drag the browser layer into core.
@@ -260,15 +284,30 @@ export async function getOrLaunchSharedBrowser(
     const launchArgs = buildChromiumLaunchArgs(defaultViewport);
 
     console.log(
-      `[Playwright] Launching single shared ${browserType} browser...`,
+      `🌐 [Playwright] Launching single shared ${browserType} browser...`,
     );
 
-    const browser = await engine.launch({
-      headless,
-      channel,
-      ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
-      args: launchArgs,
-    });
+    let browser: Browser;
+    try {
+      browser = await engine.launch({
+        headless,
+        channel,
+        ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
+        args: launchArgs,
+      });
+    } catch (launchErr: any) {
+      if (launchErr?.message?.includes("Executable doesn't exist")) {
+        autoInstallPlaywrightChromium();
+        browser = await engine.launch({
+          headless,
+          channel,
+          ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
+          args: launchArgs,
+        });
+      } else {
+        throw launchErr;
+      }
+    }
 
     browser.on("disconnected", () => {
       console.warn("[Playwright] Shared browser disconnected");
@@ -2338,6 +2377,64 @@ export function pruneAllPlaywrightProfiles(baseDir = getProfilesDir()): {
 
   return { totalFreedBytes, totalFreedFiles, profilesCleaned };
 }
+/**
+ * Removes profile directories in data/qwen_profiles that do not belong to any
+ * active account configured in the database or environment, plus any lingering
+ * .stale-* directories from previous lock renames.
+ */
+export function cleanupOrphanProfiles(
+  baseDir = getProfilesDir(),
+  activeAccountIds?: Set<string>,
+): {
+  removedCount: number;
+  freedBytes: number;
+} {
+  let removedCount = 0;
+  let freedBytes = 0;
+
+  try {
+    if (!fs.existsSync(baseDir)) {
+      return { removedCount, freedBytes };
+    }
+
+    const activeIds =
+      activeAccountIds ?? new Set(loadAccounts().map((a) => a.id));
+
+    const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const isStale = entry.name.includes(".stale-");
+      const isOrphan = !isStale && !activeIds.has(entry.name);
+
+      if (isStale || isOrphan) {
+        const targetPath = path.join(baseDir, entry.name);
+        try {
+          let bytes = 0;
+          const countSize = (d: string) => {
+            try {
+              const subEntries = fs.readdirSync(d, { withFileTypes: true });
+              for (const e of subEntries) {
+                const full = path.join(d, e.name);
+                if (e.isDirectory()) countSize(full);
+                else if (e.isFile()) {
+                  try { bytes += fs.statSync(full).size; } catch {}
+                }
+              }
+            } catch {}
+          };
+          countSize(targetPath);
+          removePlaywrightProfile(targetPath);
+          if (!fs.existsSync(targetPath)) {
+            removedCount++;
+            freedBytes += bytes;
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+
+  return { removedCount, freedBytes };
+}
 
 const PROFILE_RESET_TIMEOUT_MS = Math.max(90_000, config.timeouts.headers);
 

package/src/services/qwen-chat-pool.ts

@@ -83,8 +83,9 @@ export function buildChatNewBody(
     project_id: "",
     timestamp: Date.now(),
     chat_type: "t2t",
-    // thread → normal (persisted), temp → local (ephemeral, not listed).
-    chat_mode: chatMode === "temp" ? "local" : "normal",
+    // thread → normal (persisted), temp / temp-thread → local (ephemeral, not listed).
+    chat_mode:
+      chatMode === "temp" || chatMode === "temp-thread" ? "local" : "normal",
   };
 }
 

package/src/services/qwen.ts

@@ -2653,7 +2653,10 @@ async function createQwenStreamInternal(
     chatId: chatSessionId || null,
     parentId: actualParentId ?? "",
     chat_id: chatSessionId || null,
-    chat_mode: options?.chatMode === "temp" ? "local" : "normal",
+    chat_mode:
+      options?.chatMode === "temp" || options?.chatMode === "temp-thread"
+        ? "local"
+        : "normal",
     model: model,
     parent_id: actualParentId,
     messages: [

package/src/tui/app.ts

@@ -11,7 +11,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-let cachedAppVersion = "v1.0.2";
+let cachedAppVersion = "v1.0.5";
 try {
   const currentDir = path.dirname(fileURLToPath(import.meta.url));
   const pkgPath = path.resolve(currentDir, "../../package.json");

package/src/tui/proxy-client.ts

@@ -2,7 +2,7 @@
  * QwenProxy TUI - Proxy Data Provider & Live State Client
  */
 
-import { config } from "../core/config.ts";
+import { config, type ChatMode } from "../core/config.ts";
 import { loadAccounts, type QwenAccount } from "../core/accounts.ts";
 import {
   getAccountCooldownInfo,
@@ -176,6 +176,7 @@ export interface StreamChatOptions {
   model: string;
   reasoning_effort?: "low" | "medium" | "high";
   messages: Array<{ role: "system" | "user" | "assistant"; content: string }>;
+  chatMode?: ChatMode;
   onToken: (text: string) => void;
   onReasoning?: (text: string) => void;
   signal?: AbortSignal;
@@ -197,11 +198,13 @@ export async function streamChatCompletions(
 
   let resp: Response;
   try {
+    const chatMode = options.chatMode ?? "temp-thread";
     resp = await fetch(`http://${host}:${port}/v1/chat/completions`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${apiKey}`,
+        "x-qwenproxy-chat-mode": chatMode,
       },
       body: JSON.stringify({
         model: options.model,