qwenproxy-cli 1.1.0 → 1.2.1

package/src/sync/claude-code.ts

@@ -33,12 +33,14 @@ export function syncClaudeCode(options: SyncOptions): ClientSyncResult {
       ANTHROPIC_DEFAULT_HAIKU_MODEL: "qwen3.7-plus",
       ANTHROPIC_DEFAULT_OPUS_MODEL: model,
       CLAUDE_CODE_MAX_CONTEXT_TOKENS: "1000000",
+      CLAUDE_CODE_DISABLE_ARTIFACT: "1",
     };
 
     const updatedSettings = {
       ...existingSettings,
       env,
       model,
+      enableArtifact: false,
     };
 
     fs.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
@@ -63,13 +65,48 @@ export function syncClaudeCode(options: SyncOptions): ClientSyncResult {
 }
 
 export function restoreClaudeCode(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.env && (data.env.ANTHROPIC_BASE_URL?.includes("7936") || data.env.ANTHROPIC_AUTH_TOKEN === "sk-qwenproxy-local" || data.env.ANTHROPIC_MODEL?.includes("qwen"))) {
+        delete data.env.ANTHROPIC_BASE_URL;
+        delete data.env.ANTHROPIC_AUTH_TOKEN;
+        delete data.env.ANTHROPIC_MODEL;
+        delete data.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+        delete data.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
+        delete data.env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
+        delete data.env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+        delete data.env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+        delete data.env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+        delete data.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
+        delete data.env.CLAUDE_CODE_DISABLE_ARTIFACT;
+        delete data.enableArtifact;
+        if (data.model && data.model.toLowerCase().includes("qwen")) {
+          delete data.model;
+        }
+        if (Object.keys(data.env).length === 0) {
+          delete data.env;
+        }
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        manuallyCleaned = true;
+      }
+    } catch {}
+  }
+
+  const success = restoredFromBackup || manuallyCleaned;
   return {
     client: "claude-code",
     filePath,
     backupPath,
-    success: restored,
-    action: restored ? "restored" : "failed",
-    message: restored ? "Restored Claude Code settings from backup" : "Backup file not found",
+    success,
+    action: success ? "restored" : "failed",
+    message: success
+      ? restoredFromBackup
+        ? "Restored Claude Code settings from backup"
+        : "Removed QwenProxy configuration from Claude Code settings"
+      : "Backup file not found",
   };
 }

package/src/sync/cline.ts

@@ -98,13 +98,43 @@ export function syncCline(options: SyncOptions): ClientSyncResult {
 }
 
 export function restoreCline(filePath: string, backupPath?: string): ClientSyncResult {
-  const restored = restoreFromBackup(filePath, backupPath);
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+
+  let manuallyCleaned = false;
+  if (fs.existsSync(filePath)) {
+    try {
+      const db = new Database(filePath);
+      const rows = db
+        .prepare("SELECT key, value FROM ItemTable WHERE key = 'saoudrizwan.claude-dev' OR key = 'ZooCodeOrganization.zoo-code'")
+        .all() as Array<{ key: string; value: string }>;
+
+      for (const row of rows) {
+        try {
+          const parsed = JSON.parse(row.value);
+          if (parsed.openAiBaseUrl?.includes("7936") || parsed.openAiModelId?.includes("qwen")) {
+            delete parsed.openAiBaseUrl;
+            delete parsed.openAiApiKey;
+            delete parsed.openAiModelId;
+            db.prepare("UPDATE ItemTable SET value = ? WHERE key = ?").run(JSON.stringify(parsed), row.key);
+            manuallyCleaned = true;
+          }
+        } catch {}
+      }
+      db.close();
+    } catch {}
+  }
+
+  const success = restoredFromBackup || manuallyCleaned;
   return {
     client: "cline",
     filePath,
     backupPath,
-    success: restored,
-    action: restored ? "restored" : "failed",
-    message: restored ? "Restored Cline settings from backup" : "Backup file not found",
+    success,
+    action: success ? "restored" : "failed",
+    message: success
+      ? restoredFromBackup
+        ? "Restored Cline settings from backup"
+        : "Removed QwenProxy configuration from Cline settings"
+      : "Backup file not found",
   };
 }

package/src/sync/codex.ts

@@ -111,13 +111,38 @@ experimental_bearer_token = "${apiKey}"
 }
 
 export function restoreCodex(filePath: string, backupPath?: string): ClientSyncResult {
-  const restored = restoreFromBackup(filePath, backupPath);
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+
+  // If backup was restored but still had qwenproxy (or if no backup was found),
+  // strip the QwenProxy provider block cleanly so the file is guaranteed un-synced.
+  let manuallyCleaned = false;
+  if (fs.existsSync(filePath)) {
+    try {
+      let content = fs.readFileSync(filePath, "utf-8");
+      if (content.includes("[model_providers.qwenproxy]") || /^model_provider\s*=\s*["']qwenproxy["']/m.test(content)) {
+        const providerRegex = /\[model_providers\.qwenproxy\][\s\S]*?(?=(?:^\[|\Z))/m;
+        content = content.replace(providerRegex, "").trimEnd();
+        content = content.replace(/^model_provider\s*=\s*["']qwenproxy["']\r?\n?/m, "");
+        if (/^model\s*=\s*["']qwen/m.test(content)) {
+          content = content.replace(/^model\s*=\s*["']qwen[^"']*["']\r?\n?/m, "");
+        }
+        fs.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+        manuallyCleaned = true;
+      }
+    } catch {}
+  }
+
+  const success = restoredFromBackup || manuallyCleaned;
   return {
     client: "codex",
     filePath,
     backupPath,
-    success: restored,
-    action: restored ? "restored" : "failed",
-    message: restored ? "Restored Codex config from backup" : "Backup file not found",
+    success,
+    action: success ? "restored" : "failed",
+    message: success
+      ? restoredFromBackup
+        ? "Restored Codex config from backup"
+        : "Removed QwenProxy configuration from Codex config"
+      : "Backup file not found",
   };
 }

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/tools/parser.ts

@@ -2043,18 +2043,23 @@ export class StreamingToolParser {
             recoveryAttempts: truncRecoveryAttempts,
           });
           logger.warn(
-            "[parser] Dropping unrecoverable unclosed tool call at end of stream",
-            {
-              toolName,
-              category: "truncated",
-              contentLength: trimmed.length,
-              content: trimmed.substring(0, 2000),
-              failureReason:
-                "stream ended before tool_call closing tag; content too incomplete to reconstruct",
-              recoveryAttempts: truncRecoveryAttempts,
-              emittedToolCallsSoFar: this.emittedToolCallCount,
-            },
+            `[parser] Dropping unrecoverable unclosed tool call (${toolName || "unknown"}) at end of stream: stream ended before closing tag (${trimmed.length} chars)`,
           );
+          if (isToolcallDebugEnabled()) {
+            logger.debug(
+              "[parser] Unclosed tool call payload details",
+              {
+                toolName,
+                category: "truncated",
+                contentLength: trimmed.length,
+                content: trimmed.substring(0, 2000),
+                failureReason:
+                  "stream ended before tool_call closing tag; content too incomplete to reconstruct",
+                recoveryAttempts: truncRecoveryAttempts,
+                emittedToolCallsSoFar: this.emittedToolCallCount,
+              },
+            );
+          }
           if (
             this.emittedToolCallCount === 0 &&
             this.pendingLeadIn.trim().length > 0

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";
@@ -128,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);