@mmmbuto/qwen-code-termux 0.6.0-termux → 0.6.2-termux

package/{dist/cli.js → cli.js}

@@ -140494,13 +140494,492 @@ ${[...baseTips, ...streamingSpecificTips].join("\n")}`;
   }
 });
 
+// node_modules/tiktoken/tiktoken_bg.cjs
+var require_tiktoken_bg = __commonJS({
+  "node_modules/tiktoken/tiktoken_bg.cjs"(exports2, module2) {
+    init_esbuild_shims();
+    var wasm2;
+    module2.exports.__wbg_set_wasm = function(val) {
+      wasm2 = val;
+    };
+    var lTextDecoder = typeof TextDecoder === "undefined" ? (0, module2.require)("util").TextDecoder : TextDecoder;
+    var cachedTextDecoder = new lTextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    var cachedUint8ArrayMemory0 = null;
+    function getUint8ArrayMemory0() {
+      if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm2.memory.buffer);
+      }
+      return cachedUint8ArrayMemory0;
+    }
+    __name(getUint8ArrayMemory0, "getUint8ArrayMemory0");
+    function getStringFromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+    }
+    __name(getStringFromWasm0, "getStringFromWasm0");
+    var heap = new Array(128).fill(void 0);
+    heap.push(void 0, null, true, false);
+    var heap_next = heap.length;
+    function addHeapObject(obj) {
+      if (heap_next === heap.length) heap.push(heap.length + 1);
+      const idx = heap_next;
+      heap_next = heap[idx];
+      heap[idx] = obj;
+      return idx;
+    }
+    __name(addHeapObject, "addHeapObject");
+    function handleError2(f5, args) {
+      try {
+        return f5.apply(this, args);
+      } catch (e4) {
+        wasm2.__wbindgen_export_0(addHeapObject(e4));
+      }
+    }
+    __name(handleError2, "handleError");
+    function getObject2(idx) {
+      return heap[idx];
+    }
+    __name(getObject2, "getObject");
+    function dropObject(idx) {
+      if (idx < 132) return;
+      heap[idx] = heap_next;
+      heap_next = idx;
+    }
+    __name(dropObject, "dropObject");
+    function takeObject(idx) {
+      const ret = getObject2(idx);
+      dropObject(idx);
+      return ret;
+    }
+    __name(takeObject, "takeObject");
+    var WASM_VECTOR_LEN = 0;
+    var lTextEncoder = typeof TextEncoder === "undefined" ? (0, module2.require)("util").TextEncoder : TextEncoder;
+    var cachedTextEncoder = new lTextEncoder("utf-8");
+    var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+      return cachedTextEncoder.encodeInto(arg, view);
+    } : function(arg, view) {
+      const buf = cachedTextEncoder.encode(arg);
+      view.set(buf);
+      return {
+        read: arg.length,
+        written: buf.length
+      };
+    };
+    function passStringToWasm0(arg, malloc, realloc) {
+      if (realloc === void 0) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr2 = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr2;
+      }
+      let len = arg.length;
+      let ptr = malloc(len, 1) >>> 0;
+      const mem = getUint8ArrayMemory0();
+      let offset = 0;
+      for (; offset < len; offset++) {
+        const code2 = arg.charCodeAt(offset);
+        if (code2 > 127) break;
+        mem[ptr + offset] = code2;
+      }
+      if (offset !== len) {
+        if (offset !== 0) {
+          arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+      }
+      WASM_VECTOR_LEN = offset;
+      return ptr;
+    }
+    __name(passStringToWasm0, "passStringToWasm0");
+    function isLikeNone(x3) {
+      return x3 === void 0 || x3 === null;
+    }
+    __name(isLikeNone, "isLikeNone");
+    var cachedDataViewMemory0 = null;
+    function getDataViewMemory0() {
+      if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm2.memory.buffer) {
+        cachedDataViewMemory0 = new DataView(wasm2.memory.buffer);
+      }
+      return cachedDataViewMemory0;
+    }
+    __name(getDataViewMemory0, "getDataViewMemory0");
+    var cachedUint32ArrayMemory0 = null;
+    function getUint32ArrayMemory0() {
+      if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm2.memory.buffer);
+      }
+      return cachedUint32ArrayMemory0;
+    }
+    __name(getUint32ArrayMemory0, "getUint32ArrayMemory0");
+    function getArrayU32FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+    }
+    __name(getArrayU32FromWasm0, "getArrayU32FromWasm0");
+    function passArray8ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 1, 1) >>> 0;
+      getUint8ArrayMemory0().set(arg, ptr / 1);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    __name(passArray8ToWasm0, "passArray8ToWasm0");
+    function passArray32ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 4, 4) >>> 0;
+      getUint32ArrayMemory0().set(arg, ptr / 4);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    __name(passArray32ToWasm0, "passArray32ToWasm0");
+    function getArrayU8FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+    }
+    __name(getArrayU8FromWasm0, "getArrayU8FromWasm0");
+    module2.exports.get_encoding = function(encoding, extend_special_tokens) {
+      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(encoding, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm2.get_encoding(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r22) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm2.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    module2.exports.encoding_for_model = function(model, extend_special_tokens) {
+      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(model, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm2.encoding_for_model(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r22) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm2.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    module2.exports.get_encoding_name_for_model = function(model) {
+      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      let deferred3_0;
+      let deferred3_1;
+      try {
+        const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(model, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm2.get_encoding_name_for_model(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r32 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r32) {
+          ptr2 = 0;
+          len2 = 0;
+          throw takeObject(r22);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+      } finally {
+        wasm2.__wbindgen_add_to_stack_pointer(16);
+        wasm2.__wbindgen_export_3(deferred3_0, deferred3_1, 1);
+      }
+    };
+    var TiktokenFinalization = typeof FinalizationRegistry === "undefined" ? { register: /* @__PURE__ */ __name(() => {
+    }, "register"), unregister: /* @__PURE__ */ __name(() => {
+    }, "unregister") } : new FinalizationRegistry((ptr) => wasm2.__wbg_tiktoken_free(ptr >>> 0, 1));
+    var Tiktoken = class _Tiktoken {
+      static {
+        __name(this, "Tiktoken");
+      }
+      /**
+       * @param {string} tiktoken_bfe
+       * @param {any} special_tokens
+       * @param {string} pat_str
+       */
+      constructor(tiktoken_bfe, special_tokens, pat_str) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passStringToWasm0(tiktoken_bfe, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(pat_str, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm2.tiktoken_new(ptr0, len0, addHeapObject(special_tokens), ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        TiktokenFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /** @returns {string | undefined} */
+      get name() {
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          wasm2.tiktoken_name(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          let v1;
+          if (r0 !== 0) {
+            v1 = getStringFromWasm0(r0, r1).slice();
+            wasm2.__wbindgen_export_3(r0, r1 * 1, 1);
+          }
+          return v1;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_Tiktoken.prototype);
+        obj.__wbg_ptr = ptr;
+        TiktokenFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TiktokenFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr = this.__destroy_into_raw();
+        wasm2.__wbg_tiktoken_free(ptr, 0);
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {Uint32Array}
+       */
+      encode(text, allowed_special, disallowed_special) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm2.tiktoken_encode(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          var r32 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+          if (r32) {
+            throw takeObject(r22);
+          }
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm2.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @returns {Uint32Array}
+       */
+      encode_ordinary(text) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm2.tiktoken_encode_ordinary(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm2.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {any}
+       */
+      encode_with_unstable(text, allowed_special, disallowed_special) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm2.tiktoken_encode_with_unstable(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r22) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {Uint8Array} bytes
+       * @returns {number}
+       */
+      encode_single_token(bytes) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passArray8ToWasm0(bytes, wasm2.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm2.tiktoken_encode_single_token(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+      }
+      /**
+       * @param {Uint32Array} tokens
+       * @returns {Uint8Array}
+       */
+      decode(tokens) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passArray32ToWasm0(tokens, wasm2.__wbindgen_export_1);
+          const len0 = WASM_VECTOR_LEN;
+          wasm2.tiktoken_decode(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm2.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v2;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {number} token
+       * @returns {Uint8Array}
+       */
+      decode_single_token_bytes(token2) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          wasm2.tiktoken_decode_single_token_bytes(retptr, this.__wbg_ptr, token2);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v1 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm2.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v1;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /** @returns {any} */
+      token_byte_values() {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ret = wasm2.tiktoken_token_byte_values(this.__wbg_ptr);
+        return takeObject(ret);
+      }
+    };
+    module2.exports.Tiktoken = Tiktoken;
+    module2.exports.__wbg_parse_def2e24ef1252aff = function() {
+      return handleError2(function(arg0, arg1) {
+        const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module2.exports.__wbg_stringify_f7ed6987935b4a24 = function() {
+      return handleError2(function(arg0) {
+        const ret = JSON.stringify(getObject2(arg0));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module2.exports.__wbindgen_error_new = function(arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    };
+    module2.exports.__wbindgen_is_undefined = function(arg0) {
+      const ret = getObject2(arg0) === void 0;
+      return ret;
+    };
+    module2.exports.__wbindgen_object_drop_ref = function(arg0) {
+      takeObject(arg0);
+    };
+    module2.exports.__wbindgen_string_get = function(arg0, arg1) {
+      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      const obj = getObject2(arg1);
+      const ret = typeof obj === "string" ? obj : void 0;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    module2.exports.__wbindgen_throw = function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+  }
+});
+
+// node_modules/tiktoken/tiktoken.cjs
+var require_tiktoken = __commonJS({
+  "node_modules/tiktoken/tiktoken.cjs"(exports2) {
+    init_esbuild_shims();
+    var wasm2 = require_tiktoken_bg();
+    var imports = {};
+    imports["./tiktoken_bg.js"] = wasm2;
+    var path112 = __require("path");
+    var fs101 = __require("fs");
+    var candidates = __dirname.split(path112.sep).reduce((memo, _2, index, array2) => {
+      const prefix = array2.slice(0, index + 1).join(path112.sep) + path112.sep;
+      if (!prefix.includes("node_modules" + path112.sep)) {
+        memo.unshift(
+          path112.join(
+            prefix,
+            "node_modules",
+            "tiktoken",
+            "",
+            "./tiktoken_bg.wasm"
+          )
+        );
+      }
+      return memo;
+    }, []);
+    candidates.unshift(path112.join(__dirname, "./tiktoken_bg.wasm"));
+    var bytes = null;
+    for (const candidate of candidates) {
+      try {
+        bytes = fs101.readFileSync(candidate);
+        break;
+      } catch {
+      }
+    }
+    if (bytes == null) throw new Error("Missing tiktoken_bg.wasm");
+    var wasmModule = new WebAssembly.Module(bytes);
+    var wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+    wasm2.__wbg_set_wasm(wasmInstance.exports);
+    exports2["get_encoding"] = wasm2["get_encoding"];
+    exports2["encoding_for_model"] = wasm2["encoding_for_model"];
+    exports2["get_encoding_name_for_model"] = wasm2["get_encoding_name_for_model"];
+    exports2["Tiktoken"] = wasm2["Tiktoken"];
+  }
+});
+
 // packages/core/dist/src/utils/request-tokenizer/textTokenizer.js
-import { get_encoding } from "tiktoken";
-var TextTokenizer;
+var import_tiktoken, TextTokenizer;
 var init_textTokenizer = __esm({
   "packages/core/dist/src/utils/request-tokenizer/textTokenizer.js"() {
     "use strict";
     init_esbuild_shims();
+    import_tiktoken = __toESM(require_tiktoken(), 1);
     TextTokenizer = class {
       static {
         __name(this, "TextTokenizer");
@@ -140517,7 +140996,7 @@ var init_textTokenizer = __esm({
         if (this.encoding)
           return;
         try {
-          this.encoding = get_encoding(this.encodingName);
+          this.encoding = (0, import_tiktoken.get_encoding)(this.encodingName);
         } catch (error2) {
           console.warn(`Failed to load tiktoken with encoding ${this.encodingName}:`, error2);
           this.encoding = null;
@@ -142473,8 +142952,42 @@ import crypto5 from "crypto";
 import path9 from "node:path";
 import { promises as fs13 } from "node:fs";
 import * as os7 from "os";
+import { execSync } from "node:child_process";
 import { EventEmitter as EventEmitter2 } from "events";
 import { randomUUID as randomUUID3 } from "node:crypto";
+function isTermux() {
+  return process.platform === "android" || process.env["PREFIX"]?.includes("com.termux") || process.env["TERMUX_VERSION"] !== void 0;
+}
+async function openBrowserUrl(url2) {
+  if (isTermux()) {
+    try {
+      const possiblePaths = [
+        "/data/data/com.termux/files/usr/bin/termux-open-url",
+        "/usr/bin/termux-open-url",
+        "termux-open-url"
+      ];
+      let termuxOpenUrl = "termux-open-url";
+      for (const path112 of possiblePaths) {
+        try {
+          execSync(`test -x "${path112}"`, { stdio: "ignore" });
+          termuxOpenUrl = path112;
+          break;
+        } catch {
+        }
+      }
+      console.debug(`Opening URL with: ${termuxOpenUrl}`);
+      execSync(`"${termuxOpenUrl}" "${url2}"`, {
+        stdio: ["ignore", "ignore", "ignore"],
+        env: { ...process.env, PATH: process.env["PATH"] }
+      });
+    } catch (error2) {
+      console.error(`Failed to open URL with termux-open-url: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      throw error2;
+    }
+  } else {
+    await open_default(url2);
+  }
+}
 function generateCodeVerifier() {
   return crypto5.randomBytes(32).toString("base64url");
 }
@@ -142580,13 +143093,7 @@ ${deviceAuth.verification_uri_complete}
     }, "showFallbackMessage");
     if (!config2.isBrowserLaunchSuppressed()) {
       try {
-        const childProcess3 = await open_default(deviceAuth.verification_uri_complete);
-        if (childProcess3) {
-          childProcess3.on("error", () => {
-            console.debug("Failed to open browser. Visit this URL to authorize:");
-            showFallbackMessage();
-          });
-        }
+        await openBrowserUrl(deviceAuth.verification_uri_complete);
       } catch (_err) {
         showFallbackMessage();
       }
@@ -142758,6 +143265,8 @@ var init_qwenOAuth2 = __esm({
     QWEN_OAUTH_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
     QWEN_DIR3 = ".qwen";
     QWEN_CREDENTIAL_FILENAME2 = "oauth_creds.json";
+    __name(isTermux, "isTermux");
+    __name(openBrowserUrl, "openBrowserUrl");
     __name(generateCodeVerifier, "generateCodeVerifier");
     __name(generateCodeChallenge, "generateCodeChallenge");
     __name(generatePKCEPair, "generatePKCEPair");
@@ -154418,7 +154927,7 @@ __export(geminiContentGenerator_exports, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.6.0-termux";
+  const version2 = "0.6.2-termux";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -155014,7 +155523,7 @@ var init_jsonl_utils = __esm({
 // packages/core/dist/src/utils/gitUtils.js
 import * as fs16 from "node:fs";
 import * as path11 from "node:path";
-import { execSync } from "node:child_process";
+import { execSync as execSync2 } from "node:child_process";
 function isGitRepository(directory) {
   try {
     let currentDir = path11.resolve(directory);
@@ -155042,7 +155551,7 @@ var init_gitUtils = __esm({
     __name(isGitRepository, "isGitRepository");
     getGitBranch = /* @__PURE__ */ __name((cwd7) => {
       try {
-        const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+        const branch = execSync2("git rev-parse --abbrev-ref HEAD", {
           cwd: cwd7,
           encoding: "utf8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -158959,7 +159468,7 @@ var init_types4 = __esm({
 });
 
 // packages/core/dist/src/utils/editor.js
-import { execSync as execSync2, spawn, spawnSync } from "node:child_process";
+import { execSync as execSync3, spawn, spawnSync } from "node:child_process";
 function isValidEditorType(editor) {
   return [
     "vscode",
@@ -158975,7 +159484,7 @@ function isValidEditorType(editor) {
 }
 function commandExists(cmd) {
   try {
-    execSync2(process.platform === "win32" ? `where.exe ${cmd}` : `command -v ${cmd}`, { stdio: "ignore" });
+    execSync3(process.platform === "win32" ? `where.exe ${cmd}` : `command -v ${cmd}`, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -165238,7 +165747,7 @@ var require_lib3 = __commonJS({
 });
 
 // packages/core/dist/src/utils/systemEncoding.js
-import { execSync as execSync3 } from "node:child_process";
+import { execSync as execSync4 } from "node:child_process";
 import os11 from "node:os";
 function getCachedEncodingForBuffer(buffer) {
   if (cachedSystemEncoding === void 0) {
@@ -165258,7 +165767,7 @@ function getCachedEncodingForBuffer(buffer) {
 function getSystemEncoding() {
   if (os11.platform() === "win32") {
     try {
-      const output = execSync3("chcp", { encoding: "utf8" });
+      const output = execSync4("chcp", { encoding: "utf8" });
       const match3 = output.match(/:\s*(\d+)/);
       if (match3) {
         const codePage = parseInt(match3[1], 10);
@@ -165276,7 +165785,7 @@ function getSystemEncoding() {
   let locale = env7["LC_ALL"] || env7["LC_CTYPE"] || env7["LANG"] || "";
   if (!locale) {
     try {
-      locale = execSync3("locale charmap", { encoding: "utf8" }).toString().trim();
+      locale = execSync4("locale charmap", { encoding: "utf8" }).toString().trim();
     } catch (_e2) {
       console.warn("Failed to get locale charmap.");
       return null;
@@ -280837,7 +281346,7 @@ var require_command_exists = __commonJS({
     "use strict";
     init_esbuild_shims();
     var exec5 = __require("child_process").exec;
-    var execSync9 = __require("child_process").execSync;
+    var execSync10 = __require("child_process").execSync;
     var fs101 = __require("fs");
     var path112 = __require("path");
     var access7 = fs101.access;
@@ -280911,7 +281420,7 @@ var require_command_exists = __commonJS({
     var commandExistsUnixSync = /* @__PURE__ */ __name(function(commandName, cleanedCommandName) {
       if (fileNotExistsSync(commandName)) {
         try {
-          var stdout = execSync9(
+          var stdout = execSync10(
             "command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }"
           );
           return !!stdout;
@@ -280926,7 +281435,7 @@ var require_command_exists = __commonJS({
         return false;
       }
       try {
-        var stdout = execSync9("where " + cleanedCommandName, { stdio: [] });
+        var stdout = execSync10("where " + cleanedCommandName, { stdio: [] });
         return !!stdout;
       } catch (error2) {
         return false;
@@ -348852,6 +349361,7 @@ function getMergeStrategyForPath(path112) {
 }
 __name(getMergeStrategyForPath, "getMergeStrategyForPath");
 var SETTINGS_DIRECTORY_NAME2 = ".qwen";
+var LEGACY_SETTINGS_FILENAME = "config.json";
 var USER_SETTINGS_PATH = Storage.getGlobalSettingsPath();
 var USER_SETTINGS_DIR2 = path72.dirname(USER_SETTINGS_PATH);
 var DEFAULT_EXCLUDED_ENV_VARS = ["DEBUG", "DEBUG_MODE"];
@@ -348933,6 +349443,10 @@ var MIGRATION_MAP = {
   vlmSwitchMode: "experimental.vlmSwitchMode",
   visionModelPreview: "experimental.visionModelPreview"
 };
+function isTermux2() {
+  return process25.platform === "android" || !!process25.env["TERMUX_VERSION"] || !!(process25.env["PREFIX"] && process25.env["PREFIX"].includes("com.termux"));
+}
+__name(isTermux2, "isTermux");
 function getSystemSettingsPath() {
   if (process25.env["QWEN_CODE_SYSTEM_SETTINGS_PATH"]) {
     return process25.env["QWEN_CODE_SYSTEM_SETTINGS_PATH"];
@@ -349252,6 +349766,11 @@ function loadSettings(workspaceDir = process25.cwd()) {
   const systemSettingsPath = getSystemSettingsPath();
   const systemDefaultsPath = getSystemDefaultsPath();
   const migratedInMemorScopes = /* @__PURE__ */ new Set();
+  const legacyUserSettingsPath = path72.join(
+    homedir13(),
+    SETTINGS_DIRECTORY_NAME2,
+    LEGACY_SETTINGS_FILENAME
+  );
   const resolvedWorkspaceDir = path72.resolve(workspaceDir);
   const resolvedHomeDir = path72.resolve(homedir13());
   let realWorkspaceDir = resolvedWorkspaceDir;
@@ -349263,15 +349782,29 @@ function loadSettings(workspaceDir = process25.cwd()) {
   const workspaceSettingsPath = new Storage(
     workspaceDir
   ).getWorkspaceSettingsPath();
-  const loadAndMigrate = /* @__PURE__ */ __name((filePath, scope) => {
+  const legacyWorkspaceSettingsPath = path72.join(
+    workspaceDir,
+    SETTINGS_DIRECTORY_NAME2,
+    LEGACY_SETTINGS_FILENAME
+  );
+  let warnedLegacySettings = false;
+  const loadAndMigrate = /* @__PURE__ */ __name((filePath, scope, legacyFilePath) => {
     try {
-      if (fs70.existsSync(filePath)) {
-        const content = fs70.readFileSync(filePath, "utf-8");
+      let sourcePath = filePath;
+      let usingLegacy = false;
+      if (!fs70.existsSync(sourcePath) && legacyFilePath) {
+        if (fs70.existsSync(legacyFilePath)) {
+          sourcePath = legacyFilePath;
+          usingLegacy = true;
+        }
+      }
+      if (fs70.existsSync(sourcePath)) {
+        const content = fs70.readFileSync(sourcePath, "utf-8");
         const rawSettings = JSON.parse((0, import_strip_json_comments2.default)(content));
         if (typeof rawSettings !== "object" || rawSettings === null || Array.isArray(rawSettings)) {
           settingsErrors.push({
             message: "Settings file is not a valid JSON object.",
-            path: filePath
+            path: sourcePath
           });
           return { settings: {} };
         }
@@ -349281,12 +349814,20 @@ function loadSettings(workspaceDir = process25.cwd()) {
           if (migratedSettings) {
             if (MIGRATE_V2_OVERWRITE) {
               try {
-                fs70.renameSync(filePath, `${filePath}.orig`);
-                fs70.writeFileSync(
-                  filePath,
-                  JSON.stringify(migratedSettings, null, 2),
-                  "utf-8"
-                );
+                if (!usingLegacy) {
+                  fs70.renameSync(sourcePath, `${sourcePath}.orig`);
+                  fs70.writeFileSync(
+                    sourcePath,
+                    JSON.stringify(migratedSettings, null, 2),
+                    "utf-8"
+                  );
+                } else {
+                  fs70.writeFileSync(
+                    filePath,
+                    JSON.stringify(migratedSettings, null, 2),
+                    "utf-8"
+                  );
+                }
               } catch (e4) {
                 console.error(
                   `Error migrating settings file on disk: ${getErrorMessage(
@@ -349303,8 +349844,9 @@ function loadSettings(workspaceDir = process25.cwd()) {
           settingsObject[SETTINGS_VERSION_KEY] = SETTINGS_VERSION;
           if (MIGRATE_V2_OVERWRITE) {
             try {
+              const targetPath = usingLegacy && sourcePath !== filePath ? filePath : sourcePath;
               fs70.writeFileSync(
-                filePath,
+                targetPath,
                 JSON.stringify(settingsObject, null, 2),
                 "utf-8"
               );
@@ -349315,6 +349857,27 @@ function loadSettings(workspaceDir = process25.cwd()) {
             }
           }
         }
+        if (usingLegacy && !warnedLegacySettings) {
+          console.warn(
+            `Loaded legacy settings from ${sourcePath}. Please migrate to ${filePath}.`
+          );
+          warnedLegacySettings = true;
+        }
+        if (usingLegacy && MIGRATE_V2_OVERWRITE) {
+          try {
+            fs70.writeFileSync(
+              filePath,
+              JSON.stringify(settingsObject, null, 2),
+              "utf-8"
+            );
+          } catch (e4) {
+            console.error(
+              `Error writing migrated settings to ${filePath}: ${getErrorMessage(
+                e4
+              )}`
+            );
+          }
+        }
         return { settings: settingsObject, rawJson: content };
       }
     } catch (error2) {
@@ -349330,7 +349893,11 @@ function loadSettings(workspaceDir = process25.cwd()) {
     systemDefaultsPath,
     "SystemDefaults" /* SystemDefaults */
   );
-  const userResult = loadAndMigrate(USER_SETTINGS_PATH, "User" /* User */);
+  const userResult = loadAndMigrate(
+    USER_SETTINGS_PATH,
+    "User" /* User */,
+    legacyUserSettingsPath
+  );
   let workspaceResult = {
     settings: {},
     rawJson: void 0
@@ -349338,7 +349905,8 @@ function loadSettings(workspaceDir = process25.cwd()) {
   if (realWorkspaceDir !== realHomeDir) {
     workspaceResult = loadAndMigrate(
       workspaceSettingsPath,
-      "Workspace" /* Workspace */
+      "Workspace" /* Workspace */,
+      legacyWorkspaceSettingsPath
     );
   }
   const systemOriginalSettings = structuredClone(systemResult.settings);
@@ -349351,6 +349919,39 @@ function loadSettings(workspaceDir = process25.cwd()) {
   systemDefaultSettings = resolveEnvVarsInObject(systemDefaultsResult.settings);
   userSettings = resolveEnvVarsInObject(userResult.settings);
   workspaceSettings = resolveEnvVarsInObject(workspaceResult.settings);
+  if (isTermux2()) {
+    const hasHideBannerSetting = [
+      systemSettings.ui?.hideBanner,
+      systemDefaultSettings.ui?.hideBanner,
+      userSettings.ui?.hideBanner,
+      workspaceSettings.ui?.hideBanner
+    ].some((value) => typeof value === "boolean");
+    if (!hasHideBannerSetting) {
+      systemDefaultSettings = {
+        ...systemDefaultSettings,
+        ui: {
+          ...systemDefaultSettings.ui ?? {},
+          hideBanner: true
+        }
+      };
+    }
+    const hasUseRipgrepSetting = [
+      systemSettings.tools?.useRipgrep,
+      systemDefaultSettings.tools?.useRipgrep,
+      userSettings.tools?.useRipgrep,
+      workspaceSettings.tools?.useRipgrep
+    ].some((value) => typeof value === "boolean");
+    if (!hasUseRipgrepSetting) {
+      systemDefaultSettings = {
+        ...systemDefaultSettings,
+        tools: {
+          ...systemDefaultSettings.tools ?? {},
+          useRipgrep: false,
+          useBuiltinRipgrep: false
+        }
+      };
+    }
+  }
   if (userSettings.ui?.theme === "VS") {
     userSettings.ui.theme = DefaultLight.name;
   } else if (userSettings.ui?.theme === "VS2015") {
@@ -355401,7 +356002,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.6.0-termux";
+  return "0.6.2-termux";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -363375,7 +363976,7 @@ var import_react26 = __toESM(require_react(), 1);
 init_esbuild_shims();
 import process28 from "node:process";
 import os28 from "node:os";
-import { execSync as execSync5 } from "node:child_process";
+import { execSync as execSync6 } from "node:child_process";
 
 // packages/cli/src/ui/utils/formatters.ts
 init_esbuild_shims();
@@ -363449,12 +364050,12 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "f2aa931a";
+var GIT_COMMIT_INFO2 = "6e378690";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
   try {
-    return execSync5("npm --version", { encoding: "utf-8" }).trim();
+    return execSync6("npm --version", { encoding: "utf-8" }).trim();
   } catch {
     return "unknown";
   }
@@ -366414,10 +367015,10 @@ import { Writable } from "node:stream";
 // packages/cli/src/utils/gitUtils.ts
 init_esbuild_shims();
 var import_undici4 = __toESM(require_undici2(), 1);
-import { execSync as execSync6 } from "node:child_process";
+import { execSync as execSync7 } from "node:child_process";
 var isGitHubRepository = /* @__PURE__ */ __name(() => {
   try {
-    const remotes = (execSync6("git remote -v", {
+    const remotes = (execSync7("git remote -v", {
       encoding: "utf-8"
     }) || "").trim();
     const pattern = /github\.com/;
@@ -366428,7 +367029,7 @@ var isGitHubRepository = /* @__PURE__ */ __name(() => {
   }
 }, "isGitHubRepository");
 var getGitRepoRoot = /* @__PURE__ */ __name(() => {
-  const gitRepoRoot = (execSync6("git rev-parse --show-toplevel", {
+  const gitRepoRoot = (execSync7("git rev-parse --show-toplevel", {
     encoding: "utf-8"
   }) || "").trim();
   if (!gitRepoRoot) {
@@ -366471,7 +367072,7 @@ var getLatestGitHubRelease = /* @__PURE__ */ __name(async (proxy) => {
   }
 }, "getLatestGitHubRelease");
 function getGitHubRepoInfo() {
-  const remoteUrl = execSync6("git remote get-url origin", {
+  const remoteUrl = execSync7("git remote get-url origin", {
     encoding: "utf-8"
   }).trim();
   let urlToParse = remoteUrl;
@@ -395048,7 +395649,9 @@ var import_jsx_runtime58 = __toESM(require_jsx_runtime(), 1);
 var Notifications = /* @__PURE__ */ __name(() => {
   const { startupWarnings } = useAppContext();
   const { initError, streamingState, updateInfo } = useUIState();
-  const showStartupWarnings = startupWarnings.length > 0;
+  const settings = useSettings();
+  const config2 = useConfig();
+  const showStartupWarnings = !settings.merged.ui?.hideBanner && !config2.getScreenReader() && startupWarnings.length > 0;
   const showInitError = initError && streamingState !== "responding" /* Responding */;
   if (!showStartupWarnings && !showInitError && !updateInfo) {
     return null;
@@ -411274,7 +411877,7 @@ __name(relaunchAppInChildProcess, "relaunchAppInChildProcess");
 // packages/cli/src/utils/sandbox.ts
 init_esbuild_shims();
 var import_shell_quote5 = __toESM(require_shell_quote(), 1);
-import { exec as exec4, execSync as execSync8, spawn as spawn10 } from "node:child_process";
+import { exec as exec4, execSync as execSync9, spawn as spawn10 } from "node:child_process";
 import os39 from "node:os";
 import path109 from "node:path";
 import fs97 from "node:fs";
@@ -411433,7 +412036,7 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
         "-D",
         `HOME_DIR=${fs97.realpathSync(os39.homedir())}`,
         "-D",
-        `CACHE_DIR=${fs97.realpathSync(execSync8(`getconf DARWIN_USER_CACHE_DIR`).toString().trim())}`
+        `CACHE_DIR=${fs97.realpathSync(execSync9(`getconf DARWIN_USER_CACHE_DIR`).toString().trim())}`
       ];
       const MAX_INCLUDE_DIRS = 5;
       const targetDir = fs97.realpathSync(cliConfig?.getTargetDir() || "");
@@ -411551,7 +412154,7 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
           console.error(`using ${projectSandboxDockerfile2} for sandbox`);
           buildArgs += `-f ${path109.resolve(projectSandboxDockerfile2)} -i ${image2}`;
         }
-        execSync8(
+        execSync9(
           `cd ${gcRoot} && node scripts/build_sandbox.js -s ${buildArgs}`,
           {
             stdio: "inherit",
@@ -411660,12 +412263,12 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
         args.push("--env", `no_proxy=${noProxy}`);
       }
       if (proxy) {
-        execSync8(
+        execSync9(
           `${config2.command} network inspect ${SANDBOX_NETWORK_NAME} || ${config2.command} network create --internal ${SANDBOX_NETWORK_NAME}`
         );
         args.push("--network", SANDBOX_NETWORK_NAME);
         if (proxyCommand) {
-          execSync8(
+          execSync9(
             `${config2.command} network inspect ${SANDBOX_PROXY_NAME} || ${config2.command} network create ${SANDBOX_PROXY_NAME}`
           );
         }
@@ -411681,7 +412284,7 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
       console.log(`ContainerName: ${containerName}`);
     } else {
       let index = 0;
-      const containerNameCheck = execSync8(
+      const containerNameCheck = execSync9(
         `${config2.command} ps -a --format "{{.Names}}"`
       ).toString().trim();
       while (containerNameCheck.includes(`${imageName}-${index}`)) {
@@ -411809,8 +412412,8 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
       userFlag = "--user root";
     } else if (await shouldUseCurrentUserInSandbox()) {
       args.push("--user", "root");
-      const uid = execSync8("id -u").toString().trim();
-      const gid = execSync8("id -g").toString().trim();
+      const uid = execSync9("id -u").toString().trim();
+      const gid = execSync9("id -g").toString().trim();
       const username = "gemini";
       const homeDir = getContainerPath(os39.homedir());
       const setupUserCommands = [
@@ -411839,7 +412442,7 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
       });
       const stopProxy = /* @__PURE__ */ __name(() => {
         console.log("stopping proxy container ...");
-        execSync8(`${config2.command} rm -f ${SANDBOX_PROXY_NAME}`);
+        execSync9(`${config2.command} rm -f ${SANDBOX_PROXY_NAME}`);
       }, "stopProxy");
       process.on("exit", stopProxy);
       process.on("SIGINT", stopProxy);
@@ -412029,6 +412632,11 @@ init_esbuild_shims();
 import fs99 from "node:fs/promises";
 import * as os41 from "node:os";
 import path110 from "node:path";
+function isTermux3() {
+  return process.platform === "android" || !!process.env["TERMUX_VERSION"] || !!(process.env["PREFIX"] && process.env["PREFIX"].includes("com.termux"));
+}
+__name(isTermux3, "isTermux");
+var IS_TERMUX = isTermux3();
 var homeDirectoryCheck = {
   id: "home-directory",
   check: /* @__PURE__ */ __name(async (options2) => {
@@ -412064,6 +412672,9 @@ var rootDirectoryCheck = {
 var ripgrepAvailabilityCheck = {
   id: "ripgrep-availability",
   check: /* @__PURE__ */ __name(async (options2) => {
+    if (IS_TERMUX) {
+      return null;
+    }
     if (!options2.useRipgrep) {
       return null;
     }
@@ -412079,7 +412690,7 @@ var ripgrepAvailabilityCheck = {
   }, "check")
 };
 var WARNING_CHECKS = [
-  homeDirectoryCheck,
+  ...IS_TERMUX ? [] : [homeDirectoryCheck],
   rootDirectoryCheck,
   ripgrepAvailabilityCheck
 ];
@@ -414564,7 +415175,7 @@ var GeminiAgent = class {
       name: APPROVAL_MODE_INFO[mode].name,
       description: APPROVAL_MODE_INFO[mode].description
     }));
-    const version2 = "0.6.0-termux";
+    const version2 = "0.6.2-termux";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -415022,7 +415633,7 @@ ${finalArgs[promptIndex + 1]}`;
       return runAcpAgent(config2, settings, extensions, argv);
     }
     let input = config2.getQuestion();
-    const startupWarnings = [
+    let startupWarnings = [
       ...await getStartupWarnings(),
       ...await getUserStartupWarnings({
         workspaceRoot: process.cwd(),
@@ -415030,6 +415641,9 @@ ${finalArgs[promptIndex + 1]}`;
         useBuiltinRipgrep: settings.merged.tools?.useBuiltinRipgrep ?? true
       })
     ];
+    if (settings.merged.ui?.hideBanner || config2.getScreenReader()) {
+      startupWarnings = [];
+    }
     if (config2.isInteractive()) {
       await kittyProtocolDetectionComplete;
       await startInteractiveUI(