qwenproxy-cli 1.0.0

package/src/tools/toolcall-tags.ts

@@ -0,0 +1,142 @@
+/**
+ * Central tool-call marker module.
+ *
+ * The Qwen upstream filters/corrupts the conventional `<tool_call>` token in
+ * the SSE stream. We deliberately use a private tag (`<qpx_call>`) that does
+ * NOT contain the `tool_call` substring, so the provider passes it through
+ * untouched. Every place that *emits* (prompt instructions, history replay) or
+ * *parses* (response parser) tool calls reads from this module — the two sides
+ * can never drift apart.
+ *
+ * Override with QWEN_TOOL_OPEN / QWEN_TOOL_CLOSE env vars if needed (e.g. to
+ * dodge a future provider filter that learns this tag).
+ *
+ * The parser still accepts the legacy `<tool_call>` token from model output
+ * for backward compatibility (in-flight sessions, models fine-tuned on it).
+ */
+
+const DEFAULT_OPEN = "<qpx_call>";
+const DEFAULT_CLOSE = "</qpx_call>";
+
+export const TOOL_CALL_OPEN: string =
+  (process.env.QWEN_TOOL_OPEN || DEFAULT_OPEN).trim() || DEFAULT_OPEN;
+export const TOOL_CALL_CLOSE: string =
+  (process.env.QWEN_TOOL_CLOSE || DEFAULT_CLOSE).trim() || DEFAULT_CLOSE;
+
+function tagName(tag: string): string {
+  return tag
+    .replace(/^<\/?/, "")
+    .replace(/>$/, "")
+    .trim();
+}
+
+/** All accepted open tag names (custom + legacy). */
+export function getOpenNames(): string[] {
+  return Array.from(new Set([tagName(TOOL_CALL_OPEN), "tool_call", "tool_calls"]));
+}
+
+/** All accepted close tag names (custom + legacy). */
+export function getCloseNames(): string[] {
+  return Array.from(new Set([tagName(TOOL_CALL_CLOSE), "tool_call", "tool_calls", "tool"]));
+}
+
+/** Wrap a JSON payload in the canonical open/close tags. */
+export function wrapToolCallPayload(json: string): string {
+  return `${TOOL_CALL_OPEN}\n${json}\n${TOOL_CALL_CLOSE}`;
+}
+
+function matchesAt(buffer: string, i: number, value: string): boolean {
+  if (i + value.length > buffer.length) return false;
+  for (let j = 0; j < value.length; j++) {
+    const c = buffer.charCodeAt(i + j);
+    const t = value.charCodeAt(j);
+    if (c !== t && (c | 0x20) !== (t | 0x20)) return false;
+  }
+  return true;
+}
+
+/**
+ * Find the first open tag in `buffer` (any accepted name, case-insensitive).
+ * Returns position/length/tag string or null.
+ */
+export function findToolOpen(
+  buffer: string,
+): { index: number; length: number; tag: string } | null {
+  let best: { index: number; length: number; tag: string } | null = null;
+  for (const name of getOpenNames()) {
+    const re = new RegExp(`<${name}\\b[^>]*>`, "i");
+    const m = buffer.match(re);
+    if (m && m.index !== undefined) {
+      if (!best || m.index < best.index) {
+        best = { index: m.index, length: m[0].length, tag: m[0] };
+      }
+    }
+  }
+  return best;
+}
+
+/**
+ * At buffer position `i`, is there a whitespace-tolerant close tag?
+ * Accepts `</qpx_call>`, `</tool_call >` (space before `>`), `</tool>`, etc.
+ * Returns the total length consumed, or null.
+ */
+export function matchToolCloseAt(buffer: string, i: number): number | null {
+  for (const name of getCloseNames()) {
+    const prefix = `</${name}`;
+    if (!matchesAt(buffer, i, prefix)) continue;
+    let j = i + prefix.length;
+    // Allow optional whitespace before closing `>`
+    while (j < buffer.length && /\s/.test(buffer[j])) j++;
+    if (buffer[j] === ">") return j + 1 - i;
+  }
+  return null;
+}
+
+/** Bare name of an open tag actually seen in the stream (e.g. 'qpx_call'). */
+export function openTagName(openTag: string): string {
+  const m = openTag.match(/^<\/?([a-zA-Z_][\w-]*)/);
+  return m ? m[1] : tagName(TOOL_CALL_OPEN);
+}
+
+/** Matching close tag string for an open tag actually seen in the stream. */
+export function closeTagFor(openTag: string): string {
+  return `</${openTagName(openTag)}>`;
+}
+
+/**
+ * True when `text` contains the start of any accepted open tag.
+ * Used in stream-handler to detect tool-call signals in a chunk.
+ */
+export function textContainsToolCallStart(text: string): boolean {
+  const lower = text.toLowerCase();
+  for (const name of getOpenNames()) {
+    if (lower.includes(`<${name.toLowerCase()}`)) return true;
+  }
+  return false;
+}
+
+/**
+ * Strip leading stray close tags (`</qpx_call>`, `</tool_call>`, `</tool>`)
+ * that the provider sometimes injects before real content.
+ */
+export function stripLeadingStrayCloses(s: string): string {
+  const re = /^\s*<\/(?:qpx_call|tool_call|tool_calls|tool)\s*>/i;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(s))) s = s.substring(m[0].length);
+  return s;
+}
+
+/**
+ * Strip trailing stray close tags that leak after the real payload.
+ */
+export function stripTrailingStrayCloses(s: string): string {
+  const re = /<\/(?:qpx_call|tool_call|tool_calls|tool)\s*>\s*$/i;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(s))) s = s.substring(0, s.length - m[0].length);
+  return s;
+}
+
+/** Strip both leading and trailing stray close tags. */
+export function sanitizeStrayCloses(s: string): string {
+  return stripTrailingStrayCloses(stripLeadingStrayCloses(s));
+}

package/src/tools/types.ts

@@ -0,0 +1,53 @@
+/**
+ * JSON Schema definition following the OpenAI function calling spec.
+ */
+export interface JsonSchema {
+  type: string;
+  properties?: Record<string, JsonSchema>;
+  items?: JsonSchema;
+  required?: string[];
+  enum?: unknown[];
+  const?: unknown;
+  default?: unknown;
+  description?: string;
+  additionalProperties?: boolean | JsonSchema;
+  anyOf?: JsonSchema[];
+  oneOf?: JsonSchema[];
+  allOf?: JsonSchema[];
+  not?: JsonSchema;
+  if?: JsonSchema;
+  then?: JsonSchema;
+  else?: JsonSchema;
+  minimum?: number;
+  maximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  nullable?: boolean;
+}
+
+/**
+ * OpenAI-compatible function tool definition.
+ */
+export interface FunctionToolDefinition {
+  type: "function";
+  function: {
+    name: string;
+    description?: string;
+    parameters?: JsonSchema;
+    strict?: boolean;
+  };
+}
+
+/**
+ * A parsed tool call from the LLM response.
+ */
+export interface ParsedToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}

package/src/tui/app.ts

@@ -0,0 +1,264 @@
+/**
+ * QwenProxy TUI - Main Application Controller & Navigation Coordinator
+ */
+
+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 { ServerManager } from "./server-manager.ts";
+
+import { StatusView } from "./views/status-view.ts";
+import { ChatView } from "./views/chat-view.ts";
+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";
+export class TuiApp {
+  private screen: Screen;
+  private views: TuiView[] = [];
+  private activeViewIndex = 0;
+  private hoveredTabIndex: number | null = null;
+  private isRunning = false;
+  private lastCtrlCTime = 0;
+  private pollInterval: NodeJS.Timeout | null = null;
+  private statusSnapshot: ProxyStatusSnapshot | null = null;
+  private renderScheduled = false;
+  constructor(initialTab = 1) {
+    this.screen = new Screen();
+
+    this.views = [
+      new StatusView(),
+      new ChatView(() => this.requestRender()),
+      new SyncView(),
+      new StorageView(),
+      new AccountsView(),
+      new LogsView(),
+    ];
+    const tabIdx = Math.max(0, Math.min(this.views.length - 1, initialTab - 1));
+    this.activeViewIndex = tabIdx;
+  }
+
+  private getTabAtCol(col: number): number | null {
+    let curCol = 3;
+    for (let i = 0; i < this.views.length; i++) {
+      const tabLabel = ` [${this.views[i].tabNumber}] ${this.views[i].title} `;
+      const width = stringWidth(tabLabel);
+      if (col >= curCol && col <= curCol + width) {
+        return i;
+      }
+      curCol += width + 2;
+    }
+    return null;
+  }
+
+  public async start(): Promise<void> {
+    if (this.isRunning) return;
+    // Activate stdio sandbox immediately so zero logs can leak to terminal screen
+    ServerManager.getInstance().interceptLogs();
+    const ok = this.screen.start();
+    if (!ok) {
+      console.error(
+        "[QwenProxy TUI] A interface interativa requer um terminal TTY interativo.",
+      );
+      process.exit(1);
+    }
+
+    this.isRunning = true;
+
+    // Listen for key events
+    // Listen for key and mouse events with microtask coalescing
+    this.screen.onKey(async (key) => {
+      await this.handleKey(key);
+      this.requestRender();
+    });
+
+    // Listen for terminal resize
+    this.screen.onResize(() => {
+      this.render();
+    });
+
+    // Start server in-process together with TUI ("tudo junto uma coisa só")
+    void ServerManager.getInstance().ensureStarted();
+
+    // Initial status fetch
+    try {
+      this.statusSnapshot = await fetchProxyStatus();
+    } catch {}
+
+    // Background polling every 1s for live status updates and model catalog synchronization
+    this.pollInterval = setInterval(async () => {
+      if (!this.isRunning) return;
+      try {
+        this.statusSnapshot = await fetchProxyStatus();
+        // If the active view has a model refresher, keep it synchronized
+        const activeView = this.views[this.activeViewIndex];
+        if ("refreshModels" in activeView && typeof (activeView as any).refreshModels === "function") {
+          void (activeView as any).refreshModels();
+        }
+        this.requestRender();
+      } catch {}
+    }, 1000);
+    // Initial render
+    this.render();
+  }
+
+  public requestRender(): void {
+    if (this.renderScheduled || !this.isRunning) return;
+    this.renderScheduled = true;
+    queueMicrotask(() => {
+      this.renderScheduled = false;
+      this.render();
+    });
+  }
+
+  public async stop(): Promise<void> {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    clearInterval(this.pollInterval!);
+    this.screen.stop();
+    await ServerManager.getInstance().stop();
+    ServerManager.getInstance().restoreLogs();
+  }
+
+  private async handleKey(key: KeyEvent): Promise<void> {
+    const activeView = this.views[this.activeViewIndex];
+
+    // 1. Global mouse hover & click on Header Tabs (row 2)
+    if (key.mouse && key.mouse.row === 2) {
+      const tabIdx = this.getTabAtCol(key.mouse.col);
+      if (key.name === "hover") {
+        if (this.hoveredTabIndex !== tabIdx) {
+          this.hoveredTabIndex = tabIdx;
+          this.requestRender();
+        }
+        return;
+      }
+      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();
+          return;
+        }
+      }
+    } else if (this.hoveredTabIndex !== null && key.mouse) {
+      this.hoveredTabIndex = null;
+      this.requestRender();
+    }
+
+    // 2. Double Ctrl+C to exit cleanly (within 1.5 seconds)
+    if (key.ctrl && key.name === "c") {
+      const now = Date.now();
+      if (now - this.lastCtrlCTime < 1500) {
+        await this.stop();
+        process.exit(0);
+      }
+      this.lastCtrlCTime = now;
+
+      // First Ctrl+C: execute normal action in active view (cancel stream, clear input, etc.)
+      const handled = await activeView.handleKey(key);
+      if (handled) {
+        this.requestRender();
+      }
+      return;
+    }
+    // Modal check: if a modal dialog is open (in Accounts or Chat), don't cycle tabs with Tab
+    const isModalOpen =
+      (typeof (activeView as any).isCapturingText === "function" &&
+        (activeView as any).isCapturingText()) ||
+      (typeof (activeView as any).isModalOpen === "function" &&
+        (activeView as any).isModalOpen());
+
+    // 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();
+      return;
+    }
+    // Direct tab switching with numbers 1..6 only when NOT typing text in an input
+    const isTypingText =
+      activeView.id === "chat" ||
+      (typeof (activeView as any).isCapturingText === "function" &&
+        (activeView as any).isCapturingText());
+
+    if (!isTypingText) {
+      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();
+          return;
+        }
+      }
+    }
+    // Pass event to active view and render immediately if handled
+    const handled = await activeView.handleKey(key);
+    if (handled) {
+      this.requestRender();
+    }
+  }
+  private render(): void {
+    if (!this.isRunning) return;
+    const { cols, rows } = this.screen.getSize();
+    const frame: string[] = [];
+
+    // 1. Header Deck (Tabs & Title)
+    const serverState = ServerManager.getInstance().getState();
+    let statusChip: string;
+    if (this.statusSnapshot?.online || serverState === "online") {
+      statusChip = theme.green(`[ ${glyphs.bullet} Online ]`);
+    } else if (serverState === "warming") {
+      statusChip = theme.yellow("[ ◐ Iniciando... ]");
+    } else if (serverState === "error") {
+      statusChip = theme.red("[ ✕ Erro ]");
+    } else {
+      statusChip = theme.muted(`[ ○ Offline ]`);
+    }
+
+    const tabsBar = this.views
+      .map((v, idx) => {
+        const isSelected = idx === this.activeViewIndex;
+        const isHovered = idx === this.hoveredTabIndex;
+        const tabLabel = `[${v.tabNumber}] ${v.title}`;
+        if (isSelected) {
+          return theme.bgSelected(` ${tabLabel} `);
+        }
+        if (isHovered) {
+          return theme.bgHover(` ${tabLabel} `);
+        }
+        return theme.dim(` ${tabLabel} `);
+      })
+      .join("  ");
+
+    const headerContent = [` ${tabsBar}`];
+    const headerBox = drawBox({
+      title: `QwenProxy v1.0.0 ${statusChip}`,
+      width: cols,
+      height: 3,
+      borderColor: theme.borderActive,
+      titleColor: theme.cyan,
+      content: headerContent,
+    });
+    frame.push(...headerBox);
+
+    // 2. Active View Content (occupies all remaining rows below the header deck)
+    const activeView = this.views[this.activeViewIndex];
+    const availableContentRows = Math.max(8, rows - 3);
+    const viewLines = activeView.render(cols, availableContentRows, this.statusSnapshot);
+    frame.push(...viewLines);
+    this.screen.render(frame);
+  }
+}

package/src/tui/index.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * QwenProxy TUI - Interactive Terminal Control Interface Entrypoint
+ */
+
+import { TuiApp } from "./app.ts";
+
+function parseInitialTab(): number {
+  const args = process.argv.slice(2);
+  const tabArgIdx = args.findIndex((a) => a === "--tab" || a === "-t");
+  if (tabArgIdx !== -1 && args[tabArgIdx + 1]) {
+    const parsed = parseInt(args[tabArgIdx + 1], 10);
+    if (!isNaN(parsed) && parsed >= 1 && parsed <= 6) {
+      return parsed;
+    }
+  }
+
+  // Positional numeric argument (e.g. `npm run tui 2`)
+  const firstNumeric = args.find((a) => /^[1-6]$/.test(a));
+  if (firstNumeric) {
+    return parseInt(firstNumeric, 10);
+  }
+
+  return 1;
+}
+
+async function main() {
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    console.log(
+      "\x1b[33m[QwenProxy TUI]\x1b[0m A interface interativa TUI requer uma sessão de terminal interativo.",
+    );
+    console.log("Execute diretamente no seu terminal: npm run tui");
+    process.exit(0);
+  }
+
+  const initialTab = parseInitialTab();
+  const app = new TuiApp(initialTab);
+
+  process.on("uncaughtException", async (err) => {
+    try {
+      await app.stop();
+    } catch {}
+    console.error("[QwenProxy TUI] Erro inesperado:", err);
+    process.exit(1);
+  });
+
+  process.on("unhandledRejection", async (err) => {
+    try {
+      await app.stop();
+    } catch {}
+    console.error("[QwenProxy TUI] Promessa rejeitada:", err);
+    process.exit(1);
+  });
+
+  await app.start();
+}
+
+main().catch((err) => {
+  console.error("[QwenProxy TUI] Falha ao inicializar:", err);
+  process.exit(1);
+});