@pedrofariasx/qwenproxy 1.1.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2026 Pedro Farias
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,292 @@
+# QwenProxy
+
+Proxy API local compatível com OpenAI que roteia requisições para os modelos do **Qwen (chat.qwen.ai)** via automação de navegador com Playwright. Suporte a múltiplas contas com rotação automática, execução de ferramentas, modo de pensamento (reasoning), persistência de sessão e armazenamento em SQLite.
+
+[![CI](https://github.com/pedrofariasx/qwenproxy/actions/workflows/ci.yml/badge.svg)](https://github.com/pedrofariasx/qwenproxy/actions/workflows/ci.yml)
+[![TypeScript](https://img.shields.io/badge/TypeScript-6.0-blue)](https://www.typescriptlang.org/)
+[![Hono](https://img.shields.io/badge/Hono-4.12-green)](https://hono.dev/)
+[![Playwright](https://img.shields.io/badge/Playwright-1.60-blueviolet)](https://playwright.dev/)
+[![License: ISC](https://img.shields.io/badge/License-ISC-yellow.svg)](LICENSE)
+
+---
+
+## Features
+
+- **OpenAI API Compatible** — Interface compatível com `/v1/chat/completions` e `/v1/models`.
+- **Multi-Account** — Gerencie múltiplas contas Qwen com rotação round-robin e cooldown automático.
+- **SQLite Storage** — Contas salvas em banco de dados SQLite (WAL mode) para performance e confiabilidade.
+- **Reasoning Support** — Suporte completo ao modo de pensamento (thinking) dos modelos Qwen.
+- **Tool Execution** — Sistema de execução de ferramentas locais integrado ao fluxo do chat.
+- **Session Persistence** — Perfil de navegador persistente por conta em `qwen_profiles/`.
+- **Auto-Login** — Login automático via credenciais com recuperação de sessão.
+- **Browser Selection** — Escolha entre Chromium, Chrome, Firefox, Edge ou WebKit.
+- **Monitoring** — Health check, métricas Prometheus e watchdog integrados.
+- **Docker Ready** — Deploy para VPS com Docker, volumes persistentes e graceful shutdown.
+
+---
+
+## Arquitetura
+
+```mermaid
+graph TD
+    Client[Cliente OpenAI/SDK] -->|HTTP| Proxy[QwenProxy - Hono]
+    Proxy -->|/v1/chat/completions| Handler[Chat Handler]
+    Proxy -->|/v1/models| Models[Models API]
+    Handler --> AccountMgr[Account Manager]
+    AccountMgr -->|Round-Robin| Accounts[(SQLite)]
+    AccountMgr --> Playwright[Playwright Service]
+    Playwright --> Browser1[Browser - Conta 1]
+    Playwright --> Browser2[Browser - Conta 2]
+    Playwright --> BrowserN[Browser - Conta N]
+    Handler --> QwenAPI[chat.qwen.ai]
+    Handler --> Tools[Tool Executor]
+
+    subgraph "Persistência"
+        Accounts
+        Profiles[qwen_profiles/]
+    end
+```
+
+---
+
+## Pré-requisitos
+
+| Dependência | Versão Mínima | Instalação |
+|------------|--------------|-----------|
+| Node.js | v20.x | [nvm](https://github.com/nvm-sh/nvm) |
+| npm | v9.x | Incluído com Node.js |
+| Playwright | - | `npx playwright install` |
+| Docker (opcional) | v24.x | [Docker Docs](https://docs.docker.com/get-docker/) |
+
+---
+
+## Instalação
+
+### Via npm
+
+```bash
+git clone https://github.com/pedrofariasx/qwenproxy.git
+cd qwenproxy
+npm install
+npx playwright install
+```
+
+### Via Docker
+
+```bash
+docker-compose up -d
+```
+
+---
+
+## Configuração
+
+Crie o arquivo `.env` na raiz do projeto (veja `.env.example`):
+
+```env
+# Porta do servidor (default: 3000)
+PORT=3000
+
+# Chave de API para proteger os endpoints (opcional)
+API_KEY=sua-chave-secreta-aqui
+
+# Credenciais Qwen para login automático (modo single-account)
+QWEN_EMAIL=seu-email@exemplo.com
+QWEN_PASSWORD=sua-senha-aqui
+
+# Navegador (chromium, firefox, chrome, edge)
+BROWSER=chromium
+```
+
+---
+
+## Gerenciamento de Contas
+
+As contas são armazenadas em SQLite (`data/qwenproxy.db`). Use o CLI interativo para gerenciar:
+
+```bash
+# Abrir o gerenciador de contas
+npm run login
+
+# Com navegador específico
+npm run login:firefox
+npm run login:chrome
+npm run login:edge
+```
+
+O menu interativo permite:
+- **[A]** Adicionar conta com credenciais (email + senha)
+- **[M]** Adicionar conta via login manual no navegador
+- **[R]** Remover uma conta
+- **[L]** Login em todas as contas (inicializar sessões)
+
+> Na primeira execução, se existir um `accounts.json` antigo, as contas serão migradas automaticamente para SQLite.
+
+---
+
+## Uso
+
+### Iniciar o servidor
+
+```bash
+npm start                  # Chromium (padrão)
+npm run start:chrome       # Google Chrome
+npm run start:firefox      # Firefox
+npm run start:edge         # Microsoft Edge
+```
+
+O servidor inicia em `http://localhost:3000` com as seguintes rotas:
+
+| Rota | Método | Descrição |
+|------|--------|-----------|
+| `/v1/chat/completions` | POST | Chat completions (streaming + non-streaming) |
+| `/v1/chat/completions/stop` | POST | Abortar uma geração ativa |
+| `/v1/models` | GET | Listar modelos disponíveis |
+| `/v1/models/:model` | GET | Informações de um modelo específico |
+| `/health` | GET | Health check com status do sistema |
+| `/metrics` | GET | Métricas no formato Prometheus |
+
+---
+
+## Exemplos de Integração
+
+### OpenAI SDK (Node.js)
+
+```typescript
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+  baseURL: 'http://localhost:3000/v1',
+  apiKey: process.env.API_KEY || 'sk-no-key-required'
+});
+
+const completion = await openai.chat.completions.create({
+  model: 'qwen-plus',
+  messages: [{ role: 'user', content: 'Explique como funciona o Playwright.' }]
+});
+
+console.log(completion.choices[0].message.content);
+```
+
+### cURL
+
+```bash
+curl http://localhost:3000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer sua-chave" \
+  -d '{
+    "model": "qwen-plus",
+    "messages": [{"role": "user", "content": "Hello!"}],
+    "stream": true
+  }'
+```
+
+---
+
+## Deploy com Docker
+
+### docker-compose.yml
+
+```yaml
+services:
+  qwenproxy:
+    build: .
+    container_name: qwenproxy
+    ports:
+      - "${PORT:-3000}:3000"
+    env_file:
+      - .env
+    volumes:
+      - ./data:/app/data               # Banco SQLite
+      - ./qwen_profiles:/app/qwen_profiles  # Sessões dos navegadores
+    restart: unless-stopped
+```
+
+### Volumes persistentes
+
+| Volume | Conteúdo |
+|--------|----------|
+| `./data` | Banco SQLite com as contas (`qwenproxy.db`) |
+| `./qwen_profiles` | Perfis de navegador por conta (cookies, sessões) |
+
+---
+
+## Estrutura do Projeto
+
+```
+qwenproxy/
+├── src/
+│   ├── index.ts                 # Entry point
+│   ├── login.ts                 # CLI de gerenciamento de contas
+│   ├── api/
+│   │   ├── models.ts            # Endpoints /v1/models
+│   │   └── server.ts            # Servidor Hono + startup
+│   ├── cache/
+│   │   └── memory-cache.ts      # Cache em memória com TTL
+│   ├── core/
+│   │   ├── account-manager.ts   # Rotação round-robin + cooldowns
+│   │   ├── accounts.ts          # CRUD de contas (SQLite)
+│   │   ├── config.ts            # Configuração com Zod
+│   │   ├── database.ts          # Conexão e migrations SQLite
+│   │   ├── logger.ts            # Logger estruturado
+│   │   ├── metrics.ts           # Coleta de métricas
+│   │   ├── model-registry.ts    # Registro de modelos e context windows
+│   │   ├── stream-registry.ts   # Tracking de streams ativos
+│   │   └── watchdog.ts          # Health monitoring
+│   ├── linter/
+│   │   ├── bar.ts               # Facade
+│   │   ├── extraction-engine.ts # Extraction engine
+│   │   ├── foo.ts               # Exports
+│   │   ├── index.ts             # Main public API
+│   │   ├── repair-normalize.ts  # Repair and normalize
+│   │   ├── safety-gate.ts       # Safety gate
+│   │   ├── streaming-state-machine.ts # Streaming state machine
+│   │   ├── structural-parser.ts # Structural parser
+│   │   └── types.ts             # Types
+│   ├── routes/
+│   │   └── chat.ts              # Handler /v1/chat/completions
+│   ├── services/
+│   │   ├── playwright.ts        # Automação de navegador
+│   │   └── qwen.ts              # Integração com API do Qwen
+│   ├── tests/                   # Testes automatizados
+│   ├── tools/
+│   │   ├── executor.ts          # Execução de ferramentas
+│   │   ├── parser.ts            # Parser de <tool_call> tags
+│   │   ├── registry.ts          # Registro de tools
+│   │   ├── schema.ts            # Validação JSON Schema
+│   │   └── types.ts             # Tipos do sistema de tools
+│   └── utils/
+│       ├── context-truncation.ts # Truncamento de contexto
+│       ├── json.ts              # Parser JSON robusto
+│       └── types.ts             # Re-exports de tipos
+├── data/                        # Banco SQLite (gitignored)
+├── qwen_profiles/               # Perfis de navegador por conta (gitignored)
+├── Dockerfile
+├── docker-compose.yml
+└── package.json
+```
+
+---
+
+## Troubleshooting
+
+| Problema | Solução |
+|----------|---------|
+| Porta em uso | Altere `PORT` no `.env` ou encerre o processo na porta 3000 |
+| Navegador não abre | Execute `npx playwright install` |
+| Sessão expirada | Execute `npm run login` para renovar cookies |
+| Rate limit em todas as contas | Adicione mais contas via `npm run login` |
+| Banco corrompido | Apague `data/qwenproxy.db` e re-adicione as contas |
+
+---
+
+## Disclaimer
+
+> Este projeto é fornecido estritamente para fins educacionais e de pesquisa.
+
+Os autores não incentivam ou endossam:
+- Violação dos Termos de Serviço da plataforma Qwen.
+- Automação não autorizada em larga escala.
+- Uso para atividades maliciosas.
+
+**Use por sua conta e risco.**

package/bin/qwenproxy.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const script = path.join(__dirname, '..', 'src', 'index.ts');
+
+const args = process.argv.slice(2);
+const proc = spawn('node', ['--import', 'tsx', script, ...args], { stdio: 'inherit' });
+proc.on('close', (code) => process.exit(code ?? 0));

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@pedrofariasx/qwenproxy",
+  "version": "1.1.0",
+  "description": "Local OpenAI-compatible proxy API that routes requests to Qwen (chat.qwen.ai) via Playwright browser automation.",
+  "main": "index.js",
+  "scripts": {
+    "start": "npx tsx src/index.ts",
+    "start:firefox": "npx tsx src/index.ts --browser=firefox",
+    "start:chrome": "npx tsx src/index.ts --browser=chrome",
+    "start:edge": "npx tsx src/index.ts --browser=edge",
+    "login": "npx tsx src/login.ts",
+    "login:firefox": "npx tsx src/login.ts --browser=firefox",
+    "login:chrome": "npx tsx src/login.ts --browser=chrome",
+    "login:edge": "npx tsx src/login.ts --browser=edge",
+    "test": "tsx --test src/**/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [],
+  "author": "Pedro Farias",
+  "license": "ISC",
+  "dependencies": {
+    "@hono/node-server": "^2.0.3",
+    "ajv": "^8.20.0",
+    "ali-oss": "^6.23.0",
+    "better-sqlite3": "^12.10.0",
+    "dotenv": "^17.4.2",
+    "hono": "^4.12.21",
+    "playwright": "^1.60.0",
+    "tsx": "^4.22.3",
+    "uuid": "^14.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/git": "^10.0.1",
+    "@types/ajv": "^0.0.5",
+    "@types/ali-oss": "^6.23.3",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.9.1",
+    "@types/uuid": "^11.0.0",
+    "semantic-release": "^25.0.3",
+    "typescript": "^6.0.3"
+  },
+  "bin": {
+    "qwenproxy": "./bin/qwenproxy.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src/**/*",
+    "bin/**/*"
+  ],
+  "type": "module"
+}

package/src/api/models.ts

@@ -0,0 +1,183 @@
+import { Hono } from 'hono'
+import { config } from '../core/config.js'
+import { getBasicHeaders } from '../services/playwright.js'
+import { loadAccounts } from '../core/accounts.js'
+import { getAccountCooldownInfo } from '../core/account-manager.js'
+import { cache } from '../cache/memory-cache.js'
+
+const app = new Hono()
+
+app.get('/v1/models', async (c) => {
+  try {
+    let accountId: string | undefined
+    try {
+      const accounts = loadAccounts()
+      const account = accounts.find(a => !getAccountCooldownInfo(a.id)) || accounts[0]
+      if (account) {
+        accountId = account.id
+      }
+    } catch (e) {
+      console.warn('Failed to retrieve account for models endpoint:', e)
+    }
+
+    const cacheKey = `models:${accountId || 'global'}` as any
+    const cached = await cache.get<any>(cacheKey)
+    if (cached) {
+      return c.json(cached)
+    }
+
+    const { cookie, userAgent, bxV } = await getBasicHeaders(accountId)
+    const response = await fetch(`${config.qwen.baseUrl}/api/models`, {
+      headers: {
+        'Accept': 'application/json, text/plain, */*',
+        'Accept-Language': 'pt-BR,pt;q=0.9',
+        'Connection': 'keep-alive',
+        'Referer': `${config.qwen.baseUrl}/c/demo`,
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-origin',
+        'User-Agent': userAgent,
+        'X-Request-Id': crypto.randomUUID(),
+        'source': 'web',
+        'bx-v': bxV,
+        'sec-ch-ua': '"Chromium";v="148", "Google Chrome";v="148", "Not/A)Brand";v="99"',
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': '"Linux"',
+        'Timezone': new Date().toString(),
+        'Cookie': cookie,
+      },
+    })
+    
+    if (!response.ok) {
+      throw new Error(`Failed to fetch models: ${response.status}`)
+    }
+    
+    const data = await response.json()
+    
+    const models = Array.isArray(data?.data) ? data.data : Array.isArray(data) ? data : []
+    
+    const formatted = {
+      object: 'list',
+      data: [
+        ...models.map((model: any) => ({
+          id: model.id,
+          name: model.name,
+          object: 'model',
+          owned_by: model.owned_by,
+          created: model.info?.created_at || Date.now(),
+          context_window: model.info?.meta?.max_context_length,
+          capabilities: model.info?.meta?.capabilities,
+        })),
+        ...models.map((model: any) => ({
+          id: `${model.id}-no-thinking`,
+          name: `${model.name} (No Thinking)`,
+          object: 'model',
+          owned_by: model.owned_by,
+          created: model.info?.created_at || Date.now(),
+          context_window: model.info?.meta?.max_context_length,
+          capabilities: model.info?.meta?.capabilities,
+        })),
+      ],
+    }
+
+    // Cache the formatted models list for 5 minutes (300 seconds)
+    await cache.set(cacheKey, formatted, 300)
+    
+    return c.json(formatted)
+  } catch (error: any) {
+    console.error('Error fetching models:', error)
+    return c.json({ error: error.message }, 500)
+  }
+})
+
+app.get('/v1/models/:model', async (c) => {
+  try {
+    const modelId = c.req.param('model')
+
+    let accountId: string | undefined
+    try {
+      const accounts = loadAccounts()
+      const account = accounts.find(a => !getAccountCooldownInfo(a.id)) || accounts[0]
+      if (account) {
+        accountId = account.id
+      }
+    } catch (e) {
+      console.warn('Failed to retrieve account for model endpoint:', e)
+    }
+
+    const cacheKey = `models:${accountId || 'global'}` as any
+    let formattedList = await cache.get<any>(cacheKey)
+    let models = formattedList?.data || []
+
+    if (models.length === 0) {
+      const { cookie, userAgent, bxV } = await getBasicHeaders(accountId)
+      const response = await fetch(`${config.qwen.baseUrl}/api/models`, {
+        headers: {
+          'Accept': 'application/json, text/plain, */*',
+          'Accept-Language': 'pt-BR,pt;q=0.9',
+          'Connection': 'keep-alive',
+          'Referer': `${config.qwen.baseUrl}/c/demo`,
+          'Sec-Fetch-Dest': 'empty',
+          'Sec-Fetch-Mode': 'cors',
+          'Sec-Fetch-Site': 'same-origin',
+          'User-Agent': userAgent,
+          'X-Request-Id': crypto.randomUUID(),
+          'source': 'web',
+          'bx-v': bxV,
+          'sec-ch-ua': '"Chromium";v="148", "Google Chrome";v="148", "Not/A)Brand";v="99"',
+          'sec-ch-ua-mobile': '?0',
+          'sec-ch-ua-platform': '"Linux"',
+          'Timezone': new Date().toString(),
+          'Cookie': cookie,
+        },
+      })
+      
+      if (!response.ok) {
+        throw new Error(`Failed to fetch models: ${response.status}`)
+      }
+      
+      const data = await response.json()
+      const rawModels = Array.isArray(data?.data) ? data.data : Array.isArray(data) ? data : []
+      
+      const formatted = {
+        object: 'list',
+        data: [
+          ...rawModels.map((model: any) => ({
+            id: model.id,
+            name: model.name,
+            object: 'model',
+            owned_by: model.owned_by,
+            created: model.info?.created_at || Date.now(),
+            context_window: model.info?.meta?.max_context_length,
+            capabilities: model.info?.meta?.capabilities,
+          })),
+          ...rawModels.map((model: any) => ({
+            id: `${model.id}-no-thinking`,
+            name: `${model.name} (No Thinking)`,
+            object: 'model',
+            owned_by: model.owned_by,
+            created: model.info?.created_at || Date.now(),
+            context_window: model.info?.meta?.max_context_length,
+            capabilities: model.info?.meta?.capabilities,
+          })),
+        ],
+      }
+
+      await cache.set(cacheKey, formatted, 300)
+      models = formatted.data
+    }
+
+    const model = models.find((m: any) => m.id === modelId)
+    
+    if (!model) {
+      return c.json({ error: 'Model not found' }, 404)
+    }
+    
+    return c.json(model)
+  } catch (error: any) {
+    console.error('Error fetching model:', error)
+    return c.json({ error: error.message }, 500)
+  }
+})
+
+export { app }

package/src/api/server.ts

@@ -0,0 +1,126 @@
+import { Hono } from 'hono'
+import { serve } from '@hono/node-server'
+import { config } from '../core/config.js'
+import { metrics } from '../core/metrics.js'
+import { cache } from '../cache/memory-cache.js'
+import { Watchdog } from '../core/watchdog.js'
+import { app as modelsApp } from './models.js'
+import { chatCompletions, chatCompletionsStop } from '../routes/chat.js'
+import { uploadFile } from '../routes/upload.js'
+
+const app = new Hono()
+
+let watchdog: Watchdog
+let server: any
+
+app.use('*', async (c, next) => {
+  metrics.increment('requests.total')
+  const start = Date.now()
+  await next()
+  const duration = Date.now() - start
+  metrics.histogram('latency.request', duration)
+  c.header('X-Response-Time', `${duration}ms`)
+})
+
+app.use('/v1/*', async (c, next) => {
+  const apiKey = process.env.API_KEY || config.apiKey
+  if (apiKey) {
+    const auth = c.req.header('Authorization')
+    if (!auth?.startsWith('Bearer ')) {
+      return c.json({ error: 'Missing or invalid Authorization header' }, 401)
+    }
+    const token = auth.slice(7)
+    if (token !== apiKey) {
+      return c.json({ error: 'Invalid API key' }, 401)
+    }
+  }
+  await next()
+})
+
+app.route('', modelsApp)
+app.post('/v1/chat/completions', chatCompletions)
+app.post('/v1/chat/completions/stop', chatCompletionsStop)
+app.post('/v1/upload', uploadFile)
+
+app.get('/health', async (c) => {
+  const status = await watchdog?.getStatus()
+  return c.json({
+    status: status?.overall || 'unknown',
+    timestamp: Date.now(),
+    metrics: {
+      cache: await cache?.getStats(),
+    },
+  })
+})
+
+app.get('/metrics', (c) => {
+  return c.text(metrics.formatPrometheus(), {
+    headers: { 'Content-Type': 'text/plain; version=0.0.4' },
+  })
+})
+
+app.onError((err, c) => {
+  metrics.increment('requests.errors')
+  console.error('API Error:', err)
+  return c.json({ error: err.message }, 500)
+})
+
+app.notFound((c) => c.json({ error: 'Not found' }, 404))
+
+export async function startServer(): Promise<void> {
+  await cache.connect()
+
+  const { loadAccounts } = await import('../core/accounts.ts')
+  const accounts = loadAccounts()
+
+  const { initPlaywright, initPlaywrightForAccount, getQwenHeaders } = await import('../services/playwright.ts')
+  
+  await initPlaywright(config.browser.headless)
+  
+  if (accounts.length > 0) {
+    console.log(`[Server] Pre-warming ${accounts.length} configured account(s) in parallel...`)
+    await Promise.all(
+      accounts.map(account =>
+        initPlaywrightForAccount(account, config.browser.headless).catch((err: any) => {
+          console.error(`[Server] Failed to initialize account ${account.email}:`, err.message)
+        })
+      )
+    )
+    console.log('[Server] Pre-fetching headers for all accounts in background...')
+    const { warmAllPools } = await import('../services/qwen.ts')
+    warmAllPools(accounts.map(a => a.id)).catch(() => {})
+  }
+
+  watchdog = new Watchdog()
+  watchdog.start()
+
+  metrics.startCollection()
+
+  server = serve({
+    fetch: app.fetch,
+    port: config.server.port,
+    hostname: config.server.host,
+  }, (info) => {
+    console.log(`Server listening on http://${info.address}:${info.port}`)
+  })
+
+  const shutdown = async (signal: string) => {
+    console.log(`Received ${signal}, shutting down gracefully...`)
+    watchdog.stop()
+    metrics.stopCollection()
+    await cache.close()
+    const { closePlaywright } = await import('../services/playwright.js')
+    await closePlaywright()
+    const { cleanupAllAccountMutexes } = await import('../routes/chat.js')
+    cleanupAllAccountMutexes()
+    const { closeDatabase } = await import('../core/database.ts')
+    closeDatabase()
+    server?.close()
+    process.exit(0)
+  }
+
+  process.on('SIGINT', () => shutdown('SIGINT'))
+  process.on('SIGTERM', () => shutdown('SIGTERM'))
+}
+
+export { app }