qwenproxy-cli 1.0.0

package/src/tui/screen.ts

@@ -0,0 +1,278 @@
+/**
+ * QwenProxy TUI - Screen Buffer, Resize Listener & Raw Keyboard Engine
+ */
+
+import readline from "node:readline";
+import fs from "node:fs";
+import { ANSI, theme, pad } from "./theme.ts";
+import { ServerManager } from "./server-manager.ts";
+export interface MouseInfo {
+  type: "click" | "scroll-up" | "scroll-down" | "hover";
+  button?: "left" | "right";
+  col: number;
+  row: number;
+}
+
+export interface KeyEvent {
+  name: string;
+  ctrl: boolean;
+  shift: boolean;
+  meta: boolean;
+  raw?: string;
+  char?: string;
+  mouse?: MouseInfo;
+}
+export type KeyHandler = (key: KeyEvent) => void;
+export type ResizeHandler = (cols: number, rows: number) => void;
+export class Screen {
+  private active = false;
+  private keyListeners: Set<KeyHandler> = new Set();
+  private resizeListeners: Set<ResizeHandler> = new Set();
+  private keypressHandler: ((ch: string | undefined, key: any) => void) | null = null;
+  private resizeHandler: (() => void) | null = null;
+  private exitHandler: (() => void) | null = null;
+  private prevRenderedRows: string[] = [];
+  private originalStdinEmit: typeof process.stdin.emit | null = null;
+
+  constructor() {
+    this.exitHandler = () => this.stop();
+  }
+
+  public start(): boolean {
+    if (this.active) return true;
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+      return false;
+    }
+
+    this.active = true;
+    this.prevRenderedRows = [];
+    // Switch to alternate screen buffer, clear screen, hide cursor, and enable mouse tracking
+    ServerManager.getInstance().withTuiRendering(() => {
+      process.stdout.write(
+        ANSI.enterAltScreen + "\x1b[2J" + ANSI.cursorHome + ANSI.hideCursor + ANSI.enableMouse,
+      );
+    });
+    // Setup raw keyboard input
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    readline.emitKeypressEvents(process.stdin);
+
+    // Intercept stdin 'data' to capture SGR mouse wheel sequences before readline
+    this.originalStdinEmit = process.stdin.emit.bind(process.stdin);
+    const self = this;
+    process.stdin.emit = function (event: string, ...args: any[]) {
+      if (event === "data" && args[0] && self.active) {
+        const str = typeof args[0] === "string" ? args[0] : args[0].toString();
+        const mouseRegex = /\x1b\[<(\d+);(\d+);(\d+)([mM])/g;
+        let match: RegExpExecArray | null;
+        let handled = false;
+        while ((match = mouseRegex.exec(str)) !== null) {
+          handled = true;
+          const btn = parseInt(match[1], 10);
+          const col = parseInt(match[2], 10);
+          const row = parseInt(match[3], 10);
+          const isRelease = match[4] === "m";
+
+          if (btn === 64) {
+            self.dispatchKey({
+              name: "wheelup",
+              ctrl: false,
+              shift: false,
+              meta: false,
+              mouse: { type: "scroll-up", col, row },
+            });
+          } else if (btn === 65) {
+            self.dispatchKey({
+              name: "wheeldown",
+              ctrl: false,
+              shift: false,
+              meta: false,
+              mouse: { type: "scroll-down", col, row },
+            });
+          } else if (btn === 0 && !isRelease) {
+            self.dispatchKey({
+              name: "click",
+              ctrl: false,
+              shift: false,
+              meta: false,
+              mouse: { type: "click", button: "left", col, row },
+            });
+          } else if (btn === 35) {
+            self.dispatchKey({
+              name: "hover",
+              ctrl: false,
+              shift: false,
+              meta: false,
+              mouse: { type: "hover", col, row },
+            });
+          }
+        }
+        if (handled) {
+          return true;
+        }
+      }
+      return self.originalStdinEmit!.apply(process.stdin, [event, ...args] as any);
+    } as any;
+
+    this.keypressHandler = (_ch: string | undefined, key: any) => {
+      if (!this.active || !key) return;
+
+      let name = key.name || "";
+      let shift = Boolean(key.shift);
+      if (key.sequence === "\x1b[Z") {
+        name = "tab";
+        shift = true;
+      }
+
+      // Suppress control characters from event.char
+      const isControlChar =
+        _ch && (_ch === "\t" || _ch === "\r" || _ch === "\n" || _ch < " ");
+      const char = isControlChar ? undefined : _ch;
+
+      const event: KeyEvent = {
+        name,
+        ctrl: Boolean(key.ctrl),
+        shift,
+        meta: Boolean(key.meta),
+        raw: key.sequence,
+        char,
+      };
+
+      // Direct Ctrl+C fallback to exit cleanly
+      this.dispatchKey(event);
+    };
+
+    this.resizeHandler = () => {
+      if (!this.active) return;
+      const { cols, rows } = this.getSize();
+      for (const listener of this.resizeListeners) {
+        listener(cols, rows);
+      }
+    };
+
+    process.stdin.on("keypress", this.keypressHandler);
+    process.stdout.on("resize", this.resizeHandler);
+    process.on("SIGINT", this.exitHandler!);
+    process.on("SIGTERM", this.exitHandler!);
+    process.on("SIGBREAK", this.exitHandler!);
+    process.on("exit", this.exitHandler!);
+    return true;
+  }
+
+  private dispatchKey(event: KeyEvent): void {
+    if (!this.active) return;
+    for (const listener of this.keyListeners) {
+      listener(event);
+    }
+  }
+
+  public stop(): void {
+    if (!this.active) return;
+    this.active = false;
+
+    if (this.keypressHandler) {
+      process.stdin.removeListener("keypress", this.keypressHandler);
+      this.keypressHandler = null;
+    }
+    if (this.resizeHandler) {
+      process.stdout.removeListener("resize", this.resizeHandler);
+      this.resizeHandler = null;
+    }
+    if (this.exitHandler) {
+      process.removeListener("SIGINT", this.exitHandler);
+      process.removeListener("SIGTERM", this.exitHandler);
+      process.removeListener("SIGBREAK", this.exitHandler);
+      process.removeListener("exit", this.exitHandler);
+      this.exitHandler = null;
+    }
+
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+    if (this.originalStdinEmit) {
+      process.stdin.emit = this.originalStdinEmit;
+      this.originalStdinEmit = null;
+    }
+
+    // Restore original screen buffer, cursor, and disable all mouse tracking modes synchronously
+    const restoreSeq = ANSI.disableMouse + ANSI.exitAltScreen + ANSI.showCursor + ANSI.reset;
+    try {
+      fs.writeSync(1, restoreSeq);
+    } catch {
+      try {
+        ServerManager.getInstance().withTuiRendering(() => {
+          process.stdout.write(restoreSeq);
+        });
+      } catch {}
+    }
+  }
+
+  public onKey(handler: KeyHandler): () => void {
+    this.keyListeners.add(handler);
+    return () => this.keyListeners.delete(handler);
+  }
+
+  public onResize(handler: ResizeHandler): () => void {
+    this.prevRenderedRows = [];
+    this.resizeListeners.add(handler);
+    return () => this.resizeListeners.delete(handler);
+  }
+
+  public getSize(): { cols: number; rows: number } {
+    return {
+      cols: process.stdout.columns || 100,
+      rows: process.stdout.rows || 30,
+    };
+  }
+
+  /**
+   * Renders the frame atomically with zero flicker.
+   */
+  public render(lines: string[]): void {
+    if (!this.active) return;
+    const { cols, rows } = this.getSize();
+
+    if (cols < 70 || rows < 18) {
+      // Terminal size warning
+      const warnLines = [
+        "",
+        theme.yellow("  ⚠️  Terminal muito pequeno para a interface QwenProxy."),
+        theme.muted(`  Tamanho atual: ${cols}x${rows} | Mínimo recomendado: 80x24`),
+        theme.cyan("  Por favor, expanda a janela do seu terminal."),
+        "",
+        theme.muted("  Pressione Ctrl+C duas vezes para sair."),
+      ];
+      process.stdout.write(ANSI.cursorHome + warnLines.join("\n") + "\n");
+      return;
+    }
+    const currentRows: string[] = [];
+    for (let r = 0; r < rows; r++) {
+      const rawLine = r < lines.length ? lines[r] : "";
+      currentRows.push(pad(rawLine, cols));
+    }
+
+    let diffBuffer = "";
+    let changed = 0;
+    const isFirstRender = this.prevRenderedRows.length !== rows;
+
+    for (let r = 0; r < rows; r++) {
+      if (isFirstRender || this.prevRenderedRows[r] !== currentRows[r]) {
+        diffBuffer += `\x1b[${r + 1};1H${currentRows[r]}`;
+        changed++;
+      }
+    }
+
+    if (changed === 0) {
+      return;
+    }
+
+    this.prevRenderedRows = currentRows;
+
+    ServerManager.getInstance().withTuiRendering(() => {
+      process.stdout.write(ANSI.hideCursor + diffBuffer + ANSI.cursorHome);
+    });
+  }
+}

package/src/tui/server-manager.ts

@@ -0,0 +1,270 @@
+/**
+ * QwenProxy TUI - In-Process Server Manager ("Tudo Junto Uma Coisa Só")
+ * Starts and manages the Hono + Playwright proxy server directly within the TUI process.
+ */
+
+import { config } from "../core/config.ts";
+import { startServer, stopServer } from "../api/server.ts";
+import { stripAnsi } from "./theme.ts";
+export type ServerLifecycleState = "offline" | "warming" | "online" | "error";
+
+export interface ServerLogEntry {
+  time: string;
+  level: "INFO" | "WARN" | "ERROR";
+  message: string;
+}
+
+export class ServerManager {
+  private static instance: ServerManager | null = null;
+
+  private state: ServerLifecycleState = "offline";
+  private lastError: string | null = null;
+  private logEntries: ServerLogEntry[] = [];
+  private logBuffer: string[] = [];
+  private originalLog = console.log;
+  private originalInfo = console.info;
+  private originalDebug = console.debug;
+  private originalWarn = console.warn;
+  private originalError = console.error;
+  private originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  private originalStderrWrite = process.stderr.write.bind(process.stderr);
+  private intercepted = false;
+  private isTuiRendering = false;
+  private startPromise: Promise<void> | null = null;
+
+  public static getInstance(): ServerManager {
+    if (!ServerManager.instance) {
+      ServerManager.instance = new ServerManager();
+    }
+    return ServerManager.instance;
+  }
+
+  public getState(): ServerLifecycleState {
+    return this.state;
+  }
+
+  public withTuiRendering<T>(fn: () => T): T {
+    this.isTuiRendering = true;
+    try {
+      return fn();
+    } finally {
+      this.isTuiRendering = false;
+    }
+  }
+
+  public getRawStdoutWrite(): (chunk: string | Uint8Array) => boolean {
+    return this.originalStdoutWrite;
+  }
+
+  public getLastError(): string | null {
+    return this.lastError;
+  }
+
+  public getRecentLogs(max = 12): string[] {
+    return this.logBuffer.slice(-max);
+  }
+
+  public getLogEntries(filter: "all" | "warn" | "error" = "all"): ServerLogEntry[] {
+    if (filter === "error") {
+      return this.logEntries.filter((e) => e.level === "ERROR");
+    }
+    if (filter === "warn") {
+      return this.logEntries.filter((e) => e.level === "WARN" || e.level === "ERROR");
+    }
+    return this.logEntries;
+  }
+
+  public clearLogs(): void {
+    this.logEntries = [];
+    this.logBuffer = [];
+  }
+
+  private appendLog(level: "INFO" | "WARN" | "ERROR", text: string): void {
+    if (!text) return;
+    const clean = stripAnsi(text).trim();
+    if (!clean || clean.length === 0) return;
+
+    const time = new Date().toLocaleTimeString("pt-BR", {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+    });
+
+    const lines = clean.split(/\r?\n/);
+    for (const raw of lines) {
+      let line = raw.trim();
+      if (!line) continue;
+
+      // Filter out raw ASCII box frames (like +-----+ or empty row | |)
+      if (/^[+\-=#]{5,}$/.test(line)) continue;
+      if (/^\|\s*\|$/.test(line)) continue;
+
+      // If line is an ASCII box row like "|  Endpoint   http://...  |", extract the text
+      if (line.startsWith("|") && line.endsWith("|")) {
+        line = line.slice(1, -1).trim();
+      }
+
+      if (!line) continue;
+
+      // Prevent identical consecutive duplicate logs in the same second
+      const last = this.logEntries[this.logEntries.length - 1];
+      if (last && last.time === time && last.level === level && last.message === line) {
+        continue;
+      }
+
+      this.logEntries.push({ time, level, message: line });
+      if (this.logEntries.length > 500) {
+        this.logEntries.shift();
+      }
+
+      const levelTag = level === "ERROR" ? "[ERR]" : level === "WARN" ? "[WARN]" : "";
+      const formatted = `[${time}] ${levelTag ? levelTag + " " : ""}${line}`;
+      this.logBuffer.push(formatted);
+      if (this.logBuffer.length > 500) {
+        this.logBuffer.shift();
+      }
+    }
+  }
+
+  public interceptLogs(): void {
+    if (this.intercepted) return;
+    this.intercepted = true;
+
+    console.log = (...args: any[]) => {
+      this.appendLog(
+        "INFO",
+        args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "),
+      );
+    };
+
+    console.info = (...args: any[]) => {
+      this.appendLog(
+        "INFO",
+        args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "),
+      );
+    };
+
+    console.debug = (...args: any[]) => {
+      this.appendLog(
+        "INFO",
+        args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "),
+      );
+    };
+
+    console.warn = (...args: any[]) => {
+      this.appendLog(
+        "WARN",
+        args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "),
+      );
+    };
+
+    console.error = (...args: any[]) => {
+      this.appendLog(
+        "ERROR",
+        args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "),
+      );
+    };
+
+    // Sandbox direct process.stdout.write calls (Playwright, Hono, etc.)
+    process.stdout.write = ((chunk: any, encoding?: any, cb?: any) => {
+      if (this.isTuiRendering) {
+        return this.originalStdoutWrite(chunk, encoding, cb);
+      }
+      const str = typeof chunk === "string" ? chunk : chunk?.toString(encoding);
+      // Terminal escape sequences (OSC 52 clipboard, cursor codes) bypass log capture
+      if (typeof str === "string" && (str.startsWith("\x1b]") || str.startsWith("\x1b[") || str.startsWith("\x1b"))) {
+        return this.originalStdoutWrite(chunk, encoding, cb);
+      }
+      this.appendLog("INFO", str);
+      if (typeof cb === "function") cb();
+      return true;
+    }) as any;
+
+    // Sandbox direct process.stderr.write calls
+    process.stderr.write = ((chunk: any, encoding?: any, cb?: any) => {
+      const str = typeof chunk === "string" ? chunk : chunk?.toString(encoding);
+      this.appendLog("ERROR", str);
+      if (typeof cb === "function") cb();
+      return true;
+    }) as any;
+  }
+
+  public restoreLogs(): void {
+    if (!this.intercepted) return;
+    console.log = this.originalLog;
+    console.info = this.originalInfo;
+    console.debug = this.originalDebug;
+    console.warn = this.originalWarn;
+    console.error = this.originalError;
+    process.stdout.write = this.originalStdoutWrite;
+    process.stderr.write = this.originalStderrWrite;
+    this.intercepted = false;
+  }
+
+  /**
+   * Checks if proxy is already running on port 7936, or boots it up in-process.
+   */
+  public async ensureStarted(): Promise<void> {
+    if (this.state === "online") return;
+    if (this.startPromise) return this.startPromise;
+
+    const port = config.server?.port || 7936;
+    const host = config.server?.host || "127.0.0.1";
+    const cleanHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+
+    // 1. Probe if already online
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 600);
+      const resp = await fetch(`http://${cleanHost}:${port}/health`, {
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+      if (resp.ok) {
+        this.state = "online";
+        this.appendLog(
+          "INFO",
+          `QwenProxy já está em execução na porta ${port}. Conectado com sucesso!`,
+        );
+        return;
+      }
+    } catch {}
+
+    // 2. Start in-process
+    this.state = "warming";
+    this.appendLog(
+      "INFO",
+      `Iniciando servidor QwenProxy na porta ${port} e aquecendo Playwright...`,
+    );
+
+    this.interceptLogs();
+
+    this.startPromise = (async () => {
+      try {
+        await startServer({ installSignalHandlers: false });
+        this.state = "online";
+        this.appendLog(
+          "INFO",
+          `✓ Servidor QwenProxy pronto e online em http://${cleanHost}:${port}/v1`,
+        );
+      } catch (err: any) {
+        this.state = "error";
+        this.lastError = err?.message || String(err);
+        this.appendLog(
+          "ERROR",
+          `✗ Falha ao iniciar servidor: ${this.lastError}`,
+        );
+      } finally {
+        this.startPromise = null;
+      }
+    })();
+  }
+
+  public async stop(): Promise<void> {
+    this.restoreLogs();
+    try {
+      await stopServer();
+      this.state = "offline";
+    } catch {}
+  }
+}