qwenproxy-cli 1.0.32 → 1.2.0

package/src/sync/index.ts

@@ -10,6 +10,7 @@ import type {
   ClientSyncResult,
   SyncAllOptions,
   SyncClientName,
+  SyncRecord,
   SyncStateFile,
 } from "./types.ts";
 import { syncClaudeCode, restoreClaudeCode } from "./claude-code.ts";
@@ -23,6 +24,28 @@ import { syncCline, restoreCline } from "./cline.ts";
 import { syncZed, restoreZed } from "./zed.ts";
 import { syncAider, restoreAider } from "./aider.ts";
 
+export {
+  syncClaudeCode,
+  restoreClaudeCode,
+  syncCodex,
+  restoreCodex,
+  syncOpenCode,
+  restoreOpenCode,
+  syncOmp,
+  restoreOmp,
+  syncHermes,
+  restoreHermes,
+  syncOpenClaw,
+  restoreOpenClaw,
+  syncKilo,
+  restoreKilo,
+  syncCline,
+  restoreCline,
+  syncZed,
+  restoreZed,
+  syncAider,
+  restoreAider,
+};
 export function resolveApiKey(overrideKey?: string, configKey?: string): string {
   if (overrideKey && overrideKey.trim().length > 0) {
     return overrideKey.trim();
@@ -646,16 +669,29 @@ export function syncAllClients(options: SyncAllOptions = {}): SyncAllResult {
     }
   }
 
-  // Persist sync state
+  // Persist sync state (merge with existing state if present)
   try {
     fs.mkdirSync(path.dirname(stateFilePath), { recursive: true });
+    let existingClients: SyncStateFile["clients"] = {};
+    if (fs.existsSync(stateFilePath)) {
+      try {
+        const raw = fs.readFileSync(stateFilePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.clients && typeof parsed.clients === "object") {
+          existingClients = parsed.clients;
+        }
+      } catch {}
+    }
     const stateContent: SyncStateFile = {
       version: 1,
       updatedAt: new Date().toISOString(),
       apiKey,
       port,
       host,
-      clients: stateRecords,
+      clients: {
+        ...existingClients,
+        ...stateRecords,
+      },
     };
     fs.writeFileSync(stateFilePath, JSON.stringify(stateContent, null, 2) + "\n", "utf-8");
   } catch (err) {
@@ -670,87 +706,79 @@ export interface RestoreAllResult {
   details: ClientSyncResult[];
 }
 
-export function restoreAllClients(options: { stateFilePath?: string } = {}): RestoreAllResult {
+export interface RestoreAllOptions {
+  stateFilePath?: string;
+  targets?: SyncClientName[];
+}
+
+export function restoreAllClients(options: RestoreAllOptions = {}): RestoreAllResult {
+  const defaultPaths = getDefaultPaths();
   const stateFilePath = options.stateFilePath || getDefaultStateFilePath();
   const details: ClientSyncResult[] = [];
   let restoredCount = 0;
 
-  if (!fs.existsSync(stateFilePath)) {
-    return { restoredCount: 0, details };
+  let state: SyncStateFile | null = null;
+  if (fs.existsSync(stateFilePath)) {
+    try {
+      const raw = fs.readFileSync(stateFilePath, "utf-8");
+      state = JSON.parse(raw);
+    } catch {}
   }
 
-  try {
-    const raw = fs.readFileSync(stateFilePath, "utf-8");
-    const state: SyncStateFile = JSON.parse(raw);
-
-    if (state.clients.claudeCode?.backupPath) {
-      const res = restoreClaudeCode(state.clients.claudeCode.filePath, state.clients.claudeCode.backupPath);
-      details.push(res);
-      if (res.success) restoredCount++;
-    }
-
-    if (state.clients.codex?.backupPath) {
-      const res = restoreCodex(state.clients.codex.filePath, state.clients.codex.backupPath);
-      details.push(res);
-      if (res.success) restoredCount++;
-    }
-
-    if (state.clients.openCode?.backupPath) {
-      const res = restoreOpenCode(state.clients.openCode.filePath, state.clients.openCode.backupPath);
-      details.push(res);
-      if (res.success) restoredCount++;
-    }
-
-    if (state.clients.omp?.backupPath) {
-      const res = restoreOmp(state.clients.omp.filePath, state.clients.omp.backupPath);
-      details.push(res);
-      if (res.success) restoredCount++;
-    }
-
-    if (state.clients.hermes?.backupPath) {
-      const res = restoreHermes(state.clients.hermes.filePath, state.clients.hermes.backupPath);
-      details.push(res);
-      if (res.success) restoredCount++;
-    }
-
-    if (state.clients.openClaw?.backupPath) {
-      const res = restoreOpenClaw(state.clients.openClaw.filePath, state.clients.openClaw.backupPath);
-      details.push(res);
-      if (res.success) restoredCount++;
-    }
+  const shouldRestore = (client: SyncClientName) => {
+    if (!options.targets || options.targets.length === 0) return true;
+    return options.targets.includes(client);
+  };
 
-    if (state.clients.kilo?.backupPath) {
-      const res = restoreKilo(state.clients.kilo.filePath, state.clients.kilo.backupPath);
-      details.push(res);
-      if (res.success) restoredCount++;
-    }
+  const restoreClientsList: Array<{
+    id: SyncClientName;
+    stateKey: keyof SyncStateFile["clients"];
+    defaultPath: string;
+    stateRecord?: SyncRecord;
+    restoreFn: (filePath: string, backupPath?: string) => ClientSyncResult;
+  }> = [
+    { id: "claude-code", stateKey: "claudeCode", defaultPath: defaultPaths.claudeCode, stateRecord: state?.clients?.claudeCode, restoreFn: restoreClaudeCode },
+    { id: "codex", stateKey: "codex", defaultPath: defaultPaths.codex, stateRecord: state?.clients?.codex, restoreFn: restoreCodex },
+    { id: "opencode", stateKey: "openCode", defaultPath: defaultPaths.openCode, stateRecord: state?.clients?.openCode, restoreFn: restoreOpenCode },
+    { id: "omp", stateKey: "omp", defaultPath: defaultPaths.omp, stateRecord: state?.clients?.omp, restoreFn: restoreOmp },
+    { id: "hermes", stateKey: "hermes", defaultPath: defaultPaths.hermes, stateRecord: state?.clients?.hermes, restoreFn: restoreHermes },
+    { id: "openclaw", stateKey: "openClaw", defaultPath: defaultPaths.openClaw, stateRecord: state?.clients?.openClaw, restoreFn: restoreOpenClaw },
+    { id: "kilo", stateKey: "kilo", defaultPath: defaultPaths.kilo, stateRecord: state?.clients?.kilo, restoreFn: restoreKilo },
+    { id: "cline", stateKey: "cline", defaultPath: defaultPaths.cline, stateRecord: state?.clients?.cline, restoreFn: restoreCline },
+    { id: "zed", stateKey: "zed", defaultPath: defaultPaths.zed, stateRecord: state?.clients?.zed, restoreFn: restoreZed },
+    { id: "aider", stateKey: "aider", defaultPath: defaultPaths.aider, stateRecord: state?.clients?.aider, restoreFn: restoreAider },
+  ];
 
-    if (state.clients.cline?.backupPath) {
-      const res = restoreCline(state.clients.cline.filePath, state.clients.cline.backupPath);
-      details.push(res);
-      if (res.success) restoredCount++;
-    }
+  for (const c of restoreClientsList) {
+    if (!shouldRestore(c.id)) continue;
+    const filePath = c.stateRecord?.filePath || c.defaultPath;
+    const backupPath = c.stateRecord?.backupPath;
 
-    if (state.clients.zed?.backupPath) {
-      const res = restoreZed(state.clients.zed.filePath, state.clients.zed.backupPath);
-      details.push(res);
-      if (res.success) restoredCount++;
-    }
+    const canAttempt = options.stateFilePath
+      ? Boolean(c.stateRecord)
+      : Boolean(c.stateRecord || fs.existsSync(filePath));
 
-    if (state.clients.aider?.backupPath) {
-      const res = restoreAider(state.clients.aider.filePath, state.clients.aider.backupPath);
+    if (canAttempt) {
+      const res = c.restoreFn(filePath, backupPath);
       details.push(res);
-      if (res.success) restoredCount++;
+      if (res.success) {
+        restoredCount++;
+        if (state?.clients) {
+          delete state.clients[c.stateKey];
+          delete (state.clients as any)[c.id];
+        }
+      }
     }
-
-    // Remove state file after successful restoration
+  }
+  // Update or delete state file
+  if (stateFilePath && fs.existsSync(stateFilePath)) {
     try {
-      fs.unlinkSync(stateFilePath);
-    } catch {
-      // Ignore
-    }
-  } catch (err) {
-    console.error("Error reading sync state file:", err);
+      if (state && state.clients && Object.keys(state.clients).length > 0) {
+        fs.writeFileSync(stateFilePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+      } else {
+        fs.unlinkSync(stateFilePath);
+      }
+    } catch {}
   }
 
   return { restoredCount, details };

package/src/sync/omp.ts

@@ -99,13 +99,32 @@ export function syncOmp(options: SyncOptions): ClientSyncResult {
 }
 
 export function restoreOmp(filePath: string, backupPath?: string): ClientSyncResult {
-  const restored = restoreFromBackup(filePath, backupPath);
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+
+  let manuallyCleaned = false;
+  if (fs.existsSync(filePath)) {
+    try {
+      let content = fs.readFileSync(filePath, "utf-8");
+      if (content.includes("qwenproxy:")) {
+        const regex = /^\s*qwenproxy:\s*\r?\n(?:^[ \t].*\r?\n?)*/m;
+        content = content.replace(regex, "");
+        fs.writeFileSync(filePath, content, "utf-8");
+        manuallyCleaned = true;
+      }
+    } catch {}
+  }
+
+  const success = restoredFromBackup || manuallyCleaned;
   return {
     client: "omp",
     filePath,
     backupPath,
-    success: restored,
-    action: restored ? "restored" : "failed",
-    message: restored ? "Restored OMP models config from backup" : "Backup file not found",
+    success,
+    action: success ? "restored" : "failed",
+    message: success
+      ? restoredFromBackup
+        ? "Restored OMP models config from backup"
+        : "Removed QwenProxy configuration from OMP config"
+      : "Backup file not found",
   };
 }

package/src/sync/opencode.ts

@@ -206,13 +206,37 @@ export function syncOpenCode(options: SyncOptions): ClientSyncResult {
 }
 
 export function restoreOpenCode(filePath: string, backupPath?: string): ClientSyncResult {
-  const restored = restoreFromBackup(filePath, backupPath);
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+
+  let manuallyCleaned = false;
+  if (fs.existsSync(filePath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      if (data.provider && data.provider.qwenproxy) {
+        delete data.provider.qwenproxy;
+        if (data.model && data.model.includes("qwen")) {
+          delete data.model;
+        }
+        if (Object.keys(data.provider).length === 0) {
+          delete data.provider;
+        }
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        manuallyCleaned = true;
+      }
+    } catch {}
+  }
+
+  const success = restoredFromBackup || manuallyCleaned;
   return {
     client: "opencode",
     filePath,
     backupPath,
-    success: restored,
-    action: restored ? "restored" : "failed",
-    message: restored ? "Restored OpenCode config from backup" : "Backup file not found",
+    success,
+    action: success ? "restored" : "failed",
+    message: success
+      ? restoredFromBackup
+        ? "Restored OpenCode config from backup"
+        : "Removed QwenProxy configuration from OpenCode config"
+      : "Backup file not found",
   };
 }

package/src/sync/utils.ts

@@ -13,13 +13,42 @@ export function createTimestampBackup(filePath: string): string {
   return backupPath;
 }
 
+export function findLatestBackup(filePath: string): string | undefined {
+  const dir = path.dirname(filePath);
+  const ext = path.extname(filePath);
+  const base = path.basename(filePath, ext);
+  if (!fs.existsSync(dir)) return undefined;
+
+  try {
+    const files = fs.readdirSync(dir);
+    const candidates = files
+      .filter((f) => f.startsWith(base) && f.includes("qwenproxy") && f.endsWith(".bak"))
+      .map((f) => path.join(dir, f))
+      .sort((a, b) => {
+        try {
+          return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+        } catch {
+          return 0;
+        }
+      });
+
+    return candidates[0];
+  } catch {
+    return undefined;
+  }
+}
+
 export function restoreFromBackup(filePath: string, backupPath?: string): boolean {
-  if (!backupPath || !fs.existsSync(backupPath)) {
+  const targetBackup = (backupPath && fs.existsSync(backupPath))
+    ? backupPath
+    : findLatestBackup(filePath);
+
+  if (!targetBackup || !fs.existsSync(targetBackup)) {
     return false;
   }
-  fs.copyFileSync(backupPath, filePath);
+  fs.copyFileSync(targetBackup, filePath);
   try {
-    fs.unlinkSync(backupPath);
+    fs.unlinkSync(targetBackup);
   } catch {
     // Ignore cleanup error
   }

package/src/sync/zed.ts

@@ -198,13 +198,37 @@ export function syncZed(options: SyncOptions): ClientSyncResult {
 }
 
 export function restoreZed(filePath: string, backupPath?: string): ClientSyncResult {
-  const restored = restoreFromBackup(filePath, backupPath);
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+
+  let manuallyCleaned = false;
+  if (fs.existsSync(filePath)) {
+    try {
+      let content = fs.readFileSync(filePath, "utf-8");
+      if (content.includes("127.0.0.1:7936") || content.includes("qwen3.8-max")) {
+        const data = parseJsonWithComments(content);
+        if (data.language_models?.openai?.api_url?.includes("7936")) {
+          delete data.language_models.openai;
+          if (Object.keys(data.language_models).length === 0) {
+            delete data.language_models;
+          }
+          fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+          manuallyCleaned = true;
+        }
+      }
+    } catch {}
+  }
+
+  const success = restoredFromBackup || manuallyCleaned;
   return {
     client: "zed",
     filePath,
     backupPath,
-    success: restored,
-    action: restored ? "restored" : "failed",
-    message: restored ? "Restored Zed settings from backup" : "Backup file not found",
+    success,
+    action: success ? "restored" : "failed",
+    message: success
+      ? restoredFromBackup
+        ? "Restored Zed settings from backup"
+        : "Removed QwenProxy configuration from Zed settings"
+      : "Backup file not found",
   };
 }

package/src/sync-clients.ts

@@ -73,8 +73,8 @@ Exemplos:
   npm run sync zed            # Sincroniza apenas o Zed Editor
   npm run sync aider          # Sincroniza apenas o Aider
   npm run sync claude codex   # Sincroniza múltiplos clientes específicos
-  npm run sync -- --list      # Lista status de detecção de todos os 10 clientes
-  npm run sync -- --restore   # Restaura as configurações originais (rollback)
+  npm run sync --list         # Lista status de detecção de todos os 10 clientes (ou qpx sync --list)
+  npm run sync --restore      # Restaura as configurações originais (ou qpx sync --restore)
 
 Opções:
   --client <nome>    Nome do cliente (hermes, opencode, claude, openclaw, kilo, cline, omp, codex, zed, aider)
@@ -193,8 +193,7 @@ async function main() {
   console.log("--------------------------------------------------");
   console.log(`✨ ${count} cliente(s) sincronizado(s) com zero perda de outras configs/provedores!`);
   console.log("💡 Para desfazer e restaurar a qualquer momento:");
-  console.log("   npm run sync -- --restore");
-  console.log("==================================================\n");
+  console.log("   qpx sync --restore (ou npm run sync --restore)");
 }
 
 main().catch((err) => {

package/src/tui/app.ts

@@ -5,7 +5,7 @@
 import { Screen, type KeyEvent } from "./screen.ts";
 import type { TuiView, ProxyStatusSnapshot } from "./types.ts";
 import { theme, glyphs, drawBox, stringWidth } from "./theme.ts";
-import { fetchProxyStatus } from "./proxy-client.ts";
+import { fetchProxyStatus, fetchLiveModels, getCachedLiveModels } from "./proxy-client.ts";
 import { ServerManager } from "./server-manager.ts";
 import fs from "node:fs";
 import path from "node:path";
@@ -26,6 +26,7 @@ import { SyncView } from "./views/sync-view.ts";
 import { StorageView } from "./views/storage-view.ts";
 import { AccountsView } from "./views/accounts-view.ts";
 import { LogsView } from "./views/logs-view.ts";
+import { setRuntimeChatMode } from "../core/config.ts";
 import { loadTuiSettings, saveTuiSettings } from "./settings.ts";
 export class TuiApp {
   private screen: Screen;
@@ -39,6 +40,10 @@ export class TuiApp {
   private renderScheduled = false;
   constructor(initialTab?: number) {
     this.screen = new Screen();
+    const saved = loadTuiSettings();
+    if (saved.chat?.mode) {
+      setRuntimeChatMode(saved.chat.mode);
+    }
 
     this.views = [
       new StatusView(),
@@ -49,16 +54,10 @@ export class TuiApp {
       new LogsView(),
     ];
 
-    let resolvedTab = initialTab;
-    if (!resolvedTab || isNaN(resolvedTab)) {
-      const saved = loadTuiSettings();
-      if (saved.lastTab && saved.lastTab >= 1 && saved.lastTab <= 6) {
-        resolvedTab = saved.lastTab;
-      } else {
-        resolvedTab = 1;
-      }
+    let resolvedTab = initialTab ?? (saved.lastTab && saved.lastTab >= 1 && saved.lastTab <= 6 ? saved.lastTab : 1);
+    if (isNaN(resolvedTab)) {
+      resolvedTab = 1;
     }
-
     const tabIdx = Math.max(0, Math.min(this.views.length - 1, resolvedTab - 1));
     this.activeViewIndex = tabIdx;
   }
@@ -129,10 +128,28 @@ export class TuiApp {
     } catch {}
 
     // Background polling every 1s for live status updates and model catalog synchronization
+    let pollCount = 0;
     this.pollInterval = setInterval(async () => {
       if (!this.isRunning) return;
+      pollCount++;
       try {
         this.statusSnapshot = await fetchProxyStatus();
+
+        // Sync live models catalog when server is running:
+        // Try every 5s until first successful catalog load, then refresh periodically every 30s
+        const hasLiveModels = getCachedLiveModels() !== null;
+        const shouldSync = !hasLiveModels ? pollCount % 5 === 1 : pollCount % 30 === 1;
+        if (shouldSync) {
+          const models = await fetchLiveModels(hasLiveModels);
+          if (models.length > 0) {
+            for (const view of this.views) {
+              if ("refreshModels" in view && typeof (view as any).refreshModels === "function") {
+                void (view as any).refreshModels();
+              }
+            }
+          }
+        }
+
         this.requestRender();
       } catch {}
     }, 1000);

package/src/tui/index.ts

@@ -23,6 +23,9 @@ function parseInitialTab(): number | undefined {
 
   return undefined;
 }
+try {
+  process.title = "QwenProxy";
+} catch {}
 
 async function main() {
   if (!process.stdout.isTTY || !process.stdin.isTTY) {

package/src/tui/proxy-client.ts

@@ -190,10 +190,11 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
   const cacheBytesSaved = lastMetricsData?.cache?.bytesSaved;
 
   return {
-    online,
+    online: lastOnlineState,
     port,
     host,
-    overallStatus,
+    chatMode: config.qwen.chatMode as any,
+    overallStatus: lastOverallStatus,
     uptimeSeconds,
     rssMb,
     systemMemoryPct,
@@ -335,18 +336,17 @@ export async function streamChatCompletions(
 let cachedLiveModels: string[] | null = null;
 let liveModelsPromise: Promise<string[]> | null = null;
 
-const DEFAULT_FALLBACK_MODELS = [
-  "qwen3.8-max",
-  "qwen3.7-plus",
-  "qwen3.7-max",
-  "z-image-turbo",
-  "qwen-image-3.0-pro",
-  "qwen-image-3.0",
-  "wan2.7-image-pro",
-  "wan2.7-image",
-  "wan3.0-video",
-  "wan2.7-t2v",
-];
+export { DEFAULT_FALLBACK_MODELS } from "../core/model-alias.ts";
+import { DEFAULT_FALLBACK_MODELS } from "../core/model-alias.ts";
+
+export function getCachedLiveModels(): string[] | null {
+  return cachedLiveModels;
+}
+
+export function resetCachedLiveModelsForTests(): void {
+  cachedLiveModels = null;
+  liveModelsPromise = null;
+}
 
 export async function fetchLiveModels(forceRefresh = false): Promise<string[]> {
   if (!forceRefresh && cachedLiveModels && cachedLiveModels.length > 0) {
@@ -364,7 +364,9 @@ export async function fetchLiveModels(forceRefresh = false): Promise<string[]> {
 
   liveModelsPromise = (async () => {
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 3000);
+    // Cold start with Playwright navigation and bx security token acquisition can take 5-12s
+    const timeoutMs = cachedLiveModels ? 4000 : 12000;
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
       const resp = await fetch(`http://${host}:${port}/v1/models`, {
         headers: { Authorization: `Bearer ${apiKey}` },
@@ -388,7 +390,9 @@ export async function fetchLiveModels(forceRefresh = false): Promise<string[]> {
           }
         }
       }
-    } catch {} finally {
+    } catch {
+      // Don't poison cachedLiveModels on network error so subsequent polls can retry
+    } finally {
       clearTimeout(timeout);
       liveModelsPromise = null;
     }

package/src/tui/screen.ts

@@ -47,13 +47,20 @@ export class Screen {
     if (!process.stdout.isTTY || !process.stdin.isTTY) {
       return false;
     }
-
+    try {
+      process.title = "QwenProxy";
+    } catch {}
     this.active = true;
     this.prevRenderedRows = [];
-    // Switch to alternate screen buffer, clear screen, hide cursor, and enable mouse tracking
+    // Switch to alternate screen buffer, clear screen, hide cursor, enable mouse tracking, and set terminal title
     ServerManager.getInstance().withTuiRendering(() => {
       process.stdout.write(
-        ANSI.enterAltScreen + "\x1b[2J" + ANSI.cursorHome + ANSI.hideCursor + ANSI.enableMouse,
+        ANSI.enterAltScreen +
+          "\x1b[2J" +
+          ANSI.cursorHome +
+          ANSI.hideCursor +
+          ANSI.enableMouse +
+          ANSI.setTitle("QwenProxy"),
       );
     });
     // Setup raw keyboard input

package/src/tui/settings.ts

@@ -12,6 +12,7 @@ export interface TuiSettings {
   chat?: {
     model?: string;
     effort?: "high" | "medium" | "low";
+    mode?: "thread" | "thread-temp" | "stateless" | "stateless-temp";
   };
   logs?: {
     filter?: "all" | "warn" | "error";
@@ -23,6 +24,7 @@ const defaultSettings: TuiSettings = {
   chat: {
     model: "qwen3.8-max",
     effort: "high",
+    mode: "thread",
   },
   logs: {
     filter: "all",

package/src/tui/theme.ts

@@ -18,6 +18,7 @@ export const ANSI = {
   exitAltScreen: "\x1b[?1049l",
   enableMouse: "\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h",
   disableMouse: "\x1b[?1006l\x1b[?1005l\x1b[?1004l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1015l",
+  setTitle: (title: string) => `\x1b]0;${title}\x07`,
 };
 
 export const theme = {
@@ -38,6 +39,7 @@ export const theme = {
   borderInactive: (s: string) => `\x1b[38;2;53;53;61m${s}\x1b[39m`, // #35353d (Qwen Line Primary Border)
   bgSelected: (s: string) => `\x1b[48;2;45;35;85m\x1b[38;2;247;248;252m${s}\x1b[49m\x1b[39m`, // #2d2355 Deep Violet + #f7f8fc White
   bgHover: (s: string) => `\x1b[48;2;58;46;110m\x1b[38;2;247;248;252m${s}\x1b[49m\x1b[39m`, // #3a2e6e Violet Hover + #f7f8fc White
+  bgUserCard: (s: string) => `\x1b[48;2;38;40;58m${s}\x1b[49m`, // #26283a (Catppuccin Surface / Distinct Lighter User Message Card)
   bold: (s: string) => `\x1b[1m${s}\x1b[22m`,
   italic: (s: string) => `\x1b[3m${s}\x1b[23m`,
   dim: (s: string) => `\x1b[2m${s}\x1b[22m`,

package/src/tui/types.ts

@@ -15,6 +15,7 @@ export interface ProxyStatusSnapshot {
   online: boolean;
   port: number;
   host: string;
+  chatMode?: "thread" | "thread-temp" | "stateless" | "stateless-temp";
   overallStatus?: string;
   uptimeSeconds?: number;
   rssMb?: number;