@qwen-code/qwen-code 0.19.6 → 0.19.7-nightly.20260708.394c1a289

package/chunks/chunk-2FHWCKWA.js

@@ -0,0 +1,262 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  appEvents
+} from "./chunk-YMWIKAEE.js";
+import {
+  require_undici
+} from "./chunk-54YZOP7P.js";
+import {
+  getAllProviderBaseUrls
+} from "./chunk-E7HM76PR.js";
+import {
+  initializeTelemetry
+} from "./chunk-7I4MGFBN.js";
+import {
+  detectRuntime,
+  getOrCreateSharedDispatcher,
+  redactProxyCredentials
+} from "./chunk-H6EMK6QK.js";
+import {
+  createDebugLogger
+} from "./chunk-22MNNNXE.js";
+import {
+  recordStartupEvent
+} from "./chunk-ITOGNELQ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/startup/startup-prefetch.ts
+init_esbuild_shims();
+
+// packages/cli/src/utils/apiPreconnect.ts
+init_esbuild_shims();
+var import_undici = __toESM(require_undici(), 1);
+var debugLogger = createDebugLogger("PRECONNECT");
+var preconnectFired = false;
+var DEFAULT_BASE_URLS = {
+  openai: "https://api.openai.com",
+  "qwen-oauth": "https://coding.dashscope.aliyuncs.com",
+  anthropic: "https://api.anthropic.com",
+  dashscope: "https://dashscope.aliyuncs.com"
+};
+var ALL_DEFAULT_URLS = [
+  ...Object.values(DEFAULT_BASE_URLS),
+  ...getAllProviderBaseUrls()
+];
+function shouldSkipPreconnect() {
+  if (process.env["NODE_EXTRA_CA_CERTS"]) {
+    debugLogger.debug("Skipping preconnect: custom CA certificate configured");
+    return true;
+  }
+  return false;
+}
+__name(shouldSkipPreconnect, "shouldSkipPreconnect");
+function isInSandboxMode() {
+  return process.env["SANDBOX"] !== void 0;
+}
+__name(isInSandboxMode, "isInSandboxMode");
+function isDefaultBaseUrl(baseUrl) {
+  const normalizedInput = baseUrl.toLowerCase().replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  return ALL_DEFAULT_URLS.some((defaultUrl) => {
+    const normalizedDefault = defaultUrl.toLowerCase().replace(/^https?:\/\//, "").replace(/\/+$/, "");
+    return normalizedInput === normalizedDefault || normalizedInput.startsWith(normalizedDefault + "/");
+  });
+}
+__name(isDefaultBaseUrl, "isDefaultBaseUrl");
+function getPreconnectTargetUrl(authType, resolvedBaseUrl) {
+  if (resolvedBaseUrl && /^https?:\/\//i.test(resolvedBaseUrl)) {
+    if (isDefaultBaseUrl(resolvedBaseUrl)) {
+      return resolvedBaseUrl;
+    }
+    debugLogger.debug(
+      "Skipping preconnect: resolved baseUrl is not a default URL"
+    );
+    return void 0;
+  }
+  if (authType && DEFAULT_BASE_URLS[authType]) {
+    return DEFAULT_BASE_URLS[authType];
+  }
+  return void 0;
+}
+__name(getPreconnectTargetUrl, "getPreconnectTargetUrl");
+function preconnectApi(authType, options = {}) {
+  if (preconnectFired) {
+    return;
+  }
+  if (process.env["QWEN_CODE_DISABLE_PRECONNECT"] === "1") {
+    debugLogger.debug("Preconnect disabled by environment variable");
+    preconnectFired = true;
+    return;
+  }
+  if (isInSandboxMode()) {
+    debugLogger.debug("Skipping preconnect: sandbox mode detected");
+    preconnectFired = true;
+    return;
+  }
+  if (shouldSkipPreconnect()) {
+    preconnectFired = true;
+    return;
+  }
+  if (detectRuntime() !== "node") {
+    debugLogger.debug("Skipping preconnect: unsupported runtime");
+    preconnectFired = true;
+    return;
+  }
+  if (!options.proxy) {
+    debugLogger.debug("Skipping preconnect dispatcher: no proxy configured");
+    return;
+  }
+  const proxy = options.proxy;
+  const targetUrl = getPreconnectTargetUrl(authType, options.resolvedBaseUrl);
+  if (!targetUrl) {
+    debugLogger.debug("No target URL for preconnect");
+    return;
+  }
+  preconnectFired = true;
+  debugLogger.debug(`Preconnecting to: ${targetUrl}`);
+  try {
+    const dispatcher = getOrCreateSharedDispatcher(proxy);
+    (0, import_undici.fetch)(targetUrl, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5e3),
+      headers: {
+        "User-Agent": "QwenCode-Preconnect/1.0"
+      },
+      dispatcher
+    }).then(() => {
+      debugLogger.debug("Preconnect completed");
+    }).catch((error) => {
+      const redactedError = redactProxyCredentials(String(error));
+      debugLogger.debug(`Preconnect failed (ignored): ${redactedError}`);
+    });
+  } catch (error) {
+    const redactedError = redactProxyCredentials(String(error));
+    debugLogger.debug(`Preconnect failed (ignored): ${redactedError}`);
+  }
+}
+__name(preconnectApi, "preconnectApi");
+
+// packages/cli/src/startup/startup-prefetch.ts
+var debugLogger2 = createDebugLogger("STARTUP_PREFETCH");
+var DEFERRED_IDE_CONNECT_TIMEOUT_MS = 1e4;
+var earlyStarted = /* @__PURE__ */ new WeakSet();
+var postRenderStarted = /* @__PURE__ */ new WeakSet();
+function withTimeout(promise, name, timeoutMs) {
+  let timeoutId;
+  let timedOut = false;
+  const timeout = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      timedOut = true;
+      reject(new Error(`${name} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timeoutId.unref?.();
+  });
+  promise.catch((err) => {
+    if (timedOut) {
+      debugLogger2.debug(`${name} underlying error after timeout:`, err);
+    }
+  });
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  });
+}
+__name(withTimeout, "withTimeout");
+function runDeferredTask(name, task) {
+  recordStartupEvent("startup_prefetch_started", { name });
+  void Promise.resolve().then(task).then(() => {
+    recordStartupEvent("startup_prefetch_completed", { name });
+  }).catch((err) => {
+    recordStartupEvent("startup_prefetch_failed", { name });
+    debugLogger2.warn(`${name} failed:`, err);
+  });
+}
+__name(runDeferredTask, "runDeferredTask");
+function startEarlyStartupPrefetches(config) {
+  if (earlyStarted.has(config)) return;
+  earlyStarted.add(config);
+  try {
+    const modelsConfig = config.getModelsConfig();
+    const authType = modelsConfig.getCurrentAuthType();
+    const resolvedBaseUrl = modelsConfig.getGenerationConfig().baseUrl;
+    const proxy = config.getProxy();
+    preconnectApi(authType, { resolvedBaseUrl, proxy });
+  } catch (error) {
+    debugLogger2.debug(
+      `Preconnect skipped due to error getting authType: ${error}`
+    );
+  }
+}
+__name(startEarlyStartupPrefetches, "startEarlyStartupPrefetches");
+function startPostRenderPrefetches(config, settings, options = {}) {
+  if (postRenderStarted.has(config)) return;
+  postRenderStarted.add(config);
+  if (settings.merged.general?.enableAutoUpdate !== false) {
+    runDeferredTask("update_check", async () => {
+      const [{ checkForUpdates }, { handleAutoUpdate }] = await Promise.all([
+        import("./updateCheck-RIK2YIQE.js"),
+        import("./handleAutoUpdate-4IVRMRG4.js")
+      ]);
+      const info = await checkForUpdates();
+      handleAutoUpdate(info, settings, config.getProjectRoot());
+    });
+  }
+  if (options.connectIde && config.getIdeMode()) {
+    runDeferredTask("ide_connect", async () => {
+      appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
+        state: "connecting"
+      });
+      try {
+        const { connectIdeForStartup } = await import("./initializer-DVNCPVTC.js");
+        await withTimeout(
+          connectIdeForStartup(config),
+          "ide_connect",
+          DEFERRED_IDE_CONNECT_TIMEOUT_MS
+        );
+        appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
+          state: "connected"
+        });
+      } catch (err) {
+        appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
+          state: "failed",
+          message: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    });
+  }
+  if (options.initializeTelemetry) {
+    runDeferredTask("telemetry_init", () => {
+      initializeTelemetry(config);
+    });
+  }
+  if (config.isInteractive()) {
+    runDeferredTask("background_housekeeping", async () => {
+      const { startBackgroundHousekeeping } = await import("./scheduler-FQR4XA7J.js");
+      startBackgroundHousekeeping(config, settings);
+    });
+  }
+}
+__name(startPostRenderPrefetches, "startPostRenderPrefetches");
+
+export {
+  startEarlyStartupPrefetches,
+  startPostRenderPrefetches
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */