@qwen-code/qwen-code 0.18.5-nightly.20260622.6bc3f853e → 0.18.5-preview.0

package/chunks/{askUserQuestion-WHVYL2S2.js → askUserQuestion-HF7HCWDD.js}

@@ -9,10 +9,10 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-GOMVJKBL.js";
+} from "./chunk-L7U2RI5O.js";
 import {
   createDebugLogger
-} from "./chunk-WE6TNQJU.js";
+} from "./chunk-C4K3FEQ2.js";
 import "./chunk-Z2Z3GUXZ.js";
 import {
   init_esbuild_shims
@@ -24,6 +24,14 @@ import {
 // packages/core/src/tools/askUserQuestion.ts
 init_esbuild_shims();
 var debugLogger = createDebugLogger("ASK_USER_QUESTION");
+function parseAnswerQuestionIndex(key, questionCount) {
+  const index = Number(key);
+  if (!Number.isSafeInteger(index) || index < 0 || index >= questionCount || String(index) !== key) {
+    return void 0;
+  }
+  return index;
+}
+__name(parseAnswerQuestionIndex, "parseAnswerQuestionIndex");
 var askUserQuestionToolDescription = `Use this tool when you need to ask the user questions during execution. This allows you to:
 1. Gather user preferences or requirements
 2. Clarify ambiguous instructions
@@ -175,18 +183,23 @@ var AskUserQuestionToolInvocation = class extends BaseToolInvocation {
           returnDisplay: cancellationMessage
         };
       }
-      const answersContent = Object.entries(this.userAnswers).map(([key, value]) => {
-        const questionIndex = parseInt(key, 10);
+      const answersContent = Object.entries(this.userAnswers).flatMap(([key, value]) => {
+        const questionIndex = parseAnswerQuestionIndex(
+          key,
+          this.params.questions.length
+        );
+        if (questionIndex === void 0) return [];
         const question = this.params.questions[questionIndex];
-        return `**${question?.header || `Question ${questionIndex + 1}`}**: ${value}`;
+        return `**${question.header || `Question ${questionIndex + 1}`}**: ${value}`;
       }).join("\n");
       this.applyPlanGateMetadata();
+      const messageBody = answersContent.length > 0 ? answersContent : "No valid answers were provided.";
       const llmMessage = `User has provided the following answers:
 
-${answersContent}`;
+${messageBody}`;
       const displayMessage = `User has provided the following answers:
 
-${answersContent}`;
+${messageBody}`;
       return {
         llmContent: llmMessage,
         returnDisplay: displayMessage

package/chunks/chunk-22IFUCVR.js

@@ -0,0 +1,291 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/browser.ts
+init_esbuild_shims();
+var browserBlocklist = ["www-browser"];
+function isBrowserCommandBlocked(command) {
+  const commandName = command.replace(/\\/g, "/").split("/").pop();
+  return !!commandName && browserBlocklist.includes(commandName);
+}
+__name(isBrowserCommandBlocked, "isBrowserCommandBlocked");
+function shouldAttemptBrowserLaunch(options = {}) {
+  const browserEnv = process.env["BROWSER"]?.trim();
+  const browserCommand = browserEnv?.match(/^\S+/)?.[0];
+  if (!options.ignoreBrowserBlocklist && process.platform !== "win32" && browserCommand && isBrowserCommandBlocked(browserCommand)) {
+    return false;
+  }
+  if (process.env["CI"] || process.env["DEBIAN_FRONTEND"] === "noninteractive") {
+    return false;
+  }
+  const isSSH = !!process.env["SSH_CONNECTION"];
+  if (process.platform === "linux") {
+    const displayVariables = ["DISPLAY", "WAYLAND_DISPLAY", "MIR_SOCKET"];
+    const hasDisplay = displayVariables.some((v) => !!process.env[v]);
+    if (!hasDisplay) {
+      return false;
+    }
+  }
+  if (isSSH && process.platform !== "linux") {
+    return false;
+  }
+  return true;
+}
+__name(shouldAttemptBrowserLaunch, "shouldAttemptBrowserLaunch");
+
+// packages/core/src/utils/secure-browser-launcher.ts
+init_esbuild_shims();
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { platform } from "node:os";
+import { resolve } from "node:path";
+import { URL, fileURLToPath } from "node:url";
+var execFileAsync = promisify(execFile);
+function validateUrl(url, { allowFile = false, allowedFilePaths } = {}) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch (_error) {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  const allowedProtocols = allowFile ? ["http:", "https:", "file:"] : ["http:", "https:"];
+  if (!allowedProtocols.includes(parsedUrl.protocol)) {
+    throw new Error(
+      `Unsafe protocol: ${parsedUrl.protocol}. Only ${allowedProtocols.join(
+        ", "
+      )} are allowed.`
+    );
+  }
+  if (parsedUrl.protocol === "file:" && allowFile) {
+    if (!allowedFilePaths?.length) {
+      throw new Error("allowedFilePaths is required when allowFile is true");
+    }
+    const requestedPath = resolve(fileURLToPath(parsedUrl));
+    const allowed = allowedFilePaths.map((filePath) => resolve(filePath));
+    if (!allowed.includes(requestedPath)) {
+      throw new Error("File URL is not in the allowed file set");
+    }
+  }
+  if (/[\r\n\x00-\x1f]/.test(url)) {
+    throw new Error("URL contains invalid characters");
+  }
+}
+__name(validateUrl, "validateUrl");
+async function openBrowserSecurely(url, browserOptions = {}) {
+  validateUrl(url, browserOptions);
+  const platformName = platform();
+  let command;
+  let args;
+  const browserEnv = process.env["BROWSER"]?.trim();
+  const browserCommand = platformName === "win32" ? void 0 : buildBrowserCommand(browserEnv, url);
+  if (browserCommand) {
+    try {
+      await launchDetached(browserCommand.command, browserCommand.args);
+      return;
+    } catch (_error) {
+      console.warn(
+        `Failed to open BROWSER command ${browserCommand.command}: ${formatLaunchError(
+          _error
+        )}. Falling back to the platform browser opener.`
+      );
+    }
+  }
+  if (!shouldAttemptBrowserLaunch({ ignoreBrowserBlocklist: true })) {
+    console.warn(
+      `Browser launch is not available in this environment. Please open this URL manually: ${url}`
+    );
+    return;
+  }
+  {
+    switch (platformName) {
+      case "darwin":
+        command = "open";
+        args = [url];
+        break;
+      case "win32":
+        command = "powershell.exe";
+        args = [
+          "-NoProfile",
+          "-NonInteractive",
+          "-WindowStyle",
+          "Hidden",
+          "-Command",
+          `Start-Process '${url.replace(/'/g, "''")}'`
+        ];
+        break;
+      case "linux":
+      case "freebsd":
+      case "openbsd":
+        command = "xdg-open";
+        args = [url];
+        break;
+      default:
+        throw new Error(`Unsupported platform: ${platformName}`);
+    }
+  }
+  const execOptions = {
+    // Don't inherit parent's environment to avoid potential issues
+    env: {
+      ...process.env,
+      // Ensure we're not in a shell that might interpret special characters
+      SHELL: void 0
+    },
+    // Detach the browser process so it doesn't block
+    detached: true,
+    stdio: "ignore"
+  };
+  try {
+    await execFileAsync(command, args, execOptions);
+  } catch (_error) {
+    if ((platformName === "linux" || platformName === "freebsd" || platformName === "openbsd") && command === "xdg-open") {
+      const fallbackCommands = [
+        { command: "gnome-open", detached: false },
+        { command: "kde-open", detached: false },
+        { command: "firefox", detached: true },
+        { command: "chromium", detached: true },
+        { command: "google-chrome", detached: true },
+        { command: "microsoft-edge", detached: true }
+      ];
+      for (const { command: fallbackCommand, detached } of fallbackCommands) {
+        try {
+          if (detached) {
+            await launchDetached(fallbackCommand, [url]);
+          } else {
+            await execFileAsync(fallbackCommand, [url], execOptions);
+          }
+          return;
+        } catch {
+          continue;
+        }
+      }
+    }
+    console.warn(
+      `Failed to open browser automatically. Please open this URL manually: ${url}`
+    );
+    return;
+  }
+}
+__name(openBrowserSecurely, "openBrowserSecurely");
+async function launchDetached(command, args) {
+  const spawnOptions = {
+    env: {
+      ...process.env,
+      SHELL: void 0
+    },
+    detached: true,
+    stdio: "ignore"
+  };
+  await new Promise((resolve2, reject) => {
+    const child = spawn(command, args, spawnOptions);
+    let settled = false;
+    child.once("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(error);
+    });
+    child.once("spawn", () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.unref();
+      resolve2();
+    });
+  });
+}
+__name(launchDetached, "launchDetached");
+function formatLaunchError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(formatLaunchError, "formatLaunchError");
+function buildBrowserCommand(browserEnv, url) {
+  if (!browserEnv) {
+    return void 0;
+  }
+  const browserCommand = parseBrowserCommand(browserEnv);
+  if (!browserCommand) {
+    console.warn(
+      "Invalid BROWSER environment variable, falling back to platform default."
+    );
+    return void 0;
+  }
+  if (isBrowserCommandBlocked(browserCommand.command)) {
+    return void 0;
+  }
+  let usedPlaceholder = false;
+  const args = browserCommand.args.map((arg) => {
+    if (!arg.includes("%s")) {
+      return arg;
+    }
+    usedPlaceholder = true;
+    return arg.replace(/%s/g, () => url);
+  });
+  if (!usedPlaceholder) {
+    args.push(url);
+  }
+  return { command: browserCommand.command, args };
+}
+__name(buildBrowserCommand, "buildBrowserCommand");
+function parseBrowserCommand(browserEnv) {
+  const parts = [];
+  let current = "";
+  let quote;
+  for (const char of browserEnv) {
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (quote) {
+    return void 0;
+  }
+  if (current) {
+    parts.push(current);
+  }
+  const [command, ...args] = parts;
+  if (!command) {
+    return void 0;
+  }
+  return { command, args };
+}
+__name(parseBrowserCommand, "parseBrowserCommand");
+function shouldLaunchBrowser() {
+  return shouldAttemptBrowserLaunch();
+}
+__name(shouldLaunchBrowser, "shouldLaunchBrowser");
+
+export {
+  isBrowserCommandBlocked,
+  shouldAttemptBrowserLaunch,
+  openBrowserSecurely,
+  shouldLaunchBrowser
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-26ZYKTYZ.js → chunk-2BIF2NVV.js}

@@ -10,11 +10,11 @@ import {
 } from "./chunk-LD2XBG6Z.js";
 import {
   atomicWriteJSON
-} from "./chunk-LTN3VYMZ.js";
+} from "./chunk-3UALQ56H.js";
 import {
   Storage,
   isNodeError
-} from "./chunk-WE6TNQJU.js";
+} from "./chunk-C4K3FEQ2.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-VKILGMZQ.js → chunk-2QDQTWCI.js}

@@ -5,7 +5,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-GOMVJKBL.js";
+} from "./chunk-L7U2RI5O.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-XGU3ETVO.js → chunk-3BR4OIOE.js}

@@ -15,15 +15,15 @@ import {
   readCronTasks,
   removeCronTasks,
   updateCronTasks
-} from "./chunk-C6MI2ASN.js";
+} from "./chunk-GZCJS5WH.js";
 import {
   ToolNames
-} from "./chunk-GOMVJKBL.js";
+} from "./chunk-L7U2RI5O.js";
 import {
   Storage,
   createDebugLogger,
   getProjectHash
-} from "./chunk-WE6TNQJU.js";
+} from "./chunk-C4K3FEQ2.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-LTN3VYMZ.js → chunk-3UALQ56H.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-WE6TNQJU.js";
+} from "./chunk-C4K3FEQ2.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-QBUR6J4B.js → chunk-BC5POO46.js}

@@ -2,24 +2,24 @@
 "use strict";
 import {
   t
-} from "./chunk-EJ6NFQ2L.js";
+} from "./chunk-ZC675NGC.js";
 import {
   computeThresholds,
   getCoreSystemPrompt
-} from "./chunk-CXZV4Q4J.js";
+} from "./chunk-ZXNEOCW2.js";
 import {
   buildSkillLlmContent
-} from "./chunk-ID533GA3.js";
+} from "./chunk-OTBK43JR.js";
 import {
   DiscoveredMCPTool,
   uiTelemetryService
-} from "./chunk-GM3LTU6K.js";
+} from "./chunk-UMRZ7XCR.js";
 import {
   ToolNames
-} from "./chunk-GOMVJKBL.js";
+} from "./chunk-L7U2RI5O.js";
 import {
   DEFAULT_TOKEN_LIMIT
-} from "./chunk-G4BUMVEY.js";
+} from "./chunk-F6XNTYNE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -568,7 +568,8 @@ async function collectContextData(config, showDetails) {
   const modelName = config.getModel() || "unknown";
   const contentGeneratorConfig = config.getContentGeneratorConfig();
   const contextWindowSize = contentGeneratorConfig.contextWindowSize ?? DEFAULT_TOKEN_LIMIT;
-  const apiTotalTokens = uiTelemetryService.getLastPromptTokenCount();
+  const geminiClient = config.getGeminiClient?.();
+  const apiTotalTokens = geminiClient?.isInitialized?.() ? geminiClient.getChat().getLastPromptTokenCount() : uiTelemetryService.getLastPromptTokenCount();
   const apiCachedTokens = uiTelemetryService.getLastCachedContentTokenCount();
   const systemPromptText = getCoreSystemPrompt(void 0, modelName);
   const systemPromptTokens = estimateTokens(systemPromptText);