@musistudio/claude-code-router 1.0.36 → 1.0.38

package/dist/cli.js

@@ -1138,11 +1138,11 @@ var require_lib = __commonJS({
   "node_modules/.pnpm/json5@2.2.3/node_modules/json5/lib/index.js"(exports2, module2) {
     var parse = require_parse();
     var stringify = require_stringify();
-    var JSON52 = {
+    var JSON53 = {
       parse,
       stringify
     };
-    module2.exports = JSON52;
+    module2.exports = JSON53;
   }
 });
 
@@ -1202,13 +1202,68 @@ var init_logCleanup = __esm({
   }
 });
 
+// src/utils/update.ts
+async function checkForUpdates(currentVersion) {
+  try {
+    const { stdout } = await execPromise("npm view @musistudio/claude-code-router version");
+    const latestVersion = stdout.trim();
+    const hasUpdate = compareVersions(latestVersion, currentVersion) > 0;
+    let changelog = "";
+    return { hasUpdate, latestVersion, changelog };
+  } catch (error) {
+    console.error("Error checking for updates:", error);
+    return { hasUpdate: false, latestVersion: currentVersion, changelog: "" };
+  }
+}
+async function performUpdate() {
+  try {
+    const { stdout, stderr } = await execPromise("npm update -g @musistudio/claude-code-router");
+    if (stderr) {
+      console.error("Update stderr:", stderr);
+    }
+    console.log("Update stdout:", stdout);
+    return {
+      success: true,
+      message: "Update completed successfully. Please restart the application to apply changes."
+    };
+  } catch (error) {
+    console.error("Error performing update:", error);
+    return {
+      success: false,
+      message: `Failed to perform update: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const num1 = i < parts1.length ? parts1[i] : 0;
+    const num2 = i < parts2.length ? parts2[i] : 0;
+    if (num1 > num2) return 1;
+    if (num1 < num2) return -1;
+  }
+  return 0;
+}
+var import_child_process, import_util, execPromise;
+var init_update = __esm({
+  "src/utils/update.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    import_util = require("util");
+    execPromise = (0, import_util.promisify)(import_child_process.exec);
+  }
+});
+
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
   backupConfigFile: () => backupConfigFile,
+  checkForUpdates: () => checkForUpdates,
   cleanupLogFiles: () => cleanupLogFiles,
   initConfig: () => initConfig,
   initDir: () => initDir,
+  performUpdate: () => performUpdate,
   readConfigFile: () => readConfigFile,
   writeConfigFile: () => writeConfigFile
 });
@@ -1222,6 +1277,7 @@ var init_utils = __esm({
     import_node_path3 = __toESM(require("node:path"));
     init_constants();
     init_logCleanup();
+    init_update();
     interpolateEnvVars = (obj) => {
       if (typeof obj === "string") {
         return obj.replace(/\$\{([^}]+)\}|\$([A-Z_][A-Z0-9_]*)/g, (match, braced, unbraced) => {
@@ -4774,8 +4830,8 @@ var require_req = __commonJS({
       if (req.originalUrl) {
         _req.url = req.originalUrl;
       } else {
-        const path6 = req.path;
-        _req.url = typeof path6 === "string" ? path6 : req.url ? req.url.path || req.url : void 0;
+        const path7 = req.path;
+        _req.url = typeof path7 === "string" ? path7 : req.url ? req.url.path || req.url : void 0;
       }
       if (req.query) {
         _req.query = req.query;
@@ -4964,17 +5020,17 @@ var require_parse2 = __commonJS({
       const wildcards = [];
       var wcLen = 0;
       const secret = paths.reduce(function(o, strPath, ix) {
-        var path6 = strPath.match(rx).map((p) => p.replace(/'|"|`/g, ""));
+        var path7 = strPath.match(rx).map((p) => p.replace(/'|"|`/g, ""));
         const leadingBracket = strPath[0] === "[";
-        path6 = path6.map((p) => {
+        path7 = path7.map((p) => {
           if (p[0] === "[") return p.substr(1, p.length - 2);
           else return p;
         });
-        const star = path6.indexOf("*");
+        const star = path7.indexOf("*");
         if (star > -1) {
-          const before = path6.slice(0, star);
+          const before = path7.slice(0, star);
           const beforeStr = before.join(".");
-          const after = path6.slice(star + 1, path6.length);
+          const after = path7.slice(star + 1, path7.length);
           const nested = after.length > 0;
           wcLen++;
           wildcards.push({
@@ -4985,7 +5041,7 @@ var require_parse2 = __commonJS({
           });
         } else {
           o[strPath] = {
-            path: path6,
+            path: path7,
             val: void 0,
             precensored: false,
             circle: "",
@@ -5031,20 +5087,20 @@ var require_redactor = __commonJS({
       return redact;
     }
     function redactTmpl(secret, isCensorFct, censorFctTakesPath) {
-      return Object.keys(secret).map((path6) => {
-        const { escPath, leadingBracket, path: arrPath } = secret[path6];
+      return Object.keys(secret).map((path7) => {
+        const { escPath, leadingBracket, path: arrPath } = secret[path7];
         const skip = leadingBracket ? 1 : 0;
         const delim = leadingBracket ? "" : ".";
         const hops = [];
         var match;
-        while ((match = rx.exec(path6)) !== null) {
+        while ((match = rx.exec(path7)) !== null) {
           const [, ix] = match;
           const { index, input } = match;
           if (index > skip) hops.push(input.substring(0, index - (ix ? 0 : 1)));
         }
         var existence = hops.map((p) => `o${delim}${p}`).join(" && ");
-        if (existence.length === 0) existence += `o${delim}${path6} != null`;
-        else existence += ` && o${delim}${path6} != null`;
+        if (existence.length === 0) existence += `o${delim}${path7} != null`;
+        else existence += ` && o${delim}${path7} != null`;
         const circularDetection = `
       switch (true) {
         ${hops.reverse().map((p) => `
@@ -5057,12 +5113,12 @@ var require_redactor = __commonJS({
         const censorArgs = censorFctTakesPath ? `val, ${JSON.stringify(arrPath)}` : `val`;
         return `
       if (${existence}) {
-        const val = o${delim}${path6}
+        const val = o${delim}${path7}
         if (val === censor) {
           secret[${escPath}].precensored = true
         } else {
           secret[${escPath}].val = val
-          o${delim}${path6} = ${isCensorFct ? `censor(${censorArgs})` : "censor"}
+          o${delim}${path7} = ${isCensorFct ? `censor(${censorArgs})` : "censor"}
           ${circularDetection}
         }
       }
@@ -5114,13 +5170,13 @@ var require_modifiers = __commonJS({
         target[k] = values[i];
       }
     }
-    function groupRedact(o, path6, censor, isCensorFct, censorFctTakesPath) {
-      const target = get(o, path6);
+    function groupRedact(o, path7, censor, isCensorFct, censorFctTakesPath) {
+      const target = get(o, path7);
       if (target == null || typeof target === "string") return { keys: null, values: null, target, flat: true };
       const keys = Object.keys(target);
       const keysLength = keys.length;
-      const pathLength = path6.length;
-      const pathWithKey = censorFctTakesPath ? [...path6] : void 0;
+      const pathLength = path7.length;
+      const pathWithKey = censorFctTakesPath ? [...path7] : void 0;
       const values = new Array(keysLength);
       for (var i = 0; i < keysLength; i++) {
         const key = keys[i];
@@ -5138,29 +5194,29 @@ var require_modifiers = __commonJS({
     }
     function nestedRestore(instructions) {
       for (let i = 0; i < instructions.length; i++) {
-        const { target, path: path6, value } = instructions[i];
+        const { target, path: path7, value } = instructions[i];
         let current = target;
-        for (let i2 = path6.length - 1; i2 > 0; i2--) {
-          current = current[path6[i2]];
+        for (let i2 = path7.length - 1; i2 > 0; i2--) {
+          current = current[path7[i2]];
         }
-        current[path6[0]] = value;
+        current[path7[0]] = value;
       }
     }
-    function nestedRedact(store, o, path6, ns, censor, isCensorFct, censorFctTakesPath) {
-      const target = get(o, path6);
+    function nestedRedact(store, o, path7, ns, censor, isCensorFct, censorFctTakesPath) {
+      const target = get(o, path7);
       if (target == null) return;
       const keys = Object.keys(target);
       const keysLength = keys.length;
       for (var i = 0; i < keysLength; i++) {
         const key = keys[i];
-        specialSet(store, target, key, path6, ns, censor, isCensorFct, censorFctTakesPath);
+        specialSet(store, target, key, path7, ns, censor, isCensorFct, censorFctTakesPath);
       }
       return store;
     }
     function has(obj, prop) {
       return obj !== void 0 && obj !== null ? "hasOwn" in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop) : false;
     }
-    function specialSet(store, o, k, path6, afterPath, censor, isCensorFct, censorFctTakesPath) {
+    function specialSet(store, o, k, path7, afterPath, censor, isCensorFct, censorFctTakesPath) {
       const afterPathLen = afterPath.length;
       const lastPathIndex = afterPathLen - 1;
       const originalKey = k;
@@ -5203,7 +5259,7 @@ var require_modifiers = __commonJS({
             if (consecutive) {
               redactPathCurrent = node(redactPathCurrent, wck, depth);
               level = i;
-              ov = iterateNthLevel(wcov, level - 1, k, path6, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
+              ov = iterateNthLevel(wcov, level - 1, k, path7, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
             } else {
               if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
                 if (kIsWc) {
@@ -5211,7 +5267,7 @@ var require_modifiers = __commonJS({
                 } else {
                   ov = wcov[k];
                 }
-                nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path6, originalKey, ...afterPath]) : censor(ov) : censor;
+                nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path7, originalKey, ...afterPath]) : censor(ov) : censor;
                 if (kIsWc) {
                   const rv = restoreInstr(node(redactPathCurrent, wck, depth), ov, o[originalKey]);
                   store.push(rv);
@@ -5234,7 +5290,7 @@ var require_modifiers = __commonJS({
         } else {
           ov = n[k];
           redactPathCurrent = node(redactPathCurrent, k, depth);
-          nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path6, originalKey, ...afterPath]) : censor(ov) : censor;
+          nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path7, originalKey, ...afterPath]) : censor(ov) : censor;
           if (has(n, k) && nv === ov || nv === void 0 && censor !== void 0) {
           } else {
             const rv = restoreInstr(redactPathCurrent, ov, o[originalKey]);
@@ -5257,7 +5313,7 @@ var require_modifiers = __commonJS({
       }
       return n;
     }
-    function iterateNthLevel(wcov, level, k, path6, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
+    function iterateNthLevel(wcov, level, k, path7, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
       if (level === 0) {
         if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
           if (kIsWc) {
@@ -5265,7 +5321,7 @@ var require_modifiers = __commonJS({
           } else {
             ov = wcov[k];
           }
-          nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path6, originalKey, ...afterPath]) : censor(ov) : censor;
+          nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path7, originalKey, ...afterPath]) : censor(ov) : censor;
           if (kIsWc) {
             const rv = restoreInstr(redactPathCurrent, ov, parent);
             store.push(rv);
@@ -5284,7 +5340,7 @@ var require_modifiers = __commonJS({
       for (const key in wcov) {
         if (typeof wcov[key] === "object") {
           redactPathCurrent = node(redactPathCurrent, key, depth);
-          iterateNthLevel(wcov[key], level - 1, k, path6, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
+          iterateNthLevel(wcov[key], level - 1, k, path7, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
         }
       }
     }
@@ -5306,12 +5362,12 @@ var require_modifiers = __commonJS({
     }
     function restoreInstr(node2, value, target) {
       let current = node2;
-      const path6 = [];
+      const path7 = [];
       do {
-        path6.push(current.key);
+        path7.push(current.key);
         current = current.parent;
       } while (current.parent != null);
-      return { path: path6, value, target };
+      return { path: path7, value, target };
     }
   }
 });
@@ -5341,10 +5397,10 @@ var require_restorer = __commonJS({
       };
     }
     function resetTmpl(secret, paths) {
-      return paths.map((path6) => {
-        const { circle, escPath, leadingBracket } = secret[path6];
+      return paths.map((path7) => {
+        const { circle, escPath, leadingBracket } = secret[path7];
         const delim = leadingBracket ? "" : ".";
-        const reset = circle ? `o.${circle} = secret[${escPath}].val` : `o${delim}${path6} = secret[${escPath}].val`;
+        const reset = circle ? `o.${circle} = secret[${escPath}].val` : `o${delim}${path7} = secret[${escPath}].val`;
         const clear = `secret[${escPath}].val = undefined`;
         return `
       if (secret[${escPath}].val !== undefined) {
@@ -5576,8 +5632,8 @@ var require_redaction = __commonJS({
         if (shape[k] === null) {
           o[k] = (value) => topCensor(value, [k]);
         } else {
-          const wrappedCensor = typeof censor === "function" ? (value, path6) => {
-            return censor(value, [k, ...path6]);
+          const wrappedCensor = typeof censor === "function" ? (value, path7) => {
+            return censor(value, [k, ...path7]);
           } : censor;
           o[k] = fastRedact({
             paths: shape[k],
@@ -5777,10 +5833,10 @@ var require_atomic_sleep = __commonJS({
 var require_sonic_boom = __commonJS({
   "node_modules/.pnpm/sonic-boom@4.2.0/node_modules/sonic-boom/index.js"(exports2, module2) {
     "use strict";
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var EventEmitter = require("events");
     var inherits = require("util").inherits;
-    var path6 = require("path");
+    var path7 = require("path");
     var sleep = require_atomic_sleep();
     var assert = require("assert");
     var BUSY_WRITE_TIMEOUT = 100;
@@ -5834,20 +5890,20 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs6.mkdirSync(path6.dirname(file), { recursive: true });
-          const fd2 = fs6.openSync(file, flags, mode);
+          if (sonic.mkdir) fs7.mkdirSync(path7.dirname(file), { recursive: true });
+          const fd2 = fs7.openSync(file, flags, mode);
           fileOpened(null, fd2);
         } catch (err) {
           fileOpened(err);
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs6.mkdir(path6.dirname(file), { recursive: true }, (err) => {
+        fs7.mkdir(path7.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
-          fs6.open(file, flags, mode, fileOpened);
+          fs7.open(file, flags, mode, fileOpened);
         });
       } else {
-        fs6.open(file, flags, mode, fileOpened);
+        fs7.open(file, flags, mode, fileOpened);
       }
     }
     function SonicBoom(opts) {
@@ -5888,16 +5944,16 @@ var require_sonic_boom = __commonJS({
         this.flush = flushBuffer;
         this.flushSync = flushBufferSync;
         this._actualWrite = actualWriteBuffer;
-        fsWriteSync = () => fs6.writeSync(this.fd, this._writingBuf);
-        fsWrite = () => fs6.write(this.fd, this._writingBuf, this.release);
+        fsWriteSync = () => fs7.writeSync(this.fd, this._writingBuf);
+        fsWrite = () => fs7.write(this.fd, this._writingBuf, this.release);
       } else if (contentMode === void 0 || contentMode === kContentModeUtf8) {
         this._writingBuf = "";
         this.write = write;
         this.flush = flush;
         this.flushSync = flushSync;
         this._actualWrite = actualWrite;
-        fsWriteSync = () => fs6.writeSync(this.fd, this._writingBuf, "utf8");
-        fsWrite = () => fs6.write(this.fd, this._writingBuf, "utf8", this.release);
+        fsWriteSync = () => fs7.writeSync(this.fd, this._writingBuf, "utf8");
+        fsWrite = () => fs7.write(this.fd, this._writingBuf, "utf8", this.release);
       } else {
         throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
       }
@@ -5953,7 +6009,7 @@ var require_sonic_boom = __commonJS({
           }
         }
         if (this._fsync) {
-          fs6.fsyncSync(this.fd);
+          fs7.fsyncSync(this.fd);
         }
         const len = this._len;
         if (this._reopening) {
@@ -6065,7 +6121,7 @@ var require_sonic_boom = __commonJS({
       const onDrain = () => {
         if (!this._fsync) {
           try {
-            fs6.fsync(this.fd, (err) => {
+            fs7.fsync(this.fd, (err) => {
               this._flushPending = false;
               cb(err);
             });
@@ -6167,7 +6223,7 @@ var require_sonic_boom = __commonJS({
       const fd2 = this.fd;
       this.once("ready", () => {
         if (fd2 !== this.fd) {
-          fs6.close(fd2, (err) => {
+          fs7.close(fd2, (err) => {
             if (err) {
               return this.emit("error", err);
             }
@@ -6216,7 +6272,7 @@ var require_sonic_boom = __commonJS({
           buf = this._bufs[0];
         }
         try {
-          const n = fs6.writeSync(this.fd, buf, "utf8");
+          const n = fs7.writeSync(this.fd, buf, "utf8");
           const releasedBufObj = releaseWritingBuf(buf, this._len, n);
           buf = releasedBufObj.writingBuf;
           this._len = releasedBufObj.len;
@@ -6232,7 +6288,7 @@ var require_sonic_boom = __commonJS({
         }
       }
       try {
-        fs6.fsyncSync(this.fd);
+        fs7.fsyncSync(this.fd);
       } catch {
       }
     }
@@ -6253,7 +6309,7 @@ var require_sonic_boom = __commonJS({
           buf = mergeBuf(this._bufs[0], this._lens[0]);
         }
         try {
-          const n = fs6.writeSync(this.fd, buf);
+          const n = fs7.writeSync(this.fd, buf);
           buf = buf.subarray(n);
           this._len = Math.max(this._len - n, 0);
           if (buf.length <= 0) {
@@ -6281,13 +6337,13 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf || this._bufs.shift() || "";
       if (this.sync) {
         try {
-          const written = fs6.writeSync(this.fd, this._writingBuf, "utf8");
+          const written = fs7.writeSync(this.fd, this._writingBuf, "utf8");
           release(null, written);
         } catch (err) {
           release(err);
         }
       } else {
-        fs6.write(this.fd, this._writingBuf, "utf8", release);
+        fs7.write(this.fd, this._writingBuf, "utf8", release);
       }
     }
     function actualWriteBuffer() {
@@ -6296,7 +6352,7 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
       if (this.sync) {
         try {
-          const written = fs6.writeSync(this.fd, this._writingBuf);
+          const written = fs7.writeSync(this.fd, this._writingBuf);
           release(null, written);
         } catch (err) {
           release(err);
@@ -6305,7 +6361,7 @@ var require_sonic_boom = __commonJS({
         if (kCopyBuffer) {
           this._writingBuf = Buffer.from(this._writingBuf);
         }
-        fs6.write(this.fd, this._writingBuf, release);
+        fs7.write(this.fd, this._writingBuf, release);
       }
     }
     function actualClose(sonic) {
@@ -6321,12 +6377,12 @@ var require_sonic_boom = __commonJS({
       sonic._lens = [];
       assert(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
       try {
-        fs6.fsync(sonic.fd, closeWrapped);
+        fs7.fsync(sonic.fd, closeWrapped);
       } catch {
       }
       function closeWrapped() {
         if (sonic.fd !== 1 && sonic.fd !== 2) {
-          fs6.close(sonic.fd, done);
+          fs7.close(sonic.fd, done);
         } else {
           done();
         }
@@ -7572,9 +7628,9 @@ var require_levels = __commonJS({
       const { levels, levelVal } = this;
       return levels && levels.labels ? levels.labels[levelVal] : "";
     }
-    function isLevelEnabled(logLevel) {
+    function isLevelEnabled(logLevel2) {
       const { values } = this.levels;
-      const logLevelVal = values[logLevel];
+      const logLevelVal = values[logLevel2];
       return logLevelVal !== void 0 && this[levelCompSym](logLevelVal, this[levelValSym]);
     }
     function compareLevel(direction, current, expected) {
@@ -11902,7 +11958,7 @@ var require_context = __commonJS({
       childLoggerFactory,
       errorHandler,
       bodyLimit,
-      logLevel,
+      logLevel: logLevel2,
       logSerializers,
       attachValidation,
       validatorCompiler,
@@ -11937,7 +11993,7 @@ var require_context = __commonJS({
       };
       this.exposeHeadRoute = exposeHeadRoute;
       this.prefixTrailingSlash = prefixTrailingSlash;
-      this.logLevel = logLevel || server[kLogLevel];
+      this.logLevel = logLevel2 || server[kLogLevel];
       this.logSerializers = logSerializers;
       this[kFourOhFourContext] = null;
       this.attachValidation = attachValidation;
@@ -16185,9 +16241,9 @@ var require_validate = __commonJS({
       }
       let expr = data;
       const segments = jsonPointer.split("/");
-      for (const segment of segments) {
-        if (segment) {
-          data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;
+      for (const segment2 of segments) {
+        if (segment2) {
+          data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment2))}`;
           expr = (0, codegen_1._)`${expr} && ${data}`;
         }
       }
@@ -16782,8 +16838,8 @@ var require_schemes = __commonJS({
         wsComponents.secure = void 0;
       }
       if (wsComponents.resourceName) {
-        const [path6, query] = wsComponents.resourceName.split("?");
-        wsComponents.path = path6 && path6 !== "/" ? path6 : void 0;
+        const [path7, query] = wsComponents.resourceName.split("?");
+        wsComponents.path = path7 && path7 !== "/" ? path7 : void 0;
         wsComponents.query = query;
         wsComponents.resourceName = void 0;
       }
@@ -20099,12 +20155,12 @@ var require_dist2 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs6, exportName) {
+    function addFormats(ajv, list, fs7, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs6[f]);
+        ajv.addFormat(f, fs7[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -28778,40 +28834,40 @@ var require_node = __commonJS({
         super();
         this.staticChildren = {};
       }
-      findStaticMatchingChild(path6, pathIndex) {
-        const staticChild = this.staticChildren[path6.charAt(pathIndex)];
-        if (staticChild === void 0 || !staticChild.matchPrefix(path6, pathIndex)) {
+      findStaticMatchingChild(path7, pathIndex) {
+        const staticChild = this.staticChildren[path7.charAt(pathIndex)];
+        if (staticChild === void 0 || !staticChild.matchPrefix(path7, pathIndex)) {
           return null;
         }
         return staticChild;
       }
-      getStaticChild(path6, pathIndex = 0) {
-        if (path6.length === pathIndex) {
+      getStaticChild(path7, pathIndex = 0) {
+        if (path7.length === pathIndex) {
           return this;
         }
-        const staticChild = this.findStaticMatchingChild(path6, pathIndex);
+        const staticChild = this.findStaticMatchingChild(path7, pathIndex);
         if (staticChild) {
-          return staticChild.getStaticChild(path6, pathIndex + staticChild.prefix.length);
+          return staticChild.getStaticChild(path7, pathIndex + staticChild.prefix.length);
         }
         return null;
       }
-      createStaticChild(path6) {
-        if (path6.length === 0) {
+      createStaticChild(path7) {
+        if (path7.length === 0) {
           return this;
         }
-        let staticChild = this.staticChildren[path6.charAt(0)];
+        let staticChild = this.staticChildren[path7.charAt(0)];
         if (staticChild) {
           let i = 1;
           for (; i < staticChild.prefix.length; i++) {
-            if (path6.charCodeAt(i) !== staticChild.prefix.charCodeAt(i)) {
+            if (path7.charCodeAt(i) !== staticChild.prefix.charCodeAt(i)) {
               staticChild = staticChild.split(this, i);
               break;
             }
           }
-          return staticChild.createStaticChild(path6.slice(i));
+          return staticChild.createStaticChild(path7.slice(i));
         }
-        const label = path6.charAt(0);
-        this.staticChildren[label] = new StaticNode(path6);
+        const label = path7.charAt(0);
+        this.staticChildren[label] = new StaticNode(path7);
         return this.staticChildren[label];
       }
     };
@@ -28871,8 +28927,8 @@ var require_node = __commonJS({
         parentNode.staticChildren[parentPrefix.charAt(0)] = staticNode;
         return staticNode;
       }
-      getNextNode(path6, pathIndex, nodeStack, paramsCount) {
-        let node = this.findStaticMatchingChild(path6, pathIndex);
+      getNextNode(path7, pathIndex, nodeStack, paramsCount) {
+        let node = this.findStaticMatchingChild(path7, pathIndex);
         let parametricBrotherNodeIndex = 0;
         if (node === null) {
           if (this.parametricChildren.length === 0) {
@@ -28919,8 +28975,8 @@ var require_node = __commonJS({
         this.kind = NODE_TYPES.PARAMETRIC;
         this.nodePaths = /* @__PURE__ */ new Set([nodePath]);
       }
-      getNextNode(path6, pathIndex) {
-        return this.findStaticMatchingChild(path6, pathIndex);
+      getNextNode(path7, pathIndex) {
+        return this.findStaticMatchingChild(path7, pathIndex);
       }
     };
     var WildcardNode = class extends Node {
@@ -29256,33 +29312,33 @@ var require_url_sanitizer = __commonJS({
       }
       return null;
     }
-    function safeDecodeURI(path6, useSemicolonDelimiter) {
+    function safeDecodeURI(path7, useSemicolonDelimiter) {
       let shouldDecode = false;
       let shouldDecodeParam = false;
       let querystring = "";
-      for (let i = 1; i < path6.length; i++) {
-        const charCode = path6.charCodeAt(i);
+      for (let i = 1; i < path7.length; i++) {
+        const charCode = path7.charCodeAt(i);
         if (charCode === 37) {
-          const highCharCode = path6.charCodeAt(i + 1);
-          const lowCharCode = path6.charCodeAt(i + 2);
+          const highCharCode = path7.charCodeAt(i + 1);
+          const lowCharCode = path7.charCodeAt(i + 2);
           if (decodeComponentChar(highCharCode, lowCharCode) === null) {
             shouldDecode = true;
           } else {
             shouldDecodeParam = true;
             if (highCharCode === 50 && lowCharCode === 53) {
               shouldDecode = true;
-              path6 = path6.slice(0, i + 1) + "25" + path6.slice(i + 1);
+              path7 = path7.slice(0, i + 1) + "25" + path7.slice(i + 1);
               i += 2;
             }
             i += 2;
           }
         } else if (charCode === 63 || charCode === 35 || charCode === 59 && useSemicolonDelimiter) {
-          querystring = path6.slice(i + 1);
-          path6 = path6.slice(0, i);
+          querystring = path7.slice(i + 1);
+          path7 = path7.slice(0, i);
           break;
         }
       }
-      const decodedPath = shouldDecode ? decodeURI(path6) : path6;
+      const decodedPath = shouldDecode ? decodeURI(path7) : path7;
       return { path: decodedPath, querystring, shouldDecodeParam };
     }
     function safeDecodeURIComponent(uriComponent) {
@@ -29375,7 +29431,7 @@ var require_find_my_way = __commonJS({
       this.routes = [];
       this.trees = {};
     }
-    Router.prototype.on = function on(method, path6, opts, handler, store) {
+    Router.prototype.on = function on(method, path7, opts, handler, store) {
       if (typeof opts === "function") {
         if (handler !== void 0) {
           store = handler;
@@ -29383,34 +29439,34 @@ var require_find_my_way = __commonJS({
         handler = opts;
         opts = {};
       }
-      assert(typeof path6 === "string", "Path should be a string");
-      assert(path6.length > 0, "The path could not be empty");
-      assert(path6[0] === "/" || path6[0] === "*", "The first character of a path should be `/` or `*`");
+      assert(typeof path7 === "string", "Path should be a string");
+      assert(path7.length > 0, "The path could not be empty");
+      assert(path7[0] === "/" || path7[0] === "*", "The first character of a path should be `/` or `*`");
       assert(typeof handler === "function", "Handler should be a function");
-      const optionalParamMatch = path6.match(OPTIONAL_PARAM_REGEXP);
+      const optionalParamMatch = path7.match(OPTIONAL_PARAM_REGEXP);
       if (optionalParamMatch) {
-        assert(path6.length === optionalParamMatch.index + optionalParamMatch[0].length, "Optional Parameter needs to be the last parameter of the path");
-        const pathFull = path6.replace(OPTIONAL_PARAM_REGEXP, "$1$2");
-        const pathOptional = path6.replace(OPTIONAL_PARAM_REGEXP, "$2") || "/";
+        assert(path7.length === optionalParamMatch.index + optionalParamMatch[0].length, "Optional Parameter needs to be the last parameter of the path");
+        const pathFull = path7.replace(OPTIONAL_PARAM_REGEXP, "$1$2");
+        const pathOptional = path7.replace(OPTIONAL_PARAM_REGEXP, "$2") || "/";
         this.on(method, pathFull, opts, handler, store);
         this.on(method, pathOptional, opts, handler, store);
         return;
       }
-      const route = path6;
+      const route = path7;
       if (this.ignoreDuplicateSlashes) {
-        path6 = removeDuplicateSlashes(path6);
+        path7 = removeDuplicateSlashes(path7);
       }
       if (this.ignoreTrailingSlash) {
-        path6 = trimLastSlash(path6);
+        path7 = trimLastSlash(path7);
       }
       const methods = Array.isArray(method) ? method : [method];
       for (const method2 of methods) {
         assert(typeof method2 === "string", "Method should be a string");
         assert(httpMethods.includes(method2), `Method '${method2}' is not an http method.`);
-        this._on(method2, path6, opts, handler, store, route);
+        this._on(method2, path7, opts, handler, store, route);
       }
     };
-    Router.prototype._on = function _on(method, path6, opts, handler, store) {
+    Router.prototype._on = function _on(method, path7, opts, handler, store) {
       let constraints = {};
       if (opts.constraints !== void 0) {
         assert(typeof opts.constraints === "object" && opts.constraints !== null, "Constraints should be an object");
@@ -29423,7 +29479,7 @@ var require_find_my_way = __commonJS({
       if (this.trees[method] === void 0) {
         this.trees[method] = new StaticNode("/");
       }
-      let pattern = path6;
+      let pattern = path7;
       if (pattern === "*" && this.trees[method].prefix.length !== 0) {
         const currentRoot = this.trees[method];
         this.trees[method] = new StaticNode("");
@@ -29526,19 +29582,19 @@ var require_find_my_way = __commonJS({
           throw new Error(`Method '${method}' already declared for route '${pattern}' with constraints '${JSON.stringify(constraints)}'`);
         }
       }
-      const route = { method, path: path6, pattern, params, opts, handler, store };
+      const route = { method, path: path7, pattern, params, opts, handler, store };
       this.routes.push(route);
       currentNode.addRoute(route, this.constrainer);
     };
-    Router.prototype.hasRoute = function hasRoute(method, path6, constraints) {
-      const route = this.findRoute(method, path6, constraints);
+    Router.prototype.hasRoute = function hasRoute(method, path7, constraints) {
+      const route = this.findRoute(method, path7, constraints);
       return route !== null;
     };
-    Router.prototype.findRoute = function findNode(method, path6, constraints = {}) {
+    Router.prototype.findRoute = function findNode(method, path7, constraints = {}) {
       if (this.trees[method] === void 0) {
         return null;
       }
-      let pattern = path6;
+      let pattern = path7;
       let currentNode = this.trees[method];
       let parentNodePathIndex = currentNode.prefix.length;
       const params = [];
@@ -29656,39 +29712,39 @@ var require_find_my_way = __commonJS({
       this.trees = {};
       this.routes = [];
     };
-    Router.prototype.off = function off(method, path6, constraints) {
-      assert(typeof path6 === "string", "Path should be a string");
-      assert(path6.length > 0, "The path could not be empty");
-      assert(path6[0] === "/" || path6[0] === "*", "The first character of a path should be `/` or `*`");
+    Router.prototype.off = function off(method, path7, constraints) {
+      assert(typeof path7 === "string", "Path should be a string");
+      assert(path7.length > 0, "The path could not be empty");
+      assert(path7[0] === "/" || path7[0] === "*", "The first character of a path should be `/` or `*`");
       assert(
         typeof constraints === "undefined" || typeof constraints === "object" && !Array.isArray(constraints) && constraints !== null,
         "Constraints should be an object or undefined."
       );
-      const optionalParamMatch = path6.match(OPTIONAL_PARAM_REGEXP);
+      const optionalParamMatch = path7.match(OPTIONAL_PARAM_REGEXP);
       if (optionalParamMatch) {
-        assert(path6.length === optionalParamMatch.index + optionalParamMatch[0].length, "Optional Parameter needs to be the last parameter of the path");
-        const pathFull = path6.replace(OPTIONAL_PARAM_REGEXP, "$1$2");
-        const pathOptional = path6.replace(OPTIONAL_PARAM_REGEXP, "$2");
+        assert(path7.length === optionalParamMatch.index + optionalParamMatch[0].length, "Optional Parameter needs to be the last parameter of the path");
+        const pathFull = path7.replace(OPTIONAL_PARAM_REGEXP, "$1$2");
+        const pathOptional = path7.replace(OPTIONAL_PARAM_REGEXP, "$2");
         this.off(method, pathFull, constraints);
         this.off(method, pathOptional, constraints);
         return;
       }
       if (this.ignoreDuplicateSlashes) {
-        path6 = removeDuplicateSlashes(path6);
+        path7 = removeDuplicateSlashes(path7);
       }
       if (this.ignoreTrailingSlash) {
-        path6 = trimLastSlash(path6);
+        path7 = trimLastSlash(path7);
       }
       const methods = Array.isArray(method) ? method : [method];
       for (const method2 of methods) {
-        this._off(method2, path6, constraints);
+        this._off(method2, path7, constraints);
       }
     };
-    Router.prototype._off = function _off(method, path6, constraints) {
+    Router.prototype._off = function _off(method, path7, constraints) {
       assert(typeof method === "string", "Method should be a string");
       assert(httpMethods.includes(method), `Method '${method}' is not an http method.`);
       function matcherWithoutConstraints(route) {
-        return method !== route.method || path6 !== route.path;
+        return method !== route.method || path7 !== route.path;
       }
       function matcherWithConstraints(route) {
         return matcherWithoutConstraints(route) || !deepEqual(constraints, route.opts.constraints || {});
@@ -29725,37 +29781,37 @@ var require_find_my_way = __commonJS({
       if (handle === null) return this._defaultRoute(req, res, ctx);
       return ctx === void 0 ? handle.handler(req, res, handle.params, handle.store, handle.searchParams) : handle.handler.call(ctx, req, res, handle.params, handle.store, handle.searchParams);
     };
-    Router.prototype.find = function find(method, path6, derivedConstraints) {
+    Router.prototype.find = function find(method, path7, derivedConstraints) {
       let currentNode = this.trees[method];
       if (currentNode === void 0) return null;
-      if (path6.charCodeAt(0) !== 47) {
-        path6 = path6.replace(FULL_PATH_REGEXP, "/");
+      if (path7.charCodeAt(0) !== 47) {
+        path7 = path7.replace(FULL_PATH_REGEXP, "/");
       }
       if (this.ignoreDuplicateSlashes) {
-        path6 = removeDuplicateSlashes(path6);
+        path7 = removeDuplicateSlashes(path7);
       }
       let sanitizedUrl;
       let querystring2;
       let shouldDecodeParam;
       try {
-        sanitizedUrl = safeDecodeURI(path6, this.useSemicolonDelimiter);
-        path6 = sanitizedUrl.path;
+        sanitizedUrl = safeDecodeURI(path7, this.useSemicolonDelimiter);
+        path7 = sanitizedUrl.path;
         querystring2 = sanitizedUrl.querystring;
         shouldDecodeParam = sanitizedUrl.shouldDecodeParam;
       } catch (error) {
-        return this._onBadUrl(path6);
+        return this._onBadUrl(path7);
       }
       if (this.ignoreTrailingSlash) {
-        path6 = trimLastSlash(path6);
+        path7 = trimLastSlash(path7);
       }
-      const originPath = path6;
+      const originPath = path7;
       if (this.caseSensitive === false) {
-        path6 = path6.toLowerCase();
+        path7 = path7.toLowerCase();
       }
       const maxParamLength = this.maxParamLength;
       let pathIndex = currentNode.prefix.length;
       const params = [];
-      const pathLen = path6.length;
+      const pathLen = path7.length;
       const brothersNodesStack = [];
       while (true) {
         if (pathIndex === pathLen && currentNode.isLeafNode) {
@@ -29769,7 +29825,7 @@ var require_find_my_way = __commonJS({
             };
           }
         }
-        let node = currentNode.getNextNode(path6, pathIndex, brothersNodesStack, params.length);
+        let node = currentNode.getNextNode(path7, pathIndex, brothersNodesStack, params.length);
         if (node === null) {
           if (brothersNodesStack.length === 0) {
             return null;
@@ -29823,8 +29879,8 @@ var require_find_my_way = __commonJS({
     Router.prototype._rebuild = function(routes) {
       this.reset();
       for (const route of routes) {
-        const { method, path: path6, opts, handler, store } = route;
-        this._on(method, path6, opts, handler, store);
+        const { method, path: path7, opts, handler, store } = route;
+        this._on(method, path7, opts, handler, store);
       }
     };
     Router.prototype._defaultRoute = function(req, res, ctx) {
@@ -29835,13 +29891,13 @@ var require_find_my_way = __commonJS({
         res.end();
       }
     };
-    Router.prototype._onBadUrl = function(path6) {
+    Router.prototype._onBadUrl = function(path7) {
       if (this.onBadUrl === null) {
         return null;
       }
       const onBadUrl = this.onBadUrl;
       return {
-        handler: (req, res, ctx) => onBadUrl(path6, req, res),
+        handler: (req, res, ctx) => onBadUrl(path7, req, res),
         params: {},
         store: null
       };
@@ -29873,25 +29929,25 @@ var require_find_my_way = __commonJS({
       if (!httpMethods.hasOwnProperty(i)) continue;
       const m = httpMethods[i];
       const methodName = m.toLowerCase();
-      Router.prototype[methodName] = function(path6, handler, store) {
-        return this.on(m, path6, handler, store);
+      Router.prototype[methodName] = function(path7, handler, store) {
+        return this.on(m, path7, handler, store);
       };
     }
-    Router.prototype.all = function(path6, handler, store) {
-      this.on(httpMethods, path6, handler, store);
+    Router.prototype.all = function(path7, handler, store) {
+      this.on(httpMethods, path7, handler, store);
     };
     module2.exports = Router;
     function escapeRegExp(string) {
       return string.replace(ESCAPE_REGEXP, "\\$&");
     }
-    function removeDuplicateSlashes(path6) {
-      return path6.indexOf("//") !== -1 ? path6.replace(REMOVE_DUPLICATE_SLASHES_REGEXP, "/") : path6;
+    function removeDuplicateSlashes(path7) {
+      return path7.indexOf("//") !== -1 ? path7.replace(REMOVE_DUPLICATE_SLASHES_REGEXP, "/") : path7;
     }
-    function trimLastSlash(path6) {
-      if (path6.length > 1 && path6.charCodeAt(path6.length - 1) === 47) {
-        return path6.slice(0, -1);
+    function trimLastSlash(path7) {
+      if (path7.length > 1 && path7.charCodeAt(path7.length - 1) === 47) {
+        return path7.slice(0, -1);
       }
-      return path6;
+      return path7;
     }
     function trimRegExpStartAndEnd(regexString) {
       if (regexString.charCodeAt(1) === 94) {
@@ -29902,22 +29958,22 @@ var require_find_my_way = __commonJS({
       }
       return regexString;
     }
-    function getClosingParenthensePosition(path6, idx) {
+    function getClosingParenthensePosition(path7, idx) {
       let parentheses = 1;
-      while (idx < path6.length) {
+      while (idx < path7.length) {
         idx++;
-        if (path6.charCodeAt(idx) === 92) {
+        if (path7.charCodeAt(idx) === 92) {
           idx++;
           continue;
         }
-        if (path6.charCodeAt(idx) === 41) {
+        if (path7.charCodeAt(idx) === 41) {
           parentheses--;
-        } else if (path6.charCodeAt(idx) === 40) {
+        } else if (path7.charCodeAt(idx) === 40) {
           parentheses++;
         }
         if (!parentheses) return idx;
       }
-      throw new TypeError('Invalid regexp expression in "' + path6 + '"');
+      throw new TypeError('Invalid regexp expression in "' + path7 + '"');
     }
     function defaultBuildPrettyMeta(route) {
       if (!route) return {};
@@ -30124,12 +30180,12 @@ var require_route = __commonJS({
       function route({ options: options2, isFastify }) {
         throwIfAlreadyStarted("Cannot add route!");
         const opts = { ...options2 };
-        const path6 = opts.url || opts.path || "";
+        const path7 = opts.url || opts.path || "";
         if (!opts.handler) {
-          throw new FST_ERR_ROUTE_MISSING_HANDLER(opts.method, path6);
+          throw new FST_ERR_ROUTE_MISSING_HANDLER(opts.method, path7);
         }
         if (opts.errorHandler !== void 0 && typeof opts.errorHandler !== "function") {
-          throw new FST_ERR_ROUTE_HANDLER_NOT_FN(opts.method, path6);
+          throw new FST_ERR_ROUTE_HANDLER_NOT_FN(opts.method, path7);
         }
         validateBodyLimitOption(opts.bodyLimit);
         const shouldExposeHead = opts.exposeHeadRoute ?? globalExposeHeadRoutes;
@@ -30138,22 +30194,22 @@ var require_route = __commonJS({
         if (Array.isArray(opts.method)) {
           for (let i = 0; i < opts.method.length; ++i) {
             opts.method[i] = normalizeAndValidateMethod.call(this, opts.method[i]);
-            validateSchemaBodyOption.call(this, opts.method[i], path6, opts.schema);
+            validateSchemaBodyOption.call(this, opts.method[i], path7, opts.schema);
             isGetRoute = opts.method.includes("GET");
             isHeadRoute = opts.method.includes("HEAD");
           }
         } else {
           opts.method = normalizeAndValidateMethod.call(this, opts.method);
-          validateSchemaBodyOption.call(this, opts.method, path6, opts.schema);
+          validateSchemaBodyOption.call(this, opts.method, path7, opts.schema);
           isGetRoute = opts.method === "GET";
           isHeadRoute = opts.method === "HEAD";
         }
         const headOpts = shouldExposeHead && isGetRoute ? { ...options2 } : null;
         const prefix = this[kRoutePrefix];
-        if (path6 === "/" && prefix.length > 0 && opts.method !== "HEAD") {
+        if (path7 === "/" && prefix.length > 0 && opts.method !== "HEAD") {
           switch (opts.prefixTrailingSlash) {
             case "slash":
-              addNewRoute.call(this, { path: path6, isFastify });
+              addNewRoute.call(this, { path: path7, isFastify });
               break;
             case "no-slash":
               addNewRoute.call(this, { path: "", isFastify });
@@ -30162,20 +30218,20 @@ var require_route = __commonJS({
             default:
               addNewRoute.call(this, { path: "", isFastify });
               if (ignoreTrailingSlash !== true && (ignoreDuplicateSlashes !== true || !prefix.endsWith("/"))) {
-                addNewRoute.call(this, { path: path6, prefixing: true, isFastify });
+                addNewRoute.call(this, { path: path7, prefixing: true, isFastify });
               }
           }
-        } else if (path6[0] === "/" && prefix.endsWith("/")) {
-          addNewRoute.call(this, { path: path6.slice(1), isFastify });
+        } else if (path7[0] === "/" && prefix.endsWith("/")) {
+          addNewRoute.call(this, { path: path7.slice(1), isFastify });
         } else {
-          addNewRoute.call(this, { path: path6, isFastify });
+          addNewRoute.call(this, { path: path7, isFastify });
         }
         return this;
-        function addNewRoute({ path: path7, prefixing = false, isFastify: isFastify2 = false }) {
-          const url = prefix + path7;
+        function addNewRoute({ path: path8, prefixing = false, isFastify: isFastify2 = false }) {
+          const url = prefix + path8;
           opts.url = url;
           opts.path = url;
-          opts.routePath = path7;
+          opts.routePath = path8;
           opts.prefix = prefix;
           opts.logLevel = opts.logLevel || this[kLogLevel];
           if (this[kLogSerializers] || opts.logSerializers) {
@@ -30299,7 +30355,7 @@ var require_route = __commonJS({
           });
           if (shouldExposeHead && isGetRoute && !isHeadRoute && !hasHEADHandler) {
             const onSendHandlers = parseHeadOnSendHandlers(headOpts.onSend);
-            prepareRoute.call(this, { method: "HEAD", url: path7, options: { ...headOpts, onSend: onSendHandlers }, isFastify: true });
+            prepareRoute.call(this, { method: "HEAD", url: path8, options: { ...headOpts, onSend: onSendHandlers }, isFastify: true });
           }
         }
       }
@@ -30400,9 +30456,9 @@ var require_route = __commonJS({
       }
       return method;
     }
-    function validateSchemaBodyOption(method, path6, schema) {
+    function validateSchemaBodyOption(method, path7, schema) {
       if (this[kSupportedHTTPMethods].bodyless.has(method) && schema?.body) {
-        throw new FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED(method, path6);
+        throw new FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED(method, path7);
       }
     }
     function validateBodyLimitOption(bodyLimit) {
@@ -30481,7 +30537,7 @@ var require_fourOhFour = __commonJS({
         });
       }
       function createOnBadUrl() {
-        return function onBadUrl(path6, req, res) {
+        return function onBadUrl(path7, req, res) {
           const fourOhFourContext = this[kFourOhFourLevelInstance][kFourOhFourContext];
           const id = getGenReqId(fourOhFourContext.server, req);
           const childLogger = createChildLogger(fourOhFourContext, logger, req, id);
@@ -34198,7 +34254,7 @@ ${body}`);
         }
         fourOhFour.router.lookup(req, res);
       }
-      function onBadUrl(path6, req, res) {
+      function onBadUrl(path7, req, res) {
         if (frameworkErrors) {
           const id = getGenReqId(onBadUrlContext.server, req);
           const childLogger = createChildLogger(onBadUrlContext, logger, req, id);
@@ -34207,9 +34263,9 @@ ${body}`);
           if (disableRequestLogging === false) {
             childLogger.info({ req: request }, "incoming request");
           }
-          return frameworkErrors(new FST_ERR_BAD_URL(path6), request, reply);
+          return frameworkErrors(new FST_ERR_BAD_URL(path7), request, reply);
         }
-        const body = `{"error":"Bad Request","code":"FST_ERR_BAD_URL","message":"'${path6}' is not a valid url component","statusCode":400}`;
+        const body = `{"error":"Bad Request","code":"FST_ERR_BAD_URL","message":"'${path7}' is not a valid url component","statusCode":400}`;
         res.writeHead(400, {
           "Content-Type": "application/json",
           "Content-Length": body.length
@@ -34838,8 +34894,8 @@ var require_package2 = __commonJS({
 // node_modules/.pnpm/dotenv@16.6.1/node_modules/dotenv/lib/main.js
 var require_main = __commonJS({
   "node_modules/.pnpm/dotenv@16.6.1/node_modules/dotenv/lib/main.js"(exports2, module2) {
-    var fs6 = require("fs");
-    var path6 = require("path");
+    var fs7 = require("fs");
+    var path7 = require("path");
     var os2 = require("os");
     var crypto2 = require("crypto");
     var packageJson = require_package2();
@@ -34947,7 +35003,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs6.existsSync(filepath)) {
+            if (fs7.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -34955,15 +35011,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path6.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path7.resolve(process.cwd(), ".env.vault");
       }
-      if (fs6.existsSync(possibleVaultPath)) {
+      if (fs7.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path6.join(os2.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path7.join(os2.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -34980,7 +35036,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path6.resolve(process.cwd(), ".env");
+      const dotenvPath = path7.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       const debug = Boolean(options && options.debug);
       const quiet = options && "quiet" in options ? options.quiet : true;
@@ -35004,13 +35060,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path7 of optionPaths) {
+      for (const path8 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs6.readFileSync(path7, { encoding }));
+          const parsed = DotenvModule.parse(fs7.readFileSync(path8, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path7} ${e.message}`);
+            _debug(`Failed to load ${path8} ${e.message}`);
           }
           lastError = e;
         }
@@ -35025,7 +35081,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path6.relative(process.cwd(), filePath);
+            const relative = path7.relative(process.cwd(), filePath);
             shortPaths.push(relative);
           } catch (e) {
             if (debug) {
@@ -36039,14 +36095,14 @@ var require_util4 = __commonJS({
         }
         const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
         let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`;
-        let path6 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
+        let path7 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
         if (origin[origin.length - 1] === "/") {
           origin = origin.slice(0, origin.length - 1);
         }
-        if (path6 && path6[0] !== "/") {
-          path6 = `/${path6}`;
+        if (path7 && path7[0] !== "/") {
+          path7 = `/${path7}`;
         }
-        return new URL(`${origin}${path6}`);
+        return new URL(`${origin}${path7}`);
       }
       if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
         throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
@@ -36594,9 +36650,9 @@ var require_diagnostics = __commonJS({
         "undici:client:sendHeaders",
         (evt) => {
           const {
-            request: { method, path: path6, origin }
+            request: { method, path: path7, origin }
           } = evt;
-          debugLog("sending request to %s %s%s", method, origin, path6);
+          debugLog("sending request to %s %s%s", method, origin, path7);
         }
       );
     }
@@ -36610,14 +36666,14 @@ var require_diagnostics = __commonJS({
         "undici:request:headers",
         (evt) => {
           const {
-            request: { method, path: path6, origin },
+            request: { method, path: path7, origin },
             response: { statusCode }
           } = evt;
           debugLog(
             "received response to %s %s%s - HTTP %d",
             method,
             origin,
-            path6,
+            path7,
             statusCode
           );
         }
@@ -36626,23 +36682,23 @@ var require_diagnostics = __commonJS({
         "undici:request:trailers",
         (evt) => {
           const {
-            request: { method, path: path6, origin }
+            request: { method, path: path7, origin }
           } = evt;
-          debugLog("trailers received from %s %s%s", method, origin, path6);
+          debugLog("trailers received from %s %s%s", method, origin, path7);
         }
       );
       diagnosticsChannel.subscribe(
         "undici:request:error",
         (evt) => {
           const {
-            request: { method, path: path6, origin },
+            request: { method, path: path7, origin },
             error
           } = evt;
           debugLog(
             "request to %s %s%s errored - %s",
             method,
             origin,
-            path6,
+            path7,
             error.message
           );
         }
@@ -36737,7 +36793,7 @@ var require_request3 = __commonJS({
     var kHandler = Symbol("handler");
     var Request = class {
       constructor(origin, {
-        path: path6,
+        path: path7,
         method,
         body,
         headers,
@@ -36752,11 +36808,11 @@ var require_request3 = __commonJS({
         servername,
         throwOnError
       }, handler) {
-        if (typeof path6 !== "string") {
+        if (typeof path7 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path6[0] !== "/" && !(path6.startsWith("http://") || path6.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path7[0] !== "/" && !(path7.startsWith("http://") || path7.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.test(path6)) {
+        } else if (invalidPathRegex.test(path7)) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -36821,7 +36877,7 @@ var require_request3 = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query ? serializePathWithQuery(path6, query) : path6;
+        this.path = query ? serializePathWithQuery(path7, query) : path7;
         this.origin = origin;
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
         this.blocking = blocking ?? this.method !== "HEAD";
@@ -41598,7 +41654,7 @@ var require_client_h1 = __commonJS({
       return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
     }
     function writeH1(client, request) {
-      const { method, path: path6, host, upgrade, blocking, reset } = request;
+      const { method, path: path7, host, upgrade, blocking, reset } = request;
       let { body, headers, contentLength } = request;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       if (util.isFormDataLike(body)) {
@@ -41664,7 +41720,7 @@ var require_client_h1 = __commonJS({
       if (blocking) {
         socket[kBlocking] = true;
       }
-      let header = `${method} ${path6} HTTP/1.1\r
+      let header = `${method} ${path7} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -42221,7 +42277,7 @@ var require_client_h2 = __commonJS({
     function writeH2(client, request) {
       const requestTimeout = request.bodyTimeout ?? client[kBodyTimeout];
       const session = client[kHTTP2Session];
-      const { method, path: path6, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
+      const { method, path: path7, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
       let { body } = request;
       if (upgrade) {
         util.errorRequest(client, request, new Error("Upgrade not supported for H2"));
@@ -42292,7 +42348,7 @@ var require_client_h2 = __commonJS({
         stream.setTimeout(requestTimeout);
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path6;
+      headers[HTTP2_HEADER_PATH] = path7;
       headers[HTTP2_HEADER_SCHEME] = "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
@@ -45819,20 +45875,20 @@ var require_mock_utils = __commonJS({
       }
       return normalizedQp;
     }
-    function safeUrl(path6) {
-      if (typeof path6 !== "string") {
-        return path6;
+    function safeUrl(path7) {
+      if (typeof path7 !== "string") {
+        return path7;
       }
-      const pathSegments = path6.split("?", 3);
+      const pathSegments = path7.split("?", 3);
       if (pathSegments.length !== 2) {
-        return path6;
+        return path7;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
-    function matchKey(mockDispatch2, { path: path6, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path6);
+    function matchKey(mockDispatch2, { path: path7, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path7);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -45857,8 +45913,8 @@ var require_mock_utils = __commonJS({
       const basePath = key.query ? serializePathWithQuery(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
       const resolvedPathWithoutTrailingSlash = removeTrailingSlash(resolvedPath);
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path6, ignoreTrailingSlash }) => {
-        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path6)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path6), resolvedPath);
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path7, ignoreTrailingSlash }) => {
+        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path7)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path7), resolvedPath);
       });
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
@@ -45896,19 +45952,19 @@ var require_mock_utils = __commonJS({
         mockDispatches.splice(index, 1);
       }
     }
-    function removeTrailingSlash(path6) {
-      while (path6.endsWith("/")) {
-        path6 = path6.slice(0, -1);
+    function removeTrailingSlash(path7) {
+      while (path7.endsWith("/")) {
+        path7 = path7.slice(0, -1);
       }
-      if (path6.length === 0) {
-        path6 = "/";
+      if (path7.length === 0) {
+        path7 = "/";
       }
-      return path6;
+      return path7;
     }
     function buildKey(opts) {
-      const { path: path6, method, body, headers, query } = opts;
+      const { path: path7, method, body, headers, query } = opts;
       return {
-        path: path6,
+        path: path7,
         method,
         body,
         headers,
@@ -46223,7 +46279,7 @@ var require_mock_interceptor = __commonJS({
 var require_mock_client = __commonJS({
   "node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-client.js"(exports2, module2) {
     "use strict";
-    var { promisify } = require("node:util");
+    var { promisify: promisify2 } = require("node:util");
     var Client = require_client();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -46271,7 +46327,7 @@ var require_mock_client = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify(this[kOriginalClose])();
+        await promisify2(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -46484,7 +46540,7 @@ var require_mock_call_history = __commonJS({
 var require_mock_pool = __commonJS({
   "node_modules/.pnpm/undici@7.11.0/node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) {
     "use strict";
-    var { promisify } = require("node:util");
+    var { promisify: promisify2 } = require("node:util");
     var Pool = require_pool();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -46532,7 +46588,7 @@ var require_mock_pool = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify(this[kOriginalClose])();
+        await promisify2(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -46565,10 +46621,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path6, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path7, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
-            Path: path6,
+            Path: path7,
             "Status code": statusCode,
             Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
             Invocations: timesInvoked,
@@ -46645,9 +46701,9 @@ var require_mock_agent = __commonJS({
         const acceptNonStandardSearchParameters = this[kMockAgentAcceptsNonStandardSearchParameters];
         const dispatchOpts = { ...opts };
         if (acceptNonStandardSearchParameters && dispatchOpts.path) {
-          const [path6, searchParams] = dispatchOpts.path.split("?");
+          const [path7, searchParams] = dispatchOpts.path.split("?");
           const normalizedSearchParams = normalizeSearchParams(searchParams, acceptNonStandardSearchParameters);
-          dispatchOpts.path = `${path6}?${normalizedSearchParams}`;
+          dispatchOpts.path = `${path7}?${normalizedSearchParams}`;
         }
         return this[kAgent].dispatch(dispatchOpts, handler);
       }
@@ -46941,9 +46997,9 @@ var require_redirect_handler = __commonJS({
           return;
         }
         const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path6 = search ? `${pathname}${search}` : pathname;
+        const path7 = search ? `${pathname}${search}` : pathname;
         this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
-        this.opts.path = path6;
+        this.opts.path = path7;
         this.opts.origin = origin;
         this.opts.maxRedirections = 0;
         this.opts.query = null;
@@ -52627,9 +52683,9 @@ var require_util7 = __commonJS({
         }
       }
     }
-    function validateCookiePath(path6) {
-      for (let i = 0; i < path6.length; ++i) {
-        const code = path6.charCodeAt(i);
+    function validateCookiePath(path7) {
+      for (let i = 0; i < path7.length; ++i) {
+        const code = path7.charCodeAt(i);
         if (code < 32 || // exclude CTLs (0-31)
         code === 127 || // DEL
         code === 59) {
@@ -55669,11 +55725,11 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path6 = opts.path;
+          let path7 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path6 = `/${path6}`;
+            path7 = `/${path7}`;
           }
-          url = new URL(util.parseOrigin(url).origin + path6);
+          url = new URL(util.parseOrigin(url).origin + path7);
         } else {
           if (!opts) {
             opts = typeof url === "object" ? url : {};
@@ -56709,11 +56765,11 @@ var require_commonjs3 = __commonJS({
       return (f) => f.length === len && f !== "." && f !== "..";
     };
     var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    var path6 = {
+    var path7 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    exports2.sep = defaultPlatform === "win32" ? path6.win32.sep : path6.posix.sep;
+    exports2.sep = defaultPlatform === "win32" ? path7.win32.sep : path7.posix.sep;
     exports2.minimatch.sep = exports2.sep;
     exports2.GLOBSTAR = Symbol("globstar **");
     exports2.minimatch.GLOBSTAR = exports2.GLOBSTAR;
@@ -59981,12 +60037,12 @@ var require_commonjs6 = __commonJS({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path6) {
-        if (!path6) {
+      resolve(path7) {
+        if (!path7) {
           return this;
         }
-        const rootPath = this.getRootString(path6);
-        const dir = path6.substring(rootPath.length);
+        const rootPath = this.getRootString(path7);
+        const dir = path7.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -60739,8 +60795,8 @@ var require_commonjs6 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path6) {
-        return node_path_1.win32.parse(path6).root;
+      getRootString(path7) {
+        return node_path_1.win32.parse(path7).root;
       }
       /**
        * @internal
@@ -60787,8 +60843,8 @@ var require_commonjs6 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path6) {
-        return path6.startsWith("/") ? "/" : "";
+      getRootString(path7) {
+        return path7.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -60838,8 +60894,8 @@ var require_commonjs6 = __commonJS({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs6);
+      constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs7 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs7);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = (0, node_url_1.fileURLToPath)(cwd);
         }
@@ -60878,11 +60934,11 @@ var require_commonjs6 = __commonJS({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path6 = this.cwd) {
-        if (typeof path6 === "string") {
-          path6 = this.cwd.resolve(path6);
+      depth(path7 = this.cwd) {
+        if (typeof path7 === "string") {
+          path7 = this.cwd.resolve(path7);
         }
-        return path6.depth();
+        return path7.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -61369,9 +61425,9 @@ var require_commonjs6 = __commonJS({
         process2();
         return results;
       }
-      chdir(path6 = this.cwd) {
+      chdir(path7 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path6 === "string" ? this.cwd.resolve(path6) : path6;
+        this.cwd = typeof path7 === "string" ? this.cwd.resolve(path7) : path7;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -61398,8 +61454,8 @@ var require_commonjs6 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -61428,8 +61484,8 @@ var require_commonjs6 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs6) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
+      newRoot(fs7) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs7 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -61759,8 +61815,8 @@ var require_processor = __commonJS({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path6, n]) => [
-          path6,
+        return [...this.store.entries()].map(([path7, n]) => [
+          path7,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -61978,9 +62034,9 @@ var require_walker = __commonJS({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path6, opts) {
+      constructor(patterns, path7, opts) {
         this.patterns = patterns;
-        this.path = path6;
+        this.path = path7;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -61999,11 +62055,11 @@ var require_walker = __commonJS({
           });
         }
       }
-      #ignored(path6) {
-        return this.seen.has(path6) || !!this.#ignore?.ignored?.(path6);
+      #ignored(path7) {
+        return this.seen.has(path7) || !!this.#ignore?.ignored?.(path7);
       }
-      #childrenIgnored(path6) {
-        return !!this.#ignore?.childrenIgnored?.(path6);
+      #childrenIgnored(path7) {
+        return !!this.#ignore?.childrenIgnored?.(path7);
       }
       // backpressure mechanism
       pause() {
@@ -62219,8 +62275,8 @@ var require_walker = __commonJS({
     exports2.GlobUtil = GlobUtil;
     var GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path6, opts) {
-        super(patterns, path6, opts);
+      constructor(patterns, path7, opts) {
+        super(patterns, path7, opts);
       }
       matchEmit(e) {
         this.matches.add(e);
@@ -62258,8 +62314,8 @@ var require_walker = __commonJS({
     exports2.GlobWalker = GlobWalker;
     var GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path6, opts) {
-        super(patterns, path6, opts);
+      constructor(patterns, path7, opts) {
+        super(patterns, path7, opts);
         this.results = new minipass_1.Minipass({
           signal: this.signal,
           objectMode: true
@@ -62661,11 +62717,11 @@ var require_Mime = __commonJS({
         }
       }
     };
-    Mime.prototype.getType = function(path6) {
-      path6 = String(path6);
-      let last = path6.replace(/^.*[/\\]/, "").toLowerCase();
+    Mime.prototype.getType = function(path7) {
+      path7 = String(path7);
+      let last = path7.replace(/^.*[/\\]/, "").toLowerCase();
       let ext = last.replace(/^.*\./, "").toLowerCase();
-      let hasPath = last.length < path6.length;
+      let hasPath = last.length < path7.length;
       let hasDot = ext.length < last.length - 1;
       return (hasDot || !hasPath) && this._types[ext] || null;
     };
@@ -63694,8 +63750,8 @@ var require_createHttpError = __commonJS({
 var require_send = __commonJS({
   "node_modules/.pnpm/@fastify+send@4.1.0/node_modules/@fastify/send/lib/send.js"(exports2, module2) {
     "use strict";
-    var fs6 = require("node:fs");
-    var path6 = require("node:path");
+    var fs7 = require("node:fs");
+    var path7 = require("node:path");
     var stream = require("node:stream");
     var debug = require("node:util").debuglog("send");
     var decode = require_fast_decode_uri_component();
@@ -63711,11 +63767,11 @@ var require_send = __commonJS({
     var { parseBytesRange } = require_parseBytesRange();
     var { parseTokenList } = require_parseTokenList();
     var { createHttpError } = require_createHttpError();
-    var extname = path6.extname;
-    var join5 = path6.join;
-    var normalize = path6.normalize;
-    var resolve = path6.resolve;
-    var sep2 = path6.sep;
+    var extname = path7.extname;
+    var join5 = path7.join;
+    var normalize = path7.normalize;
+    var resolve = path7.resolve;
+    var sep2 = path7.sep;
     var Readable = stream.Readable;
     var BYTES_RANGE_REGEXP = /^ *bytes=/;
     var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1e3;
@@ -63782,36 +63838,36 @@ var require_send = __commonJS({
       };
     }
     function normalizePath(_path, root) {
-      let path7 = decode(_path);
-      if (path7 == null) {
+      let path8 = decode(_path);
+      if (path8 == null) {
         return { statusCode: 400 };
       }
-      if (~path7.indexOf("\0")) {
+      if (~path8.indexOf("\0")) {
         return { statusCode: 400 };
       }
       let parts;
       if (root !== null) {
-        if (path7) {
-          path7 = normalize("." + sep2 + path7);
+        if (path8) {
+          path8 = normalize("." + sep2 + path8);
         }
-        if (UP_PATH_REGEXP.test(path7)) {
-          debug('malicious path "%s"', path7);
+        if (UP_PATH_REGEXP.test(path8)) {
+          debug('malicious path "%s"', path8);
           return { statusCode: 403 };
         }
-        parts = path7.split(sep2);
-        path7 = normalize(join5(root, path7));
+        parts = path8.split(sep2);
+        path8 = normalize(join5(root, path8));
       } else {
-        if (UP_PATH_REGEXP.test(path7)) {
-          debug('malicious path "%s"', path7);
+        if (UP_PATH_REGEXP.test(path8)) {
+          debug('malicious path "%s"', path8);
           return { statusCode: 403 };
         }
-        parts = normalize(path7).split(sep2);
-        path7 = resolve(path7);
+        parts = normalize(path8).split(sep2);
+        path8 = resolve(path8);
       }
-      return { path: path7, parts };
+      return { path: path8, parts };
     }
-    function hasTrailingSlash(path7) {
-      return path7[path7.length - 1] === "/";
+    function hasTrailingSlash(path8) {
+      return path8[path8.length - 1] === "/";
     }
     function isConditionalGET(request) {
       return request.headers["if-match"] || request.headers["if-unmodified-since"] || request.headers["if-none-match"] || request.headers["if-modified-since"];
@@ -63901,9 +63957,9 @@ var require_send = __commonJS({
         lastModified <= ifRangeTimestamp
       );
     }
-    function tryStat(path7) {
+    function tryStat(path8) {
       return new Promise((resolve2) => {
-        fs6.stat(path7, function onstat(error, stat2) {
+        fs7.stat(path8, function onstat(error, stat2) {
           resolve2({ error, stat: stat2 });
         });
       });
@@ -63939,7 +63995,7 @@ var require_send = __commonJS({
           return sendError(500, err);
       }
     }
-    function sendNotModified(headers, path7, stat2) {
+    function sendNotModified(headers, path8, stat2) {
       debug("not modified");
       delete headers["Content-Encoding"];
       delete headers["Content-Language"];
@@ -63952,15 +64008,15 @@ var require_send = __commonJS({
         stream: Readable.from(""),
         // metadata
         type: "file",
-        metadata: { path: path7, stat: stat2 }
+        metadata: { path: path8, stat: stat2 }
       };
     }
-    function sendFileDirectly(request, path7, stat2, options) {
+    function sendFileDirectly(request, path8, stat2, options) {
       let len = stat2.size;
       let offset = options.start ?? 0;
       let statusCode = 200;
       const headers = {};
-      debug('send "%s"', path7);
+      debug('send "%s"', path8);
       if (options.acceptRanges) {
         debug("accept ranges");
         headers["Accept-Ranges"] = "bytes";
@@ -63984,7 +64040,7 @@ var require_send = __commonJS({
         headers.ETag = etag;
       }
       if (options.contentType) {
-        let type = mime.getType(path7) || mime.default_type;
+        let type = mime.getType(path8) || mime.default_type;
         debug("content-type %s", type);
         if (type && isUtf8MimeType(type)) {
           type += "; charset=utf-8";
@@ -63998,7 +64054,7 @@ var require_send = __commonJS({
           return sendError(412);
         }
         if (isNotModifiedFailure(request, headers)) {
-          return sendNotModified(headers, path7, stat2);
+          return sendNotModified(headers, path8, stat2);
         }
       }
       len = Math.max(0, len - offset);
@@ -64040,10 +64096,10 @@ var require_send = __commonJS({
           stream: Readable.from(""),
           // metadata
           type: "file",
-          metadata: { path: path7, stat: stat2 }
+          metadata: { path: path8, stat: stat2 }
         };
       }
-      const stream2 = fs6.createReadStream(path7, {
+      const stream2 = fs7.createReadStream(path8, {
         highWaterMark: options.highWaterMark,
         start: offset,
         end: Math.max(offset, offset + len - 1)
@@ -64054,10 +64110,10 @@ var require_send = __commonJS({
         stream: stream2,
         // metadata
         type: "file",
-        metadata: { path: path7, stat: stat2 }
+        metadata: { path: path8, stat: stat2 }
       };
     }
-    function sendRedirect(path7, options) {
+    function sendRedirect(path8, options) {
       if (hasTrailingSlash(options.path)) {
         return sendError(403);
       }
@@ -64075,14 +64131,14 @@ var require_send = __commonJS({
         stream: Readable.from(doc[0]),
         // metadata
         type: "directory",
-        metadata: { requestPath: options.path, path: path7 }
+        metadata: { requestPath: options.path, path: path8 }
       };
     }
-    async function sendIndex(request, path7, options) {
+    async function sendIndex(request, path8, options) {
       let err;
       for (let i = 0; i < options.index.length; i++) {
         const index = options.index[i];
-        const p = join5(path7, index);
+        const p = join5(path8, index);
         const { error, stat: stat2 } = await tryStat(p);
         if (error) {
           err = error;
@@ -64096,13 +64152,13 @@ var require_send = __commonJS({
       }
       return sendError(404);
     }
-    async function sendFile(request, path7, options) {
-      const { error, stat: stat2 } = await tryStat(path7);
-      if (error && error.code === "ENOENT" && !extname(path7) && path7[path7.length - 1] !== sep2) {
+    async function sendFile(request, path8, options) {
+      const { error, stat: stat2 } = await tryStat(path8);
+      if (error && error.code === "ENOENT" && !extname(path8) && path8[path8.length - 1] !== sep2) {
         let err = error;
         for (let i = 0; i < options.extensions.length; i++) {
           const extension = options.extensions[i];
-          const p = path7 + "." + extension;
+          const p = path8 + "." + extension;
           const { error: error2, stat: stat3 } = await tryStat(p);
           if (error2) {
             err = error2;
@@ -64120,14 +64176,14 @@ var require_send = __commonJS({
         return sendError(404);
       }
       if (error) return sendStatError(error);
-      if (stat2.isDirectory()) return sendRedirect(path7, options);
-      return sendFileDirectly(request, path7, stat2, options);
+      if (stat2.isDirectory()) return sendRedirect(path8, options);
+      return sendFileDirectly(request, path8, stat2, options);
     }
     async function send(request, _path, options) {
       const opts = normalizeOptions(options);
       opts.path = _path;
       const parsed = normalizePath(_path, opts.root);
-      const { path: path7, parts } = parsed;
+      const { path: path8, parts } = parsed;
       if (parsed.statusCode !== void 0) {
         return sendError(parsed.statusCode);
       }
@@ -64137,23 +64193,23 @@ var require_send = __commonJS({
           /* c8 ignore start */
           /* unreachable, because NODE_DEBUG can not be set after process is running */
           case 0:
-            debug('allow dotfile "%s"', path7);
+            debug('allow dotfile "%s"', path8);
             break;
           /* c8 ignore stop */
           case 2:
-            debug('deny dotfile "%s"', path7);
+            debug('deny dotfile "%s"', path8);
             return sendError(403);
           case 1:
           // 'ignore'
           default:
-            debug('ignore dotfile "%s"', path7);
+            debug('ignore dotfile "%s"', path8);
             return sendError(404);
         }
       }
       if (opts.index.length && hasTrailingSlash(_path)) {
-        return sendIndex(request, path7, opts);
+        return sendIndex(request, path8, opts);
       }
-      return sendFile(request, path7, opts);
+      return sendFile(request, path8, opts);
     }
     module2.exports.send = send;
   }
@@ -64540,30 +64596,30 @@ var require_dirList = __commonJS({
   "node_modules/.pnpm/@fastify+static@8.2.0/node_modules/@fastify/static/lib/dirList.js"(exports2, module2) {
     "use strict";
     var os2 = require("node:os");
-    var path6 = require("node:path");
-    var fs6 = require("node:fs/promises");
+    var path7 = require("node:path");
+    var fs7 = require("node:fs/promises");
     var fastq = require_queue();
     var fastqConcurrency = Math.max(1, os2.cpus().length - 1);
     var dirList = {
       _getExtendedInfo: async function(dir, info) {
-        const depth = dir.split(path6.sep).length;
-        const files = await fs6.readdir(dir);
+        const depth = dir.split(path7.sep).length;
+        const files = await fs7.readdir(dir);
         const worker = async (filename) => {
-          const filePath = path6.join(dir, filename);
+          const filePath = path7.join(dir, filename);
           let stats;
           try {
-            stats = await fs6.stat(filePath);
+            stats = await fs7.stat(filePath);
           } catch {
             return;
           }
           if (stats.isDirectory()) {
             info.totalFolderCount++;
-            filePath.split(path6.sep).length === depth + 1 && info.folderCount++;
+            filePath.split(path7.sep).length === depth + 1 && info.folderCount++;
             await dirList._getExtendedInfo(filePath, info);
           } else {
             info.totalSize += stats.size;
             info.totalFileCount++;
-            filePath.split(path6.sep).length === depth + 1 && info.fileCount++;
+            filePath.split(path7.sep).length === depth + 1 && info.fileCount++;
             info.lastModified = Math.max(info.lastModified, stats.mtimeMs);
           }
         };
@@ -64596,7 +64652,7 @@ var require_dirList = __commonJS({
        */
       list: async function(dir, options, dotfiles) {
         const entries = { dirs: [], files: [] };
-        let files = await fs6.readdir(dir);
+        let files = await fs7.readdir(dir);
         if (dotfiles === "deny" || dotfiles === "ignore") {
           files = files.filter((file) => file.charAt(0) !== ".");
         }
@@ -64606,14 +64662,14 @@ var require_dirList = __commonJS({
         const worker = async (filename) => {
           let stats;
           try {
-            stats = await fs6.stat(path6.join(dir, filename));
+            stats = await fs7.stat(path7.join(dir, filename));
           } catch {
             return;
           }
           const entry = { name: filename, stats };
           if (stats.isDirectory()) {
             if (options.extendedFolderInfo) {
-              entry.extendedInfo = await dirList.getExtendedInfo(path6.join(dir, filename));
+              entry.extendedInfo = await dirList.getExtendedInfo(path7.join(dir, filename));
             }
             entries.dirs.push(entry);
           } else {
@@ -64669,11 +64725,11 @@ var require_dirList = __commonJS({
        * @return {ListFile}
        */
       htmlInfo: function(entry, route, prefix, options) {
-        if (options.names?.includes(path6.basename(route))) {
-          route = path6.normalize(path6.join(route, ".."));
+        if (options.names?.includes(path7.basename(route))) {
+          route = path7.normalize(path7.join(route, ".."));
         }
         return {
-          href: encodeURI(path6.join(prefix, route, entry.name).replace(/\\/gu, "/")),
+          href: encodeURI(path7.join(prefix, route, entry.name).replace(/\\/gu, "/")),
           name: entry.name,
           stats: entry.stats,
           extendedInfo: entry.extendedInfo
@@ -64686,7 +64742,7 @@ var require_dirList = __commonJS({
        * @return {boolean}
        */
       handle: function(route, options) {
-        return options.names?.includes(path6.basename(route)) || // match trailing slash
+        return options.names?.includes(path7.basename(route)) || // match trailing slash
         ((options.names?.includes("/") && route[route.length - 1] === "/") ?? false);
       },
       /**
@@ -64696,7 +64752,7 @@ var require_dirList = __commonJS({
        */
       path: function(root, route) {
         const _route = route[route.length - 1] === "/" ? route + "none" : route;
-        return path6.dirname(path6.join(root, _route));
+        return path7.dirname(path7.join(root, _route));
       },
       /**
        * validate options
@@ -64731,7 +64787,7 @@ var require_dirList = __commonJS({
 var require_static = __commonJS({
   "node_modules/.pnpm/@fastify+static@8.2.0/node_modules/@fastify/static/index.js"(exports2, module2) {
     "use strict";
-    var path6 = require("node:path");
+    var path7 = require("node:path");
     var { fileURLToPath } = require("node:url");
     var { statSync } = require("node:fs");
     var { glob } = require_commonjs7();
@@ -64838,7 +64894,7 @@ var require_static = __commonJS({
           const routes = /* @__PURE__ */ new Set();
           const roots = Array.isArray(sendOptions.root) ? sendOptions.root : [sendOptions.root];
           for (let rootPath of roots) {
-            rootPath = rootPath.split(path6.win32.sep).join(path6.posix.sep);
+            rootPath = rootPath.split(path7.win32.sep).join(path7.posix.sep);
             !rootPath.endsWith("/") && (rootPath += "/");
             const files = await glob("**/**", {
               cwd: rootPath,
@@ -64849,16 +64905,16 @@ var require_static = __commonJS({
               ignore: opts.globIgnore
             });
             for (let file of files) {
-              file = file.split(path6.win32.sep).join(path6.posix.sep);
+              file = file.split(path7.win32.sep).join(path7.posix.sep);
               const route = prefix + file;
               if (routes.has(route)) {
                 continue;
               }
               routes.add(route);
               setUpHeadAndGet(routeOpts, route, `/${file}`, rootPath);
-              const key = path6.posix.basename(route);
+              const key = path7.posix.basename(route);
               if (indexes.includes(key) && !indexDirs.has(key)) {
-                indexDirs.set(path6.posix.dirname(route), rootPath);
+                indexDirs.set(path7.posix.dirname(route), rootPath);
               }
             }
           }
@@ -64914,11 +64970,11 @@ var require_static = __commonJS({
         } = await send(request.raw, encodeURI(pathnameForSend), options);
         switch (type) {
           case "directory": {
-            const path7 = metadata.path;
+            const path8 = metadata.path;
             if (opts.list) {
               await dirList.send({
                 reply,
-                dir: path7,
+                dir: path8,
                 options: opts.list,
                 route: pathname,
                 prefix,
@@ -65077,7 +65133,7 @@ var require_static = __commonJS({
             '"root" option array contains one or more duplicate paths'
           );
         }
-        rootPath.map((path7) => checkPath(fastify, path7));
+        rootPath.map((path8) => checkPath(fastify, path8));
         return;
       }
       if (typeof rootPath === "string") {
@@ -65089,7 +65145,7 @@ var require_static = __commonJS({
       if (typeof rootPath !== "string") {
         throw new TypeError('"root" option must be a string');
       }
-      if (path6.isAbsolute(rootPath) === false) {
+      if (path7.isAbsolute(rootPath) === false) {
         throw new Error('"root" option must be an absolute path');
       }
       let pathStat;
@@ -65106,8 +65162,8 @@ var require_static = __commonJS({
         throw new Error('"root" option must point to a directory');
       }
     }
-    function getContentType(path7) {
-      const type = send.mime.getType(path7) || send.mime.default_type;
+    function getContentType(path8) {
+      const type = send.mime.getType(path8) || send.mime.default_type;
       if (!send.isUtf8MimeType(type)) {
         return type;
       }
@@ -65116,7 +65172,7 @@ var require_static = __commonJS({
     function findIndexFile(pathname, root, indexFiles = ["index.html"]) {
       if (Array.isArray(indexFiles)) {
         return indexFiles.find((filename) => {
-          const p = path6.join(root, pathname, filename);
+          const p = path7.join(root, pathname, filename);
           try {
             const stats = statSync(p);
             return !stats.isDirectory();
@@ -65168,6 +65224,57 @@ var require_static = __commonJS({
   }
 });
 
+// package.json
+var require_package3 = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@musistudio/claude-code-router",
+      version: "1.0.38",
+      description: "Use Claude Code without an Anthropics account and route it to another LLM provider",
+      bin: {
+        ccr: "./dist/cli.js"
+      },
+      scripts: {
+        build: "node scripts/build.js",
+        release: "npm run build && npm publish"
+      },
+      keywords: [
+        "claude",
+        "code",
+        "router",
+        "llm",
+        "anthropic"
+      ],
+      author: "musistudio",
+      license: "MIT",
+      dependencies: {
+        "@fastify/static": "^8.2.0",
+        "@musistudio/llms": "^1.0.24",
+        dotenv: "^16.4.7",
+        json5: "^2.2.3",
+        openurl: "^1.1.1",
+        "pino-rotating-file-stream": "^0.0.2",
+        tiktoken: "^1.0.21",
+        uuid: "^11.1.0"
+      },
+      devDependencies: {
+        "@types/node": "^24.0.15",
+        esbuild: "^0.25.1",
+        fastify: "^5.4.0",
+        shx: "^0.4.0",
+        typescript: "^5.8.2"
+      },
+      publishConfig: {
+        ignore: [
+          "!build/",
+          "src/",
+          "screenshots/"
+        ]
+      }
+    };
+  }
+});
+
 // node_modules/.pnpm/tiktoken@1.0.21/node_modules/tiktoken/tiktoken_bg.cjs
 var require_tiktoken_bg = __commonJS({
   "node_modules/.pnpm/tiktoken@1.0.21/node_modules/tiktoken/tiktoken_bg.cjs"(exports2, module2) {
@@ -65562,13 +65669,13 @@ var require_tiktoken = __commonJS({
     var wasm = require_tiktoken_bg();
     var imports = {};
     imports["./tiktoken_bg.js"] = wasm;
-    var path6 = require("path");
-    var fs6 = require("fs");
-    var candidates = __dirname.split(path6.sep).reduce((memo, _, index, array) => {
-      const prefix = array.slice(0, index + 1).join(path6.sep) + path6.sep;
-      if (!prefix.includes("node_modules" + path6.sep)) {
+    var path7 = require("path");
+    var fs7 = require("fs");
+    var candidates = __dirname.split(path7.sep).reduce((memo, _, index, array) => {
+      const prefix = array.slice(0, index + 1).join(path7.sep) + path7.sep;
+      if (!prefix.includes("node_modules" + path7.sep)) {
         memo.unshift(
-          path6.join(
+          path7.join(
             prefix,
             "node_modules",
             "tiktoken",
@@ -65579,11 +65686,11 @@ var require_tiktoken = __commonJS({
       }
       return memo;
     }, []);
-    candidates.unshift(path6.join(__dirname, "./tiktoken_bg.wasm"));
+    candidates.unshift(path7.join(__dirname, "./tiktoken_bg.wasm"));
     var bytes = null;
     for (const candidate of candidates) {
       try {
-        bytes = fs6.readFileSync(candidate);
+        bytes = fs7.readFileSync(candidate);
         break;
       } catch {
       }
@@ -65605,7 +65712,7 @@ var import_os = require("os");
 var import_path4 = require("path");
 init_utils();
 
-// node_modules/.pnpm/@musistudio+llms@1.0.22_ws@8.18.3_zod@3.25.67/node_modules/@musistudio/llms/dist/esm/server.mjs
+// node_modules/.pnpm/@musistudio+llms@1.0.24_ws@8.18.3_zod@3.25.67/node_modules/@musistudio/llms/dist/esm/server.mjs
 var import_node_fs = require("node:fs");
 var import_node_path4 = require("node:path");
 var import_node_stream = __toESM(require("node:stream"), 1);
@@ -74622,7 +74729,7 @@ async function jf(r, e, t) {
 function Lf(r, e, t, n) {
   let o = new Headers({ "Content-Type": "application/json" });
   t.headers && Object.entries(t.headers).forEach(([f, h]) => {
-    o.set(f, h);
+    h && o.set(f, h);
   });
   let a, u = AbortSignal.timeout(t.TIMEOUT ?? 60 * 1e3 * 60);
   if (t.signal) {
@@ -74630,9 +74737,9 @@ function Lf(r, e, t, n) {
     t.signal.addEventListener("abort", h), u.addEventListener("abort", h), a = f.signal;
   } else a = u;
   let l = { method: "POST", headers: o, body: JSON.stringify(e), signal: a };
-  return t.httpsProxy && (l.dispatcher = new import_undici.ProxyAgent(new URL(t.httpsProxy).toString())), n?.debug({ request: l, requestUrl: typeof r == "string" ? r : r.toString(), useProxy: t.httpsProxy }, "final request"), fetch(typeof r == "string" ? r : r.toString(), l);
+  return t.httpsProxy && (l.dispatcher = new import_undici.ProxyAgent(new URL(t.httpsProxy).toString())), n?.debug({ request: l, headers: Object.fromEntries(o.entries()), requestUrl: typeof r == "string" ? r : r.toString(), useProxy: t.httpsProxy }, "final request"), fetch(typeof r == "string" ? r : r.toString(), l);
 }
-var Uf = "1.0.22";
+var Uf = "1.0.24";
 async function o0(r, e, t, n) {
   let o = r.body, a = r.provider, u = t._server.providerService.getProvider(a);
   if (!u) throw bt(`Provider '${a}' not found`, 404, "provider_not_found");
@@ -74641,7 +74748,7 @@ async function o0(r, e, t, n) {
 }
 async function i0(r, e, t, n) {
   let o = r, a = {}, u = false;
-  if (u = a0(e, t, r), u && (a.headers = n), !u && typeof t.transformRequestOut == "function") {
+  if (u = a0(e, t, r), u && (n instanceof Headers ? n.delete("content-length") : delete n["content-length"], a.headers = n), !u && typeof t.transformRequestOut == "function") {
     let l = await t.transformRequestOut(o);
     l.body ? (o = l.body, a = l.config || {}) : o = l;
   }
@@ -74663,7 +74770,7 @@ async function u0(r, e, t, n, o, a) {
     if (f.body) {
       r = f.body;
       let h = e.headers || {};
-      f.config?.headers && (h = { ...h, host: void 0, ...f.config.headers }, delete f.config.headers), e = { ...e, ...f.config, headers: h };
+      f.config?.headers && (h = { ...h, ...f.config.headers }, delete h.host, delete f.config.headers), e = { ...e, ...f.config, headers: h };
     } else r = f;
   }
   let l = await Lf(u, r, { httpsProxy: n._server.configService.getHttpsProxy(), ...e, headers: { Authorization: `Bearer ${t.apiKey}`, ...e?.headers || {} } }, n.log);
@@ -74900,7 +75007,7 @@ var bo = class {
   name = "Anthropic";
   endPoint = "/v1/messages";
   async auth(e, t) {
-    return { body: e, config: { headers: { "x-api-key": t.apiKey, Authorization: void 0 } } };
+    return { body: e, config: { headers: { "x-api-key": t.apiKey, authorization: void 0 } } };
   }
   async transformRequestOut(e) {
     let t = [];
@@ -74966,10 +75073,13 @@ var bo = class {
         }
       }, U = () => {
         if (!g) try {
-          u && (v(o.encode(`event: message_delta
+          u ? (v(o.encode(`event: message_delta
 data: ${JSON.stringify(u)}
 
-`)), u = null);
+`)), u = null) : v(o.encode(`event: message_delta
+data: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 } })}
+
+`));
           let j = { type: "message_stop" };
           v(o.encode(`event: message_stop
 data: ${JSON.stringify(j)}
@@ -74994,14 +75104,7 @@ data: ${JSON.stringify(j)}
             if (g || d) break;
             if (!he.startsWith("data: ")) continue;
             let le = he.slice(6);
-            if (this.logger.debug(`recieved data: ${le}`), le === "[DONE]") {
-              u && (v(o.encode(`event: message_delta
-data: ${JSON.stringify(u)}
-
-`)), u = null);
-              continue;
-            }
-            try {
+            if (this.logger.debug(`recieved data: ${le}`), le !== "[DONE]") try {
               let ne = JSON.parse(le);
               if (P++, this.logger.debug({ response: ne }, "Original Response"), ne.error) {
                 let oe = { type: "error", message: { type: "api_error", message: JSON.stringify(ne.error) } };
@@ -76646,6 +76749,7 @@ var XT = bl;
 
 // src/server.ts
 init_utils();
+init_utils();
 var import_path2 = require("path");
 var import_static = __toESM(require_static());
 var createServer = (config) => {
@@ -76673,11 +76777,6 @@ var createServer = (config) => {
     return { success: true, message: "Config saved successfully" };
   });
   server.app.post("/api/restart", async (req, reply) => {
-    const accessLevel = req.accessLevel || "restricted";
-    if (accessLevel !== "full") {
-      reply.status(403).send("Full access required to restart service");
-      return;
-    }
     reply.send({ success: true, message: "Service restart initiated" });
     setTimeout(() => {
       const { spawn: spawn3 } = require("child_process");
@@ -76695,6 +76794,34 @@ var createServer = (config) => {
   server.app.get("/ui", async (_, reply) => {
     return reply.redirect("/ui/");
   });
+  server.app.get("/api/update/check", async (req, reply) => {
+    try {
+      const currentVersion = require_package3().version;
+      const { hasUpdate, latestVersion, changelog } = await checkForUpdates(currentVersion);
+      return {
+        hasUpdate,
+        latestVersion: hasUpdate ? latestVersion : void 0,
+        changelog: hasUpdate ? changelog : void 0
+      };
+    } catch (error) {
+      console.error("Failed to check for updates:", error);
+      reply.status(500).send({ error: "Failed to check for updates" });
+    }
+  });
+  server.app.post("/api/update/perform", async (req, reply) => {
+    try {
+      const accessLevel = req.accessLevel || "restricted";
+      if (accessLevel !== "full") {
+        reply.status(403).send("Full access required to perform updates");
+        return;
+      }
+      const result = await performUpdate();
+      return result;
+    } catch (error) {
+      console.error("Failed to perform update:", error);
+      reply.status(500).send({ error: "Failed to perform update" });
+    }
+  });
   return server;
 };
 
@@ -76709,8 +76836,16 @@ var LOG_FILE = import_node_path5.default.join(HOME_DIR, "claude-code-router.log"
 if (!import_node_fs2.default.existsSync(HOME_DIR)) {
   import_node_fs2.default.mkdirSync(HOME_DIR, { recursive: true });
 }
+var isLogEnabled = null;
+var logLevel = "info";
+function configureLogging(config) {
+  isLogEnabled = config.LOG !== false;
+  logLevel = config.LOG_LEVEL || "info";
+}
 function log2(...args) {
-  const isLogEnabled = process.env.LOG === "true";
+  if (isLogEnabled === null) {
+    isLogEnabled = true;
+  }
   if (!isLogEnabled) {
     return;
   }
@@ -76860,7 +76995,7 @@ var apiKeyAuth = (config) => async (req, reply, done) => {
       `http://127.0.0.1:${config.PORT || 3456}`,
       `http://localhost:${config.PORT || 3456}`
     ];
-    if (req.headers.origin && allowedOrigins.includes(req.headers.origin)) {
+    if (req.headers.origin && !allowedOrigins.includes(req.headers.origin)) {
       reply.status(403).send("CORS not allowed for this origin");
       return;
     } else {
@@ -76960,8 +77095,8 @@ function savePid(pid) {
 function cleanupPidFile() {
   if ((0, import_fs2.existsSync)(PID_FILE)) {
     try {
-      const fs6 = require("fs");
-      fs6.unlinkSync(PID_FILE);
+      const fs7 = require("fs");
+      fs7.unlinkSync(PID_FILE);
     } catch (e) {
     }
   }
@@ -76996,13 +77131,13 @@ async function getServiceInfo() {
 init_constants();
 
 // node_modules/.pnpm/rotating-file-stream@3.2.6/node_modules/rotating-file-stream/dist/esm/index.js
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 var import_zlib = require("zlib");
 var import_stream = require("stream");
 var import_fs3 = require("fs");
 var import_promises3 = require("fs/promises");
 var import_path3 = require("path");
-var import_util = require("util");
+var import_util2 = require("util");
 var import_timers = require("timers");
 async function exists(filename) {
   return new Promise((resolve) => (0, import_fs3.access)(filename, import_fs3.constants.F_OK, (error) => resolve(!error)));
@@ -77038,11 +77173,11 @@ var RotatingFileStream = class extends import_stream.Writable {
   timeout;
   timeoutPromise;
   constructor(generator, options) {
-    const { encoding, history, maxFiles, maxSize, path: path6 } = options;
+    const { encoding, history, maxFiles, maxSize, path: path7 } = options;
     super({ decodeStrings: true, defaultEncoding: encoding });
     this.createGzip = import_zlib.createGzip;
-    this.exec = import_child_process.exec;
-    this.filename = path6 + generator(null);
+    this.exec = import_child_process2.exec;
+    this.filename = path7 + generator(null);
     this.fsCreateReadStream = import_fs3.createReadStream;
     this.fsCreateWriteStream = import_fs3.createWriteStream;
     this.fsOpen = import_promises3.open;
@@ -77054,7 +77189,7 @@ var RotatingFileStream = class extends import_stream.Writable {
     this.options = options;
     this.stdout = process.stdout;
     if (maxFiles || maxSize)
-      options.history = path6 + (history ? history : this.generator(null) + ".txt");
+      options.history = path7 + (history ? history : this.generator(null) + ".txt");
     this.on("close", () => this.finished ? null : this.emit("finish"));
     this.on("finish", () => this.finished = this.clear());
     (async () => {
@@ -77182,9 +77317,9 @@ var RotatingFileStream = class extends import_stream.Writable {
     return this.move();
   }
   async findName() {
-    const { interval, path: path6, intervalBoundary } = this.options;
+    const { interval, path: path7, intervalBoundary } = this.options;
     for (let index = 1; index < 1e3; ++index) {
-      const filename = path6 + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
+      const filename = path7 + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
       if (!await exists(filename))
         return filename;
     }
@@ -77214,11 +77349,11 @@ var RotatingFileStream = class extends import_stream.Writable {
     return this.unlink(filename);
   }
   async classical() {
-    const { compress, path: path6, rotate } = this.options;
+    const { compress, path: path7, rotate } = this.options;
     let rotatedName = "";
     for (let count = rotate; count > 0; --count) {
-      const currName = path6 + this.generator(count);
-      const prevName = count === 1 ? this.filename : path6 + this.generator(count - 1);
+      const currName = path7 + this.generator(count);
+      const prevName = count === 1 ? this.filename : path7 + this.generator(count - 1);
       if (!await exists(prevName))
         continue;
       if (!rotatedName)
@@ -77481,7 +77616,7 @@ function checkSize(value) {
   return ret.num;
 }
 var checks = {
-  encoding: (type, options, value) => new import_util.TextDecoder(value),
+  encoding: (type, options, value) => new import_util2.TextDecoder(value),
   immutable: () => {
   },
   initialRotation: () => {
@@ -77595,7 +77730,7 @@ function createStream(filename, options) {
 
 // node_modules/.pnpm/pino-rotating-file-stream@0.0.2/node_modules/pino-rotating-file-stream/dist/mjs/index.js
 var mjs_default = (options) => {
-  const { filename, size, maxSize, interval, compress, path: path6, ...otherOptions } = options;
+  const { filename, size, maxSize, interval, compress, path: path7, ...otherOptions } = options;
   return createStream(filename, {
     ...otherOptions,
     // Set some default values
@@ -77603,7 +77738,7 @@ var mjs_default = (options) => {
     maxSize: maxSize || "1G",
     interval: interval || "7d",
     compress: compress || "gzip",
-    path: path6
+    path: path7
   });
 };
 
@@ -77637,6 +77772,7 @@ async function run(options = {}) {
   await initDir();
   await cleanupLogFiles();
   const config = await initConfig();
+  configureLogging(config);
   let HOST = config.HOST;
   if (config.HOST && !config.APIKEY) {
     HOST = "127.0.0.1";
@@ -77655,6 +77791,15 @@ async function run(options = {}) {
   });
   console.log(HOST);
   const servicePort = process.env.SERVICE_PORT ? parseInt(process.env.SERVICE_PORT) : port;
+  const loggerConfig = config.LOG !== false ? {
+    level: config.LOG_LEVEL || "info",
+    stream: mjs_default({
+      path: HOME_DIR,
+      filename: config.LOGNAME || `./logs/ccr-${+/* @__PURE__ */ new Date()}.log`,
+      maxFiles: 3,
+      interval: "1d"
+    })
+  } : false;
   const server = createServer({
     jsonPath: CONFIG_FILE,
     initialConfig: {
@@ -77668,15 +77813,7 @@ async function run(options = {}) {
         "claude-code-router.log"
       )
     },
-    logger: {
-      level: "debug",
-      stream: mjs_default({
-        path: HOME_DIR,
-        filename: config.LOGNAME || `./logs/ccr-${+/* @__PURE__ */ new Date()}.log`,
-        maxFiles: 3,
-        interval: "1d"
-      })
-    }
+    logger: loggerConfig
   });
   server.addHook("preHandler", async (req, reply) => {
     return new Promise((resolve, reject) => {
@@ -77720,7 +77857,7 @@ async function showStatus() {
 }
 
 // src/utils/codeCommand.ts
-var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 init_utils();
 
 // src/utils/close.ts
@@ -77774,7 +77911,7 @@ async function executeCodeCommand(args = []) {
   const claudePath = process.env.CLAUDE_PATH || "claude";
   const joinedArgs = args.length > 0 ? args.map((arg) => `"${arg.replace(/\"/g, '\\"')}"`).join(" ") : "";
   const stdioConfig = config.NON_INTERACTIVE_MODE ? ["pipe", "inherit", "inherit"] : "inherit";
-  const claudeProcess = (0, import_child_process2.spawn)(claudePath + (joinedArgs ? ` ${joinedArgs}` : ""), [], {
+  const claudeProcess = (0, import_child_process3.spawn)(claudePath + (joinedArgs ? ` ${joinedArgs}` : ""), [], {
     env,
     stdio: stdioConfig,
     shell: true
@@ -77797,11 +77934,513 @@ async function executeCodeCommand(args = []) {
   });
 }
 
-// package.json
-var version = "1.0.36";
+// src/utils/statusline.ts
+var import_promises5 = __toESM(require("node:fs/promises"));
+var import_child_process4 = require("child_process");
+var import_node_path6 = __toESM(require("node:path"));
+init_constants();
+var import_json52 = __toESM(require_lib());
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  // 标准颜色
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  // 亮色
+  bright_black: "\x1B[90m",
+  bright_red: "\x1B[91m",
+  bright_green: "\x1B[92m",
+  bright_yellow: "\x1B[93m",
+  bright_blue: "\x1B[94m",
+  bright_magenta: "\x1B[95m",
+  bright_cyan: "\x1B[96m",
+  bright_white: "\x1B[97m",
+  // 背景颜色
+  bg_black: "\x1B[40m",
+  bg_red: "\x1B[41m",
+  bg_green: "\x1B[42m",
+  bg_yellow: "\x1B[43m",
+  bg_blue: "\x1B[44m",
+  bg_magenta: "\x1B[45m",
+  bg_cyan: "\x1B[46m",
+  bg_white: "\x1B[47m",
+  // 亮背景色
+  bg_bright_black: "\x1B[100m",
+  bg_bright_red: "\x1B[101m",
+  bg_bright_green: "\x1B[102m",
+  bg_bright_yellow: "\x1B[103m",
+  bg_bright_blue: "\x1B[104m",
+  bg_bright_magenta: "\x1B[105m",
+  bg_bright_cyan: "\x1B[106m",
+  bg_bright_white: "\x1B[107m"
+};
+var TRUE_COLOR_PREFIX = "\x1B[38;2;";
+function hexToRgb(hex) {
+  hex = hex.replace(/^#/, "").trim();
+  if (hex.length === 3) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+  }
+  if (hex.length !== 6) {
+    return null;
+  }
+  const r = parseInt(hex.substring(0, 2), 16);
+  const g = parseInt(hex.substring(2, 4), 16);
+  const b = parseInt(hex.substring(4, 6), 16);
+  if (isNaN(r) || isNaN(g) || isNaN(b) || r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
+    return null;
+  }
+  return { r, g, b };
+}
+function getColorCode(colorName) {
+  if (colorName.startsWith("#") || /^[0-9a-fA-F]{6}$/.test(colorName) || /^[0-9a-fA-F]{3}$/.test(colorName)) {
+    const rgb = hexToRgb(colorName);
+    if (rgb) {
+      return `${TRUE_COLOR_PREFIX}${rgb.r};${rgb.g};${rgb.b}m`;
+    }
+  }
+  return "";
+}
+function replaceVariables(text, variables) {
+  return text.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
+    return variables[varName] || match;
+  });
+}
+var DEFAULT_THEME = {
+  modules: [
+    {
+      type: "workDir",
+      icon: "\u{F024B}",
+      // nf-md-folder_outline
+      text: "{{workDirName}}",
+      color: "bright_blue"
+    },
+    {
+      type: "gitBranch",
+      icon: "\uE725",
+      // nf-dev-git_branch
+      text: "{{gitBranch}}",
+      color: "bright_magenta"
+    },
+    {
+      type: "model",
+      icon: "\u{F06A9}",
+      // nf-md-robot_outline
+      text: "{{model}}",
+      color: "bright_cyan"
+    },
+    {
+      type: "usage",
+      icon: "\u2191",
+      // 上箭头
+      text: "{{inputTokens}}",
+      color: "bright_green"
+    },
+    {
+      type: "usage",
+      icon: "\u2193",
+      // 下箭头
+      text: "{{outputTokens}}",
+      color: "bright_yellow"
+    }
+  ]
+};
+var POWERLINE_THEME = {
+  modules: [
+    {
+      type: "workDir",
+      icon: "\u{F024B}",
+      // nf-md-folder_outline
+      text: "{{workDirName}}",
+      color: "white",
+      background: "bg_bright_blue"
+    },
+    {
+      type: "gitBranch",
+      icon: "\uE725",
+      // nf-dev-git_branch
+      text: "{{gitBranch}}",
+      color: "white",
+      background: "bg_bright_magenta"
+    },
+    {
+      type: "model",
+      icon: "\u{F06A9}",
+      // nf-md-robot_outline
+      text: "{{model}}",
+      color: "white",
+      background: "bg_bright_cyan"
+    },
+    {
+      type: "usage",
+      icon: "\u2191",
+      // 上箭头
+      text: "{{inputTokens}}",
+      color: "white",
+      background: "bg_bright_green"
+    },
+    {
+      type: "usage",
+      icon: "\u2193",
+      // 下箭头
+      text: "{{outputTokens}}",
+      color: "white",
+      background: "bg_bright_yellow"
+    }
+  ]
+};
+var SIMPLE_THEME = {
+  modules: [
+    {
+      type: "workDir",
+      icon: "",
+      text: "{{workDirName}}",
+      color: "bright_blue"
+    },
+    {
+      type: "gitBranch",
+      icon: "",
+      text: "{{gitBranch}}",
+      color: "bright_magenta"
+    },
+    {
+      type: "model",
+      icon: "",
+      text: "{{model}}",
+      color: "bright_cyan"
+    },
+    {
+      type: "usage",
+      icon: "\u2191",
+      text: "{{inputTokens}}",
+      color: "bright_green"
+    },
+    {
+      type: "usage",
+      icon: "\u2193",
+      text: "{{outputTokens}}",
+      color: "bright_yellow"
+    }
+  ]
+};
+function formatUsage(input_tokens, output_tokens) {
+  if (input_tokens > 1e3 || output_tokens > 1e3) {
+    const inputFormatted = input_tokens > 1e3 ? `${(input_tokens / 1e3).toFixed(1)}k` : `${input_tokens}`;
+    const outputFormatted = output_tokens > 1e3 ? `${(output_tokens / 1e3).toFixed(1)}k` : `${output_tokens}`;
+    return `${inputFormatted} ${outputFormatted}`;
+  }
+  return `${input_tokens} ${output_tokens}`;
+}
+async function getProjectThemeConfig() {
+  try {
+    const configPath = CONFIG_FILE;
+    try {
+      await import_promises5.default.access(configPath);
+    } catch {
+      return { theme: null, style: "default" };
+    }
+    const configContent = await import_promises5.default.readFile(configPath, "utf-8");
+    const config = import_json52.default.parse(configContent);
+    if (config.StatusLine) {
+      const currentStyle = config.StatusLine.currentStyle || "default";
+      if (config.StatusLine[currentStyle] && config.StatusLine[currentStyle].modules) {
+        return { theme: config.StatusLine[currentStyle], style: currentStyle };
+      }
+    }
+  } catch (error) {
+  }
+  return { theme: null, style: "default" };
+}
+function shouldUseSimpleTheme() {
+  if (process.env.USE_SIMPLE_ICONS === "true") {
+    return true;
+  }
+  const term = process.env.TERM || "";
+  const unsupportedTerms = ["dumb", "unknown"];
+  if (unsupportedTerms.includes(term)) {
+    return true;
+  }
+  return false;
+}
+function canDisplayNerdFonts() {
+  if (process.env.USE_SIMPLE_ICONS === "true") {
+    return false;
+  }
+  const fontEnvVars = ["NERD_FONT", "NERDFONT", "FONT"];
+  for (const envVar of fontEnvVars) {
+    const value = process.env[envVar];
+    if (value && (value.includes("Nerd") || value.includes("nerd"))) {
+      return true;
+    }
+  }
+  const termProgram = process.env.TERM_PROGRAM || "";
+  const supportedTerminals = ["iTerm.app", "vscode", "Hyper", "kitty", "alacritty"];
+  if (supportedTerminals.includes(termProgram)) {
+    return true;
+  }
+  const colorTerm = process.env.COLORTERM || "";
+  if (colorTerm.includes("truecolor") || colorTerm.includes("24bit")) {
+    return true;
+  }
+  return process.env.USE_SIMPLE_ICONS !== "true";
+}
+async function parseStatusLineData(input) {
+  try {
+    const useSimpleTheme = shouldUseSimpleTheme();
+    const canDisplayNerd = canDisplayNerdFonts();
+    const effectiveTheme = useSimpleTheme || !canDisplayNerd ? SIMPLE_THEME : DEFAULT_THEME;
+    const { theme: projectTheme, style: currentStyle } = await getProjectThemeConfig();
+    const theme = projectTheme || effectiveTheme;
+    const workDir = input.workspace.current_dir;
+    let gitBranch = "";
+    try {
+      gitBranch = (0, import_child_process4.execSync)("git branch --show-current", {
+        cwd: workDir,
+        stdio: ["pipe", "pipe", "ignore"]
+      }).toString().trim();
+    } catch (error) {
+    }
+    const transcriptContent = await import_promises5.default.readFile(input.transcript_path, "utf-8");
+    const lines = transcriptContent.trim().split("\n");
+    let model = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const message = JSON.parse(lines[i]);
+        if (message.type === "assistant" && message.message.model) {
+          model = message.message.model;
+          if (message.message.usage) {
+            inputTokens = message.message.usage.input_tokens;
+            outputTokens = message.message.usage.output_tokens;
+          }
+          break;
+        }
+      } catch (parseError) {
+        continue;
+      }
+    }
+    if (!model) {
+      try {
+        const projectConfigPath = import_node_path6.default.join(workDir, ".claude-code-router", "config.json");
+        let configPath = projectConfigPath;
+        try {
+          await import_promises5.default.access(projectConfigPath);
+        } catch {
+          configPath = CONFIG_FILE;
+        }
+        const configContent = await import_promises5.default.readFile(configPath, "utf-8");
+        const config = import_json52.default.parse(configContent);
+        if (config.Router && config.Router.default) {
+          const [, defaultModel] = config.Router.default.split(",");
+          if (defaultModel) {
+            model = defaultModel.trim();
+          }
+        }
+      } catch (configError) {
+      }
+    }
+    if (!model) {
+      model = input.model.display_name;
+    }
+    const workDirName = workDir.split("/").pop() || "";
+    const usage = formatUsage(inputTokens, outputTokens);
+    const [formattedInputTokens, formattedOutputTokens] = usage.split(" ");
+    const variables = {
+      workDirName,
+      gitBranch,
+      model,
+      inputTokens: formattedInputTokens,
+      outputTokens: formattedOutputTokens
+    };
+    const isPowerline = currentStyle === "powerline";
+    if (isPowerline) {
+      return renderPowerlineStyle(theme, variables);
+    } else {
+      return renderDefaultStyle(theme, variables);
+    }
+  } catch (error) {
+    return "";
+  }
+}
+function renderDefaultStyle(theme, variables) {
+  const modules = theme.modules || DEFAULT_THEME.modules;
+  const parts = [];
+  for (let i = 0; i < Math.min(modules.length, 5); i++) {
+    const module2 = modules[i];
+    const color = module2.color ? getColorCode(module2.color) : "";
+    const background = module2.background ? getColorCode(module2.background) : "";
+    const icon = module2.icon || "";
+    const text = replaceVariables(module2.text, variables);
+    if (!text && module2.type !== "usage") {
+      continue;
+    }
+    let part = `${background}${color}`;
+    if (icon) {
+      part += `${icon} `;
+    }
+    part += `${text}${COLORS.reset}`;
+    parts.push(part);
+  }
+  return parts.join(" ");
+}
+var SEP_RIGHT = "\uE0B0";
+var COLOR_MAP = {
+  // 基础颜色映射到256色
+  black: 0,
+  red: 1,
+  green: 2,
+  yellow: 3,
+  blue: 4,
+  magenta: 5,
+  cyan: 6,
+  white: 7,
+  bright_black: 8,
+  bright_red: 9,
+  bright_green: 10,
+  bright_yellow: 11,
+  bright_blue: 12,
+  bright_magenta: 13,
+  bright_cyan: 14,
+  bright_white: 15,
+  // 亮背景色映射
+  bg_black: 0,
+  bg_red: 1,
+  bg_green: 2,
+  bg_yellow: 3,
+  bg_blue: 4,
+  bg_magenta: 5,
+  bg_cyan: 6,
+  bg_white: 7,
+  bg_bright_black: 8,
+  bg_bright_red: 9,
+  bg_bright_green: 10,
+  bg_bright_yellow: 11,
+  bg_bright_blue: 12,
+  bg_bright_magenta: 13,
+  bg_bright_cyan: 14,
+  bg_bright_white: 15,
+  // 自定义颜色映射
+  bg_bright_orange: 202,
+  bg_bright_purple: 129
+};
+function getTrueColorRgb(colorName) {
+  if (COLOR_MAP[colorName] !== void 0) {
+    const color256 = COLOR_MAP[colorName];
+    return color256ToRgb(color256);
+  }
+  if (colorName.startsWith("#") || /^[0-9a-fA-F]{6}$/.test(colorName) || /^[0-9a-fA-F]{3}$/.test(colorName)) {
+    return hexToRgb(colorName);
+  }
+  if (colorName.startsWith("bg_#")) {
+    return hexToRgb(colorName.substring(3));
+  }
+  return null;
+}
+function color256ToRgb(index) {
+  if (index < 0 || index > 255) return null;
+  if (index < 16) {
+    const basicColors = [
+      [0, 0, 0],
+      [128, 0, 0],
+      [0, 128, 0],
+      [128, 128, 0],
+      [0, 0, 128],
+      [128, 0, 128],
+      [0, 128, 128],
+      [192, 192, 192],
+      [128, 128, 128],
+      [255, 0, 0],
+      [0, 255, 0],
+      [255, 255, 0],
+      [0, 0, 255],
+      [255, 0, 255],
+      [0, 255, 255],
+      [255, 255, 255]
+    ];
+    return { r: basicColors[index][0], g: basicColors[index][1], b: basicColors[index][2] };
+  } else if (index < 232) {
+    const i = index - 16;
+    const r = Math.floor(i / 36);
+    const g = Math.floor(i % 36 / 6);
+    const b = i % 6;
+    const rgb = [0, 95, 135, 175, 215, 255];
+    return { r: rgb[r], g: rgb[g], b: rgb[b] };
+  } else {
+    const gray = 8 + (index - 232) * 10;
+    return { r: gray, g: gray, b: gray };
+  }
+}
+function segment(text, textFg, bgColor, nextBgColor) {
+  const bgRgb = getTrueColorRgb(bgColor);
+  if (!bgRgb) {
+    const defaultBlueRgb = { r: 33, g: 150, b: 243 };
+    const curBg2 = `\x1B[48;2;${defaultBlueRgb.r};${defaultBlueRgb.g};${defaultBlueRgb.b}m`;
+    const fgColor2 = `\x1B[38;2;255;255;255m`;
+    const body2 = `${curBg2}${fgColor2} ${text} \x1B[0m`;
+    return body2;
+  }
+  const curBg = `\x1B[48;2;${bgRgb.r};${bgRgb.g};${bgRgb.b}m`;
+  let fgRgb = { r: 255, g: 255, b: 255 };
+  const textFgRgb = getTrueColorRgb(textFg);
+  if (textFgRgb) {
+    fgRgb = textFgRgb;
+  }
+  const fgColor = `\x1B[38;2;${fgRgb.r};${fgRgb.g};${fgRgb.b}m`;
+  const body = `${curBg}${fgColor} ${text} \x1B[0m`;
+  if (nextBgColor != null) {
+    const nextBgRgb = getTrueColorRgb(nextBgColor);
+    if (nextBgRgb) {
+      const sepCurFg2 = `\x1B[38;2;${bgRgb.r};${bgRgb.g};${bgRgb.b}m`;
+      const sepNextBg2 = `\x1B[48;2;${nextBgRgb.r};${nextBgRgb.g};${nextBgRgb.b}m`;
+      const sep3 = `${sepCurFg2}${sepNextBg2}${SEP_RIGHT}\x1B[0m`;
+      return body + sep3;
+    }
+    const sepCurFg = `\x1B[38;2;${bgRgb.r};${bgRgb.g};${bgRgb.b}m`;
+    const sepNextBg = `\x1B[48;2;0;0;0m`;
+    const sep2 = `${sepCurFg}${sepNextBg}${SEP_RIGHT}\x1B[0m`;
+    return body + sep2;
+  }
+  return body;
+}
+function renderPowerlineStyle(theme, variables) {
+  const modules = theme.modules || POWERLINE_THEME.modules;
+  const segments = [];
+  for (let i = 0; i < Math.min(modules.length, 5); i++) {
+    const module2 = modules[i];
+    const color = module2.color || "white";
+    const backgroundName = module2.background || "";
+    const icon = module2.icon || "";
+    const text = replaceVariables(module2.text, variables);
+    if (!text && module2.type !== "usage") {
+      continue;
+    }
+    let displayText = "";
+    if (icon) {
+      displayText += `${icon} `;
+    }
+    displayText += text;
+    let nextBackground = null;
+    if (i < modules.length - 1) {
+      const nextModule = modules[i + 1];
+      nextBackground = nextModule.background || null;
+    }
+    const actualBackground = backgroundName || "bg_bright_blue";
+    const segmentStr = segment(displayText, color, actualBackground, nextBackground);
+    segments.push(segmentStr);
+  }
+  return segments.join("");
+}
 
 // src/cli.ts
-var import_child_process3 = require("child_process");
+var import_package = __toESM(require_package3());
+var import_child_process5 = require("child_process");
 init_constants();
 var import_fs6 = __toESM(require("fs"));
 var import_path6 = require("path");
@@ -77814,6 +78453,7 @@ Commands:
   stop          Stop server
   restart       Restart server
   status        Show server status
+  statusline    Integrated statusline
   code          Execute claude command
   ui            Open the web UI in browser
   -v, version   Show version information
@@ -77865,11 +78505,31 @@ async function main() {
     case "status":
       await showStatus();
       break;
+    case "statusline":
+      let inputData = "";
+      process.stdin.setEncoding("utf-8");
+      process.stdin.on("readable", () => {
+        let chunk;
+        while ((chunk = process.stdin.read()) !== null) {
+          inputData += chunk;
+        }
+      });
+      process.stdin.on("end", async () => {
+        try {
+          const input = JSON.parse(inputData);
+          const statusLine = await parseStatusLineData(input);
+          console.log(statusLine);
+        } catch (error) {
+          console.error("Error parsing status line data:", error);
+          process.exit(1);
+        }
+      });
+      break;
     case "code":
       if (!isServiceRunning()) {
         console.log("Service not running, starting service...");
         const cliPath2 = (0, import_path6.join)(__dirname, "cli.js");
-        const startProcess2 = (0, import_child_process3.spawn)("node", [cliPath2, "start"], {
+        const startProcess2 = (0, import_child_process5.spawn)("node", [cliPath2, "start"], {
           detached: true,
           stdio: "ignore"
         });
@@ -77896,7 +78556,7 @@ async function main() {
       if (!isServiceRunning()) {
         console.log("Service not running, starting service...");
         const cliPath2 = (0, import_path6.join)(__dirname, "cli.js");
-        const startProcess2 = (0, import_child_process3.spawn)("node", [cliPath2, "start"], {
+        const startProcess2 = (0, import_child_process5.spawn)("node", [cliPath2, "start"], {
           detached: true,
           stdio: "ignore"
         });
@@ -77933,7 +78593,7 @@ async function main() {
             console.log(
               "Please edit this file with your actual configuration."
             );
-            const restartProcess = (0, import_child_process3.spawn)("node", [cliPath2, "start"], {
+            const restartProcess = (0, import_child_process5.spawn)("node", [cliPath2, "start"], {
               detached: true,
               stdio: "ignore"
             });
@@ -77975,7 +78635,7 @@ async function main() {
         console.error("Unsupported platform for opening browser");
         process.exit(1);
       }
-      (0, import_child_process3.exec)(openCommand, (error) => {
+      (0, import_child_process5.exec)(openCommand, (error) => {
         if (error) {
           console.error("Failed to open browser:", error.message);
           process.exit(1);
@@ -77984,7 +78644,7 @@ async function main() {
       break;
     case "-v":
     case "version":
-      console.log(`claude-code-router version: ${version}`);
+      console.log(`claude-code-router version: ${import_package.version}`);
       break;
     case "restart":
       try {
@@ -78004,7 +78664,7 @@ async function main() {
       }
       console.log("Starting claude code router service...");
       const cliPath = (0, import_path6.join)(__dirname, "cli.js");
-      const startProcess = (0, import_child_process3.spawn)("node", [cliPath, "start"], {
+      const startProcess = (0, import_child_process5.spawn)("node", [cliPath, "start"], {
         detached: true,
         stdio: "ignore"
       });