qwenproxy-cli 1.0.26 → 1.0.28

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) {
@@ -112,6 +113,11 @@ export class ServerManager {
       ) {
         continue;
       }
+      // Clean redundant leading level tags (e.g. "WARN [Qwen]" -> "[Qwen]")
+      // and normalize multi-space gaps after emojis
+      line = line
+        .replace(/^(?:\[?(?:INFO|WARN|WARNING|ERROR|ERR|DEBUG)\]?\s+)+/i, "")
+        .replace(/([\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}\u{2300}-\u{23FF}]\uFE0F?)\s{2,}/gu, "$1 ");
       if (!line) continue;
 
       // Prevent identical consecutive duplicate logs in the same second
@@ -234,6 +240,7 @@ export class ServerManager {
           "INFO",
           `✨ [Server] Conectado à instância em execução na porta ${port}`,
         );
+        this.startRemoteLogStream(cleanHost, port);
         return;
       }
     } catch {}
@@ -269,10 +276,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 {}
+}

package/src/tui/theme.ts

@@ -47,11 +47,14 @@ export const theme = {
 
 import { execSync, spawnSync } from "node:child_process";
 
+let memoryClipboard = "";
+
 /**
  * Safely writes text to the system clipboard on Windows/macOS/Linux.
  * Also emits OSC 52 to copy inside terminal emulators supporting it.
  */
 export function setClipboardText(text: string): boolean {
+  memoryClipboard = text;
   try {
     // 1. Emit OSC 52 sequence for terminal emulators supporting it natively (only when interactive TTY)
     try {
@@ -64,8 +67,7 @@ export function setClipboardText(text: string): boolean {
     // 2. OS-level clipboard utility
     if (process.platform === "win32") {
       const p = spawnSync("clip.exe", {
-        input: text,
-        encoding: "utf-8",
+        input: Buffer.from(text, "utf16le"),
         windowsHide: true,
       });
       return p.status === 0;
@@ -90,17 +92,21 @@ export function setClipboardText(text: string): boolean {
 export function getClipboardText(): string {
   try {
     if (process.platform === "win32") {
-      return execSync("powershell -NoProfile -Command Get-Clipboard", {
-        timeout: 1000,
-        windowsHide: true,
-        stdio: ["pipe", "pipe", "ignore"],
-      })
-        .toString()
+      const res = execSync(
+        'powershell -NoProfile -Command "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Get-Clipboard"',
+        {
+          timeout: 2000,
+          windowsHide: true,
+          stdio: ["pipe", "pipe", "ignore"],
+        },
+      )
+        .toString("utf8")
         .replace(/\r?\n/g, "")
         .trim();
+      if (res) return res;
     }
   } catch {}
-  return "";
+  return memoryClipboard;
 }
 
 export const glyphs = {

package/src/tui/types.ts

@@ -21,6 +21,22 @@ export interface ProxyStatusSnapshot {
   systemMemoryPct?: number;
   activeStreams?: number;
   waitingStreams?: number;
+  metrics?: {
+    requestsTotal: number;
+    requestsErrors: number;
+    successRate: number;
+    latencyAvgMs: number;
+    deltasCount: number;
+    fullReplaysCount: number;
+    deltaRatio: number;
+    toolCallsCount: number;
+    toolCallsRecovered: number;
+    captchasDetected: number;
+    captchasSolved: number;
+    chatsCleaned: number;
+    cacheHitRatio?: number;
+    cacheBytesSaved?: number;
+  };
   accounts: Array<{
     id: string;
     emailOrName: string;
@@ -28,7 +44,10 @@ export interface ProxyStatusSnapshot {
     cooldownUntil: number | null;
     onCooldown: boolean;
     remainingCooldownMs: number;
+    cooldownReason?: string | null;
     headersReady: boolean;
     isInitialized?: boolean;
+    activeStreams?: number;
+    streamLimit?: number;
   }>;
 }

package/src/tui/views/accounts-view.ts

@@ -13,6 +13,33 @@ import {
 import { addAccount, removeAccount } from "../../core/accounts.ts";
 import { ServerManager } from "../server-manager.ts";
 import { config } from "../../core/config.ts";
+export function formatCooldownReason(reason?: string | null, maxLen = 28): string {
+  if (!reason) return theme.yellow("Cooldown ativo");
+  if (
+    reason.startsWith("AuthFailed") ||
+    reason.startsWith("AuthPermanentFailure") ||
+    reason.includes("All login methods exhausted")
+  ) {
+    return theme.red(truncate("❌ Senha/Login inválido", maxLen));
+  }
+  if (reason === "AuthInitFailed") {
+    return theme.yellow(truncate("⚠️ Timeout Inicial (WAF/Headers)", maxLen));
+  }
+  if (reason === "RateLimited" || reason === "QuotaExceeded") {
+    return theme.yellow(truncate("⏳ Cota Excedida (Reset 00:00 UTC)", maxLen));
+  }
+  if (reason === "WafChallenge") {
+    return theme.peach(truncate("🛡️ Bloqueio WAF/Anti-Bot", maxLen));
+  }
+  if (reason.startsWith("StandbyValidationError")) {
+    return theme.red(truncate("❌ Falha Validação Standby", maxLen));
+  }
+  if (reason === "MediaGenFailed") {
+    return theme.yellow(truncate("⚠️ Falha Geração de Mídia", maxLen));
+  }
+  return theme.yellow(truncate(reason, maxLen));
+}
+
 export class AccountsView implements TuiView {
   public readonly id = "accounts";
   public readonly title = "Contas";
@@ -662,8 +689,22 @@ export class AccountsView implements TuiView {
 
         let status = theme.green(`${glyphs.bullet} Pronto   `);
         if (acc.onCooldown) {
-          const mins = Math.max(1, Math.round(acc.remainingCooldownMs / 60000));
-          status = theme.yellow(`⚠️ ${mins}m cd   `);
+          const reason = acc.cooldownReason || "";
+          if (
+            reason.startsWith("AuthFailed") ||
+            reason.startsWith("AuthPermanentFailure") ||
+            reason.includes("All login methods exhausted")
+          ) {
+            status = theme.red(`❌ Auth Fail `);
+          } else if (reason === "WafChallenge") {
+            status = theme.peach(`🛡️ WAF Block  `);
+          } else if (reason === "AuthInitFailed") {
+            const mins = Math.max(1, Math.round(acc.remainingCooldownMs / 60000));
+            status = theme.yellow(`⚠️ ${mins}m init `);
+          } else {
+            const mins = Math.max(1, Math.round(acc.remainingCooldownMs / 60000));
+            status = theme.yellow(`⚠️ ${mins}m cd   `);
+          }
         } else if (!acc.headersReady) {
           status = acc.isInitialized
             ? theme.yellow(`◐ Aquecendo...`)
@@ -724,7 +765,13 @@ export class AccountsView implements TuiView {
           ? theme.yellow(`◐ Aquecendo...`)
           : theme.muted(`${glyphs.circle} Standby (Sob Demanda)`);
       rightContent.push(`  ${theme.bold("Headers:")}    ${hStatus}`);
-      rightContent.push("");
+      if (selected.onCooldown && selected.cooldownReason) {
+        const maxReasonW = Math.max(16, rightW - 14);
+        const cdReason = formatCooldownReason(selected.cooldownReason, maxReasonW);
+        rightContent.push(`  ${theme.bold("Motivo:")}     ${cdReason}`);
+      } else {
+        rightContent.push("");
+      }
       rightContent.push(`  ${theme.dim("─────────────────────────────────")}`);
       rightContent.push(`  ${this.hoveredActionRow === 15 ? theme.bgHover(` ${theme.cyan("[ A ] Adicionar Conta")} `) : `${theme.cyan("[ A ]")} Adicionar Conta`}`);
       rightContent.push(`  ${this.hoveredActionRow === 16 ? theme.bgHover(` ${theme.red("[ D ] Remover Conta")} `) : `${theme.red("[ D ]")} Remover Conta`}`);

package/src/tui/views/chat-view.ts

@@ -8,6 +8,7 @@ import { theme, glyphs, drawBox, stringWidth, truncate, stripAnsi, pad, wrapCont
 import { streamChatCompletions, fetchLiveModels } from "../proxy-client.ts";
 import { ServerManager } from "../server-manager.ts";
 import { formatMarkdown, formatReasoning } from "../markdown.ts";
+import { loadTuiSettings, saveTuiSettings } from "../settings.ts";
 
 interface ChatMessage {
   role: "user" | "assistant";
@@ -122,6 +123,21 @@ export class ChatView implements TuiView {
 
   constructor(onNeedsRender?: () => void) {
     this.onNeedsRender = onNeedsRender;
+    const saved = loadTuiSettings();
+    if (saved.chat?.model) {
+      const idx = this.availableModels.indexOf(saved.chat.model);
+      if (idx !== -1) {
+        this.selectedModelIndex = idx;
+      }
+    }
+    const savedEffort = saved.chat?.effort;
+    if (savedEffort && ["high", "medium", "low"].includes(savedEffort)) {
+      this.selectedEffort = savedEffort;
+      const effIdx = this.availableEfforts.findIndex((e) => e.id === savedEffort);
+      if (effIdx !== -1) {
+        this.effortSelectedIndex = effIdx;
+      }
+    }
     void this.refreshModels();
   }
   public onActivate(): void {
@@ -138,7 +154,13 @@ export class ChatView implements TuiView {
       if (live.length > 0) {
         const current = this.availableModels[this.selectedModelIndex];
         this.availableModels = live;
-        const foundIdx = this.availableModels.indexOf(current);
+        let foundIdx = this.availableModels.indexOf(current);
+        if (foundIdx === -1) {
+          const saved = loadTuiSettings();
+          if (saved.chat?.model) {
+            foundIdx = this.availableModels.indexOf(saved.chat.model);
+          }
+        }
         this.selectedModelIndex = foundIdx !== -1 ? foundIdx : 0;
         this.onNeedsRender?.();
       }
@@ -169,7 +191,12 @@ export class ChatView implements TuiView {
     if (!chosen) return;
     this.selectedModelIndex = idx;
     this.isModelModalOpen = false;
-
+    saveTuiSettings({
+      chat: {
+        model: chosen,
+        effort: this.selectedEffort,
+      },
+    });
     const info = classifyModel(chosen);
     if (info.category === "Texto & Raciocínio") {
       this.isEffortModalOpen = true;
@@ -249,6 +276,12 @@ export class ChatView implements TuiView {
           this.selectedEffort = this.availableEfforts[row - 9].id;
           this.isEffortModalOpen = false;
           const currentM = this.availableModels[this.selectedModelIndex];
+          saveTuiSettings({
+            chat: {
+              model: currentM,
+              effort: this.selectedEffort,
+            },
+          });
           this.statusNote = `Modelo: ${currentM} | Effort: ${this.availableEfforts[row - 9].label}`;
           this.onNeedsRender?.();
           return true;
@@ -274,6 +307,12 @@ export class ChatView implements TuiView {
         this.selectedEffort = this.availableEfforts[this.effortSelectedIndex].id;
         this.isEffortModalOpen = false;
         const currentM = this.availableModels[this.selectedModelIndex];
+        saveTuiSettings({
+          chat: {
+            model: currentM,
+            effort: this.selectedEffort,
+          },
+        });
         this.statusNote = `Modelo: ${currentM} | Effort: ${this.availableEfforts[this.effortSelectedIndex].label}`;
         this.onNeedsRender?.();
         return true;

package/src/tui/views/logs-view.ts

@@ -7,6 +7,7 @@ import type { TuiView } from "../types.ts";
 import type { KeyEvent } from "../screen.ts";
 import { theme, drawBox, stringWidth, truncate, pad, stripAnsi, setClipboardText } from "../theme.ts";
 import { ServerManager } from "../server-manager.ts";
+import { loadTuiSettings, saveTuiSettings } from "../settings.ts";
 
 export class LogsView implements TuiView {
   public readonly id = "logs";
@@ -14,6 +15,21 @@ export class LogsView implements TuiView {
   public readonly tabNumber = 6;
 
   private filter: "all" | "warn" | "error" = "all";
+
+  constructor() {
+    const saved = loadTuiSettings();
+    if (saved.logs?.filter && ["all", "warn", "error"].includes(saved.logs.filter)) {
+      this.filter = saved.logs.filter;
+    }
+  }
+
+  private setFilter(newFilter: "all" | "warn" | "error"): void {
+    this.filter = newFilter;
+    this.scrollOffset = 0;
+    this.selectedLogIndex = null;
+    saveTuiSettings({ logs: { filter: newFilter } });
+  }
+
   private scrollOffset = 0; // 0 = at the bottom (follow newest)
   private hoveredChip: "all" | "warn" | "error" | "copy" | "clear" | null = null;
   private selectedLogIndex: number | null = null;
@@ -103,21 +119,15 @@ export class LogsView implements TuiView {
       for (const c of chips) {
         if (col >= c.startCol && col <= c.endCol) {
           if (c.id === "all") {
-            this.filter = "all";
-            this.scrollOffset = 0;
-            this.selectedLogIndex = null;
+            this.setFilter("all");
             return true;
           }
           if (c.id === "warn") {
-            this.filter = "warn";
-            this.scrollOffset = 0;
-            this.selectedLogIndex = null;
+            this.setFilter("warn");
             return true;
           }
           if (c.id === "error") {
-            this.filter = "error";
-            this.scrollOffset = 0;
-            this.selectedLogIndex = null;
+            this.setFilter("error");
             return true;
           }
           if (c.id === "copy") {
@@ -202,21 +212,15 @@ export class LogsView implements TuiView {
 
     // Filter toggles
     if ((key.name === "t" || key.name === "T") && !key.ctrl) {
-      this.filter = "all";
-      this.scrollOffset = 0;
-      this.selectedLogIndex = null;
+      this.setFilter("all");
       return true;
     }
     if ((key.name === "w" || key.name === "W") && !key.ctrl) {
-      this.filter = "warn";
-      this.scrollOffset = 0;
-      this.selectedLogIndex = null;
+      this.setFilter("warn");
       return true;
     }
     if ((key.name === "e" || key.name === "E") && !key.ctrl) {
-      this.filter = "error";
-      this.scrollOffset = 0;
-      this.selectedLogIndex = null;
+      this.setFilter("error");
       return true;
     }