qwenproxy-cli 1.0.0

package/src/tui/markdown.ts

@@ -0,0 +1,258 @@
+/**
+ * QwenProxy TUI - Lightweight Terminal Markdown Formatter
+ * Formats Markdown bold, italic, code blocks, bullet lists, and headers into ANSI styles
+ * with word-wrapping that respects terminal column constraints.
+ */
+
+import { theme, stringWidth } from "./theme.ts";
+export interface MarkdownOptions {
+  dim?: boolean;
+}
+
+/**
+ * Formats Qwen's internal reasoning into a uniform, subdued, all-italic monologue.
+ * Strips distracting markdown formatting and keeps every thought in a homogeneous opaque tone.
+ */
+export function formatReasoning(content: string, maxWidth: number): string[] {
+  const rawLines = content.split("\n");
+  const result: string[] = [];
+  const dimItalic = (s: string) => `\x1b[3m\x1b[38;2;120;125;145m${s}\x1b[39m\x1b[23m`;
+
+  for (const raw of rawLines) {
+    const trimmed = raw.trimEnd();
+    if (!trimmed) {
+      result.push("");
+      continue;
+    }
+    // Strip markdown asterisks and backticks so thoughts don't have clashing colors
+    const cleanText = trimmed
+      .replace(/(\*\*|__)(.*?)\1/g, "$2")
+      .replace(/`([^`]+)`/g, "$1")
+      .replace(/^#+\s*/, "");
+
+    const wrapped = wrapAnsiLine(cleanText, maxWidth);
+    for (const w of wrapped) {
+      result.push(dimItalic(w));
+    }
+  }
+  return result;
+}
+
+
+/**
+ * Renders an elegant OSC 8 interactive card for images generated by Qwen.
+ */
+export function formatImageCard(alt: string, url: string, maxWidth: number): string[] {
+  const cardW = Math.max(30, Math.min(maxWidth, 70));
+  const cleanAlt =
+    alt && alt !== "Generated image" && alt !== "image"
+      ? ` ${alt.trim()} `
+      : " Imagem Gerada ";
+  const innerW = cardW - 2;
+  const linkLabel = `[ 🔗 Clique para abrir a imagem no navegador ]`;
+  const osc8 = `\x1b]8;;${url}\x1b\\${theme.cyan(theme.underline(linkLabel))}\x1b]8;;\x1b\\`;
+  const labelVisualW = stringWidth(linkLabel);
+  const paddingRight = " ".repeat(Math.max(0, innerW - labelVisualW - 2));
+
+  const titleW = stringWidth(cleanAlt);
+  const topHr = "─".repeat(Math.max(2, innerW - titleW - 5));
+  const bottomHr = "─".repeat(innerW);
+
+  return [
+    `  ${theme.borderActive(`╭─ 🖼️ ${cleanAlt}${topHr}╮`)}`,
+    `  ${theme.borderActive("│")}  ${osc8}${paddingRight}${theme.borderActive("│")}`,
+    `  ${theme.borderActive(`╰${bottomHr}╯`)}`,
+  ];
+}
+/**
+ * Formats inline Markdown elements (bold, italic, code, strikethrough).
+ */
+export function formatMarkdownInline(text: string, options?: MarkdownOptions): string {
+  const dim = options?.dim ?? false;
+  let res = text;
+
+  if (dim) {
+    const muted = "\x1b[38;2;120;125;145m";
+    const reset = "\x1b[39m";
+    // Uniform dimmed italic mode
+    res = res.replace(/(\*\*|__)(.*?)\1/g, (_m, _d, content) => `\x1b[3m${content}\x1b[23m`);
+    res = res.replace(/(?<!\w)(\*|_)(.*?)\1(?!\w)/g, (_m, _d, content) => `\x1b[3m${content}\x1b[23m`);
+    res = res.replace(/`([^`]+)`/g, (_m, content) => `\x1b[3m${content}\x1b[23m`);
+    res = res.replace(/~~(.*?)~~/g, (_m, content) => `\x1b[9m${content}\x1b[29m`);
+    return `\x1b[3m${muted}${res}${reset}\x1b[23m`;
+  }
+
+  // Standard vibrant TrueColor mode (for assistant final responses)
+  res = res.replace(/(\*\*|__)(.*?)\1/g, (_m, _d, content) => theme.bold(theme.white(content)));
+  res = res.replace(/(?<!\w)(\*|_)(.*?)\1(?!\w)/g, (_m, _d, content) =>
+    theme.italic(theme.lavender(content)),
+  );
+  res = res.replace(/`([^`]+)`/g, (_m, content) => theme.cyan(content));
+  res = res.replace(/~~(.*?)~~/g, (_m, content) => `\x1b[9m${content}\x1b[29m`);
+
+  return res;
+}
+
+/**
+ * Word-wraps a single ANSI-styled string into multiple lines without breaking ANSI sequences.
+ */
+export function wrapAnsiLine(line: string, maxWidth: number): string[] {
+  if (maxWidth <= 0) return [line];
+  if (stringWidth(line) <= maxWidth) return [line];
+
+  const words = line.split(" ");
+  const lines: string[] = [];
+  let currentLine = "";
+
+  for (const word of words) {
+    const testLine = currentLine ? `${currentLine} ${word}` : word;
+    if (stringWidth(testLine) <= maxWidth) {
+      currentLine = testLine;
+    } else {
+      if (currentLine) lines.push(currentLine);
+      currentLine = word;
+    }
+  }
+
+  if (currentLine) lines.push(currentLine);
+  return lines.length > 0 ? lines : [""];
+}
+
+/**
+ * Parses full multi-line Markdown text and returns an array of formatted, word-wrapped lines.
+ */
+export function formatMarkdown(
+  content: string,
+  maxWidth: number,
+  options?: MarkdownOptions,
+): string[] {
+  const rawLines = content.split("\n");
+  const result: string[] = [];
+  let inCodeBlock = false;
+  const isDim = options?.dim ?? false;
+
+  for (const rawLine of rawLines) {
+    const trimmed = rawLine.trimEnd();
+
+    // Image Markdown: ![alt](url)
+    const imgRegex = /!\[(.*?)\]\((https?:\/\/[^\s)]+)\)/g;
+    if (imgRegex.test(trimmed)) {
+      const parts = trimmed.split(/(!\[.*?\]\(https?:\/\/[^\s)]+\))/g);
+      for (const part of parts) {
+        const m = part.match(/^!\[(.*?)\]\((https?:\/\/[^\s)]+)\)$/);
+        if (m) {
+          result.push(...formatImageCard(m[1], m[2], maxWidth));
+        } else if (part.trim()) {
+          const inlineFormatted = formatMarkdownInline(part.trim(), options);
+          result.push(...wrapAnsiLine(inlineFormatted, maxWidth));
+        }
+      }
+      continue;
+    }
+
+    // Code blocks: ```lang ... ```
+    if (trimmed.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      const lang = trimmed.slice(3).trim();
+      if (inCodeBlock) {
+        const border = isDim ? theme.dark : theme.blue;
+        result.push(border(`┌─── ${lang || "code"} ───────────────────────────`));
+      } else {
+        const border = isDim ? theme.dark : theme.blue;
+        result.push(border("└───"));
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      if (isDim) {
+        result.push(theme.dark(`│ `) + theme.muted(trimmed));
+      } else {
+        result.push(theme.blue(`│ `) + theme.cyan(trimmed));
+      }
+      continue;
+    }
+
+    // Headers
+    if (/^#{1,3}\s+/.test(trimmed)) {
+      const level = trimmed.match(/^#+/)?.[0].length || 1;
+      const cleanHeader = trimmed.replace(/^#+\s*/, "");
+      const formattedHeader = formatMarkdownInline(cleanHeader, options);
+      if (isDim) {
+        result.push(theme.bold(theme.muted(`■ ${cleanHeader}`)));
+      } else {
+        if (level === 1) {
+          result.push(theme.bold(theme.lavender(`■ ${formattedHeader}`)));
+        } else if (level === 2) {
+          result.push(theme.bold(theme.blue(`● ${formattedHeader}`)));
+        } else {
+          result.push(theme.bold(theme.cyan(`▸ ${formattedHeader}`)));
+        }
+      }
+      continue;
+    }
+
+    // Blockquotes
+    if (trimmed.startsWith(">")) {
+      const quoteText = trimmed.replace(/^>\s*/, "");
+      const formattedQuote = formatMarkdownInline(quoteText, options);
+      const wrapped = wrapAnsiLine(formattedQuote, Math.max(10, maxWidth - 4));
+      for (const wl of wrapped) {
+        result.push(theme.muted("│ ") + theme.italic(wl));
+      }
+      continue;
+    }
+
+    // Bullet lists (- or * or •)
+    if (/^(\s*)[-*•]\s+/.test(trimmed)) {
+      const match = trimmed.match(/^(\s*)[-*•]\s+(.*)$/);
+      if (match) {
+        const indent = match[1] || "";
+        const itemText = formatMarkdownInline(match[2], options);
+        const wrapped = wrapAnsiLine(itemText, Math.max(10, maxWidth - indent.length - 4));
+        const bullet = isDim ? theme.dark("•") : theme.cyan("•");
+        wrapped.forEach((wl, idx) => {
+          if (idx === 0) {
+            result.push(`${indent}  ${bullet} ${wl}`);
+          } else {
+            result.push(`${indent}    ${wl}`);
+          }
+        });
+        continue;
+      }
+    }
+
+    // Numbered lists (1. 2.)
+    if (/^(\s*)\d+\.\s+/.test(trimmed)) {
+      const match = trimmed.match(/^(\s*)(\d+\.)\s+(.*)$/);
+      if (match) {
+        const indent = match[1] || "";
+        const num = match[2];
+        const itemText = formatMarkdownInline(match[3], options);
+        const wrapped = wrapAnsiLine(itemText, Math.max(10, maxWidth - indent.length - num.length - 3));
+        const numStyled = isDim ? theme.muted(num) : theme.blue(num);
+        wrapped.forEach((wl, idx) => {
+          if (idx === 0) {
+            result.push(`${indent}  ${numStyled} ${wl}`);
+          } else {
+            result.push(`${indent}     ${wl}`);
+          }
+        });
+        continue;
+      }
+    }
+
+    // Empty lines
+    if (!trimmed) {
+      result.push("");
+      continue;
+    }
+
+    // Standard paragraph with inline formatting and word-wrap
+    const inlineFormatted = formatMarkdownInline(trimmed, options);
+    const wrapped = wrapAnsiLine(inlineFormatted, maxWidth);
+    result.push(...wrapped);
+  }
+
+  return result;
+}

package/src/tui/proxy-client.ts

@@ -0,0 +1,326 @@
+/**
+ * QwenProxy TUI - Proxy Data Provider & Live State Client
+ */
+
+import { config } from "../core/config.ts";
+import { loadAccounts, type QwenAccount } from "../core/accounts.ts";
+import {
+  getAccountCooldownInfo,
+  clearAllAccountCooldowns,
+  clearAccountCooldown,
+  isAccountHeadersReady,
+} from "../core/account-manager.ts";
+import { getAccountConcurrencySnapshot } from "../core/account-concurrency.ts";
+import { getRssUsageSnapshot } from "../core/memory-usage.ts";
+import type { ProxyStatusSnapshot } from "./types.ts";
+
+export function maskAccountIdentifier(idOrEmail: string): string {
+  if (!idOrEmail) return "unknown";
+  if (idOrEmail.includes("@")) {
+    const [user, domain] = idOrEmail.split("@");
+    const visible = user.slice(0, 2);
+    return `${visible}***@${domain}`;
+  }
+
+  if (idOrEmail.length > 8) {
+    return `${idOrEmail.slice(0, 3)}***${idOrEmail.slice(-3)}`;
+  }
+  return idOrEmail;
+}
+
+export function formatUptime(seconds: number): string {
+  const hrs = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+  const pad2 = (n: number) => n.toString().padStart(2, "0");
+  if (hrs > 0) {
+    return `${pad2(hrs)}:${pad2(mins)}:${pad2(secs)}`;
+  }
+  return `${pad2(mins)}:${pad2(secs)}`;
+}
+let cachedAccounts: Array<{
+  id: string;
+  emailOrName: string;
+  priority: number;
+  cooldownUntil: number | null;
+  onCooldown: boolean;
+  remainingCooldownMs: number;
+  headersReady: boolean;
+}> = [];
+let lastAccountsFetch = 0;
+let isHealthCheckPending = false;
+let lastOnlineState = false;
+let lastOverallStatus = "offline";
+
+export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
+  const port = config.server?.port || 7936;
+  const configuredHost = config.server?.host;
+  const host = configuredHost && configuredHost !== "0.0.0.0" ? configuredHost : "127.0.0.1";
+  const uptimeSeconds = Math.floor(process.uptime());
+
+  // Fast non-blocking health probe
+  if (!isHealthCheckPending) {
+    isHealthCheckPending = true;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 350);
+    fetch(`http://${host}:${port}/health`, { signal: controller.signal })
+      .then(async (resp) => {
+        clearTimeout(timeout);
+        if (resp.ok) {
+          lastOnlineState = true;
+          const data = (await resp.json()) as any;
+          lastOverallStatus = data.status || "healthy";
+        } else {
+          lastOnlineState = false;
+        }
+      })
+      .catch(() => {
+        clearTimeout(timeout);
+        lastOnlineState = false;
+      })
+      .finally(() => {
+        isHealthCheckPending = false;
+      });
+  }
+
+  const now = Date.now();
+  if (now - lastAccountsFetch > 3000 || cachedAccounts.length === 0) {
+    lastAccountsFetch = now;
+    let rawAccounts: QwenAccount[] = [];
+    try {
+      rawAccounts = loadAccounts();
+    } catch {
+      rawAccounts = [];
+    }
+
+    cachedAccounts = rawAccounts.map((acc) => {
+      const cooldownInfo = getAccountCooldownInfo(acc.id);
+      const onCooldown = Boolean(cooldownInfo?.onCooldown);
+      const remainingCooldownMs = cooldownInfo?.remainingMs || 0;
+      const headersReady = isAccountHeadersReady(acc.id);
+
+      return {
+        id: acc.id,
+        emailOrName: maskAccountIdentifier(acc.email || acc.id),
+        priority: 1,
+        cooldownUntil: acc.cooldown_until || null,
+        onCooldown,
+        remainingCooldownMs,
+        headersReady,
+      };
+    });
+  }
+
+  const accounts = cachedAccounts;
+  const online = lastOnlineState;
+  const overallStatus = lastOverallStatus;
+
+  // Concurrency stats
+  let activeStreams = 0;
+  let waitingStreams = 0;
+  try {
+    const snapshot = getAccountConcurrencySnapshot();
+    for (const item of snapshot) {
+      activeStreams += item.active;
+      waitingStreams += item.waiting;
+    }
+  } catch {}
+
+  // RAM usage
+  let rssMb = 0;
+  let systemMemoryPct = 0;
+  try {
+    const rssSnap = getRssUsageSnapshot();
+    rssMb = Math.round(rssSnap.rss / (1024 * 1024));
+    systemMemoryPct = Math.round(rssSnap.usagePercent * 10) / 10;
+  } catch {}
+
+  return {
+    online,
+    port,
+    host,
+    overallStatus,
+    uptimeSeconds,
+    rssMb,
+    systemMemoryPct,
+    activeStreams,
+    waitingStreams,
+    accounts,
+  };
+}
+
+export function resetAllCooldowns(): number {
+  return clearAllAccountCooldowns();
+}
+
+export function resetAccountCooldownById(accountId: string): void {
+  clearAccountCooldown(accountId);
+}
+
+export interface StreamChatOptions {
+  model: string;
+  reasoning_effort?: "low" | "medium" | "high";
+  messages: Array<{ role: "system" | "user" | "assistant"; content: string }>;
+  onToken: (text: string) => void;
+  onReasoning?: (text: string) => void;
+  signal?: AbortSignal;
+}
+
+/**
+ * Streams a chat completion response from the local proxy endpoint.
+ */
+export async function streamChatCompletions(
+  options: StreamChatOptions,
+): Promise<{ totalTimeMs: number; ttfbMs: number }> {
+  const port = config.server?.port || 7936;
+  const configuredHost = config.server?.host;
+  const host = configuredHost && configuredHost !== "0.0.0.0" ? configuredHost : "127.0.0.1";
+  const apiKey = config.apiKey || "sk-qwenproxy-local";
+
+  const startTime = Date.now();
+  let ttfbMs = 0;
+
+  let resp: Response;
+  try {
+    resp = await fetch(`http://${host}:${port}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model: options.model,
+        reasoning_effort: options.reasoning_effort,
+        messages: options.messages,
+        stream: true,
+      }),
+      signal: options.signal,
+    });
+  } catch (fetchErr: any) {
+    if (fetchErr?.name === "AbortError" || options.signal?.aborted) {
+      throw fetchErr;
+    }
+    throw new Error(
+      `O servidor QwenProxy está iniciando ou indisponível (:7936). Verifique o status ou a aba [6] Logs.`,
+    );
+  }
+
+  if (!resp.ok) {
+    const errText = await resp.text();
+    throw new Error(`HTTP ${resp.status}: ${errText}`);
+  }
+
+  if (!resp.body) {
+    throw new Error("No response body received from proxy");
+  }
+
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    if (ttfbMs === 0) {
+      ttfbMs = Date.now() - startTime;
+    }
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data:")) continue;
+      const dataStr = trimmed.replace(/^data:\s*/, "").trim();
+      if (dataStr === "[DONE]") break;
+
+      try {
+        const parsed = JSON.parse(dataStr);
+        const delta = parsed.choices?.[0]?.delta;
+        if (!delta) continue;
+
+        if (delta.reasoning_content && options.onReasoning) {
+          options.onReasoning(delta.reasoning_content);
+        }
+        if (delta.content) {
+          options.onToken(delta.content);
+        }
+      } catch {}
+    }
+  }
+
+  return {
+    totalTimeMs: Date.now() - startTime,
+    ttfbMs: ttfbMs || Date.now() - startTime,
+  };
+}
+
+/**
+ * Fetches all live models dynamically from the running proxy /v1/models catalog.
+ */
+let cachedLiveModels: string[] | null = null;
+let isFetchingLiveModels = false;
+
+export async function fetchLiveModels(): Promise<string[]> {
+  if (cachedLiveModels && cachedLiveModels.length > 0) {
+    return cachedLiveModels;
+  }
+
+  const port = config.server?.port || 7936;
+  const configuredHost = config.server?.host;
+  const host = configuredHost && configuredHost !== "0.0.0.0" ? configuredHost : "127.0.0.1";
+  const apiKey = config.apiKey || "sk-qwenproxy-local";
+
+  if (!isFetchingLiveModels) {
+    isFetchingLiveModels = true;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2500);
+    fetch(`http://${host}:${port}/v1/models`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: controller.signal,
+    })
+      .then(async (resp) => {
+        clearTimeout(timeout);
+        if (resp.ok) {
+          const json = (await resp.json()) as any;
+          if (Array.isArray(json?.data)) {
+            const models = json.data
+              .map((m: any) => m.id)
+              .filter((id: any): id is string => typeof id === "string" && id.trim().length > 0)
+              .filter(
+                (id: string) =>
+                  !id.endsWith("-fast") &&
+                  !id.endsWith("-thinking") &&
+                  !id.endsWith("-no-thinking"),
+              );
+            if (models.length > 0) {
+              cachedLiveModels = Array.from(new Set(models));
+            }
+          }
+        }
+      })
+      .catch(() => {
+        clearTimeout(timeout);
+      })
+      .finally(() => {
+        isFetchingLiveModels = false;
+      });
+  }
+
+  return (
+    cachedLiveModels || [
+      "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",
+    ]
+  );
+}