qwenproxy-cli 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "High-performance OpenAI & Anthropic compatible API gateway for Qwen with multi-account rotation, interactive TUI, and resilient tool calling.",
   "main": "src/index.ts",
   "bin": {
@@ -16,7 +16,6 @@
     "LICENSE"
   ],
   "scripts": {
-    "postinstall": "patchright install chromium",
     "start": "tsx src/index.ts",
     "tui": "npx tsx src/tui/index.ts",
     "login": "npx tsx src/login.ts",

package/src/api/server.ts

@@ -269,6 +269,7 @@ app.get("/health", async (c) => {
       : undefined,
     timestamp: Date.now(),
     readyAccounts: (await import("../core/account-manager.js")).getHeadersReadyAccountIds(),
+    activeAccounts: (await import("../services/playwright.js")).getActivePlaywrightAccountIds(),
     metrics: {
       cache: await cache?.getStats(),
     },

package/src/core/config.ts

@@ -52,7 +52,7 @@ const envSchema = z
     // own context while serving. Accounts in cooldown (rate-limited) sit idle,
     // drop out of the warm set and get evicted.
     PLAYWRIGHT_MAX_ACTIVE_CONTEXTS: z.string().default("2"),
-    PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("true"),
+    PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("false"),
     CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
     CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
     CAPTCHA_SOLVER_TIMEOUT_MS: z.string().default("15000"),
@@ -166,7 +166,7 @@ const envSchema = z
     // trust score and gets TMD-challenged on the next request. On by default;
     // the keeper skips accounts that are mid-stream or mutex-busy.
     SESSION_KEEP_ALIVE_ENABLED: z.string().default("true"),
-    SESSION_KEEP_ALIVE_INTERVAL_MS: z.string().default("30000"),
+    SESSION_KEEP_ALIVE_INTERVAL_MS: z.string().default("180000"),
     SESSION_KEEP_ALIVE_IDLE_MS: z.string().default("120000"),
     SESSION_KEEP_ALIVE_NAVIGATION_INTERVAL_MS: z.string().default("480000"),
     API_KEY: z.string().default(""),

package/src/services/playwright.ts

@@ -3,7 +3,7 @@
  * Captures real browser headers (bx-ua, bx-umidtoken) per account.
  */
 
-import { chromium, type BrowserContext, type Page } from "patchright";
+import { chromium, type Browser, type BrowserContext, type Page } from "patchright";
 import path from "path";
 import fs from "fs";
 import crypto from "crypto";
@@ -183,6 +183,112 @@ const accountContexts = new Map<string, BrowserContext>();
 const accountPages = new Map<string, Page>();
 const cachedUserAgents = new Map<string, string>();
 
+let sharedBrowser: Browser | null = null;
+let sharedBrowserPromise: Promise<Browser> | null = null;
+
+export function getSharedBrowser(): Browser | null {
+  return sharedBrowser;
+}
+
+export function getStorageStatePath(accountId: string): string {
+  const profileDir = getAccountProfilePath(accountId);
+  return path.join(profileDir, "storage_state.json");
+}
+
+export function loadStorageState(accountId: string): string | undefined {
+  const p1 = getStorageStatePath(accountId);
+  const p2 = path.join(path.dirname(p1), `${accountId}_state.json`);
+  const chosenPath = fs.existsSync(p1) ? p1 : fs.existsSync(p2) ? p2 : undefined;
+  if (!chosenPath) return undefined;
+  try {
+    const raw = fs.readFileSync(chosenPath, "utf8");
+    const state = JSON.parse(raw);
+    if (!state || typeof state !== "object" || !Array.isArray(state.cookies)) {
+      return undefined;
+    }
+    return chosenPath;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function saveStorageState(
+  context: BrowserContext,
+  accountId: string,
+): Promise<void> {
+  try {
+    const stateFile = getStorageStatePath(accountId);
+    const dir = path.dirname(stateFile);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    await context.storageState({ path: stateFile });
+  } catch (error) {
+    console.warn(
+      `[Playwright] Failed to save storage state for ${accountId}: ${getErrorMessage(error)}`,
+    );
+  }
+}
+
+async function hasValidAuthCookie(context: BrowserContext): Promise<boolean> {
+  try {
+    const cookies = await context.cookies();
+    return cookies.some(
+      (c) =>
+        (c.name.toLowerCase().includes("token") || c.name.toLowerCase().includes("session")) &&
+        (c.expires === undefined || c.expires === -1 || c.expires * 1000 > Date.now()),
+    );
+  } catch {
+    return false;
+  }
+}
+
+export async function getOrLaunchSharedBrowser(
+  browserType: BrowserType = "chromium",
+  headless = true,
+): Promise<Browser> {
+  if (sharedBrowser && sharedBrowser.isConnected()) {
+    return sharedBrowser;
+  }
+  if (sharedBrowserPromise) {
+    return sharedBrowserPromise;
+  }
+
+  sharedBrowserPromise = (async () => {
+    const { engine, channel } = resolveBrowserEngine(browserType);
+    const defaultViewport = { width: 1280, height: 800 };
+    const launchArgs = buildChromiumLaunchArgs(defaultViewport);
+
+    console.log(
+      `[Playwright] Launching single shared ${browserType} browser...`,
+    );
+
+    const browser = await engine.launch({
+      headless,
+      channel,
+      ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
+      args: launchArgs,
+    });
+
+    browser.on("disconnected", () => {
+      console.warn("[Playwright] Shared browser disconnected");
+      sharedBrowser = null;
+      for (const accountId of Array.from(accountPages.keys())) {
+        cleanupPlaywrightAccountState(accountId);
+      }
+    });
+
+    sharedBrowser = browser;
+    return browser;
+  })();
+
+  try {
+    return await sharedBrowserPromise;
+  } finally {
+    sharedBrowserPromise = null;
+  }
+}
+
 // Header cache per account
 interface AccountHeaderCache {
   headers: Record<string, string>;
@@ -1041,13 +1147,12 @@ export async function initPlaywrightForAccount(
     // If a context limit is configured, make room by closing idle contexts.
     await evictIdlePlaywrightContextsToLimit().catch(() => {});
 
-    const profilePath = getAccountProfilePath(account.id);
     const fingerprint = getFingerprintProfile(account.id);
-    const { engine, channel } = resolveBrowserEngine(browserType);
+    const sharedBrowser = await getOrLaunchSharedBrowser(browserType, headless);
+    const storageState = loadStorageState(account.id);
 
-    const acctContext = await engine.launchPersistentContext(profilePath, {
-      headless,
-      channel,
+    const acctContext = await sharedBrowser.newContext({
+      ...(storageState ? { storageState } : {}),
       userAgent: fingerprint.userAgent,
       locale: fingerprint.locale,
       timezoneId: fingerprint.timezoneId,
@@ -1062,8 +1167,6 @@ export async function initPlaywrightForAccount(
         "sec-ch-ua-mobile": "?0",
         "sec-ch-ua-platform": '"Windows"',
       },
-      ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
-      args: buildChromiumLaunchArgs(fingerprint.viewport),
     });
 
     try {
@@ -1073,23 +1176,7 @@ export async function initPlaywrightForAccount(
         await hook(acctContext);
       }
 
-      // Persistent contexts may already contain an initial about:blank tab.
-      // Reuse it instead of creating a second tab. Prefer a tab already on the
-      // Qwen origin when one exists.
-      const existingPages = acctContext.pages().filter((p) => !p.isClosed());
-      const acctPage =
-        existingPages.find((p) => p.url().startsWith(qwenOrigin())) ??
-        existingPages[0] ??
-        (await acctContext.newPage());
-
-      // Close any extra blank tabs that may have been created by the browser
-      // profile/startup, but keep the primary page selected above.
-      for (const extraPage of existingPages.slice(1)) {
-        if (extraPage !== acctPage && extraPage.url() === "about:blank") {
-          await extraPage.close({ runBeforeUnload: false }).catch(() => {});
-        }
-      }
-
+      const acctPage = await acctContext.newPage();
       acctPage.setDefaultTimeout(config.timeouts.page);
       acctPage.setDefaultNavigationTimeout(config.timeouts.navigation);
       accountContexts.set(account.id, acctContext);
@@ -1205,12 +1292,12 @@ export async function validateAccountLogin(
   try {
     if (accountPages.has(account.id)) return true;
 
-    const profilePath = getAccountProfilePath(account.id);
     const fingerprint = getFingerprintProfile(account.id);
-    const { engine, channel } = resolveBrowserEngine(browserType);
-    const acctContext = await engine.launchPersistentContext(profilePath, {
-      headless,
-      channel,
+    const sharedBrowser = await getOrLaunchSharedBrowser(browserType, headless);
+    const storageState = loadStorageState(account.id);
+
+    const acctContext = await sharedBrowser.newContext({
+      ...(storageState ? { storageState } : {}),
       userAgent: fingerprint.userAgent,
       locale: fingerprint.locale,
       timezoneId: fingerprint.timezoneId,
@@ -1225,18 +1312,11 @@ export async function validateAccountLogin(
         "sec-ch-ua-mobile": "?0",
         "sec-ch-ua-platform": '"Windows"',
       },
-      ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
-      args: buildChromiumLaunchArgs(fingerprint.viewport),
     });
 
     try {
       await acctContext.addInitScript(getStealthScript(fingerprint));
-
-      const existingPages = acctContext.pages().filter((p) => !p.isClosed());
-      const acctPage =
-        existingPages.find((p) => p.url().startsWith(qwenOrigin())) ??
-        existingPages[0] ??
-        (await acctContext.newPage());
+      const acctPage = await acctContext.newPage();
 
       // Check if already logged in via cookies
       const cookies = await acctContext.cookies();
@@ -1306,12 +1386,14 @@ async function loginToQwen(
     // Try API login first
     const apiResult = await loginViaApi(page, email, password);
     if (apiResult) {
+      await saveStorageState(page.context(), accountId);
       return true;
     }
 
     // Fallback to UI login
     const uiResult = await loginViaUi(page, email, password);
     if (uiResult) {
+      await saveStorageState(page.context(), accountId);
       return true;
     }
 
@@ -2107,6 +2189,8 @@ async function resetPlaywrightProfileLocked(accountId: string): Promise<void> {
   await closePlaywrightForAccountLocked(accountId);
   const profilePath = getAccountProfilePath(accountId);
   removePlaywrightProfile(profilePath);
+  const stateFile2 = path.join(path.dirname(profilePath), `${accountId}_state.json`);
+  try { fs.rmSync(stateFile2, { force: true }); } catch {}
 }
 
 /**
@@ -2533,7 +2617,11 @@ async function closePlaywrightContextBestEffort(
   accountId: string,
   context: BrowserContext,
 ): Promise<void> {
-  const browserProcess = getBrowserProcess(context);
+  try {
+    if (await hasValidAuthCookie(context)) {
+      await saveStorageState(context, accountId);
+    }
+  } catch {}
 
   try {
     const pages = context.pages();
@@ -2558,19 +2646,6 @@ async function closePlaywrightContextBestEffort(
         `[Playwright] Failed to close context for ${accountId}: ${getErrorMessage(error)}`,
       );
     }
-
-    if (browserProcess && !browserProcess.killed) {
-      try {
-        browserProcess.kill("SIGKILL");
-        console.warn(
-          `[Playwright] Killed lingering browser process for ${accountId}`,
-        );
-      } catch (killError) {
-        console.warn(
-          `[Playwright] Failed to kill browser process for ${accountId}: ${getErrorMessage(killError)}`,
-        );
-      }
-    }
   }
 }
 
@@ -2651,6 +2726,10 @@ export async function closeAllPlaywright(): Promise<void> {
     for (const accountId of accountIds) {
       await closePlaywrightForAccount(accountId);
     }
+    if (sharedBrowser && sharedBrowser.isConnected()) {
+      await sharedBrowser.close().catch(() => {});
+      sharedBrowser = null;
+    }
   } finally {
     closingAllPlaywright = false;
   }
@@ -2726,7 +2805,6 @@ export async function getTokenDiagnostics(
   const targetAccounts = accountId
     ? [accountId]
     : Array.from(accountContexts.keys());
-
   const allCookies: CookieDiagnostic[] = [];
   const headerDiags: HeaderDiagnostic[] = [];
 

package/src/tui/app.ts

@@ -7,7 +7,19 @@ 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 fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 
+let cachedAppVersion = "v1.0.2";
+try {
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  const pkgPath = path.resolve(currentDir, "../../package.json");
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (pkg.version) cachedAppVersion = `v${pkg.version}`;
+  }
+} catch {}
 import { StatusView } from "./views/status-view.ts";
 import { ChatView } from "./views/chat-view.ts";
 import { SyncView } from "./views/sync-view.ts";
@@ -91,11 +103,6 @@ export class TuiApp {
       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);
@@ -245,7 +252,7 @@ export class TuiApp {
 
     const headerContent = [` ${tabsBar}`];
     const headerBox = drawBox({
-      title: `QwenProxy v1.0.0 ${statusChip}`,
+      title: `QwenProxy ${cachedAppVersion} ${statusChip}`,
       width: cols,
       height: 3,
       borderColor: theme.borderActive,

package/src/tui/proxy-client.ts

@@ -10,6 +10,7 @@ import {
   clearAccountCooldown,
   isAccountHeadersReady,
 } from "../core/account-manager.ts";
+import { isPlaywrightInitialized } from "../services/playwright.ts";
 import { getAccountConcurrencySnapshot } from "../core/account-concurrency.ts";
 import { getRssUsageSnapshot } from "../core/memory-usage.ts";
 import type { ProxyStatusSnapshot } from "./types.ts";
@@ -46,12 +47,14 @@ let cachedAccounts: Array<{
   onCooldown: boolean;
   remainingCooldownMs: number;
   headersReady: boolean;
+  isInitialized: boolean;
 }> = [];
 let lastAccountsFetch = 0;
 let isHealthCheckPending = false;
 let lastOnlineState = false;
 let lastOverallStatus = "offline";
 let lastServerReadyAccounts: Set<string> | null = null;
+let lastServerActiveAccounts: Set<string> | null = null;
 export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
   const port = config.server?.port || 7936;
   const configuredHost = config.server?.host;
@@ -73,9 +76,13 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
           if (Array.isArray(data.readyAccounts)) {
             lastServerReadyAccounts = new Set(data.readyAccounts);
           }
+          if (Array.isArray(data.activeAccounts)) {
+            lastServerActiveAccounts = new Set(data.activeAccounts);
+          }
         } else {
           lastOnlineState = false;
           lastServerReadyAccounts = null;
+          lastServerActiveAccounts = null;
         }
       })
       .catch(() => {
@@ -104,6 +111,9 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
       const headersReady = lastServerReadyAccounts !== null
         ? lastServerReadyAccounts.has(acc.id)
         : isAccountHeadersReady(acc.id);
+      const isInitialized = lastServerActiveAccounts !== null
+        ? lastServerActiveAccounts.has(acc.id)
+        : isPlaywrightInitialized(acc.id);
       return {
         id: acc.id,
         emailOrName: maskAccountIdentifier(acc.email || acc.id),
@@ -112,10 +122,10 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
         onCooldown,
         remainingCooldownMs,
         headersReady,
+        isInitialized,
       };
     });
   }
-
   const accounts = cachedAccounts;
   const online = lastOnlineState;
   const overallStatus = lastOverallStatus;

package/src/tui/theme.ts

@@ -16,7 +16,7 @@ export const ANSI = {
   showCursor: "\x1b[?25h",
   enterAltScreen: "\x1b[?1049h",
   exitAltScreen: "\x1b[?1049l",
-  enableMouse: "\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h",
+  enableMouse: "\x1b[?1000h\x1b[?1002h\x1b[?1006h",
   disableMouse: "\x1b[?1006l\x1b[?1005l\x1b[?1004l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1015l",
 };
 

package/src/tui/types.ts

@@ -29,5 +29,6 @@ export interface ProxyStatusSnapshot {
     onCooldown: boolean;
     remainingCooldownMs: number;
     headersReady: boolean;
+    isInitialized?: boolean;
   }>;
 }

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

@@ -497,7 +497,9 @@ export class AccountsView implements TuiView {
           const mins = Math.max(1, Math.round(acc.remainingCooldownMs / 60000));
           status = theme.yellow(`⚠ ${mins}m cd   `);
         } else if (!acc.headersReady) {
-          status = theme.yellow(`◐ Aquecendo...`);
+          status = acc.isInitialized
+            ? theme.yellow(`◐ Aquecendo...`)
+            : theme.muted(`○ Standby     `);
         }
 
         const line = `${pointer}${num}${name}${status}`;
@@ -550,7 +552,9 @@ export class AccountsView implements TuiView {
 
       const hStatus = selected.headersReady
         ? theme.green(`${glyphs.check} Capturados`)
-        : theme.muted(`${glyphs.circle} Pendente`);
+        : selected.isInitialized
+          ? theme.yellow(`◐ Aquecendo...`)
+          : theme.muted(`${glyphs.circle} Standby (Sob Demanda)`);
       rightContent.push(`  ${theme.bold("Headers:")}    ${hStatus}`);
       rightContent.push("");
       rightContent.push(`  ${theme.dim("─────────────────────────────────")}`);

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

@@ -175,7 +175,9 @@ export class StatusView implements TuiView {
           const mins = Math.max(1, Math.round(acc.remainingCooldownMs / 60000));
           status = theme.yellow(`⚠ Cooldown ${mins}m`);
         } else if (!acc.headersReady) {
-          status = theme.yellow(`◐ Aquecendo...`);
+          status = acc.isInitialized
+            ? theme.yellow(`◐ Aquecendo...`)
+            : theme.muted(`○ Standby`);
         }
         rightContent.push(`  ${num} ${name} ${status}`);
       });

package/src/update-cli.ts

@@ -0,0 +1,121 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(__dirname, "..");
+const packageJsonPath = path.join(packageRoot, "package.json");
+
+export type PackageManager = "bun" | "pnpm" | "yarn" | "npm";
+
+export function detectPackageManager(): PackageManager {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.startsWith("bun")) return "bun";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("yarn")) return "yarn";
+
+  // Check which executable is actually running the script or installed in PATH
+  const execPath = process.execPath.toLowerCase();
+  if (execPath.includes("bun")) return "bun";
+
+  // Check if installation path contains pnpm / bun / yarn markers
+  const currentPath = packageRoot.toLowerCase();
+  if (currentPath.includes(".pnpm") || currentPath.includes("pnpm")) return "pnpm";
+  if (currentPath.includes(".bun") || currentPath.includes("bun")) return "bun";
+  if (currentPath.includes("yarn")) return "yarn";
+
+  return "npm";
+}
+export function getUpdateArgs(pm: PackageManager, packageName: string): { cmd: string; args: string[] } {
+  switch (pm) {
+    case "bun":
+      return { cmd: "bun", args: ["add", "-g", `${packageName}@latest`] };
+    case "pnpm":
+      return { cmd: "pnpm", args: ["update", "-g", packageName] };
+    case "yarn":
+      return { cmd: "yarn", args: ["global", "upgrade", packageName] };
+    case "npm":
+    default:
+      return { cmd: "npm", args: ["install", "-g", `${packageName}@latest`] };
+  }
+}
+
+export function isNewerVersion(current: string, latest: string): boolean {
+  const c = current.replace(/^v/i, "").split(".").map((n) => parseInt(n, 10));
+  const l = latest.replace(/^v/i, "").split(".").map((n) => parseInt(n, 10));
+  for (let i = 0; i < 3; i++) {
+    const cv = c[i] || 0;
+    const lv = l[i] || 0;
+    if (lv > cv) return true;
+    if (lv < cv) return false;
+  }
+  return false;
+}
+
+export async function runUpdateCommand(): Promise<void> {
+  let pkg: any = { name: "qwenproxy-cli", version: "1.0.0" };
+  try {
+    pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  } catch {}
+
+  const currentVersion = pkg.version || "1.0.0";
+  const packageName = pkg.name || "qwenproxy-cli";
+  const pm = detectPackageManager();
+
+  console.log(`\n📦 [QwenProxy] Versão local instalada: v${currentVersion}`);
+  console.log(`⚙️ [QwenProxy] Gerenciador de pacotes detectado: ${pm}`);
+  console.log(`🔍 [QwenProxy] Verificando se há novas versões de ${packageName} no npm registry...`);
+
+  let latestVersion = "";
+  try {
+    const fullCmd = `npm view ${packageName} version`;
+    const res = spawnSync(fullCmd, {
+      encoding: "utf-8",
+      shell: true,
+      timeout: 10000,
+    });
+    latestVersion = res.stdout ? res.stdout.trim() : "";
+  } catch {}
+
+  if (!latestVersion) {
+    console.warn("⚠️  [QwenProxy] Não foi possível consultar o registro online.");
+    const manual = getUpdateArgs(pm, packageName);
+    console.log(`👉 Você pode forçar a atualização manualmente com:\n   ${manual.cmd} ${manual.args.join(" ")}\n`);
+    return;
+  }
+
+  console.log(`🌐 [QwenProxy] Versão mais recente disponível: v${latestVersion}`);
+
+  if (!isNewerVersion(currentVersion, latestVersion)) {
+    console.log(`\n✨ Você já está utilizando a versão mais recente (v${currentVersion})!\n`);
+    return;
+  }
+
+  console.log(`\n🚀 Nova versão disponível: v${currentVersion} ➔ v${latestVersion}`);
+  const { cmd, args } = getUpdateArgs(pm, packageName);
+  console.log(`⏳ Atualizando globalmente via ${pm} (${cmd} ${args.join(" ")})...`);
+  const fullUpdateCmd = `${cmd} ${args.join(" ")}`;
+  const updateProc = spawnSync(fullUpdateCmd, {
+    stdio: "inherit",
+    shell: true,
+  });
+  if (updateProc.status === 0) {
+    console.log(`\n✅ [QwenProxy] Atualizado com sucesso para a versão v${latestVersion}!`);
+    console.log("👉 Digite 'qpx' para iniciar a nova versão.\n");
+  } else {
+    console.error(`\n❌ [QwenProxy] Falha ao atualizar automaticamente com ${cmd}.`);
+    console.log(`👉 Tente executar manualmente:\n   ${cmd} ${args.join(" ")}\n`);
+  }
+}
+
+// Execute if run directly via CLI runner, not when imported in unit tests
+const isDirectRun =
+  Boolean(process.argv[1]) &&
+  (fileURLToPath(import.meta.url) === path.resolve(process.argv[1]) ||
+    process.argv[1].endsWith("update-cli.ts") ||
+    process.argv[1].endsWith("update-cli.js"));
+
+if (isDirectRun) {
+  void runUpdateCommand();
+}