qwenproxy-cli 1.2.10 → 1.3.1

package/src/services/qwen.ts

@@ -1666,10 +1666,10 @@ export async function syncQwenRequestPersonalization(
 
   if (isUnauthorized) {
     console.warn(
-      `[Qwen] Personalization 401 — refreshing session and retrying | account=${cacheKey}`,
+      `[Qwen] Personalization 401 — refreshing session with re-auth and retrying | account=${cacheKey}`,
     );
     try {
-      const { headers: freshHeaders } = await getQwenHeaders(true, accountId);
+      const { headers: freshHeaders } = await getQwenHeaders(true, accountId, true);
       requestHeaders = buildCapturedQwenHeaders(freshHeaders, {
         referer: qwenUrl("/settings/personalization"),
       });

package/src/sync/codex.ts

@@ -1,7 +1,34 @@
 import fs from "node:fs";
 import path from "node:path";
+import os from "node:os";
 import type { ClientSyncResult, SyncOptions } from "./types.ts";
 import { createTimestampBackup, restoreFromBackup, formatModelDisplayName } from "./utils.ts";
+import { isRunningUnderNodeTest } from "../core/paths.ts";
+
+export function removeTomlSection(content: string, sectionHeader: string): string {
+  const lines = content.split(/\r?\n/);
+  const result: string[] = [];
+  let inTargetSection = false;
+  const targetNorm = sectionHeader.replace(/\s+/g, "");
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      const headerInside = trimmed.slice(1, -1).trim().replace(/\s+/g, "");
+      if (headerInside === targetNorm) {
+        inTargetSection = true;
+        continue;
+      } else {
+        inTargetSection = false;
+      }
+    }
+    if (!inTargetSection) {
+      result.push(line);
+    }
+  }
+
+  return result.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
 
 function updateTopLevelKey(content: string, key: string, value: string | number): string {
   // Find first section header [section]
@@ -22,74 +49,108 @@ function updateTopLevelKey(content: string, key: string, value: string | number)
   return newTopPart + restPart;
 }
 
-export function syncCodex(options: SyncOptions): ClientSyncResult {
-  const { filePath, apiKey, baseUrl, model = "qwen3.8-max", setActive = true } = options;
-  try {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+function syncCodexSingleFile(
+  targetPath: string,
+  options: SyncOptions,
+): { backupPath?: string } {
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
 
-    let backupPath: string | undefined;
-    let content = "";
+  let backupPath: string | undefined;
+  let content = "";
 
-    if (fs.existsSync(filePath)) {
-      backupPath = createTimestampBackup(filePath);
-      content = fs.readFileSync(filePath, "utf-8");
-    }
+  if (fs.existsSync(targetPath)) {
+    backupPath = createTimestampBackup(targetPath);
+    content = fs.readFileSync(targetPath, "utf-8");
+  }
 
-    // Build the qwenproxy model_provider block
-    const providerBlock = `[model_providers.qwenproxy]
+  const { apiKey, baseUrl, model = "qwen3.8-max", setActive = true } = options;
+
+  // Build the qwenproxy model_provider block
+  const providerBlock = `[model_providers.qwenproxy]
 name = "QwenProxy"
 base_url = "${baseUrl}"
 wire_api = "responses"
 experimental_bearer_token = "${apiKey}"
 `;
 
-    // Replace or append [model_providers.qwenproxy]
-    const providerRegex = /\[model_providers\.qwenproxy\][\s\S]*?(?=(?:^\[|\Z))/m;
-    if (providerRegex.test(content)) {
-      content = content.replace(providerRegex, providerBlock);
-    } else {
-      content = content.trimEnd() + (content.length > 0 ? "\n\n" : "") + providerBlock;
-    }
+  // Clean any previous or duplicate [model_providers.qwenproxy] blocks to guarantee zero duplicates
+  content = removeTomlSection(content, "model_providers.qwenproxy");
+  content = content.trimEnd() + (content.length > 0 ? "\n\n" : "") + providerBlock;
 
-    // Set active model if requested
-    if (setActive) {
-      content = updateTopLevelKey(content, "model", model);
-      content = updateTopLevelKey(content, "model_provider", "qwenproxy");
-      content = updateTopLevelKey(content, "model_context_window", 1000000);
-    }
+  // Set active model if requested
+  if (setActive) {
+    content = updateTopLevelKey(content, "model", model);
+    content = updateTopLevelKey(content, "model_provider", "qwenproxy");
+    content = updateTopLevelKey(content, "model_context_window", 1000000);
+  }
 
-    // If a custom model_catalog_json is configured, ensure the target model is listed in it
-    const catalogMatch = content.match(/^model_catalog_json\s*=\s*["']([^"']+)["']/m);
-    if (catalogMatch && catalogMatch[1]) {
-      try {
-        const rawCatalogPath = catalogMatch[1];
-        const catalogPath = path.isAbsolute(rawCatalogPath)
-          ? rawCatalogPath
-          : path.resolve(path.dirname(filePath), rawCatalogPath);
-        if (fs.existsSync(catalogPath)) {
-          const catalog = JSON.parse(fs.readFileSync(catalogPath, "utf-8"));
-          if (Array.isArray(catalog.models)) {
-            const hasModel = catalog.models.some((m: any) => m?.slug === model);
-            if (!hasModel) {
-              const template = catalog.models[0] || {};
-              catalog.models.unshift({
-                ...template,
-                slug: model,
-                display_name: formatModelDisplayName(model),
-                description: `QwenProxy ${model}`,
-                context_window: 1000000,
-                max_context_window: 1000000,
-              });
-              fs.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2), "utf-8");
-            }
+  // If a custom model_catalog_json is configured, ensure the target model is listed in it
+  const catalogMatch = content.match(/^model_catalog_json\s*=\s*["']([^"']+)["']/m);
+  if (catalogMatch && catalogMatch[1]) {
+    try {
+      const rawCatalogPath = catalogMatch[1];
+      const catalogPath = path.isAbsolute(rawCatalogPath)
+        ? rawCatalogPath
+        : path.resolve(path.dirname(targetPath), rawCatalogPath);
+      if (fs.existsSync(catalogPath)) {
+        const catalog = JSON.parse(fs.readFileSync(catalogPath, "utf-8"));
+        if (Array.isArray(catalog.models)) {
+          const hasModel = catalog.models.some((m: any) => m?.slug === model);
+          if (!hasModel) {
+            const template = catalog.models[0] || {};
+            catalog.models.unshift({
+              ...template,
+              slug: model,
+              display_name: formatModelDisplayName(model),
+              description: `QwenProxy ${model}`,
+              context_window: 1000000,
+              max_context_window: 1000000,
+            });
+            fs.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2), "utf-8");
           }
         }
-      } catch {
-        // Non-fatal catalog enhancement
       }
+    } catch {
+      // Non-fatal catalog enhancement
     }
+  }
+
+  fs.writeFileSync(targetPath, content.trimEnd() + "\n", "utf-8");
+  return { backupPath };
+}
 
-    fs.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+export function syncCodex(options: SyncOptions): ClientSyncResult {
+  const { filePath, baseUrl } = options;
+  try {
+    const { backupPath } = syncCodexSingleFile(filePath, options);
+
+    // If an alternate Codex config exists (e.g. ~/.codex/config.toml vs CODEX_HOME/config.toml),
+    // sync it as well so both standard CLI and custom launcher environments are always synchronized.
+    const home = os.homedir();
+    const standardPath = path.join(home, ".codex", "config.toml");
+    const codexHomePath = process.env.CODEX_HOME
+      ? path.join(process.env.CODEX_HOME, "config.toml")
+      : undefined;
+
+    const isStandard =
+      path.resolve(filePath).toLowerCase() === path.resolve(standardPath).toLowerCase();
+    const isCodexHome =
+      Boolean(codexHomePath) &&
+      path.resolve(filePath).toLowerCase() === path.resolve(codexHomePath!).toLowerCase();
+
+    if ((isStandard || isCodexHome) && !isRunningUnderNodeTest()) {
+      const alternatePath = isStandard ? codexHomePath : standardPath;
+      if (
+        alternatePath &&
+        path.resolve(alternatePath).toLowerCase() !== path.resolve(filePath).toLowerCase()
+      ) {
+        try {
+          if (fs.existsSync(alternatePath) || fs.existsSync(path.dirname(alternatePath))) {
+            syncCodexSingleFile(alternatePath, options);
+          }
+        } catch {}
+      }
+    }
 
     return {
       client: "codex",
@@ -116,20 +177,48 @@ export function restoreCodex(filePath: string, backupPath?: string): ClientSyncR
   // If backup was restored but still had qwenproxy (or if no backup was found),
   // strip the QwenProxy provider block cleanly so the file is guaranteed un-synced.
   let manuallyCleaned = false;
-  if (fs.existsSync(filePath)) {
-    try {
-      let content = fs.readFileSync(filePath, "utf-8");
-      if (content.includes("[model_providers.qwenproxy]") || /^model_provider\s*=\s*["']qwenproxy["']/m.test(content)) {
-        const providerRegex = /\[model_providers\.qwenproxy\][\s\S]*?(?=(?:^\[|\Z))/m;
-        content = content.replace(providerRegex, "").trimEnd();
-        content = content.replace(/^model_provider\s*=\s*["']qwenproxy["']\r?\n?/m, "");
-        if (/^model\s*=\s*["']qwen/m.test(content)) {
-          content = content.replace(/^model\s*=\s*["']qwen[^"']*["']\r?\n?/m, "");
+  const cleanSingleFile = (p: string) => {
+    if (fs.existsSync(p)) {
+      try {
+        let content = fs.readFileSync(p, "utf-8");
+        if (
+          content.includes("[model_providers.qwenproxy]") ||
+          /^model_provider\s*=\s*["']qwenproxy["']/m.test(content)
+        ) {
+          content = removeTomlSection(content, "model_providers.qwenproxy");
+          content = content.replace(/^model_provider\s*=\s*["']qwenproxy["']\r?\n?/m, "");
+          if (/^model\s*=\s*["']qwen/m.test(content)) {
+            content = content.replace(/^model\s*=\s*["']qwen[^"']*["']\r?\n?/m, "");
+          }
+          fs.writeFileSync(p, content.trimEnd() + "\n", "utf-8");
+          manuallyCleaned = true;
         }
-        fs.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
-        manuallyCleaned = true;
-      }
-    } catch {}
+      } catch {}
+    }
+  };
+
+  cleanSingleFile(filePath);
+
+  const home = os.homedir();
+  const standardPath = path.join(home, ".codex", "config.toml");
+  const codexHomePath = process.env.CODEX_HOME
+    ? path.join(process.env.CODEX_HOME, "config.toml")
+    : undefined;
+
+  const isStandard =
+    path.resolve(filePath).toLowerCase() === path.resolve(standardPath).toLowerCase();
+  const isCodexHome =
+    Boolean(codexHomePath) &&
+    path.resolve(filePath).toLowerCase() === path.resolve(codexHomePath!).toLowerCase();
+
+  if ((isStandard || isCodexHome) && !isRunningUnderNodeTest()) {
+    const alternatePath = isStandard ? codexHomePath : standardPath;
+    if (
+      alternatePath &&
+      path.resolve(alternatePath).toLowerCase() !== path.resolve(filePath).toLowerCase()
+    ) {
+      cleanSingleFile(alternatePath);
+    }
   }
 
   const success = restoredFromBackup || manuallyCleaned;

package/src/sync/index.ts

@@ -64,7 +64,10 @@ export function resolveApiKey(
     }
     return overrideKey.trim();
   }
-  const envKey = process.env.API_KEY || process.env.ADMIN_PASSWORD || configKey;
+  const envKey =
+    (!isPlaceholderApiKey(process.env.API_KEY) ? process.env.API_KEY : undefined) ||
+    (!isPlaceholderApiKey(process.env.ADMIN_PASSWORD) ? process.env.ADMIN_PASSWORD : undefined) ||
+    configKey;
   if (envKey && !isPlaceholderApiKey(envKey)) {
     return envKey.trim();
   }
@@ -165,7 +168,9 @@ export function getDefaultPaths(): {
 
   return {
     claudeCode: path.join(home, ".claude", "settings.json"),
-    codex: process.env.CODEX_HOME
+    codex: fs.existsSync(path.join(home, ".codex", "config.toml"))
+      ? path.join(home, ".codex", "config.toml")
+      : process.env.CODEX_HOME
       ? path.join(process.env.CODEX_HOME, "config.toml")
       : path.join(home, ".codex", "config.toml"),
     openCode: existingOpenCode || openCodeCandidates[0],

package/src/tools/parser.ts

@@ -629,6 +629,9 @@ function coerceParameterValue(rawValue: string): unknown {
  */
 function extractToolName(openTag: string, block: string): string {
   const combined = `${openTag}\n${block}`;
+  const fnMatch = combined.match(/<function=([^\s>]+)>/i);
+  if (fnMatch) return fnMatch[1].trim();
+
   const attrMatch = combined.match(
     /<tool_call(?:s)?\b[^>]*\bname\s*=\s*["']([^"']+)["']/i,
   );
@@ -640,6 +643,48 @@ function extractToolName(openTag: string, block: string): string {
   return "";
 }
 
+/**
+ * Parse function shorthand XML <function=name><parameter=key>value</parameter></function> format.
+ */
+function parseFunctionShorthandToolCall(
+  block: string,
+  openTag: string,
+  tools: ToolDefinitionLike[],
+): { name: string; arguments: Record<string, unknown> } | null {
+  const combined = `${openTag}\n${block}`;
+  const fnMatch = combined.match(/<function=([^\s>]+)>/i);
+  let toolName = fnMatch ? fnMatch[1].trim() : "";
+
+  const args: Record<string, unknown> = {};
+  const parameterRe = /<parameter=([^\s>]+)>([\s\S]*?)<\/parameter>/gi;
+  let match: RegExpExecArray | null = parameterRe.exec(block);
+  while (match !== null) {
+    args[match[1]] = coerceParameterValue(match[2]);
+    match = parameterRe.exec(block);
+  }
+
+  // Also support <parameter name="..."> inside <function=...>
+  if (Object.keys(args).length === 0) {
+    const namedParamRe =
+      /<parameter\b[^>]*\bname\s*=\s*["']([^"']+)["'][^>]*>([\s\S]*?)<\/parameter>/gi;
+    let namedMatch: RegExpExecArray | null = namedParamRe.exec(block);
+    while (namedMatch !== null) {
+      args[namedMatch[1]] = coerceParameterValue(namedMatch[2]);
+      namedMatch = namedParamRe.exec(block);
+    }
+  }
+
+  if (Object.keys(args).length === 0) return null;
+
+  if (!toolName) {
+    toolName =
+      extractToolName(openTag, block) || inferToolNameFromParameters(args, tools);
+  }
+  if (!toolName) return null;
+
+  return { name: toolName, arguments: args };
+}
+
 /**
  * Infer tool name by matching parameter keys against tool definitions.
  * Only returns a name if exactly one tool matches all argument keys.
@@ -2193,6 +2238,47 @@ export class StreamingToolParser {
       });
     }
 
+    // 0) Try function shorthand format (<function=name><parameter=k>v</parameter></function>)
+    const fnShorthand = parseFunctionShorthandToolCall(
+      t,
+      this.currentOpenTag,
+      this.tools,
+    );
+    if (fnShorthand) {
+      const resolvedName = this.resolveDeclaredToolName(fnShorthand.name);
+      if (!resolvedName) {
+        this.recordMalformedToolCall(content, {
+          undeclaredNames: [fnShorthand.name],
+          category: "undeclared",
+        });
+        this.preserveLiteralToolCall(
+          content,
+          result,
+          `undeclared tool name: ${fnShorthand.name}`,
+        );
+        return;
+      }
+      fnShorthand.name = resolvedName;
+      if (isToolcallDebugEnabled()) {
+        logger.debug(
+          "[parser] processToolContent: function shorthand parsed successfully",
+          {
+            name: fnShorthand.name,
+            arguments: fnShorthand.arguments,
+          },
+        );
+      }
+      this.finalizeSuccessfulToolCall(
+        {
+          id: `call_${crypto.randomUUID()}`,
+          name: fnShorthand.name,
+          arguments: fnShorthand.arguments,
+        },
+        result,
+      );
+      return;
+    }
+
     // 1) Try Hermes-style XML <parameter> format first
     const xmlParsed = parseXmlParameterToolCall(
       t,
@@ -2488,6 +2574,23 @@ export class StreamingToolParser {
       });
     }
 
+    // Try function shorthand format first
+    const fnShorthand = parseFunctionShorthandToolCall(
+      block,
+      this.currentOpenTag,
+      this.tools,
+    );
+    if (fnShorthand) {
+      const resolvedName = this.resolveDeclaredToolName(fnShorthand.name);
+      if (resolvedName) {
+        return {
+          id: `call_${crypto.randomUUID()}`,
+          name: resolvedName,
+          arguments: fnShorthand.arguments,
+        };
+      }
+    }
+
     // Try full parse first
     const xmlParsed = parseXmlParameterToolCall(
       block,

package/src/tools/toolcall-tags.ts

@@ -32,12 +32,12 @@ function tagName(tag: string): string {
 
 /** All accepted open tag names (custom + legacy). */
 export function getOpenNames(): string[] {
-  return Array.from(new Set([tagName(TOOL_CALL_OPEN), "tool_call", "tool_calls"]));
+  return Array.from(new Set([tagName(TOOL_CALL_OPEN), "tool_call", "tool_calls", "function"]));
 }
 
 /** 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"]));
+  return Array.from(new Set([tagName(TOOL_CALL_CLOSE), "tool_call", "tool_calls", "tool", "function"]));
 }
 
 /** Wrap a JSON payload in the canonical open/close tags. */

package/src/tui/server-manager.ts

@@ -282,10 +282,16 @@ export class ServerManager {
     }
     this.restoreLogs();
     try {
+      await stopServer();
       this.state = "offline";
     } catch {}
   }
 
+  public async restart(): Promise<void> {
+    await this.stop();
+    await this.ensureStarted();
+  }
+
   public startRemoteLogStream(host: string, port: number): void {
     if (this.remoteLogAbort) {
       this.remoteLogAbort.abort();

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

@@ -2,6 +2,7 @@
  * QwenProxy TUI - Accounts & Cooldowns Management View (Tab 5)
  */
 
+import crypto from "crypto";
 import type { TuiView, ProxyStatusSnapshot } from "../types.ts";
 import type { KeyEvent } from "../screen.ts";
 import { theme, glyphs, drawBox, pad, truncate, getClipboardText } from "../theme.ts";
@@ -56,6 +57,7 @@ export class AccountsView implements TuiView {
   private statusMessageTimer: NodeJS.Timeout | null = null;
   private isAddModalOpen = false;
   private isBatchModalOpen = false;
+  private isValidatingAccount = false;
   private addEmailInput = "";
   private addPasswordInput = "";
   private addEmailCursor = 0;
@@ -147,6 +149,7 @@ export class AccountsView implements TuiView {
   }
 
   private async saveModalAccount(): Promise<void> {
+    if (this.isValidatingAccount) return;
     const email = this.addEmailInput.trim();
     const password = this.addPasswordInput.trim();
     if (!email || !password) {
@@ -154,17 +157,54 @@ export class AccountsView implements TuiView {
       return;
     }
 
+    if (process.env.NODE_TEST_CONTEXT) {
+      try {
+        const newAcc = addAccount(email, password);
+        this.isAddModalOpen = false;
+        this.addEmailInput = "";
+        this.addPasswordInput = "";
+        this.addEmailCursor = 0;
+        this.addPasswordCursor = 0;
+        await this.refresh();
+        this.setStatusMessage(theme.green(`✓ Conta ${email} salva! Conectando...`));
+      } catch (err: any) {
+        this.setStatusMessage(theme.red(`✗ Erro ao salvar: ${err?.message || String(err)}`));
+      }
+      return;
+    }
+
+    this.isValidatingAccount = true;
+    this.setStatusMessage(theme.yellow(`[...] Validando credenciais para ${email}...`));
+
+    const tempId = crypto.randomUUID();
     try {
-      const newAcc = addAccount(email, password);
+      const { validateAccountLogin } = await import("../../services/playwright.ts");
+      const { wipeAccountSessionFiles } = await import("../../core/accounts.ts");
+      const { clearAccountCooldown } = await import("../../core/account-manager.ts");
+
+      const ok = await validateAccountLogin(
+        { id: tempId, email, password },
+        config.playwright.headless,
+        config.playwright.browser,
+      );
+
+      if (!ok) {
+        wipeAccountSessionFiles(tempId);
+        clearAccountCooldown(tempId);
+        this.setStatusMessage(theme.red(`✗ Falha no login: credenciais inválidas ou bloqueio no Qwen`));
+        return;
+      }
+
+      const newAcc = addAccount(email, password, tempId);
       this.isAddModalOpen = false;
       this.addEmailInput = "";
       this.addPasswordInput = "";
       this.addEmailCursor = 0;
       this.addPasswordCursor = 0;
       await this.refresh();
-      this.setStatusMessage(theme.green(`✓ Conta ${email} salva! Conectando...`));
+      this.setStatusMessage(theme.green(`✓ Conta ${email} validada e salva! Conectando...`));
 
-      if (process.stdout.isTTY && !process.env.NODE_TEST_CONTEXT) {
+      if (process.stdout.isTTY) {
         const sManager = ServerManager.getInstance();
         const sState = sManager.getState();
         if (sState !== "online" && sState !== "warming") {
@@ -189,7 +229,13 @@ export class AccountsView implements TuiView {
         }
       }
     } catch (err: any) {
-      this.setStatusMessage(theme.red(`✗ Erro ao salvar: ${err?.message || String(err)}`));
+      const { wipeAccountSessionFiles } = await import("../../core/accounts.ts");
+      const { clearAccountCooldown } = await import("../../core/account-manager.ts");
+      wipeAccountSessionFiles(tempId);
+      clearAccountCooldown(tempId);
+      this.setStatusMessage(theme.red(`✗ Erro ao validar: ${err?.message || String(err)}`));
+    } finally {
+      this.isValidatingAccount = false;
     }
   }
   private async saveBatchAccounts(): Promise<void> {
@@ -445,6 +491,7 @@ export class AccountsView implements TuiView {
 
     // 1. Add Account Modal Active
     if (this.isAddModalOpen) {
+      if (this.isValidatingAccount) return true;
       if (key.name === "escape") {
         this.isAddModalOpen = false;
         this.addEmailInput = "";
@@ -1161,8 +1208,9 @@ export class AccountsView implements TuiView {
           ? (passHover ? theme.bgHover(` ${maskedPass} `) : theme.cyan(` ${maskedPass} `))
           : (passHover ? theme.bgHover(" (digite a senha) ") : theme.muted(" (digite a senha) "));
       }
-      const saveBtn =
-        this.modalHoveredField === "save"
+      const saveBtn = this.isValidatingAccount
+        ? theme.yellow(" [ Validando... ] ")
+        : this.modalHoveredField === "save"
           ? theme.bgHover(theme.green(" [ Enter ] Salvar "))
           : theme.green("[ Enter ] Salvar");
 

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

@@ -469,26 +469,10 @@ export class LogsView implements TuiView {
     if (singleLineOnly && this.selectedLogIndex !== null && rawEntries[this.selectedLogIndex]) {
       const entry = rawEntries[this.selectedLogIndex];
       text = `[${entry.time}] [${entry.level}] ${entry.message}`;
-    } else {
-      // For full copy of "all" filter, prefer the complete persistent file from disk if available
-      if (this.filter === "all" && !isRunningUnderNodeTest()) {
-        try {
-          const logPath = getServerLogFilePath();
-          if (fs.existsSync(logPath)) {
-            const diskContent = fs.readFileSync(logPath, "utf-8");
-            if (diskContent && diskContent.trim().length > 0) {
-              text = diskContent.trim();
-            }
-          }
-        } catch {}
-      }
-
-      // Fallback to memory buffer if disk log is empty or on filtered view
-      if (!text && rawEntries.length > 0) {
-        text = rawEntries
-          .map((entry) => `[${entry.time}] [${entry.level}] ${entry.message}`)
-          .join("\n");
-      }
+    } else if (rawEntries.length > 0) {
+      text = rawEntries
+        .map((entry) => `[${entry.time}] [${entry.level}] ${entry.message}`)
+        .join("\n");
     }
 
     if (!text) return;