@qwen-code/qwen-code 0.22.3 → 0.23.0

package/chunks/chunk-KOGW3YWJ.js

@@ -0,0 +1,2054 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  reportChatRecordingFailureToAdapter
+} from "./chunk-5Q5RC2WE.js";
+import {
+  StreamJsonOutputAdapter
+} from "./chunk-UAKRDON5.js";
+import {
+  ICON
+} from "./chunk-HJBHMANB.js";
+import {
+  theme
+} from "./chunk-PDAKFU7M.js";
+import {
+  require_jsx_runtime
+} from "./chunk-SV5PQVQE.js";
+import {
+  Box_default,
+  Text
+} from "./chunk-O4KNCAX4.js";
+import {
+  require_react
+} from "./chunk-5QWWOFGG.js";
+import {
+  createLoadedSettingsAdapter
+} from "./chunk-32LU3APX.js";
+import {
+  SettingScope,
+  settingExistsInScope
+} from "./chunk-VWTSRH6C.js";
+import {
+  t
+} from "./chunk-I4NRYS6A.js";
+import {
+  Logger,
+  applyProviderInstallPlan,
+  buildInstallPlan,
+  getDefaultBaseUrlForProtocol,
+  getDefaultModelIds,
+  resolveBaseUrl,
+  shouldShowStep
+} from "./chunk-JUARRUMA.js";
+import {
+  qwenOAuth2Events,
+  sanitizeForOsc
+} from "./chunk-3AKCBZVW.js";
+import {
+  allowEditorTypeInSandbox,
+  checkHasEditorType
+} from "./chunk-4F7GQGXB.js";
+import {
+  AuthEvent,
+  logAuth
+} from "./chunk-GH2S4GD5.js";
+import {
+  createDebugLogger,
+  getErrorMessage
+} from "./chunk-EAHOJF6V.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/utils/windowTitle.ts
+init_esbuild_shims();
+var DEFAULT_WINDOW_TITLE = "qwen";
+var MULTIPLEXER_ENV_KEYS = ["TMUX", "STY", "ZELLIJ", "DVTM"];
+function sanitizeWindowTitle(title) {
+  return sanitizeForOsc(title);
+}
+__name(sanitizeWindowTitle, "sanitizeWindowTitle");
+function computeWindowTitle(folderName) {
+  return sanitizeWindowTitle(
+    process.env["CLI_TITLE"] || `Qwen - ${folderName || DEFAULT_WINDOW_TITLE}`
+  );
+}
+__name(computeWindowTitle, "computeWindowTitle");
+function writeTerminalTitle(write, title) {
+  const clean = sanitizeWindowTitle(title);
+  if (process.platform === "win32") {
+    process.title = clean;
+  }
+  const inMultiplexer = MULTIPLEXER_ENV_KEYS.some((k) => !!process.env[k]);
+  if (clean.length === 0) {
+    if (inMultiplexer) {
+      write("\x1B]2;\x07");
+    } else {
+      write("\x1B]0;\x07\x1B]2;\x07");
+    }
+    return;
+  }
+  if (inMultiplexer) {
+    write(`\x1B]2;${clean}\x07`);
+  } else {
+    const padded = clean.substring(0, 80).padEnd(80, " ");
+    write(`\x1B]0;${padded}\x07\x1B]2;${padded}\x07`);
+  }
+}
+__name(writeTerminalTitle, "writeTerminalTitle");
+function formatSessionWindowTitle(sessionName, folderName, statusPrefix = "") {
+  const base = sessionName ? sanitizeWindowTitle(sessionName) : computeWindowTitle(folderName);
+  return sanitizeWindowTitle(statusPrefix + base);
+}
+__name(formatSessionWindowTitle, "formatSessionWindowTitle");
+function titleStatusPrefix(streamingState) {
+  switch (streamingState) {
+    case "responding" /* Responding */:
+      return `${ICON.CIRCLE_LEFT_HALF} `;
+    case "waiting_for_confirmation" /* WaitingForConfirmation */:
+      return `${ICON.SPARKLE} `;
+    default:
+      return "";
+  }
+}
+__name(titleStatusPrefix, "titleStatusPrefix");
+
+// packages/cli/src/ui/hooks/useLogger.ts
+init_esbuild_shims();
+var import_react = __toESM(require_react(), 1);
+var useLogger = /* @__PURE__ */ __name((storage, sessionId) => {
+  const [logger, setLogger] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    if (!sessionId) {
+      return;
+    }
+    let cancelled = false;
+    const newLogger = new Logger(sessionId, storage);
+    newLogger.initialize().then(() => {
+      if (!cancelled) {
+        setLogger(newLogger);
+      }
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [storage, sessionId]);
+  return logger;
+}, "useLogger");
+
+// packages/cli/src/dualOutput/DualOutputBridge.ts
+init_esbuild_shims();
+import {
+  createWriteStream,
+  fstatSync,
+  openSync,
+  constants
+} from "node:fs";
+
+// packages/cli/src/nonInteractive/io/index.ts
+init_esbuild_shims();
+
+// packages/cli/src/dualOutput/DualOutputBridge.ts
+var debugLogger = createDebugLogger("DUAL_OUTPUT");
+var SUPPORTED_EVENTS = [
+  "system",
+  "user",
+  "assistant",
+  "stream_event",
+  "result",
+  "control_request",
+  "control_response"
+];
+var DUAL_OUTPUT_PROTOCOL_VERSION = 2;
+var MAX_BUFFERED_BYTES = 1024 * 1024;
+var DualOutputBridge = class {
+  static {
+    __name(this, "DualOutputBridge");
+  }
+  adapter;
+  stream;
+  sessionId;
+  active = true;
+  shutdownPromise = null;
+  unsubscribeRecordingFailure;
+  constructor(config, target, options = {}) {
+    this.sessionId = config.getSessionId();
+    if ("fd" in target) {
+      if (target.fd <= 2) {
+        throw new Error(
+          `--json-fd ${target.fd}: file descriptors 0 (stdin), 1 (stdout), and 2 (stderr) are reserved. Use fd 3 or higher.`
+        );
+      }
+      try {
+        fstatSync(target.fd);
+      } catch {
+        throw new Error(
+          `--json-fd ${target.fd}: file descriptor is not open. The caller must provide this fd via spawn stdio configuration or shell redirection (e.g., 3>/tmp/events.jsonl).`
+        );
+      }
+      this.stream = createWriteStream("", { fd: target.fd });
+    } else {
+      try {
+        const fd = openSync(
+          target.filePath,
+          constants.O_WRONLY | constants.O_NONBLOCK
+        );
+        this.stream = createWriteStream("", { fd });
+      } catch (err) {
+        const code = err.code;
+        if (code === "ENXIO") {
+          try {
+            const fd = openSync(
+              target.filePath,
+              constants.O_RDWR | constants.O_NONBLOCK
+            );
+            this.stream = createWriteStream("", { fd });
+          } catch (retryErr) {
+            if (retryErr.code === "EACCES") {
+              throw new Error(
+                `--json-file "${target.filePath}": permission denied opening FIFO for read-write. Check read/write permissions on the file and its parent directories, or start a reader before launching Qwen Code.`
+              );
+            }
+            throw retryErr;
+          }
+        } else if (code === "ENOENT") {
+          this.stream = createWriteStream(target.filePath, { flags: "w" });
+        } else {
+          throw err;
+        }
+      }
+    }
+    this.stream.on("error", (err) => {
+      const code = err.code;
+      if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+        debugLogger.warn("DualOutput: consumer disconnected, disabling");
+      } else if (code === "ERR_SYSTEM_ERROR") {
+        debugLogger.warn(
+          "DualOutput: system error on stream, disabling:",
+          err.message
+        );
+      } else {
+        debugLogger.error("DualOutput stream error:", err);
+      }
+      this.active = false;
+    });
+    this.adapter = new StreamJsonOutputAdapter(
+      config,
+      true,
+      // includePartialMessages — always emit streaming events
+      this.stream
+    );
+    this.unsubscribeRecordingFailure = typeof config.onChatRecordingFailure === "function" ? config.onChatRecordingFailure((event) => {
+      this.emitRecordingFailure(event);
+    }) : () => {
+    };
+    try {
+      this.adapter.emitSystemMessage("session_start", {
+        session_id: this.sessionId,
+        cwd: process.cwd(),
+        protocol_version: DUAL_OUTPUT_PROTOCOL_VERSION,
+        version: options.version,
+        supported_events: [...SUPPORTED_EVENTS]
+      });
+    } catch (err) {
+      debugLogger.error("DualOutput session_start error:", err);
+      this.active = false;
+    }
+  }
+  processEvent(event) {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      this.adapter.processEvent(event);
+    } catch (err) {
+      debugLogger.error("DualOutput processEvent error:", err);
+      this.active = false;
+    }
+  }
+  startAssistantMessage() {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      this.adapter.startAssistantMessage();
+    } catch (err) {
+      debugLogger.error("DualOutput startAssistantMessage error:", err);
+      this.active = false;
+    }
+  }
+  finalizeAssistantMessage() {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      this.adapter.finalizeAssistantMessage();
+    } catch (err) {
+      debugLogger.error("DualOutput finalizeAssistantMessage error:", err);
+      this.active = false;
+    }
+  }
+  emitUserMessage(parts) {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      this.adapter.emitUserMessage(parts);
+    } catch (err) {
+      debugLogger.error("DualOutput emitUserMessage error:", err);
+      this.active = false;
+    }
+  }
+  emitToolResult(request, response) {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      this.adapter.emitToolResult(request, response);
+    } catch (err) {
+      debugLogger.error("DualOutput emitToolResult error:", err);
+      this.active = false;
+    }
+  }
+  /** Whether the underlying stream is still writable. */
+  get isConnected() {
+    return this.active;
+  }
+  disableIfBufferOverflowed() {
+    if (this.stream.writableLength > MAX_BUFFERED_BYTES) {
+      debugLogger.warn(
+        "DualOutput: buffered data exceeds limit, disabling (no consumer draining?)"
+      );
+      this.active = false;
+      this.stream.destroy();
+    }
+  }
+  /**
+   * Emits a `can_use_tool` permission request so an external consumer can
+   * approve or deny the tool call. Pairs with {@link emitControlResponse}.
+   */
+  emitPermissionRequest(requestId, toolName, toolUseId, input, blockedPath = null, permissionSuggestions = null) {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      this.adapter.emitPermissionRequest(
+        requestId,
+        toolName,
+        toolUseId,
+        input,
+        blockedPath,
+        permissionSuggestions
+      );
+    } catch (err) {
+      debugLogger.error("DualOutput emitPermissionRequest error:", err);
+      this.active = false;
+    }
+  }
+  /**
+   * Emits the result of a permission decision (made either in the TUI or by
+   * the external consumer) so all observers stay in sync.
+   */
+  emitControlResponse(requestId, allowed) {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      this.adapter.emitControlResponse(requestId, allowed);
+    } catch (err) {
+      debugLogger.error("DualOutput emitControlResponse error:", err);
+      this.active = false;
+    }
+  }
+  /**
+   * Emits a `control_response` with subtype `error` — used when an external
+   * `confirmation_response` cannot be satisfied (unknown request_id, the
+   * tool call already resolved, stream already closed, etc.). Lets
+   * consumers retry or surface the error instead of silently hanging.
+   */
+  emitControlError(requestId, message) {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      this.adapter.emitControlError(requestId, message);
+    } catch (err) {
+      debugLogger.error("DualOutput emitControlError error:", err);
+      this.active = false;
+    }
+  }
+  /** General-purpose system event escape hatch. */
+  emitSystemMessage(subtype, data) {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      this.adapter.emitSystemMessage(subtype, data);
+    } catch (err) {
+      debugLogger.error("DualOutput emitSystemMessage error:", err);
+      this.active = false;
+    }
+  }
+  emitRecordingFailure(event) {
+    if (!this.active) return;
+    this.disableIfBufferOverflowed();
+    if (!this.active) return;
+    try {
+      reportChatRecordingFailureToAdapter(this.adapter, event);
+    } catch (err) {
+      debugLogger.error("DualOutput recording failure output error:", err);
+      this.active = false;
+    }
+  }
+  shutdown() {
+    if (this.shutdownPromise) return this.shutdownPromise;
+    this.unsubscribeRecordingFailure();
+    if (this.active) {
+      try {
+        this.adapter.emitSystemMessage("session_end", {
+          session_id: this.sessionId
+        });
+      } catch {
+      }
+    }
+    this.active = false;
+    this.shutdownPromise = new Promise((resolve) => {
+      if (this.stream.closed || this.stream.destroyed) {
+        resolve();
+        return;
+      }
+      const cleanup = /* @__PURE__ */ __name(() => {
+        this.stream.off("close", onClose);
+        this.stream.off("error", onError);
+      }, "cleanup");
+      const onClose = /* @__PURE__ */ __name(() => {
+        cleanup();
+        resolve();
+      }, "onClose");
+      const onError = /* @__PURE__ */ __name((err) => {
+        debugLogger.debug("DualOutput: stream error during shutdown:", err);
+      }, "onError");
+      this.stream.once("close", onClose);
+      this.stream.once("error", onError);
+      try {
+        this.stream.end();
+      } catch (err) {
+        cleanup();
+        debugLogger.debug("DualOutput: stream end error during shutdown:", err);
+        resolve();
+      }
+    });
+    return this.shutdownPromise;
+  }
+};
+
+// packages/cli/src/remoteInput/RemoteInputWatcher.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import {
+  closeSync,
+  createReadStream,
+  openSync as openSync2,
+  readSync,
+  statSync,
+  unwatchFile,
+  watchFile
+} from "node:fs";
+import { createInterface } from "node:readline";
+var debugLogger2 = createDebugLogger("REMOTE_INPUT");
+var RemoteInputWatcher = class {
+  static {
+    __name(this, "RemoteInputWatcher");
+  }
+  submitFn = null;
+  confirmationHandler = null;
+  queue = [];
+  processing = false;
+  active = true;
+  bytesRead = 0;
+  consumedPrefixHash = null;
+  reading = false;
+  filePath;
+  retryTimer = null;
+  pollIntervalMs;
+  constructor(filePath, options) {
+    this.filePath = filePath;
+    this.pollIntervalMs = options?.pollIntervalMs ?? 500;
+    this.startWatching();
+  }
+  /**
+   * Register the TUI's submit function. Called from AppContainer
+   * once useLlmStream's submitQuery is available.
+   */
+  setSubmitFn(fn) {
+    this.submitFn = fn;
+    this.processQueue();
+  }
+  /**
+   * Register the handler invoked when a `confirmation_response` command is
+   * read from the input file. Used to bridge external approvals back into
+   * the tool's `onConfirm` callback.
+   */
+  setConfirmationHandler(fn) {
+    this.confirmationHandler = fn;
+  }
+  /**
+   * Notify the watcher that the TUI has become idle.
+   * Call this when streamingState transitions to Idle — it triggers
+   * processing of any queued commands that were deferred due to TUI busy.
+   */
+  notifyIdle() {
+    if (this.queue.length > 0 && !this.processing) {
+      this.processQueue();
+    }
+  }
+  startWatching() {
+    try {
+      const stat = statSync(this.filePath);
+      this.bytesRead = stat.size;
+      this.consumedPrefixHash = this.hashFilePrefix(this.bytesRead);
+    } catch {
+      this.bytesRead = 0;
+      this.consumedPrefixHash = null;
+    }
+    watchFile(this.filePath, { interval: this.pollIntervalMs }, () => {
+      if (!this.active) return;
+      this.readNewLines();
+    });
+    debugLogger2.debug(`RemoteInput: watching ${this.filePath}`);
+  }
+  /**
+   * Manually trigger a check for new input. Returns a promise that resolves
+   * once any new lines have been read and processed. In production the
+   * `watchFile` poll calls this automatically; tests can call it directly
+   * to avoid depending on filesystem-polling timing.
+   */
+  checkForNewInput() {
+    return this.readNewLines();
+  }
+  readNewLines() {
+    if (!this.active || this.reading) return Promise.resolve();
+    let currentSize;
+    try {
+      const stat = statSync(this.filePath);
+      currentSize = stat.size;
+    } catch {
+      return Promise.resolve();
+    }
+    if (currentSize < this.bytesRead) {
+      debugLogger2.debug(
+        "RemoteInput: input file shrank, resetting read offset"
+      );
+      this.bytesRead = 0;
+      this.consumedPrefixHash = null;
+    } else if (this.hasConsumedPrefixChanged()) {
+      debugLogger2.debug(
+        "RemoteInput: input file prefix changed, resetting read offset"
+      );
+      this.bytesRead = 0;
+      this.consumedPrefixHash = null;
+    }
+    if (currentSize <= this.bytesRead) return Promise.resolve();
+    const consumeUntil = this.findLastCompleteRecordEnd(
+      this.bytesRead,
+      currentSize
+    );
+    if (consumeUntil === null) {
+      return Promise.resolve();
+    }
+    const nextConsumedPrefixHash = this.hashFilePrefix(consumeUntil);
+    this.reading = true;
+    const stream = createReadStream(this.filePath, {
+      start: this.bytesRead,
+      end: consumeUntil - 1,
+      encoding: "utf-8"
+    });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const cmd = JSON.parse(trimmed);
+        if (cmd && cmd.type === "confirmation_response" && typeof cmd.request_id === "string" && typeof cmd.allowed === "boolean") {
+          debugLogger2.debug(
+            `RemoteInput: confirmation_response for ${cmd.request_id} (allowed=${cmd.allowed})`
+          );
+          this.confirmationHandler?.(cmd.request_id, cmd.allowed);
+        } else if (cmd && cmd.type === "submit" && typeof cmd.text === "string") {
+          debugLogger2.debug(
+            `RemoteInput: queued command: ${cmd.text.slice(0, 50)}...`
+          );
+          this.queue.push(
+            cmd
+          );
+        } else {
+          debugLogger2.warn(
+            `RemoteInput: unknown command type: ${String(cmd?.type)}`
+          );
+        }
+      } catch (_err) {
+        debugLogger2.warn(`RemoteInput: failed to parse line: ${trimmed}`);
+      }
+    });
+    return new Promise((resolve) => {
+      rl.on("close", () => {
+        this.bytesRead = consumeUntil;
+        if (nextConsumedPrefixHash !== null) {
+          this.consumedPrefixHash = nextConsumedPrefixHash;
+        }
+        this.reading = false;
+        this.processQueue();
+        resolve();
+      });
+    });
+  }
+  findLastCompleteRecordEnd(start, end) {
+    if (end <= start) return null;
+    let fd = null;
+    try {
+      fd = openSync2(this.filePath, "r");
+      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, end - start));
+      let remaining = end - start;
+      let position = start;
+      let lastLineBreak = -1;
+      while (remaining > 0) {
+        const bytesToRead = Math.min(buffer.length, remaining);
+        const bytesRead = readSync(fd, buffer, 0, bytesToRead, position);
+        if (bytesRead <= 0) break;
+        for (let i = 0; i < bytesRead; i++) {
+          if (buffer[i] === 10) {
+            lastLineBreak = position + i;
+          }
+        }
+        remaining -= bytesRead;
+        position += bytesRead;
+      }
+      return lastLineBreak >= start ? lastLineBreak + 1 : null;
+    } catch (err) {
+      debugLogger2.warn("RemoteInput: failed to scan complete records:", err);
+      return null;
+    } finally {
+      if (fd !== null) {
+        closeSync(fd);
+      }
+    }
+  }
+  hasConsumedPrefixChanged() {
+    if (this.bytesRead === 0) {
+      return false;
+    }
+    if (this.consumedPrefixHash === null) {
+      debugLogger2.warn(
+        "RemoteInput: missing consumed prefix hash, resetting read offset"
+      );
+      return true;
+    }
+    const currentHash = this.hashFilePrefix(this.bytesRead);
+    if (currentHash === null) {
+      debugLogger2.warn(
+        "RemoteInput: failed to hash consumed prefix, resetting read offset"
+      );
+      return true;
+    }
+    return currentHash !== this.consumedPrefixHash;
+  }
+  hashFilePrefix(size) {
+    if (size <= 0) return null;
+    let fd = null;
+    try {
+      fd = openSync2(this.filePath, "r");
+      const hash = createHash("sha256");
+      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, size));
+      let remaining = size;
+      let position = 0;
+      while (remaining > 0) {
+        const bytesToRead = Math.min(buffer.length, remaining);
+        const bytesRead = readSync(fd, buffer, 0, bytesToRead, position);
+        if (bytesRead <= 0) return null;
+        hash.update(buffer.subarray(0, bytesRead));
+        remaining -= bytesRead;
+        position += bytesRead;
+      }
+      return hash.digest("base64");
+    } catch (err) {
+      debugLogger2.warn("RemoteInput: failed to hash file prefix:", err);
+      return null;
+    } finally {
+      if (fd !== null) {
+        closeSync(fd);
+      }
+    }
+  }
+  async processQueue() {
+    if (this.processing || !this.submitFn || this.queue.length === 0) return;
+    this.processing = true;
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    try {
+      while (this.queue.length > 0 && this.active) {
+        if (!this.submitFn) break;
+        const cmd = this.queue[0];
+        debugLogger2.debug(
+          `RemoteInput: submitting: ${cmd.text.slice(0, 50)}...`
+        );
+        try {
+          const result = await this.submitFn(cmd.text);
+          if (result === false) {
+            debugLogger2.debug("RemoteInput: TUI busy, will retry on idle");
+            this.scheduleRetry();
+            break;
+          }
+          this.queue.shift();
+        } catch (err) {
+          debugLogger2.error("RemoteInput: submit failed:", err);
+          this.queue.shift();
+        }
+        if (this.queue.length > 0) {
+          await new Promise((r) => setTimeout(r, 500));
+        }
+      }
+    } finally {
+      this.processing = false;
+    }
+  }
+  scheduleRetry() {
+    if (this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      if (this.queue.length > 0 && !this.processing) {
+        this.processQueue();
+      }
+    }, 2e3);
+  }
+  shutdown() {
+    this.active = false;
+    unwatchFile(this.filePath);
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.queue.length = 0;
+    debugLogger2.debug("RemoteInput: shut down");
+  }
+};
+
+// packages/cli/src/ui/auth/useAuth.ts
+init_esbuild_shims();
+var import_react3 = __toESM(require_react(), 1);
+
+// packages/cli/src/ui/hooks/useQwenAuth.ts
+init_esbuild_shims();
+var import_react2 = __toESM(require_react(), 1);
+var useQwenAuth = /* @__PURE__ */ __name((pendingAuthType, isAuthenticating) => {
+  const [qwenAuthState, setQwenAuthState] = (0, import_react2.useState)({
+    deviceAuth: null,
+    authStatus: "idle",
+    authMessage: null
+  });
+  const isQwenAuth = pendingAuthType === "qwen-oauth" /* QWEN_OAUTH */;
+  (0, import_react2.useEffect)(() => {
+    if (!isQwenAuth || !isAuthenticating) {
+      setQwenAuthState({
+        deviceAuth: null,
+        authStatus: "idle",
+        authMessage: null
+      });
+      return;
+    }
+    setQwenAuthState((prev) => ({
+      ...prev,
+      authStatus: "idle"
+    }));
+    const handleDeviceAuth = /* @__PURE__ */ __name((deviceAuth) => {
+      setQwenAuthState((prev) => ({
+        ...prev,
+        deviceAuth: {
+          verification_uri: deviceAuth.verification_uri,
+          verification_uri_complete: deviceAuth.verification_uri_complete,
+          user_code: deviceAuth.user_code,
+          expires_in: deviceAuth.expires_in,
+          device_code: deviceAuth.device_code
+        },
+        authStatus: "polling"
+      }));
+    }, "handleDeviceAuth");
+    const handleAuthProgress = /* @__PURE__ */ __name((status, message) => {
+      setQwenAuthState((prev) => ({
+        ...prev,
+        authStatus: status,
+        authMessage: message || null
+      }));
+    }, "handleAuthProgress");
+    qwenOAuth2Events.on("auth-uri" /* AuthUri */, handleDeviceAuth);
+    qwenOAuth2Events.on("auth-progress" /* AuthProgress */, handleAuthProgress);
+    return () => {
+      qwenOAuth2Events.off("auth-uri" /* AuthUri */, handleDeviceAuth);
+      qwenOAuth2Events.off("auth-progress" /* AuthProgress */, handleAuthProgress);
+    };
+  }, [isQwenAuth, isAuthenticating]);
+  const cancelQwenAuth = (0, import_react2.useCallback)(() => {
+    qwenOAuth2Events.emit("auth-cancel" /* AuthCancel */);
+    setQwenAuthState({
+      deviceAuth: null,
+      authStatus: "idle",
+      authMessage: null
+    });
+  }, []);
+  return {
+    qwenAuthState,
+    cancelQwenAuth
+  };
+}, "useQwenAuth");
+
+// packages/cli/src/ui/auth/useAuth.ts
+function normalizeModelIds(modelIdsInput) {
+  return modelIdsInput.split(",").map((id) => id.trim()).filter((id, index, array) => id.length > 0 && array.indexOf(id) === index);
+}
+__name(normalizeModelIds, "normalizeModelIds");
+function maskApiKey(apiKey) {
+  const trimmed = apiKey.trim();
+  if (trimmed.length === 0) return "(not set)";
+  if (trimmed.length <= 6) return "***";
+  return `${trimmed.slice(0, 3)}...${trimmed.slice(-4)}`;
+}
+__name(maskApiKey, "maskApiKey");
+var useAuthCommand = /* @__PURE__ */ __name((settings, config, addItem, onAuthChange) => {
+  const unAuthenticated = config.getAuthType() === void 0;
+  const [authState, setAuthState] = (0, import_react3.useState)(
+    unAuthenticated ? "updating" /* Updating */ : "unauthenticated" /* Unauthenticated */
+  );
+  const [authError, setAuthError] = (0, import_react3.useState)(null);
+  const [isAuthenticating, setIsAuthenticating] = (0, import_react3.useState)(false);
+  const [isAuthDialogOpen, setIsAuthDialogOpen] = (0, import_react3.useState)(unAuthenticated);
+  const [pendingAuthType, setPendingAuthType] = (0, import_react3.useState)(
+    void 0
+  );
+  const [externalAuthState, setExternalAuthState] = (0, import_react3.useState)(null);
+  const { qwenAuthState, cancelQwenAuth } = useQwenAuth(
+    pendingAuthType,
+    isAuthenticating
+  );
+  const openedViaCommandRef = (0, import_react3.useRef)(false);
+  const onAuthError = (0, import_react3.useCallback)(
+    (error) => {
+      setAuthError(error);
+      if (error) {
+        setAuthState("updating" /* Updating */);
+        setIsAuthDialogOpen(true);
+      }
+    },
+    [setAuthError, setAuthState]
+  );
+  const handleAuthFailure = (0, import_react3.useCallback)(
+    (error, protocolForTelemetry) => {
+      setIsAuthenticating(false);
+      setExternalAuthState(null);
+      const msg = t("Failed to authenticate. Message: {{message}}", {
+        message: getErrorMessage(error)
+      });
+      onAuthError(msg);
+      const effectiveProtocol = protocolForTelemetry ?? pendingAuthType;
+      if (effectiveProtocol) {
+        logAuth(
+          config,
+          new AuthEvent(effectiveProtocol, "manual", "error", msg)
+        );
+      }
+    },
+    [onAuthError, pendingAuthType, config]
+  );
+  const completeAuthentication = (0, import_react3.useCallback)(() => {
+    setAuthError(null);
+    setAuthState("authenticated" /* Authenticated */);
+    setPendingAuthType(void 0);
+    setIsAuthDialogOpen(false);
+    setIsAuthenticating(false);
+    onAuthChange?.();
+  }, [onAuthChange]);
+  const handleProviderSubmit = (0, import_react3.useCallback)(
+    async (providerConfig, inputs) => {
+      const protocol = inputs.protocol ?? providerConfig.protocol;
+      try {
+        setPendingAuthType(protocol);
+        setIsAuthenticating(true);
+        setAuthError(null);
+        const plan = buildInstallPlan(providerConfig, inputs);
+        await applyProviderInstallPlan(plan, {
+          settings: createLoadedSettingsAdapter(settings),
+          reloadModelProviders: /* @__PURE__ */ __name((mp) => config.reloadModelProvidersConfig(mp), "reloadModelProviders"),
+          syncAuthState: /* @__PURE__ */ __name((authType, modelId, baseUrl) => config.getModelsConfig().syncAfterAuthRefresh(authType, modelId, baseUrl), "syncAuthState"),
+          refreshAuth: /* @__PURE__ */ __name((authType) => config.refreshAuth(authType), "refreshAuth")
+        });
+        completeAuthentication();
+        const feedbackItem = {
+          type: "info" /* INFO */,
+          text: t(
+            "Successfully configured {{provider}}. Use /model to switch models.",
+            { provider: providerConfig.label }
+          )
+        };
+        addItem(feedbackItem, Date.now());
+        if (openedViaCommandRef.current) {
+          openedViaCommandRef.current = false;
+          config.getChatRecordingService?.()?.recordSlashCommand({
+            phase: "result",
+            rawCommand: "/auth",
+            outputHistoryItems: [feedbackItem]
+          });
+        }
+        logAuth(config, new AuthEvent(protocol, "manual", "success"));
+      } catch (error) {
+        handleAuthFailure(error, protocol);
+      }
+    },
+    [settings, config, completeAuthentication, addItem, handleAuthFailure]
+  );
+  const openAuthDialog = (0, import_react3.useCallback)(() => {
+    openedViaCommandRef.current = true;
+    setIsAuthDialogOpen(true);
+  }, []);
+  const closeAuthDialog = (0, import_react3.useCallback)(() => {
+    openedViaCommandRef.current = false;
+    setIsAuthDialogOpen(false);
+    setAuthError(null);
+  }, []);
+  const cancelAuthentication = (0, import_react3.useCallback)(() => {
+    if (isAuthenticating && pendingAuthType === "qwen-oauth" /* QWEN_OAUTH */) {
+      cancelQwenAuth();
+    }
+    if (isAuthenticating && pendingAuthType) {
+      logAuth(config, new AuthEvent(pendingAuthType, "manual", "cancelled"));
+    }
+    setIsAuthenticating(false);
+    setExternalAuthState(null);
+    setIsAuthDialogOpen(true);
+    setAuthError(null);
+  }, [isAuthenticating, pendingAuthType, cancelQwenAuth, config]);
+  (0, import_react3.useEffect)(() => {
+    const val = process.env["QWEN_DEFAULT_AUTH_TYPE"];
+    const valid = [
+      "qwen-oauth" /* QWEN_OAUTH */,
+      "openai" /* USE_OPENAI */,
+      "anthropic" /* USE_ANTHROPIC */,
+      "gemini" /* USE_GEMINI */,
+      "vertex-ai" /* USE_VERTEX_AI */
+    ];
+    if (val && !valid.includes(val)) {
+      onAuthError(
+        t(
+          'Invalid QWEN_DEFAULT_AUTH_TYPE value: "{{value}}". Valid values are: {{validValues}}',
+          { value: val, validValues: valid.join(", ") }
+        )
+      );
+    }
+  }, [onAuthError]);
+  const state = (0, import_react3.useMemo)(
+    () => ({
+      authError,
+      isAuthDialogOpen,
+      isAuthenticating,
+      pendingAuthType,
+      externalAuthState,
+      qwenAuthState
+    }),
+    [
+      authError,
+      isAuthDialogOpen,
+      isAuthenticating,
+      pendingAuthType,
+      externalAuthState,
+      qwenAuthState
+    ]
+  );
+  const actions = (0, import_react3.useMemo)(
+    () => ({
+      setAuthState,
+      onAuthError,
+      closeAuthDialog,
+      handleProviderSubmit,
+      openAuthDialog,
+      cancelAuthentication
+    }),
+    [
+      setAuthState,
+      onAuthError,
+      closeAuthDialog,
+      handleProviderSubmit,
+      openAuthDialog,
+      cancelAuthentication
+    ]
+  );
+  return {
+    authState,
+    setAuthState,
+    authError,
+    onAuthError,
+    isAuthDialogOpen,
+    isAuthenticating,
+    pendingAuthType,
+    externalAuthState,
+    qwenAuthState,
+    closeAuthDialog,
+    handleProviderSubmit,
+    openAuthDialog,
+    cancelAuthentication,
+    state,
+    actions
+  };
+}, "useAuthCommand");
+
+// packages/cli/src/ui/components/mcp/utils.ts
+init_esbuild_shims();
+
+// packages/cli/src/ui/components/mcp/constants.ts
+init_esbuild_shims();
+var VISIBLE_TOOLS_COUNT = 10;
+var VISIBLE_RESOURCES_COUNT = 10;
+var SOURCE_ORDER = [
+  "user",
+  "project",
+  "workspace",
+  "system",
+  "extension"
+];
+
+// packages/cli/src/ui/components/mcp/utils.ts
+function getSourceDisplayName(source) {
+  switch (source) {
+    case "user":
+      return t("User MCPs");
+    case "project":
+      return t("Project MCPs");
+    case "workspace":
+      return t("Workspace Settings");
+    case "system":
+      return t("System Settings");
+    case "extension":
+      return t("Extension MCPs");
+    default:
+      return source;
+  }
+}
+__name(getSourceDisplayName, "getSourceDisplayName");
+function groupServersBySource(servers) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const server of servers) {
+    const existing = groups.get(server.source);
+    if (existing) {
+      existing.push(server);
+    } else {
+      groups.set(server.source, [server]);
+    }
+  }
+  const result = [];
+  for (const source of SOURCE_ORDER) {
+    const servers2 = groups.get(source);
+    if (servers2 && servers2.length > 0) {
+      result.push({
+        source,
+        displayName: getSourceDisplayName(source),
+        servers: servers2
+      });
+    }
+  }
+  return result;
+}
+__name(groupServersBySource, "groupServersBySource");
+function getStatusColor(status) {
+  switch (status) {
+    case "connected":
+      return "green";
+    case "connecting":
+      return "yellow";
+    case "disconnected":
+      return "red";
+    default:
+      return "gray";
+  }
+}
+__name(getStatusColor, "getStatusColor");
+function getStatusIcon(status) {
+  switch (status) {
+    case "connected":
+      return "\u2713";
+    case "connecting":
+      return "\u2026";
+    case "disconnected":
+      return "\u2717";
+    default:
+      return "?";
+  }
+}
+__name(getStatusIcon, "getStatusIcon");
+function formatServerCommand(server) {
+  const config = server.config;
+  if (config.httpUrl) {
+    return `${config.httpUrl} (http)`;
+  }
+  if (config.url) {
+    return `${config.url} (sse)`;
+  }
+  if (config.command) {
+    const args = config.args?.join(" ") || "";
+    return `${config.command} ${args} (stdio)`.trim();
+  }
+  return t("Unknown");
+}
+__name(formatServerCommand, "formatServerCommand");
+function isToolValid(name, description) {
+  return !!name && !!description;
+}
+__name(isToolValid, "isToolValid");
+function getToolInvalidReasons(name, description) {
+  const reasons = [];
+  if (!name) reasons.push(t("missing name"));
+  if (!description) reasons.push(t("missing description"));
+  return reasons;
+}
+__name(getToolInvalidReasons, "getToolInvalidReasons");
+
+// packages/cli/src/config/dialogScopeUtils.ts
+init_esbuild_shims();
+var SCOPE_LABELS = {
+  ["User" /* User */]: "User Settings",
+  ["Workspace" /* Workspace */]: "Workspace Settings"
+  // TODO: migrate system settings to user settings
+  // we don't want to save settings to system scope, it is a troublemaker
+  // comment it out for now.
+  // [SettingScope.System]: 'System Settings',
+};
+function getScopeItems() {
+  return [
+    { label: SCOPE_LABELS["User" /* User */], value: "User" /* User */ },
+    {
+      label: SCOPE_LABELS["Workspace" /* Workspace */],
+      value: "Workspace" /* Workspace */
+    }
+    // { label: SCOPE_LABELS[SettingScope.System], value: SettingScope.System },
+  ];
+}
+__name(getScopeItems, "getScopeItems");
+function getScopeMessageForSetting(settingKey, selectedScope, settings) {
+  const otherScopes = Object.values(SettingScope).filter(
+    (scope) => scope !== selectedScope
+  );
+  const modifiedInOtherScopes = otherScopes.filter((scope) => {
+    const scopeSettings = settings.forScope(scope).settings;
+    return settingExistsInScope(settingKey, scopeSettings);
+  });
+  if (modifiedInOtherScopes.length === 0) {
+    return "";
+  }
+  const modifiedScopesStr = modifiedInOtherScopes.join(", ");
+  const currentScopeSettings = settings.forScope(selectedScope).settings;
+  const existsInCurrentScope = settingExistsInScope(
+    settingKey,
+    currentScopeSettings
+  );
+  return existsInCurrentScope ? `(Also modified in ${modifiedScopesStr})` : `(Modified in ${modifiedScopesStr})`;
+}
+__name(getScopeMessageForSetting, "getScopeMessageForSetting");
+
+// packages/cli/src/ui/components/stats-helpers.tsx
+init_esbuild_shims();
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+var TAB_DEFS = [
+  { tab: "session", label: /* @__PURE__ */ __name(() => t("Session"), "label") },
+  { tab: "activity", label: /* @__PURE__ */ __name(() => t("Activity"), "label") },
+  { tab: "efficiency", label: /* @__PURE__ */ __name(() => t("Efficiency"), "label") }
+];
+var RANGE_CYCLE = ["all", "month", "week", "today"];
+function getHeatmapColors() {
+  return {
+    0: "#161b22",
+    1: "#0e4429",
+    2: "#006d32",
+    3: "#26a641",
+    4: "#39d353"
+  };
+}
+__name(getHeatmapColors, "getHeatmapColors");
+function getSeriesColors() {
+  return [
+    theme.text.link,
+    theme.status.error,
+    theme.text.accent,
+    theme.status.success,
+    theme.status.warning,
+    theme.text.code
+  ];
+}
+__name(getSeriesColors, "getSeriesColors");
+function getRangeLabel(range) {
+  const labels = {
+    today: t("Today"),
+    all: t("All time"),
+    week: t("Last 7 days"),
+    month: t("Last 30 days")
+  };
+  return labels[range] ?? range;
+}
+__name(getRangeLabel, "getRangeLabel");
+function fmtTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}m`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return `${n}`;
+}
+__name(fmtTokens, "fmtTokens");
+function fmtDurationShort(ms) {
+  const totalMinutes = Math.floor(ms / 6e4);
+  const days = Math.floor(totalMinutes / 1440);
+  const hours = Math.floor(totalMinutes % 1440 / 60);
+  const minutes = totalMinutes % 60;
+  const d = t("d");
+  const h = t("h");
+  const m = t("m");
+  if (days > 0) return `${days}${d} ${hours}${h} ${minutes}${m}`;
+  if (hours > 0) return `${hours}${h} ${minutes}${m}`;
+  return `${minutes}${m}`;
+}
+__name(fmtDurationShort, "fmtDurationShort");
+function fmtSuccessBar(rate) {
+  const filled = Math.max(0, Math.min(10, Math.round(rate / 10)));
+  return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+__name(fmtSuccessBar, "fmtSuccessBar");
+function getSuccessColor(rate) {
+  if (rate >= 95) return theme.status.success;
+  if (rate >= 80) return theme.status.warning;
+  return theme.status.error;
+}
+__name(getSuccessColor, "getSuccessColor");
+function getCacheColor(rate) {
+  if (rate >= 85) return theme.status.success;
+  if (rate >= 70) return theme.status.warning;
+  return theme.status.error;
+}
+__name(getCacheColor, "getCacheColor");
+var TableRow = /* @__PURE__ */ __name(({ cells }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box_default, { children: cells.map((cell, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box_default, { width: cell.width, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: cell.color, bold: cell.bold, children: cell.text }) }, i)) }), "TableRow");
+
+// packages/cli/src/ui/auth/useProviderSetupFlow.ts
+init_esbuild_shims();
+var import_react4 = __toESM(require_react(), 1);
+var STEP_ORDER = [
+  "protocol",
+  "baseUrl",
+  "apiKey",
+  "models",
+  "advancedConfig",
+  "review"
+];
+function getVisibleSteps(config) {
+  return STEP_ORDER.filter((step) => {
+    if (step === "review") return config.showAdvancedConfig === true;
+    return shouldShowStep(config, step);
+  });
+}
+__name(getVisibleSteps, "getVisibleSteps");
+function useProviderSetupFlow(onSubmit) {
+  const [provider, setProvider] = (0, import_react4.useState)(null);
+  const [visibleSteps, setVisibleSteps] = (0, import_react4.useState)([]);
+  const [stepIndex, setStepIndex] = (0, import_react4.useState)(0);
+  const [protocol, setProtocol] = (0, import_react4.useState)("openai" /* USE_OPENAI */);
+  const [baseUrl, setBaseUrl] = (0, import_react4.useState)("");
+  const [baseUrlPlaceholder, setBaseUrlPlaceholder] = (0, import_react4.useState)("");
+  const [baseUrlOptionIndex, setBaseUrlOptionIndex] = (0, import_react4.useState)(0);
+  const [baseUrlError, setBaseUrlError] = (0, import_react4.useState)(null);
+  const [apiKey, setApiKey] = (0, import_react4.useState)("");
+  const [apiKeyError, setApiKeyError] = (0, import_react4.useState)(null);
+  const [modelIds, setModelIds] = (0, import_react4.useState)("");
+  const [modelIdsError, setModelIdsError] = (0, import_react4.useState)(null);
+  const [thinkingEnabled, setThinkingEnabled] = (0, import_react4.useState)(false);
+  const [modalityEnabled, setModalityEnabled] = (0, import_react4.useState)(false);
+  const [modalityImage, setModalityImage] = (0, import_react4.useState)(true);
+  const [modalityVideo, setModalityVideo] = (0, import_react4.useState)(true);
+  const [modalityAudio, setModalityAudio] = (0, import_react4.useState)(false);
+  const [modalityPdf, setModalityPdf] = (0, import_react4.useState)(false);
+  const [contextWindowSize, setContextWindowSize] = (0, import_react4.useState)("");
+  const [focusedConfigIndex, setFocusedConfigIndex] = (0, import_react4.useState)(0);
+  const currentStep = visibleSteps[stepIndex] ?? null;
+  const start = (0, import_react4.useCallback)(
+    (config, initialProtocol, existingEnv, existingModelIds) => {
+      setProvider(config);
+      const steps = getVisibleSteps(config);
+      setVisibleSteps(steps);
+      setStepIndex(0);
+      const proto = initialProtocol ?? config.protocol;
+      setProtocol(proto);
+      const resolved = resolveBaseUrl(config);
+      setBaseUrl(resolved);
+      setBaseUrlPlaceholder(
+        resolved ? "" : getDefaultBaseUrlForProtocol(proto)
+      );
+      setBaseUrlOptionIndex(0);
+      setBaseUrlError(null);
+      let prefillKey = "";
+      if (existingEnv) {
+        const envKeyName = typeof config.envKey === "function" ? config.envKey(proto, resolved) : config.envKey;
+        prefillKey = existingEnv[envKeyName] ?? "";
+      }
+      setApiKey(prefillKey);
+      setApiKeyError(null);
+      const defaultIds = getDefaultModelIds(config);
+      const customIds = existingModelIds ?? [];
+      setModelIds([...defaultIds, ...customIds].join(", "));
+      setModelIdsError(null);
+      setThinkingEnabled(false);
+      setModalityEnabled(false);
+      setModalityImage(true);
+      setModalityVideo(true);
+      setModalityAudio(false);
+      setModalityPdf(false);
+      setContextWindowSize("");
+      setFocusedConfigIndex(0);
+    },
+    []
+  );
+  const reset = (0, import_react4.useCallback)(() => {
+    setProvider(null);
+    setVisibleSteps([]);
+    setStepIndex(0);
+  }, []);
+  const goBack = (0, import_react4.useCallback)(() => {
+    if (stepIndex > 0) {
+      setStepIndex((i) => i - 1);
+      return true;
+    }
+    reset();
+    return false;
+  }, [stepIndex, reset]);
+  const goNext = (0, import_react4.useCallback)(() => {
+    setStepIndex((i) => Math.min(i + 1, visibleSteps.length - 1));
+  }, [visibleSteps]);
+  const selectProtocol = (0, import_react4.useCallback)(
+    (selectedProtocol) => {
+      setProtocol(selectedProtocol);
+      setBaseUrl("");
+      setBaseUrlPlaceholder(getDefaultBaseUrlForProtocol(selectedProtocol));
+      setApiKey("");
+      setApiKeyError(null);
+      goNext();
+    },
+    [goNext]
+  );
+  const selectBaseUrl = (0, import_react4.useCallback)(
+    (selectedUrl) => {
+      setBaseUrl(selectedUrl);
+      setBaseUrlError(null);
+      goNext();
+    },
+    [goNext]
+  );
+  const submitBaseUrl = (0, import_react4.useCallback)(() => {
+    const effective = baseUrl.trim() || baseUrlPlaceholder.trim();
+    if (!effective) {
+      setBaseUrlError(t("Base URL cannot be empty."));
+      return false;
+    }
+    if (!/^https?:\/\//i.test(effective)) {
+      setBaseUrlError(t("Base URL must start with http:// or https://."));
+      return false;
+    }
+    if (!baseUrl.trim()) {
+      setBaseUrl(effective);
+    }
+    setBaseUrlError(null);
+    goNext();
+    return true;
+  }, [baseUrl, baseUrlPlaceholder, goNext]);
+  const changeBaseUrl = (0, import_react4.useCallback)((value) => {
+    setBaseUrl(value);
+    setBaseUrlError(null);
+  }, []);
+  const changeApiKey = (0, import_react4.useCallback)((value) => {
+    setApiKey(value);
+    setApiKeyError(null);
+  }, []);
+  const buildCurrentInputs = (0, import_react4.useCallback)(
+    (overrides) => ({
+      protocol: provider?.protocolOptions ? protocol : void 0,
+      baseUrl: baseUrl.trim(),
+      apiKey: apiKey.trim(),
+      modelIds: normalizeModelIds(modelIds),
+      ...overrides
+    }),
+    [provider, protocol, baseUrl, apiKey, modelIds]
+  );
+  const submitOrNext = (0, import_react4.useCallback)(
+    (overrides) => {
+      if (stepIndex >= visibleSteps.length - 1) {
+        if (provider) void onSubmit(provider, buildCurrentInputs(overrides));
+      } else {
+        goNext();
+      }
+    },
+    [stepIndex, visibleSteps, provider, onSubmit, buildCurrentInputs, goNext]
+  );
+  const submitApiKey = (0, import_react4.useCallback)(
+    (keyOverride) => {
+      const trimmed = (keyOverride ?? apiKey).trim();
+      if (!trimmed) {
+        setApiKeyError(t("API key cannot be empty."));
+        return false;
+      }
+      if (provider?.validateApiKey) {
+        const err = provider.validateApiKey(trimmed, baseUrl);
+        if (err) {
+          setApiKeyError(err);
+          return false;
+        }
+      }
+      setApiKeyError(null);
+      setApiKey(trimmed);
+      submitOrNext({ apiKey: trimmed });
+      return true;
+    },
+    [apiKey, provider, baseUrl, submitOrNext]
+  );
+  const highlightBaseUrl = (0, import_react4.useCallback)(
+    (url) => {
+      if (provider && Array.isArray(provider.baseUrl)) {
+        const idx = provider.baseUrl.findIndex((o) => o.url === url);
+        setBaseUrlOptionIndex(idx >= 0 ? idx : 0);
+      }
+    },
+    [provider]
+  );
+  const changeModelIds = (0, import_react4.useCallback)((value) => {
+    setModelIds(value);
+    setModelIdsError(null);
+  }, []);
+  const clearModelIdsError = (0, import_react4.useCallback)(() => {
+    setModelIdsError(null);
+  }, []);
+  const submitModelIds = (0, import_react4.useCallback)(
+    (overrides) => {
+      const normalized = overrides?.modelIds ?? normalizeModelIds(modelIds);
+      if (normalized.length === 0) {
+        setModelIdsError(t("Model IDs cannot be empty."));
+        return false;
+      }
+      setModelIds(normalized.join(", "));
+      setModelIdsError(null);
+      submitOrNext({ ...overrides, modelIds: normalized });
+      return true;
+    },
+    [modelIds, submitOrNext]
+  );
+  const advancedOptionCount = modalityEnabled ? 7 : 3;
+  const moveAdvancedFocusUp = (0, import_react4.useCallback)(() => {
+    setFocusedConfigIndex((v) => v <= 0 ? advancedOptionCount - 1 : v - 1);
+  }, [advancedOptionCount]);
+  const moveAdvancedFocusDown = (0, import_react4.useCallback)(() => {
+    setFocusedConfigIndex((v) => v >= advancedOptionCount - 1 ? 0 : v + 1);
+  }, [advancedOptionCount]);
+  const toggleFocusedAdvancedOption = (0, import_react4.useCallback)(() => {
+    switch (focusedConfigIndex) {
+      case 0:
+        setThinkingEnabled((v) => !v);
+        break;
+      case 1:
+        setModalityEnabled((v) => !v);
+        break;
+      case 2:
+        setModalityImage((v) => !v);
+        break;
+      case 3:
+        setModalityVideo((v) => !v);
+        break;
+      case 4:
+        setModalityAudio((v) => !v);
+        break;
+      case 5:
+        setModalityPdf((v) => !v);
+        break;
+      default:
+        break;
+    }
+  }, [focusedConfigIndex]);
+  const submitAdvancedConfig = (0, import_react4.useCallback)(() => {
+    goNext();
+  }, [goNext]);
+  const changeContextWindowSize = (0, import_react4.useCallback)((value) => {
+    setContextWindowSize(value.replace(/[^0-9]/g, ""));
+  }, []);
+  const submit = (0, import_react4.useCallback)(() => {
+    if (!provider) return;
+    const multimodal = modalityEnabled ? {
+      image: modalityImage || void 0,
+      video: modalityVideo || void 0,
+      audio: modalityAudio || void 0,
+      pdf: modalityPdf || void 0
+    } : void 0;
+    const ctxSize = parseInt(contextWindowSize, 10);
+    const hasAdvanced = thinkingEnabled || modalityEnabled || ctxSize > 0 && !isNaN(ctxSize);
+    const advancedConfig = hasAdvanced ? {
+      enableThinking: thinkingEnabled || void 0,
+      multimodal,
+      contextWindowSize: ctxSize > 0 && !isNaN(ctxSize) ? ctxSize : void 0
+    } : void 0;
+    void onSubmit(provider, buildCurrentInputs({ advancedConfig }));
+  }, [
+    provider,
+    thinkingEnabled,
+    modalityEnabled,
+    modalityImage,
+    modalityVideo,
+    modalityAudio,
+    modalityPdf,
+    contextWindowSize,
+    onSubmit,
+    buildCurrentInputs
+  ]);
+  const getPreviewJson = (0, import_react4.useCallback)(() => {
+    if (!provider) return "";
+    const envKey = typeof provider.envKey === "function" ? provider.envKey(protocol, baseUrl.trim()) : provider.envKey;
+    const normalizedIds = normalizeModelIds(modelIds);
+    const masked = maskApiKey(apiKey);
+    const genConfig = {};
+    if (thinkingEnabled) genConfig["extra_body"] = { enable_thinking: true };
+    if (modalityEnabled) {
+      const mod = {};
+      if (modalityImage) mod["image"] = true;
+      if (modalityVideo) mod["video"] = true;
+      if (modalityAudio) mod["audio"] = true;
+      if (modalityPdf) mod["pdf"] = true;
+      if (Object.keys(mod).length > 0) genConfig["modalities"] = mod;
+    }
+    const ctxSize = parseInt(contextWindowSize, 10);
+    if (ctxSize > 0 && !isNaN(ctxSize))
+      genConfig["contextWindowSize"] = ctxSize;
+    const hasGenConfig = Object.keys(genConfig).length > 0;
+    const models = normalizedIds.map((id) => {
+      const entry = {
+        id,
+        name: id,
+        baseUrl: baseUrl.trim(),
+        envKey
+      };
+      if (hasGenConfig) entry["generationConfig"] = genConfig;
+      return entry;
+    });
+    return JSON.stringify(
+      {
+        env: { [envKey]: masked },
+        modelProviders: { [protocol]: models },
+        security: { auth: { selectedType: protocol } },
+        model: { name: normalizedIds[0] }
+      },
+      null,
+      2
+    );
+  }, [
+    provider,
+    protocol,
+    baseUrl,
+    apiKey,
+    modelIds,
+    thinkingEnabled,
+    modalityEnabled,
+    modalityImage,
+    modalityVideo,
+    modalityAudio,
+    modalityPdf,
+    contextWindowSize
+  ]);
+  const state = {
+    provider,
+    step: currentStep,
+    stepIndex: stepIndex + 1,
+    // 1-based for display
+    totalSteps: visibleSteps.length,
+    protocol,
+    baseUrl,
+    baseUrlPlaceholder,
+    baseUrlOptionIndex,
+    baseUrlError,
+    apiKey,
+    apiKeyError,
+    modelIds,
+    modelIdsError,
+    thinkingEnabled,
+    modalityEnabled,
+    modalityImage,
+    modalityVideo,
+    modalityAudio,
+    modalityPdf,
+    contextWindowSize,
+    focusedConfigIndex,
+    previewJson: currentStep === "review" ? getPreviewJson() : ""
+  };
+  return {
+    state,
+    start,
+    reset,
+    goBack,
+    selectProtocol,
+    selectBaseUrl,
+    highlightBaseUrl,
+    submitBaseUrl,
+    changeBaseUrl,
+    changeApiKey,
+    submitApiKey,
+    changeModelIds,
+    clearModelIdsError,
+    submitModelIds,
+    moveAdvancedFocusUp,
+    moveAdvancedFocusDown,
+    toggleFocusedAdvancedOption,
+    changeContextWindowSize,
+    submitAdvancedConfig,
+    submit
+  };
+}
+__name(useProviderSetupFlow, "useProviderSetupFlow");
+
+// packages/cli/src/ui/editors/editorSettingsManager.ts
+init_esbuild_shims();
+var EDITOR_DISPLAY_NAMES = {
+  cursor: "Cursor",
+  emacs: "Emacs",
+  neovim: "Neovim",
+  vim: "Vim",
+  vscode: "VS Code",
+  vscodium: "VSCodium",
+  windsurf: "Windsurf",
+  zed: "Zed",
+  trae: "Trae"
+};
+var EditorSettingsManager = class {
+  static {
+    __name(this, "EditorSettingsManager");
+  }
+  availableEditors;
+  constructor() {
+    const editorTypes = Object.keys(
+      EDITOR_DISPLAY_NAMES
+    ).sort();
+    this.availableEditors = [
+      {
+        name: "None",
+        type: "not_set",
+        disabled: false
+      },
+      ...editorTypes.map((type) => {
+        const hasEditor = checkHasEditorType(type);
+        const isAllowedInSandbox = allowEditorTypeInSandbox(type);
+        let labelSuffix = !isAllowedInSandbox ? " (Not available in sandbox)" : "";
+        labelSuffix = !hasEditor ? " (Not installed)" : labelSuffix;
+        return {
+          name: EDITOR_DISPLAY_NAMES[type] + labelSuffix,
+          type,
+          disabled: !hasEditor || !isAllowedInSandbox
+        };
+      })
+    ];
+  }
+  getAvailableEditorDisplays() {
+    return this.availableEditors;
+  }
+};
+var editorSettingsManager = new EditorSettingsManager();
+
+// packages/cli/src/ui/statusLinePresets.ts
+init_esbuild_shims();
+import nodePath from "node:path";
+var STATUS_LINE_PRESET_ITEM_IDS = [
+  "project-name",
+  "git-branch",
+  "model-with-reasoning",
+  "model",
+  "context-remaining",
+  "total-input-tokens",
+  "total-output-tokens",
+  "current-dir",
+  "pull-request-number",
+  "branch-changes",
+  "context-used",
+  "run-state",
+  "qwen-version",
+  "context-window-size",
+  "used-tokens",
+  "session-id"
+];
+function aggregateModelTokens(metrics) {
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  for (const modelMetrics of Object.values(metrics.models)) {
+    totalInputTokens += modelMetrics.tokens.prompt;
+    totalOutputTokens += modelMetrics.tokens.candidates;
+  }
+  return { totalInputTokens, totalOutputTokens };
+}
+__name(aggregateModelTokens, "aggregateModelTokens");
+var STATUS_LINE_PRESET_ITEMS = [
+  {
+    id: "project-name",
+    label: "project-name",
+    description: "Project name when available",
+    defaultSelected: true
+  },
+  {
+    id: "git-branch",
+    label: "git-branch",
+    description: "Current Git branch when available",
+    defaultSelected: true
+  },
+  {
+    id: "model-with-reasoning",
+    label: "model-with-reasoning",
+    description: "Current model name with reasoning level when available",
+    defaultSelected: true
+  },
+  {
+    id: "model",
+    label: "model-only",
+    description: "Current model name without reasoning level"
+  },
+  {
+    id: "context-remaining",
+    label: "context-remaining",
+    description: "Percentage of context window remaining"
+  },
+  {
+    id: "total-input-tokens",
+    label: "total-input-tokens",
+    description: "Total input tokens used in session"
+  },
+  {
+    id: "total-output-tokens",
+    label: "total-output-tokens",
+    description: "Total output tokens used in session"
+  },
+  {
+    id: "current-dir",
+    label: "current-dir",
+    description: "Current working directory"
+  },
+  {
+    id: "pull-request-number",
+    label: "pull-request-number",
+    description: "Open pull request number for the current branch"
+  },
+  {
+    id: "branch-changes",
+    label: "branch-changes",
+    description: "Session file changes added and removed"
+  },
+  {
+    id: "context-used",
+    label: "context-used",
+    description: "Percentage of context window used",
+    defaultSelected: true
+  },
+  {
+    id: "run-state",
+    label: "run-state",
+    description: "Compact session run-state text"
+  },
+  {
+    id: "qwen-version",
+    label: "qwen-version",
+    description: "Qwen Code application version"
+  },
+  {
+    id: "context-window-size",
+    label: "context-window-size",
+    description: "Total context window size in tokens"
+  },
+  {
+    id: "used-tokens",
+    label: "used-tokens",
+    description: "Current prompt tokens used"
+  },
+  {
+    id: "session-id",
+    label: "session-id",
+    description: "Current session identifier"
+  }
+];
+var STATUS_LINE_PRESET_ITEM_ID_SET = new Set(
+  STATUS_LINE_PRESET_ITEM_IDS
+);
+function orderStatusLinePresetItems(items) {
+  const selectedItems = new Set(
+    items.filter(
+      (item) => typeof item === "string" && STATUS_LINE_PRESET_ITEM_ID_SET.has(item)
+    )
+  );
+  return STATUS_LINE_PRESET_ITEM_IDS.filter((item) => selectedItems.has(item));
+}
+__name(orderStatusLinePresetItems, "orderStatusLinePresetItems");
+var DEFAULT_STATUS_LINE_PRESET_CONFIG = {
+  type: "preset",
+  useThemeColors: true,
+  items: orderStatusLinePresetItems(
+    STATUS_LINE_PRESET_ITEMS.filter((item) => item.defaultSelected).map(
+      (item) => item.id
+    )
+  )
+};
+function normalizeStatusLinePresetConfig(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return void 0;
+  }
+  const candidate = raw;
+  if (candidate["type"] !== "preset") {
+    return void 0;
+  }
+  const hasItemsArray = Array.isArray(candidate["items"]);
+  const items = hasItemsArray ? orderStatusLinePresetItems(candidate["items"]) : [];
+  return {
+    type: "preset",
+    useThemeColors: typeof candidate["useThemeColors"] === "boolean" ? candidate["useThemeColors"] : true,
+    items: hasItemsArray ? items : [...DEFAULT_STATUS_LINE_PRESET_CONFIG.items],
+    hideContextIndicator: typeof candidate["hideContextIndicator"] === "boolean" ? candidate["hideContextIndicator"] : void 0
+  };
+}
+__name(normalizeStatusLinePresetConfig, "normalizeStatusLinePresetConfig");
+function formatPercent(value) {
+  if (!Number.isFinite(value)) {
+    return "0%";
+  }
+  const rounded = Math.round(value * 10) / 10;
+  return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded}%`;
+}
+__name(formatPercent, "formatPercent");
+function formatTokenCount(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return "0";
+  }
+  if (value >= 1e6) {
+    return `${(value / 1e6).toFixed(1)}m`;
+  }
+  if (value >= 1e3) {
+    return `${(value / 1e3).toFixed(1)}k`;
+  }
+  return String(Math.round(value));
+}
+__name(formatTokenCount, "formatTokenCount");
+function getRunStateLabel(state) {
+  switch (state) {
+    case "idle" /* Idle */:
+      return "Ready";
+    case "responding" /* Responding */:
+      return "Working";
+    case "waiting_for_confirmation" /* WaitingForConfirmation */:
+      return "Confirm";
+    default:
+      return "Working";
+  }
+}
+__name(getRunStateLabel, "getRunStateLabel");
+function stripProviderPrefix(name) {
+  return name.replace(/^\[[^\]]*\]\s*/, "");
+}
+__name(stripProviderPrefix, "stripProviderPrefix");
+function formatModelWithReasoning(modelDisplayName, reasoning) {
+  const cleanName = stripProviderPrefix(modelDisplayName);
+  if (reasoning === false) {
+    return `${cleanName} reasoning off`;
+  }
+  if (reasoning?.effort) {
+    return `${cleanName} ${reasoning.effort}`;
+  }
+  return cleanName;
+}
+__name(formatModelWithReasoning, "formatModelWithReasoning");
+function inferPullRequestNumber(branch) {
+  if (!branch) {
+    return void 0;
+  }
+  const match = branch.match(
+    /(?:^|[/_-])(?:pr|pull|pull-request)[/_-]?#?(\d+)(?:$|[/_-])/i
+  );
+  return match?.[1];
+}
+__name(inferPullRequestNumber, "inferPullRequestNumber");
+function buildStatusLinePresetData(params) {
+  const usedPercentage = params.contextWindowSize > 0 ? Math.min(
+    100,
+    Math.max(
+      0,
+      Math.round(
+        params.currentUsage / params.contextWindowSize * 1e3
+      ) / 10
+    )
+  ) : 0;
+  return {
+    sessionId: params.sessionId,
+    version: params.version || "unknown",
+    modelDisplayName: params.modelDisplayName || "unknown",
+    reasoning: params.reasoning,
+    currentDir: params.currentDir,
+    projectName: nodePath.basename(params.currentDir) || void 0,
+    branch: params.branch,
+    pullRequestNumber: params.pullRequestNumber,
+    contextWindowSize: params.contextWindowSize,
+    usedPercentage,
+    remainingPercentage: Math.round((100 - usedPercentage) * 10) / 10,
+    currentUsage: params.currentUsage,
+    totalInputTokens: params.totalInputTokens,
+    totalOutputTokens: params.totalOutputTokens,
+    totalLinesAdded: params.totalLinesAdded,
+    totalLinesRemoved: params.totalLinesRemoved,
+    streamingState: params.streamingState
+  };
+}
+__name(buildStatusLinePresetData, "buildStatusLinePresetData");
+function formatPresetItem(item, data) {
+  switch (item) {
+    case "model-with-reasoning":
+      return formatModelWithReasoning(data.modelDisplayName, data.reasoning);
+    case "model":
+      return stripProviderPrefix(data.modelDisplayName);
+    case "context-remaining":
+      if (data.contextWindowSize > 0) {
+        return `Context ${formatPercent(data.remainingPercentage)} left`;
+      }
+      return void 0;
+    case "current-dir":
+      return data.currentDir;
+    case "context-used":
+      if (data.contextWindowSize > 0 && data.usedPercentage > 0) {
+        return `${formatTokenCount(data.contextWindowSize)} Context ${formatPercent(data.usedPercentage)} used`;
+      }
+      return void 0;
+    case "git-branch":
+      if (data.branch) {
+        return `git:(${data.branch})`;
+      }
+      return void 0;
+    case "project-name":
+      if (data.projectName) {
+        return `\u279C ${data.projectName}`;
+      }
+      return void 0;
+    case "pull-request-number": {
+      const prNumber = data.pullRequestNumber ?? inferPullRequestNumber(data.branch);
+      if (prNumber) {
+        return `#${prNumber}`;
+      }
+      return void 0;
+    }
+    case "branch-changes":
+      if (data.totalLinesAdded > 0 || data.totalLinesRemoved > 0) {
+        return `+${data.totalLinesAdded} -${data.totalLinesRemoved}`;
+      }
+      return void 0;
+    case "run-state":
+      return getRunStateLabel(data.streamingState);
+    case "qwen-version":
+      return `v${data.version}`;
+    case "context-window-size":
+      if (data.contextWindowSize > 0) {
+        return `${formatTokenCount(data.contextWindowSize)} window`;
+      }
+      return void 0;
+    case "used-tokens":
+      if (data.currentUsage > 0) {
+        return `${formatTokenCount(data.currentUsage)} used`;
+      }
+      return void 0;
+    case "total-input-tokens":
+      return `${formatTokenCount(data.totalInputTokens)} total in`;
+    case "total-output-tokens":
+      return `${formatTokenCount(data.totalOutputTokens)} total out`;
+    case "session-id":
+      return data.sessionId || void 0;
+    default: {
+      item;
+      return void 0;
+    }
+  }
+}
+__name(formatPresetItem, "formatPresetItem");
+function buildStatusLinePresetParts(config, data) {
+  const parts = [];
+  for (const item of orderStatusLinePresetItems(config.items)) {
+    const text = formatPresetItem(item, data);
+    if (text) {
+      parts.push(text);
+    }
+  }
+  return parts;
+}
+__name(buildStatusLinePresetParts, "buildStatusLinePresetParts");
+function buildStatusLinePresetLines(config, data) {
+  const line = buildStatusLinePresetParts(config, data).join(" \xB7 ");
+  return line ? [line] : [];
+}
+__name(buildStatusLinePresetLines, "buildStatusLinePresetLines");
+
+export {
+  computeWindowTitle,
+  writeTerminalTitle,
+  formatSessionWindowTitle,
+  titleStatusPrefix,
+  useLogger,
+  VISIBLE_TOOLS_COUNT,
+  VISIBLE_RESOURCES_COUNT,
+  groupServersBySource,
+  getStatusColor,
+  getStatusIcon,
+  formatServerCommand,
+  isToolValid,
+  getToolInvalidReasons,
+  getScopeItems,
+  getScopeMessageForSetting,
+  TAB_DEFS,
+  RANGE_CYCLE,
+  getHeatmapColors,
+  getSeriesColors,
+  getRangeLabel,
+  fmtTokens,
+  fmtDurationShort,
+  fmtSuccessBar,
+  getSuccessColor,
+  getCacheColor,
+  TableRow,
+  normalizeModelIds,
+  useAuthCommand,
+  useProviderSetupFlow,
+  EDITOR_DISPLAY_NAMES,
+  editorSettingsManager,
+  aggregateModelTokens,
+  STATUS_LINE_PRESET_ITEMS,
+  orderStatusLinePresetItems,
+  DEFAULT_STATUS_LINE_PRESET_CONFIG,
+  normalizeStatusLinePresetConfig,
+  buildStatusLinePresetData,
+  buildStatusLinePresetLines,
+  DualOutputBridge,
+  RemoteInputWatcher
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */