qwenproxy-cli 1.0.25 → 1.0.27

package/src/services/qwen.ts

@@ -53,6 +53,8 @@ export {
   updateSessionParent,
   invalidateLogicalThreadParent,
   clearAllSessionsForAccount,
+  removeSessionByChatId,
+  isChatSessionActive,
   getSessionParent,
 } from "./qwen-thread-state.ts";
 export type { LogicalThreadEntry } from "./qwen-thread-state.ts";
@@ -74,6 +76,8 @@ import {
 } from "./qwen-errors.ts";
 import {
   clearAllSessionsForAccount,
+  removeSessionByChatId,
+  isChatSessionActive,
   getSessionParent,
   updateSessionParent,
 } from "./qwen-thread-state.ts";
@@ -1977,6 +1981,112 @@ export async function deleteAllQwenChats(accountId?: string): Promise<boolean> {
   return true;
 }
 
+export interface RemoteQwenChat {
+  id: string;
+  title: string;
+  updated_at: number | string;
+  created_at: number | string;
+}
+
+/**
+ * Deletes a single chat session by ID on Qwen Web.
+ */
+export async function deleteSingleQwenChat(
+  accountId: string | undefined,
+  chatId: string,
+): Promise<boolean> {
+  if (!chatId) return false;
+
+  if (isAuthMockEnabled()) {
+    const url = qwenUrl(`/api/v2/chats/${encodeURIComponent(chatId)}`);
+    const response = await fetch(url, {
+      method: "DELETE",
+    });
+    removeSessionByChatId(chatId);
+    return response.ok;
+  }
+
+  const requestHeaders: Record<string, string> = {
+    source: "web",
+    version: "0.2.89",
+    timezone: new Date().toString().split(" (")[0],
+    "x-request-id": crypto.randomUUID(),
+    Referer: qwenUrl(`/c/${encodeURIComponent(chatId)}`),
+  };
+
+  try {
+    const response = await requestQwenTextInBrowser(
+      accountId,
+      "DELETE",
+      `/api/v2/chats/${encodeURIComponent(chatId)}`,
+      requestHeaders,
+      undefined,
+      { referrer: qwenUrl(`/c/${encodeURIComponent(chatId)}`), noMutexRecovery: true },
+    );
+
+    const { json: parsed } = await readJsonTextResponse(response, {
+      strict: false,
+    });
+
+    const success = response.ok && parsed?.success === true && parsed?.data?.status === true;
+    if (success) {
+      removeSessionByChatId(chatId);
+    }
+    return success;
+  } catch (error) {
+    logger.debug("[Qwen] deleteSingleQwenChat failed", {
+      accountId,
+      chatId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return false;
+  }
+}
+
+/**
+ * Fetch remote chat list from Qwen Web.
+ */
+export async function fetchRemoteQwenChats(
+  accountId?: string,
+): Promise<RemoteQwenChat[]> {
+  if (isAuthMockEnabled()) {
+    try {
+      const response = await fetch(qwenUrl("/api/v2/chats/?page=1&exclude_project=true"));
+      const json: any = await response.json().catch(() => null);
+      if (json?.success && Array.isArray(json.data)) {
+        return json.data;
+      }
+    } catch {}
+    return [];
+  }
+
+  const requestHeaders: Record<string, string> = {
+    version: "0.2.89",
+    timezone: new Date().toString().split(" (")[0],
+    "x-request-id": crypto.randomUUID(),
+    Referer: qwenUrl("/settings/chats"),
+  };
+
+  try {
+    const response = await requestQwenTextInBrowser(
+      accountId,
+      "GET",
+      "/api/v2/chats/?page=1&exclude_project=true",
+      requestHeaders,
+      undefined,
+      { referrer: qwenUrl("/settings/chats"), noMutexRecovery: true },
+    );
+    if (!response.ok) return [];
+    const json: any = await response.json().catch(() => null);
+    if (json?.success && Array.isArray(json.data)) {
+      return json.data;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+
 export async function fetchQwenModels(
   accountId?: string,
 ): Promise<PublicQwenModel[]> {

package/src/sync/index.ts

@@ -115,8 +115,12 @@ export function inspectClientSyncStatus(
       const data = JSON.parse(raw);
       const url = data?.env?.ANTHROPIC_BASE_URL || "";
       const model = data?.env?.ANTHROPIC_MODEL || data?.model || "";
+      const isLocalHost =
+        url.includes(String(port)) ||
+        url.includes(`127.0.0.1:${port}`) ||
+        url.includes(`localhost:${port}`);
       const isSynced =
-        (url.includes(String(port)) || url.includes("qwenproxy")) &&
+        isLocalHost &&
         (model.toLowerCase().includes("qwen") || Boolean(data?.env?.ANTHROPIC_AUTH_TOKEN));
       return {
         id,
@@ -132,34 +136,66 @@ export function inspectClientSyncStatus(
       const isProviderActive = /^model_provider\s*=\s*["']qwenproxy["']/m.test(raw);
       const modelMatch = raw.match(/^model\s*=\s*["']([^"']+)["']/m);
       const model = modelMatch ? modelMatch[1] : undefined;
+      const urlMatch = raw.match(/\[model_providers\.qwenproxy\][\s\S]*?base_url\s*=\s*["']([^"']+)["']/);
+      const url = urlMatch ? urlMatch[1] : "";
+      const isLocalHost = Boolean(
+        url && (url.includes(String(port)) || url.includes(`127.0.0.1:${port}`) || url.includes(`localhost:${port}`)),
+      );
       return {
         id,
         installed: true,
-        synced: hasProvider && isProviderActive,
+        synced: hasProvider && isProviderActive && isLocalHost,
         model,
       };
     }
 
     if (id === "opencode") {
-      const hasQwen =
-        raw.includes('"qwenproxy"') &&
-        (raw.includes(String(port)) || raw.includes("QwenProxy") || raw.includes("qwen3"));
+      let isSynced = false;
+      try {
+        const data = JSON.parse(raw);
+        const provider = data?.provider?.qwenproxy;
+        const url = provider?.options?.baseURL || "";
+        const isLocalHost =
+          url.includes(String(port)) ||
+          url.includes(`127.0.0.1:${port}`) ||
+          url.includes(`localhost:${port}`);
+        isSynced = Boolean(provider && isLocalHost);
+      } catch {
+        const qwenBlockMatch = raw.match(/"qwenproxy"\s*:\s*\{[\s\S]*?"baseURL"\s*:\s*"([^"]+)"/);
+        const url = qwenBlockMatch ? qwenBlockMatch[1] : "";
+        isSynced = Boolean(
+          url &&
+            (url.includes(String(port)) ||
+              url.includes(`127.0.0.1:${port}`) ||
+              url.includes(`localhost:${port}`)),
+        );
+      }
       return {
         id,
         installed: true,
-        synced: hasQwen,
+        synced: isSynced,
       };
     }
 
     if (id === "omp") {
-      const hasQwen =
-        /^ {2}qwenproxy:\s*$/m.test(raw) ||
-        raw.includes("qwenproxy:") ||
-        (raw.includes(String(port)) && raw.includes("qwen3"));
+      const ompMatch = raw.match(/^[ \t]*qwenproxy:\s*\r?\n((?:[ \t]{4,}.*\r?\n?)*)/m);
+      let isSynced = false;
+      let url: string | undefined;
+      if (ompMatch) {
+        const urlMatch = ompMatch[1].match(/baseUrl:\s*(\S+)/);
+        url = urlMatch ? urlMatch[1].replace(/['"]/g, "") : undefined;
+        isSynced = Boolean(
+          url &&
+            (url.includes(String(port)) ||
+              url.includes(`127.0.0.1:${port}`) ||
+              url.includes(`localhost:${port}`)),
+        );
+      }
       return {
         id,
         installed: true,
-        synced: hasQwen,
+        synced: isSynced,
+        url,
       };
     }
   } catch {

package/src/tools/parser.ts

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import { robustParseJSON, computeMissingJsonClosingTokens } from "../utils/json.ts";
 import { logger, isToolcallDebugEnabled } from "../core/logger.js";
+import { metrics } from "../core/metrics.ts";
 import type { ParsedToolCall } from "./types";
 import type { FunctionToolDefinition } from "./types";
 import {
@@ -1501,7 +1502,7 @@ export class StreamingToolParser {
     }
 
     this.emittedCallKeys.add(key);
-
+    metrics.increment("toolcalls.total");
     const incremental = this.activeIncrementalToolCall;
     const matchesIncrementalCall =
       incremental?.name === tc.name && incremental.startEmitted;
@@ -1725,6 +1726,7 @@ export class StreamingToolParser {
       failureReason: options.failureReason,
       recoveryAttempts: options.recoveryAttempts,
     });
+    metrics.increment("toolcalls.malformed");
   }
 
   private extractUndeclaredNamesFromContent(text: string): string[] {
@@ -1989,6 +1991,7 @@ export class StreamingToolParser {
           }
         }
         if (recovered) {
+          metrics.increment("toolcalls.recovered");
           if (isToolcallDebugEnabled()) {
             logger.debug("[parser] flush: recovery successful", {
               name: recovered.name,

package/src/tui/app.ts

@@ -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 { loadTuiSettings, saveTuiSettings } from "./settings.ts";
 export class TuiApp {
   private screen: Screen;
   private views: TuiView[] = [];
@@ -36,7 +37,7 @@ export class TuiApp {
   private pollInterval: NodeJS.Timeout | null = null;
   private statusSnapshot: ProxyStatusSnapshot | null = null;
   private renderScheduled = false;
-  constructor(initialTab = 1) {
+  constructor(initialTab?: number) {
     this.screen = new Screen();
 
     this.views = [
@@ -47,10 +48,33 @@ export class TuiApp {
       new AccountsView(),
       new LogsView(),
     ];
-    const tabIdx = Math.max(0, Math.min(this.views.length - 1, initialTab - 1));
+
+    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;
+      }
+    }
+
+    const tabIdx = Math.max(0, Math.min(this.views.length - 1, resolvedTab - 1));
     this.activeViewIndex = tabIdx;
   }
 
+  private switchTab(newIdx: number): void {
+    if (newIdx === this.activeViewIndex || !this.views[newIdx]) return;
+    const activeView = this.views[this.activeViewIndex];
+    if (activeView.onDeactivate) activeView.onDeactivate();
+    this.activeViewIndex = newIdx;
+    this.hoveredTabIndex = null;
+    const nextView = this.views[this.activeViewIndex];
+    if (nextView.onActivate) nextView.onActivate();
+    saveTuiSettings({ lastTab: newIdx + 1 });
+    this.requestRender();
+  }
+
   private getTabAtCol(col: number): number | null {
     let curCol = 3;
     for (let i = 0; i < this.views.length; i++) {
@@ -149,12 +173,7 @@ export class TuiApp {
       }
       if (key.name === "click") {
         if (tabIdx !== null && tabIdx !== this.activeViewIndex && this.views[tabIdx]) {
-          if (activeView.onDeactivate) activeView.onDeactivate();
-          this.activeViewIndex = tabIdx;
-          this.hoveredTabIndex = null;
-          const nextView = this.views[this.activeViewIndex];
-          if (nextView.onActivate) nextView.onActivate();
-          this.requestRender();
+          this.switchTab(tabIdx);
           return;
         }
       }
@@ -189,12 +208,7 @@ export class TuiApp {
     // Tab for cycling tabs across views (including from Chat view when no modal is open!)
     if (key.name === "tab" && !isModalOpen) {
       const newIdx = (this.activeViewIndex + 1) % this.views.length;
-      if (activeView.onDeactivate) activeView.onDeactivate();
-      this.activeViewIndex = newIdx;
-      this.hoveredTabIndex = null;
-      const nextView = this.views[this.activeViewIndex];
-      if (nextView.onActivate) nextView.onActivate();
-      this.requestRender();
+      this.switchTab(newIdx);
       return;
     }
     // Direct tab switching with numbers 1..6 only when NOT typing text in an input
@@ -207,12 +221,7 @@ export class TuiApp {
       if (!key.ctrl && !key.meta && ["1", "2", "3", "4", "5", "6"].includes(key.name)) {
         const newIdx = parseInt(key.name, 10) - 1;
         if (newIdx !== this.activeViewIndex && this.views[newIdx]) {
-          if (activeView.onDeactivate) activeView.onDeactivate();
-          this.activeViewIndex = newIdx;
-          this.hoveredTabIndex = null;
-          const nextView = this.views[this.activeViewIndex];
-          if (nextView.onActivate) nextView.onActivate();
-          this.requestRender();
+          this.switchTab(newIdx);
           return;
         }
       }

package/src/tui/index.ts

@@ -5,7 +5,7 @@
 
 import { TuiApp } from "./app.ts";
 
-function parseInitialTab(): number {
+function parseInitialTab(): number | undefined {
   const args = process.argv.slice(2);
   const tabArgIdx = args.findIndex((a) => a === "--tab" || a === "-t");
   if (tabArgIdx !== -1 && args[tabArgIdx + 1]) {
@@ -21,7 +21,7 @@ function parseInitialTab(): number {
     return parseInt(firstNumeric, 10);
   }
 
-  return 1;
+  return undefined;
 }
 
 async function main() {

package/src/tui/proxy-client.ts

@@ -13,6 +13,7 @@ import {
 import { isPlaywrightInitialized } from "../services/playwright.ts";
 import { getAccountConcurrencySnapshot } from "../core/account-concurrency.ts";
 import { getRssUsageSnapshot } from "../core/memory-usage.ts";
+import { metrics } from "../core/metrics.ts";
 import type { ProxyStatusSnapshot } from "./types.ts";
 
 export function maskAccountIdentifier(idOrEmail: string): string {
@@ -55,6 +56,7 @@ let lastOnlineState = false;
 let lastOverallStatus = "offline";
 let lastServerReadyAccounts: Set<string> | null = null;
 let lastServerActiveAccounts: Set<string> | null = null;
+let lastMetricsData: any = null;
 export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
   const port = config.server?.port || 7936;
   const configuredHost = config.server?.host;
@@ -79,6 +81,9 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
           if (Array.isArray(data.activeAccounts)) {
             lastServerActiveAccounts = new Set(data.activeAccounts);
           }
+          if (data.metrics) {
+            lastMetricsData = data.metrics;
+          }
         } else {
           lastOnlineState = false;
           lastServerReadyAccounts = null;
@@ -106,8 +111,9 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
 
     cachedAccounts = rawAccounts.map((acc) => {
       const cooldownInfo = getAccountCooldownInfo(acc.id);
-      const onCooldown = Boolean(cooldownInfo?.onCooldown);
-      const remainingCooldownMs = cooldownInfo?.remainingMs || 0;
+      const onCooldown = Boolean(cooldownInfo?.onCooldown || (acc.cooldown_until && acc.cooldown_until > now));
+      const remainingCooldownMs = cooldownInfo?.remainingMs || (acc.cooldown_until && acc.cooldown_until > now ? acc.cooldown_until - now : 0);
+      const cooldownReason = cooldownInfo?.reason || acc.cooldown_reason || (onCooldown ? "RateLimited" : null);
       const headersReady = lastServerReadyAccounts !== null
         ? lastServerReadyAccounts.has(acc.id)
         : isAccountHeadersReady(acc.id);
@@ -121,26 +127,37 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
         cooldownUntil: acc.cooldown_until || null,
         onCooldown,
         remainingCooldownMs,
+        cooldownReason,
         headersReady,
         isInitialized,
       };
     });
   }
-  const accounts = cachedAccounts;
   const online = lastOnlineState;
   const overallStatus = lastOverallStatus;
 
   // Concurrency stats
   let activeStreams = 0;
   let waitingStreams = 0;
+  const concurrencyMap = new Map<string, { active: number; waiting: number; limit: number }>();
   try {
     const snapshot = getAccountConcurrencySnapshot();
     for (const item of snapshot) {
       activeStreams += item.active;
       waitingStreams += item.waiting;
+      concurrencyMap.set(item.accountId, item);
     }
   } catch {}
 
+  // Attach concurrency to accounts
+  const accounts = cachedAccounts.map((acc) => {
+    const concurrency = concurrencyMap.get(acc.id);
+    return {
+      ...acc,
+      activeStreams: concurrency?.active ?? 0,
+      streamLimit: concurrency?.limit ?? config.concurrency.maxStreamsPerAccount,
+    };
+  });
   // RAM usage
   let rssMb = 0;
   let systemMemoryPct = 0;
@@ -150,6 +167,28 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
     systemMemoryPct = Math.round(rssSnap.usagePercent * 10) / 10;
   } catch {}
 
+  const totalReqs = lastMetricsData?.requestsTotal ?? Number(metrics.get("requests.total")?.value ?? 0);
+  const totalErrs = lastMetricsData?.requestsErrors ?? Number(metrics.get("requests.errors")?.value ?? 0);
+  const successRate = totalReqs > 0 ? Number((((totalReqs - totalErrs) / totalReqs) * 100).toFixed(1)) : 100;
+  const latencyAvgMs = lastMetricsData?.latencyAvgMs ?? (() => {
+    const hist = metrics.get("latency.request")?.value;
+    if (hist && typeof hist === "object" && (hist as any).count > 0) {
+      return Math.round((hist as any).sum / (hist as any).count);
+    }
+    return 0;
+  })();
+  const deltasCount = lastMetricsData?.deltasCount ?? Number(metrics.get("requests.delta")?.value ?? 0);
+  const fullReplaysCount = lastMetricsData?.fullReplaysCount ?? Number(metrics.get("requests.full")?.value ?? 0);
+  const totalModes = deltasCount + fullReplaysCount;
+  const deltaRatio = totalModes > 0 ? Number(((deltasCount / totalModes) * 100).toFixed(1)) : (deltasCount > 0 ? 100 : 0);
+  const toolCallsCount = lastMetricsData?.toolCallsCount ?? Number(metrics.get("toolcalls.total")?.value ?? 0);
+  const toolCallsRecovered = lastMetricsData?.toolCallsRecovered ?? Number(metrics.get("toolcalls.recovered")?.value ?? 0);
+  const captchasDetected = lastMetricsData?.captchasDetected ?? Number(metrics.get("captcha.challenges.detected")?.value ?? 0);
+  const captchasSolved = lastMetricsData?.captchasSolved ?? Number(metrics.get("captcha.solves.succeeded")?.value ?? 0);
+  const chatsCleaned = lastMetricsData?.chatsCleaned ?? Number(metrics.get("chats.cleaned")?.value ?? 0);
+  const cacheHitRatio = lastMetricsData?.cache?.hitRatio;
+  const cacheBytesSaved = lastMetricsData?.cache?.bytesSaved;
+
   return {
     online,
     port,
@@ -160,10 +199,25 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
     systemMemoryPct,
     activeStreams,
     waitingStreams,
+    metrics: {
+      requestsTotal: totalReqs,
+      requestsErrors: totalErrs,
+      successRate,
+      latencyAvgMs,
+      deltasCount,
+      fullReplaysCount,
+      deltaRatio,
+      toolCallsCount,
+      toolCallsRecovered,
+      captchasDetected,
+      captchasSolved,
+      chatsCleaned,
+      cacheHitRatio,
+      cacheBytesSaved,
+    },
     accounts,
   };
 }
-
 export function resetAllCooldowns(): number {
   return clearAllAccountCooldowns();
 }

package/src/tui/server-manager.ts

@@ -31,6 +31,7 @@ export class ServerManager {
   private intercepted = false;
   private isTuiRendering = false;
   private startPromise: Promise<void> | null = null;
+  private remoteLogAbort: AbortController | null = null;
 
   public static getInstance(): ServerManager {
     if (!ServerManager.instance) {
@@ -234,6 +235,7 @@ export class ServerManager {
           "INFO",
           `✨ [Server] Conectado à instância em execução na porta ${port}`,
         );
+        this.startRemoteLogStream(cleanHost, port);
         return;
       }
     } catch {}
@@ -269,10 +271,53 @@ export class ServerManager {
   }
 
   public async stop(): Promise<void> {
+    if (this.remoteLogAbort) {
+      this.remoteLogAbort.abort();
+      this.remoteLogAbort = null;
+    }
     this.restoreLogs();
     try {
-      await stopServer();
       this.state = "offline";
     } catch {}
   }
+
+  public startRemoteLogStream(host: string, port: number): void {
+    if (this.remoteLogAbort) {
+      this.remoteLogAbort.abort();
+    }
+    const abort = new AbortController();
+    this.remoteLogAbort = abort;
+
+    (async () => {
+      try {
+        const resp = await fetch(`http://${host}:${port}/logs/live`, {
+          signal: abort.signal,
+          headers: { Accept: "text/event-stream" },
+        });
+        if (!resp.ok || !resp.body) return;
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+
+        while (!abort.signal.aborted) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buf += decoder.decode(value, { stream: true });
+          const lines = buf.split("\n");
+          buf = lines.pop() ?? "";
+
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              try {
+                const data = JSON.parse(line.slice(6));
+                if (data && data.message) {
+                  this.appendLog(data.level || "INFO", data.message);
+                }
+              } catch {}
+            }
+          }
+        }
+      } catch {}
+    })();
+  }
 }

package/src/tui/settings.ts

@@ -0,0 +1,100 @@
+/**
+ * QwenProxy TUI - User Preferences & Settings Persistence
+ * Automatically saves and restores chosen model, reasoning effort, last active tab, and log filters.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { getTuiSettingsPath } from "../core/paths.ts";
+
+export interface TuiSettings {
+  lastTab?: number;
+  chat?: {
+    model?: string;
+    effort?: "high" | "medium" | "low";
+  };
+  logs?: {
+    filter?: "all" | "warn" | "error";
+  };
+}
+
+const defaultSettings: TuiSettings = {
+  lastTab: 1,
+  chat: {
+    model: "qwen3.8-max",
+    effort: "high",
+  },
+  logs: {
+    filter: "all",
+  },
+};
+
+let cachedSettings: TuiSettings | null = null;
+
+export function resetTuiSettingsCacheForTests(): void {
+  cachedSettings = null;
+}
+
+export function loadTuiSettings(): TuiSettings {
+  if (cachedSettings) {
+    return {
+      ...cachedSettings,
+      chat: { ...cachedSettings.chat },
+      logs: { ...cachedSettings.logs },
+    };
+  }
+
+  const filePath = getTuiSettingsPath();
+  try {
+    if (fs.existsSync(filePath)) {
+      const raw = fs.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const loaded: TuiSettings = {
+        ...defaultSettings,
+        ...parsed,
+        chat: { ...defaultSettings.chat, ...(parsed.chat || {}) },
+        logs: { ...defaultSettings.logs, ...(parsed.logs || {}) },
+      };
+      cachedSettings = loaded;
+      return {
+        ...loaded,
+        chat: { ...loaded.chat },
+        logs: { ...loaded.logs },
+      };
+    }
+  } catch {}
+
+  const finalSettings: TuiSettings = {
+    ...defaultSettings,
+    chat: { ...defaultSettings.chat },
+    logs: { ...defaultSettings.logs },
+  };
+  cachedSettings = finalSettings;
+  return {
+    ...finalSettings,
+    chat: { ...finalSettings.chat },
+    logs: { ...finalSettings.logs },
+  };
+}
+
+export function saveTuiSettings(updates: Partial<TuiSettings>): void {
+  try {
+    const current = loadTuiSettings();
+    const merged: TuiSettings = {
+      ...current,
+      ...updates,
+      chat: { ...current.chat, ...(updates.chat || {}) },
+      logs: { ...current.logs, ...(updates.logs || {}) },
+    };
+
+    cachedSettings = merged;
+
+    const filePath = getTuiSettingsPath();
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf-8");
+  } catch {}
+}