@fangyb/ahchat-bridge 0.1.34 → 0.1.36

package/dist/seedreamMcpCli.cjs

@@ -420,11 +420,11 @@ var require_codegen = __commonJS({
         const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
         return `${varKind} ${this.name}${rhs};` + _n;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         if (!names[this.name.str])
           return;
         if (this.rhs)
-          this.rhs = optimizeExpr(this.rhs, names, constants);
+          this.rhs = optimizeExpr(this.rhs, names, constants2);
         return this;
       }
       get names() {
@@ -441,10 +441,10 @@ var require_codegen = __commonJS({
       render({ _n }) {
         return `${this.lhs} = ${this.rhs};` + _n;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
           return;
-        this.rhs = optimizeExpr(this.rhs, names, constants);
+        this.rhs = optimizeExpr(this.rhs, names, constants2);
         return this;
       }
       get names() {
@@ -505,8 +505,8 @@ var require_codegen = __commonJS({
       optimizeNodes() {
         return `${this.code}` ? this : void 0;
       }
-      optimizeNames(names, constants) {
-        this.code = optimizeExpr(this.code, names, constants);
+      optimizeNames(names, constants2) {
+        this.code = optimizeExpr(this.code, names, constants2);
         return this;
       }
       get names() {
@@ -535,12 +535,12 @@ var require_codegen = __commonJS({
         }
         return nodes.length > 0 ? this : void 0;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         const { nodes } = this;
         let i = nodes.length;
         while (i--) {
           const n = nodes[i];
-          if (n.optimizeNames(names, constants))
+          if (n.optimizeNames(names, constants2))
             continue;
           subtractNames(names, n.names);
           nodes.splice(i, 1);
@@ -593,12 +593,12 @@ var require_codegen = __commonJS({
           return void 0;
         return this;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         var _a3;
-        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants);
-        if (!(super.optimizeNames(names, constants) || this.else))
+        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants2);
+        if (!(super.optimizeNames(names, constants2) || this.else))
           return;
-        this.condition = optimizeExpr(this.condition, names, constants);
+        this.condition = optimizeExpr(this.condition, names, constants2);
         return this;
       }
       get names() {
@@ -621,10 +621,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.iteration})` + super.render(opts);
       }
-      optimizeNames(names, constants) {
-        if (!super.optimizeNames(names, constants))
+      optimizeNames(names, constants2) {
+        if (!super.optimizeNames(names, constants2))
           return;
-        this.iteration = optimizeExpr(this.iteration, names, constants);
+        this.iteration = optimizeExpr(this.iteration, names, constants2);
         return this;
       }
       get names() {
@@ -660,10 +660,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
       }
-      optimizeNames(names, constants) {
-        if (!super.optimizeNames(names, constants))
+      optimizeNames(names, constants2) {
+        if (!super.optimizeNames(names, constants2))
           return;
-        this.iterable = optimizeExpr(this.iterable, names, constants);
+        this.iterable = optimizeExpr(this.iterable, names, constants2);
         return this;
       }
       get names() {
@@ -705,11 +705,11 @@ var require_codegen = __commonJS({
         (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
         return this;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         var _a3, _b;
-        super.optimizeNames(names, constants);
-        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants);
-        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants);
+        super.optimizeNames(names, constants2);
+        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants2);
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants2);
         return this;
       }
       get names() {
@@ -1010,7 +1010,7 @@ var require_codegen = __commonJS({
     function addExprNames(names, from) {
       return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
     }
-    function optimizeExpr(expr, names, constants) {
+    function optimizeExpr(expr, names, constants2) {
       if (expr instanceof code_1.Name)
         return replaceName(expr);
       if (!canOptimize(expr))
@@ -1025,14 +1025,14 @@ var require_codegen = __commonJS({
         return items;
       }, []));
       function replaceName(n) {
-        const c = constants[n.str];
+        const c = constants2[n.str];
         if (c === void 0 || names[n.str] !== 1)
           return n;
         delete names[n.str];
         return c;
       }
       function canOptimize(e) {
-        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== void 0);
+        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants2[c.str] !== void 0);
       }
     }
     function subtractNames(names, from) {
@@ -2901,20 +2901,20 @@ var require_compile = __commonJS({
     var util_1 = require_util();
     var validate_1 = require_validate();
     var SchemaEnv = class {
-      constructor(env) {
+      constructor(env2) {
         var _a3;
         this.refs = {};
         this.dynamicAnchors = {};
         let schema;
-        if (typeof env.schema == "object")
-          schema = env.schema;
-        this.schema = env.schema;
-        this.schemaId = env.schemaId;
-        this.root = env.root || this;
-        this.baseId = (_a3 = env.baseId) !== null && _a3 !== void 0 ? _a3 : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
-        this.schemaPath = env.schemaPath;
-        this.localRefs = env.localRefs;
-        this.meta = env.meta;
+        if (typeof env2.schema == "object")
+          schema = env2.schema;
+        this.schema = env2.schema;
+        this.schemaId = env2.schemaId;
+        this.root = env2.root || this;
+        this.baseId = (_a3 = env2.baseId) !== null && _a3 !== void 0 ? _a3 : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env2.schemaId || "$id"]);
+        this.schemaPath = env2.schemaPath;
+        this.localRefs = env2.localRefs;
+        this.meta = env2.meta;
         this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
         this.refs = {};
       }
@@ -3098,15 +3098,15 @@ var require_compile = __commonJS({
           baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
         }
       }
-      let env;
+      let env2;
       if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
         const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
-        env = resolveSchema.call(this, root, $ref);
+        env2 = resolveSchema.call(this, root, $ref);
       }
       const { schemaId } = this.opts;
-      env = env || new SchemaEnv({ schema, schemaId, root, baseId });
-      if (env.schema !== env.root.schema)
-        return env;
+      env2 = env2 || new SchemaEnv({ schema, schemaId, root, baseId });
+      if (env2.schema !== env2.root.schema)
+        return env2;
       return void 0;
     }
   }
@@ -3258,8 +3258,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path3) {
-      let input = path3;
+    function removeDotSegments(path6) {
+      let input = path6;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3512,8 +3512,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path3, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path3 && path3 !== "/" ? path3 : void 0;
+        const [path6, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path6 && path6 !== "/" ? path6 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -4437,11 +4437,11 @@ var require_core = __commonJS({
     Ajv2.ValidationError = validation_error_1.default;
     Ajv2.MissingRefError = ref_error_1.default;
     exports2.default = Ajv2;
-    function checkOptions(checkOpts, options, msg, log = "error") {
-      for (const key in checkOpts) {
+    function checkOptions(checkOpts2, options, msg, log = "error") {
+      for (const key in checkOpts2) {
         const opt = key;
         if (opt in options)
-          this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
+          this.logger[log](`${msg}: option ${key}. ${checkOpts2[opt]}`);
       }
     }
     function getSchEnv(keyRef) {
@@ -4488,13 +4488,13 @@ var require_core = __commonJS({
     }, warn() {
     }, error() {
     } };
-    function getLogger(logger) {
-      if (logger === false)
+    function getLogger(logger3) {
+      if (logger3 === false)
         return noLogs;
-      if (logger === void 0)
+      if (logger3 === void 0)
         return console;
-      if (logger.log && logger.warn && logger.error)
-        return logger;
+      if (logger3.log && logger3.warn && logger3.error)
+        return logger3;
       throw new Error("logger must implement log, warn and error methods");
     }
     var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
@@ -4601,8 +4601,8 @@ var require_ref = __commonJS({
       schemaType: "string",
       code(cxt) {
         const { gen, schema: $ref, it } = cxt;
-        const { baseId, schemaEnv: env, validateName, opts, self } = it;
-        const { root } = env;
+        const { baseId, schemaEnv: env2, validateName, opts, self } = it;
+        const { root } = env2;
         if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
           return callRootRef();
         const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
@@ -4612,8 +4612,8 @@ var require_ref = __commonJS({
           return callValidate(schOrEnv);
         return inlineRefSchema(schOrEnv);
         function callRootRef() {
-          if (env === root)
-            return callRef(cxt, validateName, env, env.$async);
+          if (env2 === root)
+            return callRef(cxt, validateName, env2, env2.$async);
           const rootName = gen.scopeValue("root", { ref: root });
           return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
         }
@@ -4643,14 +4643,14 @@ var require_ref = __commonJS({
     exports2.getValidate = getValidate;
     function callRef(cxt, v, sch, $async) {
       const { gen, it } = cxt;
-      const { allErrors, schemaEnv: env, opts } = it;
+      const { allErrors, schemaEnv: env2, opts } = it;
       const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
       if ($async)
         callAsyncRef();
       else
         callSyncRef();
       function callAsyncRef() {
-        if (!env.$async)
+        if (!env2.$async)
           throw new Error("async schema referenced by sync schema");
         const valid = gen.let("valid");
         gen.try(() => {
@@ -6952,12 +6952,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs3, exportName) {
+    function addFormats(ajv, list, fs4, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs3[f]);
+        ajv.addFormat(f, fs4[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -7350,8 +7350,8 @@ function getErrorMap() {
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v3/helpers/parseUtil.js
 init_cjs_shims();
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path6, errorMaps, issueData } = params;
+  const fullPath = [...path6, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7470,11 +7470,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path6, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path6;
     this._key = key;
   }
   get path() {
@@ -11178,12 +11178,12 @@ function $constructor(name, initializer3, params) {
     }
     inst._zod.traits.add(name);
     initializer3(inst, def);
-    const proto = _.prototype;
-    const keys = Object.keys(proto);
+    const proto2 = _.prototype;
+    const keys = Object.keys(proto2);
     for (let i = 0; i < keys.length; i++) {
       const k = keys[i];
       if (!(k in inst)) {
-        inst[k] = proto[k].bind(inst);
+        inst[k] = proto2[k].bind(inst);
       }
     }
   }
@@ -11406,10 +11406,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11628,8 +11628,8 @@ var BIGINT_FORMAT_RANGES = {
 };
 function pick(schema, mask) {
   const currDef = schema._zod.def;
-  const checks = currDef.checks;
-  const hasChecks = checks && checks.length > 0;
+  const checks2 = currDef.checks;
+  const hasChecks = checks2 && checks2.length > 0;
   if (hasChecks) {
     throw new Error(".pick() cannot be used on object schemas containing refinements");
   }
@@ -11653,8 +11653,8 @@ function pick(schema, mask) {
 }
 function omit(schema, mask) {
   const currDef = schema._zod.def;
-  const checks = currDef.checks;
-  const hasChecks = checks && checks.length > 0;
+  const checks2 = currDef.checks;
+  const hasChecks = checks2 && checks2.length > 0;
   if (hasChecks) {
     throw new Error(".omit() cannot be used on object schemas containing refinements");
   }
@@ -11680,8 +11680,8 @@ function extend(schema, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-  const checks = schema._zod.def.checks;
-  const hasChecks = checks && checks.length > 0;
+  const checks2 = schema._zod.def.checks;
+  const hasChecks = checks2 && checks2.length > 0;
   if (hasChecks) {
     const existingShape = schema._zod.def.shape;
     for (const key in shape) {
@@ -11731,8 +11731,8 @@ function merge(a, b) {
 }
 function partial(Class2, schema, mask) {
   const currDef = schema._zod.def;
-  const checks = currDef.checks;
-  const hasChecks = checks && checks.length > 0;
+  const checks2 = currDef.checks;
+  const hasChecks = checks2 && checks2.length > 0;
   if (hasChecks) {
     throw new Error(".partial() cannot be used on object schemas containing refinements");
   }
@@ -11818,11 +11818,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -11969,16 +11969,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path3 = []) => {
+  const processError = (error52, path6 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -12005,17 +12005,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path3 = []) => {
+  const processError = (error52, path6 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12047,8 +12047,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path6) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -12928,25 +12928,25 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
   inst._zod.def = def;
   inst._zod.bag = inst._zod.bag || {};
   inst._zod.version = version;
-  const checks = [...inst._zod.def.checks ?? []];
+  const checks2 = [...inst._zod.def.checks ?? []];
   if (inst._zod.traits.has("$ZodCheck")) {
-    checks.unshift(inst);
+    checks2.unshift(inst);
   }
-  for (const ch of checks) {
+  for (const ch of checks2) {
     for (const fn of ch._zod.onattach) {
       fn(inst);
     }
   }
-  if (checks.length === 0) {
+  if (checks2.length === 0) {
     (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
     inst._zod.deferred?.push(() => {
       inst._zod.run = inst._zod.parse;
     });
   } else {
-    const runChecks = (payload, checks2, ctx) => {
+    const runChecks = (payload, checks3, ctx) => {
       let isAborted2 = aborted(payload);
       let asyncResult;
-      for (const ch of checks2) {
+      for (const ch of checks3) {
         if (ch._zod.def.when) {
           if (explicitlyAborted(payload))
             continue;
@@ -12990,7 +12990,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
         canary.aborted = true;
         return canary;
       }
-      const checkResult = runChecks(payload, checks, ctx);
+      const checkResult = runChecks(payload, checks2, ctx);
       if (checkResult instanceof Promise) {
         if (ctx.async === false)
           throw new $ZodAsyncError();
@@ -13015,9 +13015,9 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
       if (result instanceof Promise) {
         if (ctx.async === false)
           throw new $ZodAsyncError();
-        return result.then((result2) => runChecks(result2, checks, ctx));
+        return result.then((result2) => runChecks(result2, checks2, ctx));
       }
-      return runChecks(result, checks, ctx);
+      return runChecks(result, checks2, ctx);
     };
   }
   defineLazy(inst, "~standard", () => ({
@@ -23117,12 +23117,12 @@ var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
   inst.safeParse = (data, params) => safeParse(inst, data, params);
   inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
   inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
-  inst.check = (...checks) => {
+  inst.check = (...checks2) => {
     return inst.clone({
       ...def,
       checks: [
         ...def.checks ?? [],
-        ...checks.map((ch) => typeof ch === "function" ? {
+        ...checks2.map((ch) => typeof ch === "function" ? {
           _zod: { check: ch, def: { check: "custom" }, onattach: [] }
         } : ch)
       ]
@@ -23853,18 +23853,18 @@ var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/schemas.js
 var _installedGroups = /* @__PURE__ */ new WeakMap();
 function _installLazyMethods(inst, group, methods) {
-  const proto = Object.getPrototypeOf(inst);
-  let installed = _installedGroups.get(proto);
+  const proto2 = Object.getPrototypeOf(inst);
+  let installed = _installedGroups.get(proto2);
   if (!installed) {
     installed = /* @__PURE__ */ new Set();
-    _installedGroups.set(proto, installed);
+    _installedGroups.set(proto2, installed);
   }
   if (installed.has(group))
     return;
   installed.add(group);
   for (const key in methods) {
     const fn = methods[key];
-    Object.defineProperty(proto, key, {
+    Object.defineProperty(proto2, key, {
       configurable: true,
       enumerable: false,
       get() {
@@ -25262,13 +25262,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.length === 0) {
+  const path6 = ref.slice(1).split("/").filter(Boolean);
+  if (path6.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path3[0] === defsKey) {
-    const key = path3[1];
+  if (path6[0] === defsKey) {
+    const key = path6[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -31232,11 +31232,1659 @@ var StdioServerTransport = class {
 };
 
 // src/seedreamMcpCli.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 
 // src/officialMcpQuota.ts
 init_cjs_shims();
+
+// src/logger.ts
+init_cjs_shims();
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+
+// ../logger/src/index.ts
+init_cjs_shims();
+
+// ../logger/src/logger.ts
+init_cjs_shims();
+
+// ../logger/src/types.ts
+init_cjs_shims();
+var LOG_LEVEL_VALUE = {
+  TRACE: 0,
+  DEBUG: 1,
+  INFO: 2,
+  WARN: 3,
+  ERROR: 4,
+  FATAL: 5
+};
+function parseLogLevel(value, fallback = "INFO") {
+  const upper = value?.trim().toUpperCase();
+  return upper && upper in LOG_LEVEL_VALUE ? upper : fallback;
+}
+
+// ../logger/src/logger.ts
+var REDACTED = "***";
+var SENSITIVE_KEY_RE = /(token|apikey|authorization|password|secret|cookie)/i;
+function shouldRedactKey(key) {
+  const normalized = key.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+  if (normalized.startsWith("has")) return false;
+  if (normalized.endsWith("hash")) return false;
+  return SENSITIVE_KEY_RE.test(normalized);
+}
+function redactString(value) {
+  return value.replace(/([?&](?:token|api_?key|access_token|refresh_token)=)[^&#\s"']+/gi, `$1${REDACTED}`).replace(/("(?:apiKey|token|bridgeToken|authorization|password|secret|cookie|access_token|refresh_token)"\s*:\s*")[^"]*/gi, `$1${REDACTED}`).replace(/((?:apiKey|token|bridgeToken|authorization|password|secret|cookie|access_token|refresh_token)=)[^\s&"']+/gi, `$1${REDACTED}`).replace(/\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, `$1${REDACTED}`).replace(/\bsk-[A-Za-z0-9._-]{6,}\b/g, "sk-***");
+}
+function serializeError(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: redactString(err.message),
+      ...err.stack ? { stack: redactString(err.stack) } : {}
+    };
+  }
+  if (typeof err === "object" && err !== null && "message" in err) {
+    const o = err;
+    return {
+      name: typeof o.name === "string" ? o.name : "Error",
+      message: redactString(String(o.message)),
+      ...typeof o.stack === "string" ? { stack: redactString(o.stack) } : {}
+    };
+  }
+  return { name: "Error", message: redactString(String(err)) };
+}
+function isPlainObject3(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto2 = Object.getPrototypeOf(value);
+  return proto2 === Object.prototype || proto2 === null;
+}
+function redactValue(value, key, seen) {
+  if (key && shouldRedactKey(key)) return REDACTED;
+  if (typeof value === "string") return redactString(value);
+  if (value instanceof Error) return serializeError(value);
+  if (Array.isArray(value)) return value.map((item) => redactValue(item, void 0, seen));
+  if (!isPlainObject3(value)) return value;
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  const out = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    out[childKey] = redactValue(childValue, childKey, seen);
+  }
+  return out;
+}
+function stripReservedFields(data) {
+  if (!data) return void 0;
+  const rest = { ...data };
+  delete rest.traceId;
+  delete rest.error;
+  if (Object.keys(rest).length === 0) return void 0;
+  return redactValue(rest, void 0, /* @__PURE__ */ new WeakSet());
+}
+var Logger = class {
+  config;
+  levelValue;
+  constructor(config2) {
+    this.config = config2;
+    this.levelValue = LOG_LEVEL_VALUE[config2.level] ?? LOG_LEVEL_VALUE.INFO;
+  }
+  trace(msg, data) {
+    this.log("TRACE", msg, data);
+  }
+  debug(msg, data) {
+    this.log("DEBUG", msg, data);
+  }
+  info(msg, data) {
+    this.log("INFO", msg, data);
+  }
+  warn(msg, data) {
+    this.log("WARN", msg, data);
+  }
+  error(msg, data) {
+    this.log("ERROR", msg, data);
+  }
+  fatal(msg, data) {
+    this.log("FATAL", msg, data);
+  }
+  log(level, msg, data) {
+    if (LOG_LEVEL_VALUE[level] < this.levelValue) return;
+    const traceId = typeof data?.traceId === "string" ? redactString(data.traceId) : void 0;
+    const hasError = data && "error" in data && data.error !== void 0;
+    const error51 = hasError ? serializeError(data.error) : void 0;
+    const rest = stripReservedFields(data);
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      source: this.config.source,
+      module: this.config.module,
+      msg,
+      ...traceId ? { traceId } : {},
+      ...error51 ? { error: error51 } : {},
+      ...rest ? { data: rest } : {}
+    };
+    for (const transport of this.config.transports) {
+      try {
+        transport(entry);
+      } catch (e) {
+        console.error("[logger] transport failed", e);
+      }
+    }
+  }
+};
+
+// ../logger/src/formatters/json.ts
+init_cjs_shims();
+function safeReplacer() {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (_key, value) => {
+    if (typeof value === "bigint") return value.toString();
+    if (typeof value === "string") return toWellFormedString(value);
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) return "[Circular]";
+      seen.add(value);
+    }
+    return value;
+  };
+}
+function toWellFormedString(value) {
+  let out = "";
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        out += value[i] + value[i + 1];
+        i += 1;
+      } else {
+        out += "\uFFFD";
+      }
+      continue;
+    }
+    if (code >= 56320 && code <= 57343) {
+      out += "\uFFFD";
+      continue;
+    }
+    out += value[i];
+  }
+  return out;
+}
+var jsonFormatter = (entry) => {
+  try {
+    return JSON.stringify(entry, safeReplacer());
+  } catch (e) {
+    return JSON.stringify({
+      ts: entry.ts,
+      level: entry.level,
+      source: entry.source,
+      module: entry.module,
+      msg: entry.msg,
+      ...entry.traceId ? { traceId: entry.traceId } : {},
+      data: { unserializable: e instanceof Error ? e.message : String(e) }
+    });
+  }
+};
+
+// ../logger/src/formatters/pretty.ts
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+init_cjs_shims();
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex3) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex3.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer2 = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer2 >> 16 & 255,
+          integer2 >> 8 & 255,
+          integer2 & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex3) => styles.rgbToAnsi256(...styles.hexToRgb(hex3)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex3) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex3)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+init_cjs_shims();
+var import_node_process2 = __toESM(require("process"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_tty = __toESM(require("tty"), 1);
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process2.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = import_node_process2.default;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (import_node_process2.default.platform === "win32") {
+    const osRelease = import_node_os.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version2 >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+init_cjs_shims();
+function stringReplaceAll(string4, substring, replacer) {
+  let index = string4.indexOf(substring);
+  if (index === -1) {
+    return string4;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string4.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string4.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string4.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string4, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string4[index - 1] === "\r";
+    returnValue += string4.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string4.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string4.slice(endIndex);
+  return returnValue;
+}
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object3, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object3.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open2, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open2;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open2;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open: open2,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string4) => {
+  if (self.level <= 0 || !string4) {
+    return self[IS_EMPTY] ? "" : string4;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string4;
+  }
+  const { openAll, closeAll } = styler;
+  if (string4.includes("\x1B")) {
+    while (styler !== void 0) {
+      string4 = stringReplaceAll(string4, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string4.indexOf("\n");
+  if (lfIndex !== -1) {
+    string4 = stringEncaseCRLFWithFirstIndex(string4, closeAll, openAll, lfIndex);
+  }
+  return openAll + string4 + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// ../logger/src/formatters/pretty.ts
+var LEVEL_COLOR = {
+  TRACE: source_default.gray,
+  DEBUG: source_default.cyan,
+  INFO: source_default.green,
+  WARN: source_default.yellow,
+  ERROR: source_default.red,
+  FATAL: source_default.bgRed.white
+};
+function formatLocalTs(iso) {
+  const d = new Date(iso);
+  const pad = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+}
+var prettyFormatter = (entry) => {
+  const ts = formatLocalTs(entry.ts);
+  const level = LEVEL_COLOR[entry.level](entry.level.padEnd(5));
+  const scope = source_default.gray(`[${entry.source}:${entry.module}]`);
+  const data = entry.data && Object.keys(entry.data).length > 0 ? ` ${source_default.gray(JSON.stringify(entry.data))}` : "";
+  const trace = entry.traceId ? source_default.gray(` traceId=${entry.traceId}`) : "";
+  const errPart = entry.error ? source_default.red(
+    ` ${entry.error.name}: ${entry.error.message}${entry.error.stack ? `
+${entry.error.stack}` : ""}`
+  ) : "";
+  return `${ts} ${level} ${scope} ${entry.msg}${data}${trace}${errPart}`;
+};
+
+// ../logger/src/fallback.ts
+init_cjs_shims();
+
+// ../logger/src/transports/console.ts
+init_cjs_shims();
+var protectedStreams = /* @__PURE__ */ new WeakSet();
+function ignoreWriteError(_error) {
+}
+function defaultStream(kind) {
+  const maybeGlobal = globalThis;
+  return maybeGlobal.process?.[kind];
+}
+function safeWriteLine(stream, line, fallback) {
+  if (!stream) {
+    fallback(line);
+    return;
+  }
+  if (stream.destroyed || stream.writableEnded) return;
+  if (typeof stream === "object" && typeof stream.on === "function" && !protectedStreams.has(stream)) {
+    protectedStreams.add(stream);
+    stream.on("error", ignoreWriteError);
+  }
+  try {
+    stream.write(`${line}
+`, ignoreWriteError);
+  } catch (e) {
+    ignoreWriteError(e);
+  }
+}
+function consoleTransport(opts) {
+  const fmt = opts?.formatter ?? jsonFormatter;
+  return (entry) => {
+    const line = fmt(entry);
+    if (LOG_LEVEL_VALUE[entry.level] >= LOG_LEVEL_VALUE.ERROR) {
+      safeWriteLine(opts?.stderr ?? defaultStream("stderr"), line, console.error);
+    } else {
+      safeWriteLine(opts?.stdout ?? defaultStream("stdout"), line, console.log);
+    }
+  };
+}
+
+// ../logger/src/transports/file.ts
+init_cjs_shims();
+var import_node_path = __toESM(require("path"), 1);
+
+// ../../node_modules/.pnpm/rotating-file-stream@3.2.9/node_modules/rotating-file-stream/dist/esm/index.js
+init_cjs_shims();
+var import_child_process = require("child_process");
+var import_zlib = require("zlib");
+var import_stream = require("stream");
+var import_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_util6 = require("util");
+var import_timers = require("timers");
+async function exists(filename) {
+  return new Promise((resolve) => (0, import_fs.access)(filename, import_fs.constants.F_OK, (error51) => resolve(!error51)));
+}
+var RotatingFileStreamError = class extends Error {
+  code = "RFS-TOO-MANY";
+  constructor() {
+    super("Too many destination file attempts");
+  }
+};
+var RotatingFileStream = class extends import_stream.Writable {
+  createGzip;
+  exec;
+  file;
+  filename;
+  finished;
+  fsCreateReadStream;
+  fsCreateWriteStream;
+  fsOpen;
+  fsReadFile;
+  fsStat;
+  fsUnlink;
+  generator;
+  initPromise;
+  last;
+  maxTimeout;
+  next;
+  options;
+  prev;
+  rotation;
+  size;
+  stdout;
+  timeout;
+  timeoutPromise;
+  constructor(generator, options) {
+    const { encoding, history, maxFiles, maxSize, path: path6 } = options;
+    super({ decodeStrings: true, defaultEncoding: encoding });
+    this.createGzip = import_zlib.createGzip;
+    this.exec = import_child_process.exec;
+    this.filename = path6 + generator(null);
+    this.fsCreateReadStream = import_fs.createReadStream;
+    this.fsCreateWriteStream = import_fs.createWriteStream;
+    this.fsOpen = import_promises.open;
+    this.fsReadFile = import_promises.readFile;
+    this.fsStat = import_promises.stat;
+    this.fsUnlink = import_promises.unlink;
+    this.generator = generator;
+    this.maxTimeout = 2147483640;
+    this.options = options;
+    this.stdout = process.stdout;
+    if (maxFiles || maxSize)
+      options.history = path6 + (history ? history : this.generator(null) + ".txt");
+    this.on("close", () => this.finished ? null : this.emit("finish"));
+    this.on("finish", () => this.finished = this.clear());
+    (async () => {
+      try {
+        this.initPromise = this.init();
+        await this.initPromise;
+        delete this.initPromise;
+      } catch (e) {
+      }
+    })();
+  }
+  _destroy(error51, callback) {
+    this.refinal(error51, callback);
+  }
+  _final(callback) {
+    this.refinal(void 0, callback);
+  }
+  _write(chunk, encoding, callback) {
+    this.rewrite([{ chunk, encoding }], 0, callback);
+  }
+  _writev(chunks, callback) {
+    this.rewrite(chunks, 0, callback);
+  }
+  async refinal(error51, callback) {
+    try {
+      this.clear();
+      if (this.initPromise)
+        await this.initPromise;
+      if (this.timeoutPromise)
+        await this.timeoutPromise;
+      await this.reclose();
+    } catch (e) {
+      return callback(error51 || e);
+    }
+    callback(error51);
+  }
+  async rewrite(chunks, index, callback) {
+    const { size, teeToStdout } = this.options;
+    try {
+      if (this.initPromise)
+        await this.initPromise;
+      for (let i = 0; i < chunks.length; ++i) {
+        const { chunk } = chunks[i];
+        this.size += chunk.length;
+        if (this.timeoutPromise)
+          await this.timeoutPromise;
+        await this.file.write(chunk);
+        if (teeToStdout && !this.stdout.destroyed)
+          this.stdout.write(chunk);
+        if (size && this.size >= size)
+          await this.rotate();
+      }
+    } catch (e) {
+      return callback(e);
+    }
+    callback();
+  }
+  async init() {
+    const { immutable, initialRotation, interval, size } = this.options;
+    if (immutable)
+      return new Promise((resolve, reject) => process.nextTick(() => this.immutate(true).then(resolve).catch(reject)));
+    let stats;
+    try {
+      stats = await (0, import_promises.stat)(this.filename);
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      return this.reopen(0);
+    }
+    if (!stats.isFile())
+      throw new Error(`Can't write on: ${this.filename} (it is not a file)`);
+    if (initialRotation) {
+      this.intervalBounds(this.now());
+      const prev = this.prev;
+      this.intervalBounds(new Date(stats.mtime.getTime()));
+      if (prev !== this.prev)
+        return this.rotate();
+    }
+    this.size = stats.size;
+    if (!size || stats.size < size)
+      return this.reopen(stats.size);
+    if (interval)
+      this.intervalBounds(this.now());
+    return this.rotate();
+  }
+  async makePath(name) {
+    return (0, import_promises.mkdir)(name.split(import_path.sep).slice(0, -1).join(import_path.sep), { recursive: true });
+  }
+  async reopen(size) {
+    let file2;
+    try {
+      file2 = await (0, import_promises.open)(this.filename, "a", this.options.mode);
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      await this.makePath(this.filename);
+      file2 = await (0, import_promises.open)(this.filename, "a", this.options.mode);
+    }
+    this.file = file2;
+    this.size = size;
+    this.interval();
+    this.emit("open", this.filename);
+  }
+  async reclose() {
+    const { file: file2 } = this;
+    if (!file2)
+      return;
+    delete this.file;
+    return file2.close();
+  }
+  now() {
+    return /* @__PURE__ */ new Date();
+  }
+  async rotate() {
+    const { immutable, rotate } = this.options;
+    this.size = 0;
+    this.rotation = this.now();
+    this.clear();
+    this.emit("rotation");
+    await this.reclose();
+    if (rotate)
+      return this.classical();
+    if (immutable)
+      return this.immutate(false);
+    return this.move();
+  }
+  async findName() {
+    const { interval, path: path6, intervalBoundary } = this.options;
+    for (let index = 1; index < 1e3; ++index) {
+      const filename = path6 + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
+      if (!await exists(filename))
+        return filename;
+    }
+    throw new RotatingFileStreamError();
+  }
+  async move() {
+    const { compress } = this.options;
+    const filename = await this.findName();
+    await this.touch(filename);
+    if (compress)
+      await this.compress(filename);
+    else
+      await (0, import_promises.rename)(this.filename, filename);
+    return this.rotated(filename);
+  }
+  async touch(filename) {
+    let file2;
+    try {
+      file2 = await this.fsOpen(filename, "a");
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      await this.makePath(filename);
+      file2 = await (0, import_promises.open)(filename, "a");
+    }
+    await file2.close();
+    return this.unlink(filename);
+  }
+  async classical() {
+    const { compress, path: path6, 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);
+      if (!await exists(prevName))
+        continue;
+      if (!rotatedName)
+        rotatedName = currName;
+      if (count === 1 && compress)
+        await this.compress(currName);
+      else {
+        try {
+          await (0, import_promises.rename)(prevName, currName);
+        } catch (e) {
+          if (e.code !== "ENOENT")
+            throw e;
+          await this.makePath(currName);
+          await (0, import_promises.rename)(prevName, currName);
+        }
+      }
+    }
+    return this.rotated(rotatedName);
+  }
+  clear() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    return true;
+  }
+  intervalBoundsBig(now) {
+    const year = this.options.intervalUTC ? now.getUTCFullYear() : now.getFullYear();
+    let month = this.options.intervalUTC ? now.getUTCMonth() : now.getMonth();
+    let day = this.options.intervalUTC ? now.getUTCDate() : now.getDate();
+    let hours = this.options.intervalUTC ? now.getUTCHours() : now.getHours();
+    const { num, unit } = this.options.interval;
+    if (unit === "M") {
+      day = 1;
+      hours = 0;
+    } else if (unit === "d")
+      hours = 0;
+    else
+      hours = parseInt(hours / num, 10) * num;
+    this.prev = new Date(year, month, day, hours, 0, 0, 0).getTime();
+    if (unit === "M")
+      month += num;
+    else if (unit === "d")
+      day += num;
+    else
+      hours += num;
+    this.next = new Date(year, month, day, hours, 0, 0, 0).getTime();
+  }
+  intervalBounds(now) {
+    const unit = this.options.interval.unit;
+    if (unit === "M" || unit === "d" || unit === "h")
+      this.intervalBoundsBig(now);
+    else {
+      let period = 1e3 * this.options.interval.num;
+      if (unit === "m")
+        period *= 60;
+      this.prev = parseInt(now.getTime() / period, 10) * period;
+      this.next = this.prev + period;
+    }
+    return new Date(this.prev);
+  }
+  interval() {
+    if (!this.options.interval)
+      return;
+    this.intervalBounds(this.now());
+    const set2 = async () => {
+      const time3 = this.next - this.now().getTime();
+      if (time3 <= 0) {
+        try {
+          this.timeoutPromise = this.rotate();
+          await this.timeoutPromise;
+          delete this.timeoutPromise;
+        } catch (e) {
+        }
+      } else {
+        this.timeout = (0, import_timers.setTimeout)(set2, time3 > this.maxTimeout ? this.maxTimeout : time3);
+        this.timeout.unref();
+      }
+    };
+    set2();
+  }
+  async compress(filename) {
+    const { compress } = this.options;
+    if (typeof compress === "function") {
+      await new Promise((resolve, reject) => {
+        this.exec(compress(this.filename, filename), (error51, stdout, stderr) => {
+          this.emit("external", stdout, stderr);
+          error51 ? reject(error51) : resolve();
+        });
+      });
+    } else
+      await this.gzip(filename);
+    return this.unlink(this.filename);
+  }
+  async gzip(filename) {
+    const { mode } = this.options;
+    const options = mode ? { mode } : {};
+    const inp = this.fsCreateReadStream(this.filename, {});
+    const out = this.fsCreateWriteStream(filename, options);
+    const zip = this.createGzip();
+    await new Promise((resolve, reject) => {
+      inp.once("error", reject);
+      out.once("error", reject);
+      zip.once("error", reject);
+      out.once("finish", resolve);
+      inp.pipe(zip).pipe(out);
+    });
+    await Promise.all([
+      new Promise((resolve) => zip.close(resolve)),
+      new Promise((resolve) => out.close((err) => {
+        if (err)
+          this.emit("warning", err);
+        resolve();
+      }))
+    ]);
+  }
+  async rotated(filename) {
+    const { maxFiles, maxSize } = this.options;
+    if (maxFiles || maxSize)
+      await this.history(filename);
+    this.emit("rotated", filename);
+    return this.reopen(0);
+  }
+  async history(filename) {
+    const { history, maxFiles, maxSize } = this.options;
+    const res = [];
+    let files = [filename];
+    try {
+      const content = await this.fsReadFile(history, "utf8");
+      files = [...content.toString().split("\n"), filename];
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+    }
+    for (const file2 of files) {
+      if (file2) {
+        try {
+          const stats = await this.fsStat(file2);
+          if (stats.isFile()) {
+            res.push({
+              name: file2,
+              size: stats.size,
+              time: stats.mtime.getTime()
+            });
+          } else
+            this.emit("warning", new Error(`File '${file2}' contained in history is not a regular file`));
+        } catch (e) {
+          if (e.code !== "ENOENT")
+            throw e;
+        }
+      }
+    }
+    res.sort((a, b) => a.time - b.time);
+    if (maxFiles) {
+      while (res.length > maxFiles) {
+        const file2 = res.shift();
+        await this.unlink(file2.name);
+        this.emit("removed", file2.name, true);
+      }
+    }
+    if (maxSize) {
+      while (res.reduce((size, file2) => size + file2.size, 0) > maxSize) {
+        const file2 = res.shift();
+        await this.unlink(file2.name);
+        this.emit("removed", file2.name, false);
+      }
+    }
+    await (0, import_promises.writeFile)(history, res.map((e) => e.name).join("\n") + "\n", "utf-8");
+    this.emit("history");
+  }
+  async immutate(first) {
+    const { size } = this.options;
+    const now = this.now();
+    for (let index = 1; index < 1e3; ++index) {
+      let fileSize = 0;
+      let stats = void 0;
+      this.filename = this.options.path + this.generator(now, index);
+      try {
+        stats = await this.fsStat(this.filename);
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
+      }
+      if (stats) {
+        fileSize = stats.size;
+        if (!stats.isFile())
+          throw new Error(`Can't write on: '${this.filename}' (it is not a file)`);
+        if (size && fileSize >= size)
+          continue;
+      }
+      if (first) {
+        this.last = this.filename;
+        return this.reopen(fileSize);
+      }
+      await this.rotated(this.last);
+      this.last = this.filename;
+      return;
+    }
+    throw new RotatingFileStreamError();
+  }
+  async unlink(filename) {
+    try {
+      await this.fsUnlink(filename);
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      this.emit("warning", e);
+    }
+  }
+};
+function buildNumberCheck(field) {
+  return (type, options, value) => {
+    const converted = parseInt(value, 10);
+    if (type !== "number" || converted !== value || converted <= 0)
+      throw new Error(`'${field}' option must be a positive integer number`);
+  };
+}
+function buildStringCheck(field, check2) {
+  return (type, options, value) => {
+    if (type !== "string")
+      throw new Error(`Don't know how to handle 'options.${field}' type: ${type}`);
+    options[field] = check2(value);
+  };
+}
+function checkMeasure(value, what, units) {
+  const ret = {};
+  ret.num = parseInt(value, 10);
+  if (isNaN(ret.num))
+    throw new Error(`Unknown 'options.${what}' format: ${value}`);
+  if (ret.num <= 0)
+    throw new Error(`A positive integer number is expected for 'options.${what}'`);
+  ret.unit = value.replace(/^[ 0]*/g, "").substr((ret.num + "").length, 1);
+  if (ret.unit.length === 0)
+    throw new Error(`Missing unit for 'options.${what}'`);
+  if (!units[ret.unit])
+    throw new Error(`Unknown 'options.${what}' unit: ${ret.unit}`);
+  return ret;
+}
+var intervalUnits = { M: true, d: true, h: true, m: true, s: true };
+function checkIntervalUnit(ret, unit, amount) {
+  if (parseInt(amount / ret.num, 10) * ret.num !== amount)
+    throw new Error(`An integer divider of ${amount} is expected as ${unit} for 'options.interval'`);
+}
+function checkInterval(value) {
+  const ret = checkMeasure(value, "interval", intervalUnits);
+  switch (ret.unit) {
+    case "h":
+      checkIntervalUnit(ret, "hours", 24);
+      break;
+    case "m":
+      checkIntervalUnit(ret, "minutes", 60);
+      break;
+    case "s":
+      checkIntervalUnit(ret, "seconds", 60);
+      break;
+  }
+  return ret;
+}
+var sizeUnits = { B: true, G: true, K: true, M: true };
+function checkSize(value) {
+  const ret = checkMeasure(value, "size", sizeUnits);
+  if (ret.unit === "K")
+    return ret.num * 1024;
+  if (ret.unit === "M")
+    return ret.num * 1048576;
+  if (ret.unit === "G")
+    return ret.num * 1073741824;
+  return ret.num;
+}
+var checks = {
+  encoding: (type, options, value) => new import_util6.TextDecoder(value),
+  immutable: () => {
+  },
+  initialRotation: () => {
+  },
+  interval: buildStringCheck("interval", checkInterval),
+  intervalBoundary: () => {
+  },
+  intervalUTC: () => {
+  },
+  maxFiles: buildNumberCheck("maxFiles"),
+  maxSize: buildStringCheck("maxSize", checkSize),
+  mode: () => {
+  },
+  omitExtension: () => {
+  },
+  rotate: buildNumberCheck("rotate"),
+  size: buildStringCheck("size", checkSize),
+  teeToStdout: () => {
+  },
+  ...{
+    compress: (type, options, value) => {
+      if (value === false)
+        return;
+      if (!value)
+        throw new Error("A value for 'options.compress' must be specified");
+      if (type === "boolean")
+        return options.compress = (source, dest) => `cat ${source} | gzip -c9 > ${dest}`;
+      if (type === "function")
+        return;
+      if (type !== "string")
+        throw new Error(`Don't know how to handle 'options.compress' type: ${type}`);
+      if (value !== "gzip")
+        throw new Error(`Don't know how to handle compression method: ${value}`);
+    },
+    history: (type) => {
+      if (type !== "string")
+        throw new Error(`Don't know how to handle 'options.history' type: ${type}`);
+    },
+    path: (type, options, value) => {
+      if (type !== "string")
+        throw new Error(`Don't know how to handle 'options.path' type: ${type}`);
+      if (value[value.length - 1] !== import_path.sep)
+        options.path = value + import_path.sep;
+    }
+  }
+};
+function checkOpts(options) {
+  const ret = {};
+  let opt;
+  for (opt in options) {
+    const value = options[opt];
+    const type = typeof value;
+    if (!(opt in checks))
+      throw new Error(`Unknown option: ${opt}`);
+    ret[opt] = options[opt];
+    checks[opt](type, ret, value);
+  }
+  if (!ret.path)
+    ret.path = "";
+  if (!ret.interval) {
+    delete ret.immutable;
+    delete ret.initialRotation;
+    delete ret.intervalBoundary;
+    delete ret.intervalUTC;
+  }
+  if (ret.rotate) {
+    delete ret.history;
+    delete ret.immutable;
+    delete ret.maxFiles;
+    delete ret.maxSize;
+    delete ret.intervalBoundary;
+    delete ret.intervalUTC;
+  }
+  if (ret.immutable)
+    delete ret.compress;
+  if (!ret.intervalBoundary)
+    delete ret.initialRotation;
+  return ret;
+}
+function createClassical(filename, compress, omitExtension) {
+  return (index) => index ? `${filename}.${index}${compress && !omitExtension ? ".gz" : ""}` : filename;
+}
+function createGenerator(filename, compress, omitExtension) {
+  const pad = (num) => (num > 9 ? "" : "0") + num;
+  return (time3, index) => {
+    if (!time3)
+      return filename;
+    const month = time3.getFullYear() + "" + pad(time3.getMonth() + 1);
+    const day = pad(time3.getDate());
+    const hour = pad(time3.getHours());
+    const minute = pad(time3.getMinutes());
+    return month + day + "-" + hour + minute + "-" + pad(index) + "-" + filename + (compress && !omitExtension ? ".gz" : "");
+  };
+}
+function createStream(filename, options) {
+  if (typeof options === "undefined")
+    options = {};
+  else if (typeof options !== "object")
+    throw new Error(`The "options" argument must be of type object. Received type ${typeof options}`);
+  const opts = checkOpts(options);
+  const { compress, omitExtension } = opts;
+  let generator;
+  if (typeof filename === "string")
+    generator = options.rotate ? createClassical(filename, !!compress, omitExtension) : createGenerator(filename, !!compress, omitExtension);
+  else if (typeof filename === "function")
+    generator = filename;
+  else
+    throw new Error(`The "filename" argument must be one of type string or function. Received type ${typeof filename}`);
+  return new RotatingFileStream(generator, opts);
+}
+
+// ../logger/src/transports/file.ts
+function parseSize(maxSize) {
+  const trimmed = maxSize.trim().toUpperCase();
+  if (trimmed.endsWith("MB")) {
+    return `${trimmed.slice(0, -2)}M`;
+  }
+  return trimmed;
+}
+var streamCache = /* @__PURE__ */ new Map();
+var droppedEntryCount = 0;
+var lastReportedDroppedTotal = 0;
+function buildLogDroppedSentinel(fmt, source, droppedTotal) {
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level: "WARN",
+    source,
+    module: "logger.file",
+    msg: "log_dropped",
+    data: { droppedTotal }
+  };
+  return fmt(entry);
+}
+function writeWithDroppedSentinel(stream, fmt, line, source) {
+  stream.write(`${line}
+`);
+  if (droppedEntryCount > lastReportedDroppedTotal) {
+    lastReportedDroppedTotal = droppedEntryCount;
+    stream.write(`${buildLogDroppedSentinel(fmt, source, droppedEntryCount)}
+`);
+  }
+}
+function fileTransport(opts) {
+  const fmt = opts.formatter ?? jsonFormatter;
+  const logSource = opts.source ?? "server";
+  const resolved = import_node_path.default.resolve(opts.path);
+  let cached2 = streamCache.get(resolved);
+  if (!cached2) {
+    cached2 = {
+      stream: createStream(import_node_path.default.basename(resolved), {
+        path: import_node_path.default.dirname(resolved),
+        size: opts.rotate?.maxSize ? parseSize(opts.rotate.maxSize) : "50M",
+        maxFiles: opts.rotate?.maxFiles ?? 7
+      }),
+      closed: false
+    };
+    streamCache.set(resolved, cached2);
+  }
+  return (entry) => {
+    if (cached2.closed || cached2.stream.destroyed || cached2.stream.writableEnded) {
+      droppedEntryCount += 1;
+      return;
+    }
+    try {
+      writeWithDroppedSentinel(cached2.stream, fmt, fmt(entry), logSource);
+    } catch {
+      droppedEntryCount += 1;
+    }
+  };
+}
+
+// ../logger/src/index.ts
+function createLogger(config2) {
+  return new Logger(config2);
+}
+
+// src/config.ts
+init_cjs_shims();
+var import_node_crypto = __toESM(require("crypto"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var DEFAULT_QUERY_CONFIG = {
+  maxActive: 5040,
+  idleTimeoutMs: 6e5,
+  workingSilenceTimeoutMs: 12e5,
+  replyStallTimeoutMs: 3e5,
+  busySilenceTimeoutMs: 18e5,
+  evictionIntervalMs: 6e4,
+  statusReportIntervalMs: 6e4,
+  allowBuiltinWebSearch: false,
+  compactPromptTemplate: "/compact \u6781\u81F4\u538B\u7F29\uFF1A\u53EA\u4FDD\u7559 1) \u7FA4\u91CC\u6210\u5458\u4E4B\u95F4\u7684\u5173\u952E\u5171\u8BC6\u4E0E\u51B3\u8BAE 2) \u8FDB\u884C\u4E2D\u7684\u4EFB\u52A1\u548C\u5F53\u524D\u72B6\u6001\uFF08\u542B\u8D1F\u8D23\u4EBA\uFF09 3) open blockers\u3002\u6BCF\u6761\u4E0D\u8D85\u8FC7 2 \u884C\uFF0C\u5176\u4ED6\u5168\u90E8\u7701\u7565\u3002",
+  inboxQuietWindowMs: 15e3,
+  inboxMaxLatencyMs: 18e4
+};
+function readEnvString(name, fallback) {
+  const v = process.env[name];
+  return v && v.length > 0 ? v : fallback;
+}
+function readEnvInt(name, fallback) {
+  const v = process.env[name];
+  if (!v || v.length === 0) return fallback;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function readEnvBool(name, fallback) {
+  const v = process.env[name];
+  if (!v || v.length === 0) return fallback;
+  const normalized = v.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return fallback;
+}
+function generateStableBridgeId(dataDir) {
+  const raw = `${import_node_os2.default.hostname()}:${import_node_os2.default.userInfo().username}:${import_node_path2.default.resolve(dataDir)}`;
+  const hash2 = import_node_crypto.default.createHash("sha256").update(raw).digest("hex").slice(0, 12);
+  return `bridge_${hash2}`;
+}
+function generateStableBridgeToken() {
+  const raw = `${import_node_os2.default.hostname()}:${import_node_os2.default.userInfo().username}:ahchat-bridge-token`;
+  return import_node_crypto.default.createHash("sha256").update(raw).digest("hex").slice(0, 32);
+}
+function tryReadJsonConfig(filePath) {
+  try {
+    if (!import_node_fs.default.existsSync(filePath)) return {};
+    const raw = import_node_fs.default.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function mergeQueryConfig(file2) {
+  const q = file2.queryConfig;
+  return {
+    maxActive: readEnvInt("AHCHAT_BRIDGE_MAX_ACTIVE", q?.maxActive ?? DEFAULT_QUERY_CONFIG.maxActive),
+    idleTimeoutMs: readEnvInt(
+      "AHCHAT_BRIDGE_IDLE_TIMEOUT_MS",
+      q?.idleTimeoutMs ?? DEFAULT_QUERY_CONFIG.idleTimeoutMs
+    ),
+    workingSilenceTimeoutMs: readEnvInt(
+      "AHCHAT_BRIDGE_WORKING_SILENCE_TIMEOUT_MS",
+      q?.workingSilenceTimeoutMs ?? DEFAULT_QUERY_CONFIG.workingSilenceTimeoutMs
+    ),
+    replyStallTimeoutMs: readEnvInt(
+      "AHCHAT_BRIDGE_REPLY_STALL_TIMEOUT_MS",
+      q?.replyStallTimeoutMs ?? DEFAULT_QUERY_CONFIG.replyStallTimeoutMs
+    ),
+    busySilenceTimeoutMs: readEnvInt(
+      "AHCHAT_BRIDGE_BUSY_SILENCE_TIMEOUT_MS",
+      q?.busySilenceTimeoutMs ?? DEFAULT_QUERY_CONFIG.busySilenceTimeoutMs ?? 18e5
+    ),
+    evictionIntervalMs: readEnvInt(
+      "AHCHAT_BRIDGE_EVICTION_INTERVAL_MS",
+      q?.evictionIntervalMs ?? DEFAULT_QUERY_CONFIG.evictionIntervalMs
+    ),
+    statusReportIntervalMs: readEnvInt(
+      "AHCHAT_BRIDGE_STATUS_REPORT_MS",
+      q?.statusReportIntervalMs ?? DEFAULT_QUERY_CONFIG.statusReportIntervalMs
+    ),
+    allowBuiltinWebSearch: readEnvBool(
+      "AHCHAT_BRIDGE_ALLOW_BUILTIN_WEBSEARCH",
+      q?.allowBuiltinWebSearch ?? DEFAULT_QUERY_CONFIG.allowBuiltinWebSearch
+    ),
+    compactPromptTemplate: readEnvString(
+      "AHCHAT_BRIDGE_COMPACT_PROMPT_TEMPLATE",
+      q?.compactPromptTemplate ?? DEFAULT_QUERY_CONFIG.compactPromptTemplate
+    ),
+    inboxQuietWindowMs: readEnvInt(
+      "AHCHAT_BRIDGE_INBOX_QUIET_WINDOW_MS",
+      q?.inboxQuietWindowMs ?? DEFAULT_QUERY_CONFIG.inboxQuietWindowMs
+    ),
+    inboxMaxLatencyMs: readEnvInt(
+      "AHCHAT_BRIDGE_INBOX_MAX_LATENCY_MS",
+      q?.inboxMaxLatencyMs ?? DEFAULT_QUERY_CONFIG.inboxMaxLatencyMs
+    )
+  };
+}
+function resolveAgentConfigDir(dataDir) {
+  const newPath = import_node_path2.default.join(dataDir, "agent-config");
+  const oldPath = import_node_path2.default.join(dataDir, "claude-config");
+  if (!import_node_fs.default.existsSync(newPath) && import_node_fs.default.existsSync(oldPath)) {
+    try {
+      import_node_fs.default.renameSync(oldPath, newPath);
+    } catch {
+      return oldPath;
+    }
+  }
+  return newPath;
+}
+function loadBridgeConfig(opts) {
+  const dataDir = opts?.dataDir ?? readEnvString(
+    "AHCHAT_DATA_DIR",
+    import_node_path2.default.join(import_node_os2.default.homedir(), ".ahchat")
+  );
+  const fileConfig = tryReadJsonConfig(import_node_path2.default.join(dataDir, "bridge.json"));
+  return {
+    serverUrl: readEnvString(
+      "AHCHAT_BRIDGE_SERVER_URL",
+      fileConfig.serverUrl ?? "ws://127.0.0.1:3001/ws/bridge"
+    ),
+    bridgeId: readEnvString(
+      "AHCHAT_BRIDGE_ID",
+      fileConfig.bridgeId ?? generateStableBridgeId(dataDir)
+    ),
+    bridgeToken: readEnvString(
+      "AHCHAT_BRIDGE_TOKEN",
+      fileConfig.bridgeToken ?? generateStableBridgeToken()
+    ),
+    logLevel: readEnvString(
+      "AHCHAT_LOG_LEVEL",
+      fileConfig.logLevel ?? "INFO"
+    ),
+    dataDir,
+    dbPath: readEnvString(
+      "AHCHAT_DB_PATH",
+      fileConfig.dbPath ?? import_node_path2.default.join(dataDir, "data.db")
+    ),
+    serverApiUrl: readEnvString(
+      "AHCHAT_SERVER_API_URL",
+      fileConfig.serverApiUrl ?? "http://127.0.0.1:3001"
+    ),
+    agentConfigDir: readEnvString(
+      "AHCHAT_AGENT_CONFIG_DIR",
+      fileConfig.agentConfigDir ?? resolveAgentConfigDir(dataDir)
+    ),
+    defaultModel: readEnvString(
+      "AHCHAT_DEFAULT_MODEL",
+      fileConfig.defaultModel ?? ""
+    ) || null,
+    logUploadIntervalMs: readEnvInt(
+      "AHCHAT_LOG_UPLOAD_INTERVAL_MS",
+      // Flush every 60s instead of once a day. Daily flushing let logs pile up for hours,
+      // then dumped tens of thousands of entries in one cycle on the next process start,
+      // blowing past the server's per-minute upload quota (3000 entries / 3MB) and getting
+      // 429'd. Small frequent batches stay well under that ceiling.
+      fileConfig.logUploadIntervalMs ?? 6e4
+    ),
+    queryConfig: mergeQueryConfig(fileConfig)
+  };
+}
+function ensureDir(dirPath) {
+  import_node_fs.default.mkdirSync(dirPath, { recursive: true, mode: 448 });
+  try {
+    import_node_fs.default.chmodSync(dirPath, 448);
+  } catch {
+  }
+}
+
+// src/logger.ts
+var bridgeConfig = loadBridgeConfig();
+var isTest = !!process.env["VITEST"];
+var activeDataDir = bridgeConfig.dataDir || import_node_path3.default.join(import_node_os3.default.homedir(), ".ahchat");
+var fileTransports = /* @__PURE__ */ new Map();
+function activeLogFile() {
+  return import_node_path3.default.join(activeDataDir, "logs", "bridge.log");
+}
+if (!isTest) ensureDir(import_node_path3.default.dirname(activeLogFile()));
+function dynamicFileTransport() {
+  return (entry) => {
+    const logFile = activeLogFile();
+    let transport = fileTransports.get(logFile);
+    if (!transport) {
+      transport = fileTransport({
+        path: logFile,
+        formatter: jsonFormatter,
+        rotate: { maxSize: "20MB", maxFiles: 5 }
+      });
+      fileTransports.set(logFile, transport);
+    }
+    transport(entry);
+  };
+}
+function createModuleLogger(module2) {
+  const transports = [consoleTransport({ formatter: prettyFormatter })];
+  if (!isTest) {
+    transports.push(dynamicFileTransport());
+  }
+  return createLogger({
+    source: "bridge",
+    module: module2,
+    level: parseLogLevel(bridgeConfig.logLevel),
+    transports
+  });
+}
+
+// src/officialMcpQuota.ts
+var logger = createModuleLogger("officialMcp.quota");
 var OfficialMcpQuotaError = class extends Error {
   constructor(message) {
     super(message);
@@ -31257,7 +32905,8 @@ async function consumeOfficialMcpDailyQuota(serverName, toolName) {
       },
       body: JSON.stringify({ serverName, toolName })
     });
-  } catch {
+  } catch (error51) {
+    logger.error("Official MCP quota consume request failed", { error: error51, serverName, toolName });
     throw new OfficialMcpQuotaError("\u6682\u65F6\u65E0\u6CD5\u6821\u9A8C\u5B98\u65B9\u5A92\u4F53 MCP \u6BCF\u65E5\u989D\u5EA6\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002");
   }
   if (response.status === 404) return;
@@ -31275,7 +32924,8 @@ async function readQuotaResponse(response) {
     if (value && typeof value === "object" && !Array.isArray(value)) {
       return value;
     }
-  } catch {
+  } catch (error51) {
+    logger.error("Official MCP quota response was not JSON", { error: error51, status: response.status });
   }
   return {};
 }
@@ -31290,8 +32940,8 @@ function formatQuotaExceededMessage(serverName, body) {
 
 // src/seedreamValidation.ts
 init_cjs_shims();
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path = __toESM(require("path"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 var HTTP_IMAGE_URL_RE = /^https?:\/\/\S+$/i;
 var DATA_IMAGE_RE = /^data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=\s]+$/i;
@@ -31310,7 +32960,7 @@ function countSeedreamImageReferences(image) {
   return image ? 1 : 0;
 }
 async function resolveSeedreamImageReferences(image, options = {}) {
-  const cwd = import_node_path.default.resolve(options.cwd ?? process.cwd());
+  const cwd = import_node_path4.default.resolve(options.cwd ?? process.cwd());
   if (!image) return { image: void 0, error: null };
   const refs = Array.isArray(image) ? image : [image];
   const resolved = [];
@@ -31354,36 +33004,37 @@ async function resolveLocalSeedreamImageReference(value, cwd) {
       error: `Seedream reference image must be a supported image file (jpg, png, webp, gif, or bmp). Unsupported path: "${formatImageReferenceSample(value)}".`
     };
   }
-  let stat;
+  let stat2;
   try {
-    stat = await import_promises.default.stat(resolvedPath);
-  } catch {
+    stat2 = await import_promises2.default.stat(resolvedPath);
+  } catch (error51) {
+    const code = error51 && typeof error51 === "object" && "code" in error51 ? String(error51.code) : "UNKNOWN";
     return {
-      error: `Seedream reference image was not found in the agent workspace: "${formatImageReferenceSample(value)}".`
+      error: `Seedream reference image was not found in the agent workspace (${code}): "${formatImageReferenceSample(value)}".`
     };
   }
-  if (!stat.isFile()) {
+  if (!stat2.isFile()) {
     return {
       error: `Seedream reference image must point to a file: "${formatImageReferenceSample(value)}".`
     };
   }
-  const bytes = await import_promises.default.readFile(resolvedPath);
+  const bytes = await import_promises2.default.readFile(resolvedPath);
   return {
     image: `data:${mimeType};base64,${bytes.toString("base64")}`,
     error: null
   };
 }
 function resolveLocalPath(value, cwd) {
-  if (/^file:/i.test(value)) return import_node_path.default.resolve((0, import_node_url.fileURLToPath)(value));
-  if (import_node_path.default.isAbsolute(value)) return import_node_path.default.resolve(value);
-  return import_node_path.default.resolve(cwd, value);
+  if (/^file:/i.test(value)) return import_node_path4.default.resolve((0, import_node_url.fileURLToPath)(value));
+  if (import_node_path4.default.isAbsolute(value)) return import_node_path4.default.resolve(value);
+  return import_node_path4.default.resolve(cwd, value);
 }
 function mimeTypeForImagePath(filePath) {
-  return SUPPORTED_IMAGE_MIME_BY_EXT[import_node_path.default.extname(filePath).toLowerCase()] ?? null;
+  return SUPPORTED_IMAGE_MIME_BY_EXT[import_node_path4.default.extname(filePath).toLowerCase()] ?? null;
 }
 function isPathInside(filePath, basePath) {
-  const relative = import_node_path.default.relative(import_node_path.default.resolve(basePath), import_node_path.default.resolve(filePath));
-  return relative === "" || !relative.startsWith("..") && !import_node_path.default.isAbsolute(relative);
+  const relative = import_node_path4.default.relative(import_node_path4.default.resolve(basePath), import_node_path4.default.resolve(filePath));
+  return relative === "" || !relative.startsWith("..") && !import_node_path4.default.isAbsolute(relative);
 }
 function formatImageReferenceSample(value) {
   const trimmed = value.trim();
@@ -31395,6 +33046,7 @@ function formatImageReferenceSample(value) {
 var SERVER_NAME = "ahchat-seedream-mcp";
 var SERVER_VERSION = "0.1.0";
 var DEFAULT_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3";
+var logger2 = createModuleLogger("seedream.mcpCli");
 var SEEDREAM_MODELS = [
   "doubao-seedream-5-0-lite-260128",
   "doubao-seedream-4-0-250828",
@@ -31709,8 +33361,8 @@ async function saveGeneratedImagesToWorkdir(images) {
     try {
       const downloaded = await downloadGeneratedImage(image.url);
       const fileName = await uniqueGeneratedImageFileName(downloaded.extension, index);
-      const filePath = import_node_path2.default.join(process.cwd(), fileName);
-      await import_promises2.default.writeFile(filePath, downloaded.buffer, { flag: "wx" });
+      const filePath = import_node_path5.default.join(process.cwd(), fileName);
+      await import_promises3.default.writeFile(filePath, downloaded.buffer, { flag: "wx" });
       saved.push({
         ...image,
         local_path: filePath,
@@ -31765,14 +33417,10 @@ function imageMimeTypeFromContentType(contentType) {
   return normalizeImageMimeType(contentType.split(";")[0]?.trim() ?? "");
 }
 function imageMimeTypeFromUrl(url2) {
-  try {
-    return imageMimeTypeFromPath(new URL(url2).pathname);
-  } catch {
-    return imageMimeTypeFromPath(url2);
-  }
+  return imageMimeTypeFromPath(URL.canParse(url2) ? new URL(url2).pathname : url2);
 }
 function imageMimeTypeFromPath(filePath) {
-  switch (import_node_path2.default.extname(filePath).toLowerCase()) {
+  switch (import_node_path5.default.extname(filePath).toLowerCase()) {
     case ".bmp":
       return "image/bmp";
     case ".gif":
@@ -31816,8 +33464,11 @@ async function uniqueGeneratedImageFileName(extension, imageIndex) {
     const suffix = attempt === 0 ? "" : `-${attempt + 1}`;
     const fileName = `${baseName}${suffix}${extension}`;
     try {
-      await import_promises2.default.access(import_node_path2.default.join(process.cwd(), fileName));
-    } catch {
+      await import_promises3.default.access(import_node_path5.default.join(process.cwd(), fileName));
+    } catch (error51) {
+      if (!isFileNotFoundError(error51)) {
+        logger2.error("Seedream generated image filename access check failed", { error: error51 });
+      }
       return fileName;
     }
   }
@@ -31828,7 +33479,12 @@ async function parseJsonSafe(response) {
   if (!text) return void 0;
   try {
     return JSON.parse(text);
-  } catch {
+  } catch (error51) {
+    logger2.error("Seedream ARK API returned non-JSON response body", {
+      error: error51,
+      status: response.status,
+      bodyLength: text.length
+    });
     return text;
   }
 }
@@ -31891,14 +33547,15 @@ function errorResult(message) {
     isError: true
   };
 }
+function isFileNotFoundError(error51) {
+  return Boolean(error51 && typeof error51 === "object" && error51.code === "ENOENT");
+}
 async function main() {
   const server = createServer();
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error(`${SERVER_NAME} v${SERVER_VERSION} running on stdio`);
 }
 main().catch((error51) => {
-  const message = error51 instanceof Error ? error51.stack ?? error51.message : String(error51);
-  console.error(`Fatal error in ${SERVER_NAME}: ${message}`);
+  logger2.error(`Fatal error in ${SERVER_NAME}`, { error: error51 });
   process.exit(1);
 });