siluzan-website-cli 1.0.1-beta.1

package/dist/index.js

@@ -0,0 +1,4192 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/constants.js
+var require_constants = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/constants.js"(exports, module) {
+    "use strict";
+    var SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module.exports = {
+      MAX_LENGTH,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.js"(exports, module) {
+    "use strict";
+    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module.exports = debug;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/re.js"(exports, module) {
+    "use strict";
+    var {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = require_constants();
+    var debug = require_debug();
+    exports = module.exports = {};
+    var re = exports.re = [];
+    var safeRe = exports.safeRe = [];
+    var src = exports.src = [];
+    var safeSrc = exports.safeSrc = [];
+    var t = exports.t = {};
+    var R = 0;
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    var makeSafeRegex = (value) => {
+      for (const [token, max] of safeRegexReplacements) {
+        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+      }
+      return value;
+    };
+    var createToken = (name, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name, index, value);
+      t[name] = index;
+      src[index] = value;
+      safeSrc[index] = safe;
+      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t.COERCE], true);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+    exports.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+    exports.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+    exports.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/parse-options.js"(exports, module) {
+    "use strict";
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions = (options) => {
+      if (!options) {
+        return emptyOpts;
+      }
+      if (typeof options !== "object") {
+        return looseOption;
+      }
+      return options;
+    };
+    module.exports = parseOptions;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/identifiers.js"(exports, module) {
+    "use strict";
+    var numeric = /^[0-9]+$/;
+    var compareIdentifiers = (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        return a === b ? 0 : a < b ? -1 : 1;
+      }
+      const anum = numeric.test(a);
+      const bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/semver.js
+var require_semver = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/semver.js"(exports, module) {
+    "use strict";
+    var debug = require_debug();
+    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+    var { safeRe: re, t } = require_re();
+    var parseOptions = require_parse_options();
+    var { compareIdentifiers } = require_identifiers();
+    var SemVer = class _SemVer {
+      constructor(version, options) {
+        options = parseOptions(options);
+        if (version instanceof _SemVer) {
+          if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+            return version;
+          } else {
+            version = version.version;
+          }
+        } else if (typeof version !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+        }
+        if (version.length > MAX_LENGTH) {
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
+        }
+        debug("SemVer", version, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m) {
+          throw new TypeError(`Invalid Version: ${version}`);
+        }
+        this.raw = version;
+        this.major = +m[1];
+        this.minor = +m[2];
+        this.patch = +m[3];
+        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+          throw new TypeError("Invalid major version");
+        }
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+          throw new TypeError("Invalid minor version");
+        }
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+          throw new TypeError("Invalid patch version");
+        }
+        if (!m[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m[4].split(".").map((id) => {
+            if (/^[0-9]+$/.test(id)) {
+              const num = +id;
+              if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                return num;
+              }
+            }
+            return id;
+          });
+        }
+        this.build = m[5] ? m[5].split(".") : [];
+        this.format();
+      }
+      format() {
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) {
+          this.version += `-${this.prerelease.join(".")}`;
+        }
+        return this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof _SemVer)) {
+          if (typeof other === "string" && other === this.version) {
+            return 0;
+          }
+          other = new _SemVer(other, this.options);
+        }
+        if (other.version === this.version) {
+          return 0;
+        }
+        return this.compareMain(other) || this.comparePre(other);
+      }
+      compareMain(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.major < other.major) {
+          return -1;
+        }
+        if (this.major > other.major) {
+          return 1;
+        }
+        if (this.minor < other.minor) {
+          return -1;
+        }
+        if (this.minor > other.minor) {
+          return 1;
+        }
+        if (this.patch < other.patch) {
+          return -1;
+        }
+        if (this.patch > other.patch) {
+          return 1;
+        }
+        return 0;
+      }
+      comparePre(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.prerelease.length && !other.prerelease.length) {
+          return -1;
+        } else if (!this.prerelease.length && other.prerelease.length) {
+          return 1;
+        } else if (!this.prerelease.length && !other.prerelease.length) {
+          return 0;
+        }
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("build compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      inc(release, identifier, identifierBase) {
+        if (release.startsWith("pre")) {
+          if (!identifier && identifierBase === false) {
+            throw new Error("invalid increment argument: identifier is empty");
+          }
+          if (identifier) {
+            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+            if (!match || match[1] !== identifier) {
+              throw new Error(`invalid identifier: ${identifier}`);
+            }
+          }
+        }
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            if (this.prerelease.length === 0) {
+              this.inc("patch", identifier, identifierBase);
+            }
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "release":
+            if (this.prerelease.length === 0) {
+              throw new Error(`version ${this.raw} is not a prerelease`);
+            }
+            this.prerelease.length = 0;
+            break;
+          case "major":
+            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+              this.major++;
+            }
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (this.patch !== 0 || this.prerelease.length === 0) {
+              this.minor++;
+            }
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (this.prerelease.length === 0) {
+              this.patch++;
+            }
+            this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
+            } else {
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === "number") {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                  throw new Error("invalid increment argument: identifier already exists");
+                }
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier) {
+              let prerelease = [identifier, base];
+              if (identifierBase === false) {
+                prerelease = [identifier];
+              }
+              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+                if (isNaN(this.prerelease[1])) {
+                  this.prerelease = prerelease;
+                }
+              } else {
+                this.prerelease = prerelease;
+              }
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join(".")}`;
+        }
+        return this;
+      }
+    };
+    module.exports = SemVer;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/parse.js
+var require_parse = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/parse.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = (version, options, throwErrors = false) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      try {
+        return new SemVer(version, options);
+      } catch (er) {
+        if (!throwErrors) {
+          return null;
+        }
+        throw er;
+      }
+    };
+    module.exports = parse;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/valid.js
+var require_valid = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/valid.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var valid = (version, options) => {
+      const v = parse(version, options);
+      return v ? v.version : null;
+    };
+    module.exports = valid;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/clean.js
+var require_clean = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/clean.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var clean = (version, options) => {
+      const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+      return s ? s.version : null;
+    };
+    module.exports = clean;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/inc.js
+var require_inc = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/inc.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var inc = (version, release, options, identifier, identifierBase) => {
+      if (typeof options === "string") {
+        identifierBase = identifier;
+        identifier = options;
+        options = void 0;
+      }
+      try {
+        return new SemVer(
+          version instanceof SemVer ? version.version : version,
+          options
+        ).inc(release, identifier, identifierBase).version;
+      } catch (er) {
+        return null;
+      }
+    };
+    module.exports = inc;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/diff.js
+var require_diff = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/diff.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var diff = (version1, version2) => {
+      const v1 = parse(version1, null, true);
+      const v2 = parse(version2, null, true);
+      const comparison = v1.compare(v2);
+      if (comparison === 0) {
+        return null;
+      }
+      const v1Higher = comparison > 0;
+      const highVersion = v1Higher ? v1 : v2;
+      const lowVersion = v1Higher ? v2 : v1;
+      const highHasPre = !!highVersion.prerelease.length;
+      const lowHasPre = !!lowVersion.prerelease.length;
+      if (lowHasPre && !highHasPre) {
+        if (!lowVersion.patch && !lowVersion.minor) {
+          return "major";
+        }
+        if (lowVersion.compareMain(highVersion) === 0) {
+          if (lowVersion.minor && !lowVersion.patch) {
+            return "minor";
+          }
+          return "patch";
+        }
+      }
+      const prefix = highHasPre ? "pre" : "";
+      if (v1.major !== v2.major) {
+        return prefix + "major";
+      }
+      if (v1.minor !== v2.minor) {
+        return prefix + "minor";
+      }
+      if (v1.patch !== v2.patch) {
+        return prefix + "patch";
+      }
+      return "prerelease";
+    };
+    module.exports = diff;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/major.js
+var require_major = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/major.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var major = (a, loose) => new SemVer(a, loose).major;
+    module.exports = major;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/minor.js
+var require_minor = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/minor.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var minor = (a, loose) => new SemVer(a, loose).minor;
+    module.exports = minor;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/patch.js
+var require_patch = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/patch.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var patch = (a, loose) => new SemVer(a, loose).patch;
+    module.exports = patch;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/prerelease.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var prerelease = (version, options) => {
+      const parsed = parse(version, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    };
+    module.exports = prerelease;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module.exports = compare;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rcompare.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var rcompare = (a, b, loose) => compare(b, a, loose);
+    module.exports = rcompare;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-loose.js
+var require_compare_loose = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-loose.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var compareLoose = (a, b) => compare(a, b, true);
+    module.exports = compareLoose;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-build.js
+var require_compare_build = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-build.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var compareBuild = (a, b, loose) => {
+      const versionA = new SemVer(a, loose);
+      const versionB = new SemVer(b, loose);
+      return versionA.compare(versionB) || versionA.compareBuild(versionB);
+    };
+    module.exports = compareBuild;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/sort.js
+var require_sort = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/sort.js"(exports, module) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+    module.exports = sort;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rsort.js
+var require_rsort = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rsort.js"(exports, module) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+    module.exports = rsort;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gt.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var gt = (a, b, loose) => compare(a, b, loose) > 0;
+    module.exports = gt;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lt.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var lt = (a, b, loose) => compare(a, b, loose) < 0;
+    module.exports = lt;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/eq.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var eq = (a, b, loose) => compare(a, b, loose) === 0;
+    module.exports = eq;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/neq.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+    module.exports = neq;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gte.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    module.exports = gte;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lte.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+    module.exports = lte;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/cmp.js"(exports, module) {
+    "use strict";
+    var eq = require_eq();
+    var neq = require_neq();
+    var gt = require_gt();
+    var gte = require_gte();
+    var lt = require_lt();
+    var lte = require_lte();
+    var cmp = (a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a === b;
+        case "!==":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
+      }
+    };
+    module.exports = cmp;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/coerce.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = require_parse();
+    var { safeRe: re, t } = require_re();
+    var coerce = (version, options) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      if (typeof version === "number") {
+        version = String(version);
+      }
+      if (typeof version !== "string") {
+        return null;
+      }
+      options = options || {};
+      let match = null;
+      if (!options.rtl) {
+        match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+      } else {
+        const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+        let next;
+        while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+          if (!match || next.index + next[0].length !== match.index + match[0].length) {
+            match = next;
+          }
+          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+        }
+        coerceRtlRegex.lastIndex = -1;
+      }
+      if (match === null) {
+        return null;
+      }
+      const major = match[2];
+      const minor = match[3] || "0";
+      const patch = match[4] || "0";
+      const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+      const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+      return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+    };
+    module.exports = coerce;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/lrucache.js"(exports, module) {
+    "use strict";
+    var LRUCache = class {
+      constructor() {
+        this.max = 1e3;
+        this.map = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        const value = this.map.get(key);
+        if (value === void 0) {
+          return void 0;
+        } else {
+          this.map.delete(key);
+          this.map.set(key, value);
+          return value;
+        }
+      }
+      delete(key) {
+        return this.map.delete(key);
+      }
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && value !== void 0) {
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
+          }
+          this.map.set(key, value);
+        }
+        return this;
+      }
+    };
+    module.exports = LRUCache;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/range.js"(exports, module) {
+    "use strict";
+    var SPACE_CHARACTERS = /\s+/g;
+    var Range = class _Range {
+      constructor(range, options) {
+        options = parseOptions(options);
+        if (range instanceof _Range) {
+          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+            return range;
+          } else {
+            return new _Range(range.raw, options);
+          }
+        }
+        if (range instanceof Comparator) {
+          this.raw = range.value;
+          this.set = [[range]];
+          this.formatted = void 0;
+          return this;
+        }
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+        if (!this.set.length) {
+          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        }
+        if (this.set.length > 1) {
+          const first = this.set[0];
+          this.set = this.set.filter((c) => !isNullSet(c[0]));
+          if (this.set.length === 0) {
+            this.set = [first];
+          } else if (this.set.length > 1) {
+            for (const c of this.set) {
+              if (c.length === 1 && isAny(c[0])) {
+                this.set = [c];
+                break;
+              }
+            }
+          }
+        }
+        this.formatted = void 0;
+      }
+      get range() {
+        if (this.formatted === void 0) {
+          this.formatted = "";
+          for (let i = 0; i < this.set.length; i++) {
+            if (i > 0) {
+              this.formatted += "||";
+            }
+            const comps = this.set[i];
+            for (let k = 0; k < comps.length; k++) {
+              if (k > 0) {
+                this.formatted += " ";
+              }
+              this.formatted += comps[k].toString().trim();
+            }
+          }
+        }
+        return this.formatted;
+      }
+      format() {
+        return this.range;
+      }
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+        const memoKey = memoOpts + ":" + range;
+        const cached = cache.get(memoKey);
+        if (cached) {
+          return cached;
+        }
+        const loose = this.options.loose;
+        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug("caret trim", range);
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        if (loose) {
+          rangeList = rangeList.filter((comp) => {
+            debug("loose invalid filter", comp, this.options);
+            return !!comp.match(re[t.COMPARATORLOOSE]);
+          });
+        }
+        debug("range list", rangeList);
+        const rangeMap = /* @__PURE__ */ new Map();
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) {
+            return [comp];
+          }
+          rangeMap.set(comp.value, comp);
+        }
+        if (rangeMap.size > 1 && rangeMap.has("")) {
+          rangeMap.delete("");
+        }
+        const result = [...rangeMap.values()];
+        cache.set(memoKey, result);
+        return result;
+      }
+      intersects(range, options) {
+        if (!(range instanceof _Range)) {
+          throw new TypeError("a Range is required");
+        }
+        return this.set.some((thisComparators) => {
+          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options);
+              });
+            });
+          });
+        });
+      }
+      // if ANY of the sets match ALL of its comparators, then pass
+      test(version) {
+        if (!version) {
+          return false;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        for (let i = 0; i < this.set.length; i++) {
+          if (testSet(this.set[i], version, this.options)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+    module.exports = Range;
+    var LRU = require_lrucache();
+    var cache = new LRU();
+    var parseOptions = require_parse_options();
+    var Comparator = require_comparator();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var {
+      safeRe: re,
+      t,
+      comparatorTrimReplace,
+      tildeTrimReplace,
+      caretTrimReplace
+    } = require_re();
+    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+    var isNullSet = (c) => c.value === "<0.0.0-0";
+    var isAny = (c) => c.value === "";
+    var isSatisfiable = (comparators, options) => {
+      let result = true;
+      const remainingComparators = comparators.slice();
+      let testComparator = remainingComparators.pop();
+      while (result && remainingComparators.length) {
+        result = remainingComparators.every((otherComparator) => {
+          return testComparator.intersects(otherComparator, options);
+        });
+        testComparator = remainingComparators.pop();
+      }
+      return result;
+    };
+    var parseComparator = (comp, options) => {
+      comp = comp.replace(re[t.BUILD], "");
+      debug("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug("stars", comp);
+      return comp;
+    };
+    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+    var replaceTildes = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+    };
+    var replaceTilde = (comp, options) => {
+      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("tilde", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+        } else if (pr) {
+          debug("replaceTilde pr", pr);
+          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+        }
+        debug("tilde return", ret);
+        return ret;
+      });
+    };
+    var replaceCarets = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+    };
+    var replaceCaret = (comp, options) => {
+      debug("caret", comp, options);
+      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("caret", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+          } else {
+            ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+          }
+        } else if (pr) {
+          debug("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+          }
+        } else {
+          debug("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+          }
+        }
+        debug("caret return", ret);
+        return ret;
+      });
+    };
+    var replaceXRanges = (comp, options) => {
+      debug("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+    };
+    var replaceXRange = (comp, options) => {
+      comp = comp.trim();
+      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+      return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+        debug("xRange", comp, ret, gtlt, M, m, p, pr);
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0-0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          if (gtlt === "<") {
+            pr = "-0";
+          }
+          ret = `${gtlt + M}.${m}.${p}${pr}`;
+        } else if (xm) {
+          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+        } else if (xp) {
+          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+        }
+        debug("xRange return", ret);
+        return ret;
+      });
+    };
+    var replaceStars = (comp, options) => {
+      debug("replaceStars", comp, options);
+      return comp.trim().replace(re[t.STAR], "");
+    };
+    var replaceGTE0 = (comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+    };
+    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+      } else if (isX(fp)) {
+        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+      } else if (fpr) {
+        from = `>=${from}`;
+      } else {
+        from = `>=${from}${incPr ? "-0" : ""}`;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = `<${+tM + 1}.0.0-0`;
+      } else if (isX(tp)) {
+        to = `<${tM}.${+tm + 1}.0-0`;
+      } else if (tpr) {
+        to = `<=${tM}.${tm}.${tp}-${tpr}`;
+      } else if (incPr) {
+        to = `<${tM}.${tm}.${+tp + 1}-0`;
+      } else {
+        to = `<=${to}`;
+      }
+      return `${from} ${to}`.trim();
+    };
+    var testSet = (set, version, options) => {
+      for (let i = 0; i < set.length; i++) {
+        if (!set[i].test(version)) {
+          return false;
+        }
+      }
+      if (version.prerelease.length && !options.includePrerelease) {
+        for (let i = 0; i < set.length; i++) {
+          debug(set[i].semver);
+          if (set[i].semver === Comparator.ANY) {
+            continue;
+          }
+          if (set[i].semver.prerelease.length > 0) {
+            const allowed = set[i].semver;
+            if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    };
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/comparator.js"(exports, module) {
+    "use strict";
+    var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
+    var Comparator = class _Comparator {
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options) {
+        options = parseOptions(options);
+        if (comp instanceof _Comparator) {
+          if (comp.loose === !!options.loose) {
+            return comp;
+          } else {
+            comp = comp.value;
+          }
+        }
+        comp = comp.trim().split(/\s+/).join(" ");
+        debug("comparator", comp, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.parse(comp);
+        if (this.semver === ANY) {
+          this.value = "";
+        } else {
+          this.value = this.operator + this.semver.version;
+        }
+        debug("comp", this);
+      }
+      parse(comp) {
+        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+        const m = comp.match(r);
+        if (!m) {
+          throw new TypeError(`Invalid comparator: ${comp}`);
+        }
+        this.operator = m[1] !== void 0 ? m[1] : "";
+        if (this.operator === "=") {
+          this.operator = "";
+        }
+        if (!m[2]) {
+          this.semver = ANY;
+        } else {
+          this.semver = new SemVer(m[2], this.options.loose);
+        }
+      }
+      toString() {
+        return this.value;
+      }
+      test(version) {
+        debug("Comparator.test", version, this.options.loose);
+        if (this.semver === ANY || version === ANY) {
+          return true;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        return cmp(version, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options) {
+        if (!(comp instanceof _Comparator)) {
+          throw new TypeError("a Comparator is required");
+        }
+        if (this.operator === "") {
+          if (this.value === "") {
+            return true;
+          }
+          return new Range(comp.value, options).test(this.value);
+        } else if (comp.operator === "") {
+          if (comp.value === "") {
+            return true;
+          }
+          return new Range(this.value, options).test(comp.semver);
+        }
+        options = parseOptions(options);
+        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+          return false;
+        }
+        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+          return false;
+        }
+        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+          return true;
+        }
+        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        return false;
+      }
+    };
+    module.exports = Comparator;
+    var parseOptions = require_parse_options();
+    var { safeRe: re, t } = require_re();
+    var cmp = require_cmp();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var Range = require_range();
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/satisfies.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var satisfies = (version, range, options) => {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version);
+    };
+    module.exports = satisfies;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/to-comparators.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+    module.exports = toComparators;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/max-satisfying.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var maxSatisfying = (versions, range, options) => {
+      let max = null;
+      let maxSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!max || maxSV.compare(v) === -1) {
+            max = v;
+            maxSV = new SemVer(max, options);
+          }
+        }
+      });
+      return max;
+    };
+    module.exports = maxSatisfying;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-satisfying.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var minSatisfying = (versions, range, options) => {
+      let min = null;
+      let minSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!min || minSV.compare(v) === 1) {
+            min = v;
+            minSV = new SemVer(min, options);
+          }
+        }
+      });
+      return min;
+    };
+    module.exports = minSatisfying;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-version.js
+var require_min_version = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-version.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var gt = require_gt();
+    var minVersion = (range, loose) => {
+      range = new Range(range, loose);
+      let minver = new SemVer("0.0.0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = new SemVer("0.0.0-0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = null;
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let setMin = null;
+        comparators.forEach((comparator) => {
+          const compver = new SemVer(comparator.semver.version);
+          switch (comparator.operator) {
+            case ">":
+              if (compver.prerelease.length === 0) {
+                compver.patch++;
+              } else {
+                compver.prerelease.push(0);
+              }
+              compver.raw = compver.format();
+            /* fallthrough */
+            case "":
+            case ">=":
+              if (!setMin || gt(compver, setMin)) {
+                setMin = compver;
+              }
+              break;
+            case "<":
+            case "<=":
+              break;
+            /* istanbul ignore next */
+            default:
+              throw new Error(`Unexpected operation: ${comparator.operator}`);
+          }
+        });
+        if (setMin && (!minver || gt(minver, setMin))) {
+          minver = setMin;
+        }
+      }
+      if (minver && range.test(minver)) {
+        return minver;
+      }
+      return null;
+    };
+    module.exports = minVersion;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/valid.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var validRange = (range, options) => {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    };
+    module.exports = validRange;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/outside.js
+var require_outside = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/outside.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var gt = require_gt();
+    var lt = require_lt();
+    var lte = require_lte();
+    var gte = require_gte();
+    var outside = (version, range, hilo, options) => {
+      version = new SemVer(version, options);
+      range = new Range(range, options);
+      let gtfn, ltefn, ltfn, comp, ecomp;
+      switch (hilo) {
+        case ">":
+          gtfn = gt;
+          ltefn = lte;
+          ltfn = lt;
+          comp = ">";
+          ecomp = ">=";
+          break;
+        case "<":
+          gtfn = lt;
+          ltefn = gte;
+          ltfn = gt;
+          comp = "<";
+          ecomp = "<=";
+          break;
+        default:
+          throw new TypeError('Must provide a hilo val of "<" or ">"');
+      }
+      if (satisfies(version, range, options)) {
+        return false;
+      }
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let high = null;
+        let low = null;
+        comparators.forEach((comparator) => {
+          if (comparator.semver === ANY) {
+            comparator = new Comparator(">=0.0.0");
+          }
+          high = high || comparator;
+          low = low || comparator;
+          if (gtfn(comparator.semver, high.semver, options)) {
+            high = comparator;
+          } else if (ltfn(comparator.semver, low.semver, options)) {
+            low = comparator;
+          }
+        });
+        if (high.operator === comp || high.operator === ecomp) {
+          return false;
+        }
+        if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+          return false;
+        } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    module.exports = outside;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/gtr.js
+var require_gtr = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/gtr.js"(exports, module) {
+    "use strict";
+    var outside = require_outside();
+    var gtr = (version, range, options) => outside(version, range, ">", options);
+    module.exports = gtr;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/ltr.js
+var require_ltr = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/ltr.js"(exports, module) {
+    "use strict";
+    var outside = require_outside();
+    var ltr = (version, range, options) => outside(version, range, "<", options);
+    module.exports = ltr;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/intersects.js
+var require_intersects = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/intersects.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var intersects = (r1, r2, options) => {
+      r1 = new Range(r1, options);
+      r2 = new Range(r2, options);
+      return r1.intersects(r2, options);
+    };
+    module.exports = intersects;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/simplify.js
+var require_simplify = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/simplify.js"(exports, module) {
+    "use strict";
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    module.exports = (versions, range, options) => {
+      const set = [];
+      let first = null;
+      let prev = null;
+      const v = versions.sort((a, b) => compare(a, b, options));
+      for (const version of v) {
+        const included = satisfies(version, range, options);
+        if (included) {
+          prev = version;
+          if (!first) {
+            first = version;
+          }
+        } else {
+          if (prev) {
+            set.push([first, prev]);
+          }
+          prev = null;
+          first = null;
+        }
+      }
+      if (first) {
+        set.push([first, null]);
+      }
+      const ranges = [];
+      for (const [min, max] of set) {
+        if (min === max) {
+          ranges.push(min);
+        } else if (!max && min === v[0]) {
+          ranges.push("*");
+        } else if (!max) {
+          ranges.push(`>=${min}`);
+        } else if (min === v[0]) {
+          ranges.push(`<=${max}`);
+        } else {
+          ranges.push(`${min} - ${max}`);
+        }
+      }
+      const simplified = ranges.join(" || ");
+      const original = typeof range.raw === "string" ? range.raw : String(range);
+      return simplified.length < original.length ? simplified : range;
+    };
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/subset.js
+var require_subset = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/subset.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    var subset = (sub, dom, options = {}) => {
+      if (sub === dom) {
+        return true;
+      }
+      sub = new Range(sub, options);
+      dom = new Range(dom, options);
+      let sawNonNull = false;
+      OUTER: for (const simpleSub of sub.set) {
+        for (const simpleDom of dom.set) {
+          const isSub = simpleSubset(simpleSub, simpleDom, options);
+          sawNonNull = sawNonNull || isSub !== null;
+          if (isSub) {
+            continue OUTER;
+          }
+        }
+        if (sawNonNull) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+    var minimumVersion = [new Comparator(">=0.0.0")];
+    var simpleSubset = (sub, dom, options) => {
+      if (sub === dom) {
+        return true;
+      }
+      if (sub.length === 1 && sub[0].semver === ANY) {
+        if (dom.length === 1 && dom[0].semver === ANY) {
+          return true;
+        } else if (options.includePrerelease) {
+          sub = minimumVersionWithPreRelease;
+        } else {
+          sub = minimumVersion;
+        }
+      }
+      if (dom.length === 1 && dom[0].semver === ANY) {
+        if (options.includePrerelease) {
+          return true;
+        } else {
+          dom = minimumVersion;
+        }
+      }
+      const eqSet = /* @__PURE__ */ new Set();
+      let gt, lt;
+      for (const c of sub) {
+        if (c.operator === ">" || c.operator === ">=") {
+          gt = higherGT(gt, c, options);
+        } else if (c.operator === "<" || c.operator === "<=") {
+          lt = lowerLT(lt, c, options);
+        } else {
+          eqSet.add(c.semver);
+        }
+      }
+      if (eqSet.size > 1) {
+        return null;
+      }
+      let gtltComp;
+      if (gt && lt) {
+        gtltComp = compare(gt.semver, lt.semver, options);
+        if (gtltComp > 0) {
+          return null;
+        } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+          return null;
+        }
+      }
+      for (const eq of eqSet) {
+        if (gt && !satisfies(eq, String(gt), options)) {
+          return null;
+        }
+        if (lt && !satisfies(eq, String(lt), options)) {
+          return null;
+        }
+        for (const c of dom) {
+          if (!satisfies(eq, String(c), options)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      let higher, lower;
+      let hasDomLT, hasDomGT;
+      let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+      let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+        needDomLTPre = false;
+      }
+      for (const c of dom) {
+        hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+        hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+        if (gt) {
+          if (needDomGTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+              needDomGTPre = false;
+            }
+          }
+          if (c.operator === ">" || c.operator === ">=") {
+            higher = higherGT(gt, c, options);
+            if (higher === c && higher !== gt) {
+              return false;
+            }
+          } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (lt) {
+          if (needDomLTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+              needDomLTPre = false;
+            }
+          }
+          if (c.operator === "<" || c.operator === "<=") {
+            lower = lowerLT(lt, c, options);
+            if (lower === c && lower !== lt) {
+              return false;
+            }
+          } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (!c.operator && (lt || gt) && gtltComp !== 0) {
+          return false;
+        }
+      }
+      if (gt && hasDomLT && !lt && gtltComp !== 0) {
+        return false;
+      }
+      if (lt && hasDomGT && !gt && gtltComp !== 0) {
+        return false;
+      }
+      if (needDomGTPre || needDomLTPre) {
+        return false;
+      }
+      return true;
+    };
+    var higherGT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+    };
+    var lowerLT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+    };
+    module.exports = subset;
+  }
+});
+
+// ../node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js
+var require_semver2 = __commonJS({
+  "../node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js"(exports, module) {
+    "use strict";
+    var internalRe = require_re();
+    var constants = require_constants();
+    var SemVer = require_semver();
+    var identifiers = require_identifiers();
+    var parse = require_parse();
+    var valid = require_valid();
+    var clean = require_clean();
+    var inc = require_inc();
+    var diff = require_diff();
+    var major = require_major();
+    var minor = require_minor();
+    var patch = require_patch();
+    var prerelease = require_prerelease();
+    var compare = require_compare();
+    var rcompare = require_rcompare();
+    var compareLoose = require_compare_loose();
+    var compareBuild = require_compare_build();
+    var sort = require_sort();
+    var rsort = require_rsort();
+    var gt = require_gt();
+    var lt = require_lt();
+    var eq = require_eq();
+    var neq = require_neq();
+    var gte = require_gte();
+    var lte = require_lte();
+    var cmp = require_cmp();
+    var coerce = require_coerce();
+    var Comparator = require_comparator();
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var toComparators = require_to_comparators();
+    var maxSatisfying = require_max_satisfying();
+    var minSatisfying = require_min_satisfying();
+    var minVersion = require_min_version();
+    var validRange = require_valid2();
+    var outside = require_outside();
+    var gtr = require_gtr();
+    var ltr = require_ltr();
+    var intersects = require_intersects();
+    var simplifyRange = require_simplify();
+    var subset = require_subset();
+    module.exports = {
+      parse,
+      valid,
+      clean,
+      inc,
+      diff,
+      major,
+      minor,
+      patch,
+      prerelease,
+      compare,
+      rcompare,
+      compareLoose,
+      compareBuild,
+      sort,
+      rsort,
+      gt,
+      lt,
+      eq,
+      neq,
+      gte,
+      lte,
+      cmp,
+      coerce,
+      Comparator,
+      Range,
+      satisfies,
+      toComparators,
+      maxSatisfying,
+      minSatisfying,
+      minVersion,
+      validRange,
+      outside,
+      gtr,
+      ltr,
+      intersects,
+      simplifyRange,
+      subset,
+      SemVer,
+      re: internalRe.re,
+      src: internalRe.src,
+      tokens: internalRe.t,
+      SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants.RELEASE_TYPES,
+      compareIdentifiers: identifiers.compareIdentifiers,
+      rcompareIdentifiers: identifiers.rcompareIdentifiers
+    };
+  }
+});
+
+// ../common/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import lockfile from "proper-lockfile";
+import * as https from "https";
+import * as http from "http";
+import * as zlib from "zlib";
+import { performance } from "perf_hooks";
+var import_semver = __toESM(require_semver2(), 1);
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+import { spawn } from "child_process";
+import Table from "cli-table3";
+var SILUZAN_DIR = path.join(os.homedir(), ".siluzan");
+var CONFIG_FILE = path.join(SILUZAN_DIR, "config.json");
+function atomicWriteFileSync(targetPath, content, encoding = "utf8") {
+  const dir = path.dirname(targetPath);
+  const tmp = path.join(
+    dir,
+    `.${path.basename(targetPath)}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`
+  );
+  try {
+    fs.writeFileSync(tmp, content, encoding);
+    fs.renameSync(tmp, targetPath);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+    }
+    try {
+      fs.writeFileSync(targetPath, content, encoding);
+    } catch {
+      throw err;
+    }
+  }
+}
+function readStr(raw, key) {
+  const v = raw[key];
+  return typeof v === "string" && v ? v : void 0;
+}
+function readSharedConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return { authToken: "" };
+  }
+  try {
+    const raw = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+    return {
+      authToken: readStr(raw, "authToken") ?? "",
+      apiKey: readStr(raw, "apiKey"),
+      dataPermission: readStr(raw, "dataPermission")
+    };
+  } catch {
+    return { authToken: "" };
+  }
+}
+function writeSharedConfig(partial) {
+  fs.mkdirSync(SILUZAN_DIR, { recursive: true });
+  let existing = {};
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+    } catch {
+    }
+  }
+  const keys = ["authToken", "apiKey", "dataPermission"];
+  for (const k of keys) {
+    if (partial[k] !== void 0) existing[k] = partial[k];
+  }
+  atomicWriteFileSync(CONFIG_FILE, JSON.stringify(existing, null, 2));
+  if (process.platform !== "win32") {
+    try {
+      fs.chmodSync(CONFIG_FILE, 384);
+    } catch {
+      console.warn("\u26A0\uFE0F  \u672A\u80FD\u6536\u655B\u914D\u7F6E\u6587\u4EF6\u6743\u9650\uFF0C\u8BF7\u624B\u52A8\u6267\u884C\uFF1Achmod 600 " + CONFIG_FILE);
+    }
+  }
+}
+function readSharedConfigRaw() {
+  if (!fs.existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+var inProcessLockChain = Promise.resolve();
+async function mergeWriteSharedConfig(partial) {
+  const next = inProcessLockChain.then(() => doMergeWriteOnce(partial));
+  inProcessLockChain = next.catch(() => void 0);
+  return next;
+}
+async function doMergeWriteOnce(partial) {
+  fs.mkdirSync(SILUZAN_DIR, { recursive: true });
+  if (!fs.existsSync(CONFIG_FILE)) {
+    fs.writeFileSync(CONFIG_FILE, "{}", "utf8");
+    if (process.platform !== "win32") {
+      try {
+        fs.chmodSync(CONFIG_FILE, 384);
+      } catch {
+      }
+    }
+  }
+  const release = await lockfile.lock(CONFIG_FILE, {
+    realpath: false,
+    retries: { retries: 30, factor: 1.1, minTimeout: 50, maxTimeout: 600 },
+    stale: 1e4
+  });
+  try {
+    const existing = readSharedConfigRaw();
+    const merged = { ...existing };
+    for (const [k, v] of Object.entries(partial)) {
+      if (v !== void 0) merged[k] = v;
+    }
+    atomicWriteFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+    if (process.platform !== "win32") {
+      try {
+        fs.chmodSync(CONFIG_FILE, 384);
+      } catch {
+      }
+    }
+  } finally {
+    await release();
+  }
+}
+function clearSharedConfig() {
+  writeSharedConfig({ authToken: "", apiKey: "" });
+}
+function maskSecret(s) {
+  if (!s) return "(\u672A\u8BBE\u7F6E)";
+  return s.length > 8 ? `${s.slice(0, 4)}****${s.slice(-4)}` : "****";
+}
+var ALLOWED_HOSTNAME_SUFFIXES = [
+  "siluzan.com",
+  "siluzan.cn",
+  /** Google / TikTok / Facebook 等媒体网关域名（TSO 专用，CSO 不会主动产生但兼容写入） */
+  "mysiluzan.com"
+];
+function validateBaseUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return `\u4E0D\u662F\u5408\u6CD5 URL\uFF1A${raw}`;
+  }
+  if (url.protocol !== "https:") {
+    return `\u5FC5\u987B\u4F7F\u7528 HTTPS\uFF0C\u5F53\u524D\u534F\u8BAE\uFF1A${url.protocol}`;
+  }
+  const hostname2 = url.hostname.toLowerCase();
+  const ok = ALLOWED_HOSTNAME_SUFFIXES.some(
+    (suffix) => hostname2 === suffix || hostname2.endsWith(`.${suffix}`)
+  );
+  if (!ok) {
+    return `\u4E3B\u673A\u540D "${hostname2}" \u4E0D\u5728\u5141\u8BB8\u5217\u8868\uFF08${ALLOWED_HOSTNAME_SUFFIXES.join("\u3001")}\uFF09\u5185\u3002
+   \u5982\u9700\u8FDE\u63A5\u81EA\u5B9A\u4E49\u90E8\u7F72\u7AEF\u70B9\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u6DFB\u52A0\u767D\u540D\u5355\u3002`;
+  }
+  return null;
+}
+var EXACT_ID_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "id",
+  "entityId",
+  "mediaCustomerId",
+  "mediaAccountId",
+  "mediaAccountGroupId",
+  "loginCustomerId",
+  "customerId",
+  "accountId",
+  "ownerAdvertiserId",
+  "advertiserId",
+  "agencyClientId",
+  "externalMediaAccountTokenId",
+  "shortId",
+  "websiteDiagnoseId",
+  "invitationId",
+  "ruleId",
+  "bcId",
+  "bmId",
+  "tradeNo",
+  "billNo",
+  "payNo",
+  "checkingNo",
+  "rechargeNo",
+  "orderNo",
+  "magKey",
+  "managedByStewardId",
+  "relyCustomerId",
+  "createdBy",
+  "lastChangedBy",
+  "userId"
+]);
+function isIdFieldName(key) {
+  if (!key) return false;
+  if (EXACT_ID_FIELD_NAMES.has(key)) return true;
+  if (/Ids$/.test(key)) return true;
+  if (/Id$/.test(key)) return true;
+  return false;
+}
+function numberToIdString(n) {
+  if (!Number.isFinite(n)) return String(n);
+  if (Number.isInteger(n)) {
+    return n.toLocaleString("en-US", { useGrouping: false, maximumFractionDigits: 0 });
+  }
+  return String(n);
+}
+function jsonParseReviverStringifyIds(key, value) {
+  if (key && isIdFieldName(key) && typeof value === "number" && Number.isFinite(value)) {
+    return numberToIdString(value);
+  }
+  return value;
+}
+function parseJsonWithStringIds(text) {
+  return JSON.parse(text, jsonParseReviverStringifyIds);
+}
+function hasSiluzanAgentCredentials() {
+  const apiKey = process.env.SILUZAN_API_KEY?.trim();
+  const authToken = process.env.SILUZAN_AUTH_TOKEN?.trim();
+  return Boolean(apiKey || authToken);
+}
+function isSiluzanAgentEnv() {
+  const raw = process.env.IS_SILUZAN_AGENT_ENV?.trim().toLowerCase();
+  return raw === "true" || raw === "1";
+}
+function skipAuthSetupInAgentEnv(commandLabel) {
+  if (!isSiluzanAgentEnv()) return false;
+  if (hasSiluzanAgentCredentials()) {
+    console.log(
+      `
+\u2139\uFE0F  \u68C0\u6D4B\u5230 Siluzan Agent \u73AF\u5883\uFF08IS_SILUZAN_AGENT_ENV=true\uFF09\uFF0C\u51ED\u636E\u5DF2\u7531\u6C99\u7BB1\u6CE8\u5165\uFF0C\u65E0\u9700\u6267\u884C ${commandLabel}\u3002
+`
+    );
+  } else {
+    console.log(
+      `
+\u2139\uFE0F  \u68C0\u6D4B\u5230 Siluzan Agent \u73AF\u5883\uFF08IS_SILUZAN_AGENT_ENV=true\uFF09\u3002
+   ${commandLabel} \u5DF2\u8DF3\u8FC7\uFF1B\u8BF7\u7531 Agent \u6C99\u7BB1\u6CE8\u5165 SILUZAN_API_KEY \u6216 SILUZAN_AUTH_TOKEN\u3002
+`
+    );
+  }
+  return true;
+}
+function trimOrUndefined(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function resolveAgentEnvCredentials() {
+  const envToken = trimOrUndefined(process.env.SILUZAN_AUTH_TOKEN);
+  if (envToken) return { authToken: envToken, apiKey: void 0 };
+  const envApiKey = trimOrUndefined(process.env.SILUZAN_API_KEY);
+  if (envApiKey) return { authToken: "", apiKey: envApiKey };
+  return { authToken: "", apiKey: void 0 };
+}
+function resolveSiluzanCredentials(opts) {
+  if (isSiluzanAgentEnv()) {
+    return resolveAgentEnvCredentials();
+  }
+  const apiKey = trimOrUndefined(process.env.SILUZAN_API_KEY) ?? trimOrUndefined(opts.configApiKey);
+  const authToken = trimOrUndefined(opts.tokenArg) ?? trimOrUndefined(process.env.SILUZAN_AUTH_TOKEN) ?? trimOrUndefined(opts.configAuthToken) ?? "";
+  return { authToken, apiKey };
+}
+function resolveRequestAuth(config) {
+  if (isSiluzanAgentEnv()) {
+    return resolveAgentEnvCredentials();
+  }
+  return { authToken: config.authToken, apiKey: config.apiKey };
+}
+function buildSiluzanAuthHeaders(config) {
+  const auth = resolveRequestAuth(config);
+  return auth.apiKey ? { "x-api-key": auth.apiKey } : { Authorization: `Bearer ${auth.authToken}` };
+}
+var SILUZAN_AGENT_COMPANY_SOURCE_TYPE = "Ctaiad";
+var DEERFLOW_AGENT_ENV = "DEERFLOW_AGENT";
+var _clientProduct = "siluzan-cli";
+var _resolveVersion;
+function getSiluzanClientProduct() {
+  return _clientProduct;
+}
+function runtimeOverrideFromEnv() {
+  const raw = process.env.SILUZAN_CLIENT_RUNTIME?.trim().toLowerCase();
+  if (raw === "siluzan_agent" || raw === "agent" || raw === "cli") return raw;
+  return void 0;
+}
+function envTruthy(name) {
+  const v = process.env[name]?.trim().toLowerCase();
+  return v !== void 0 && v !== "" && v !== "0" && v !== "false" && v !== "no" && v !== "off";
+}
+function looksLikeThirdPartyAgentEnv() {
+  if (envTruthy("IS_AGENT_ENV") || envTruthy("AI_AGENT")) return true;
+  if (envTruthy("CURSOR_AGENT")) return true;
+  if (process.env.CURSOR_EXTENSION_HOST_ROLE?.trim() === "agent-exec") return true;
+  if (envTruthy("CLAUDECODE") || envTruthy("CLAUDE_CODE")) return true;
+  if (envTruthy("CODEX_SANDBOX") || envTruthy("CODEX_CI") || envTruthy("CODEX_THREAD_ID")) {
+    return true;
+  }
+  if (envTruthy("GEMINI_CLI") || envTruthy("ANTIGRAVITY_AGENT") || envTruthy("AUGMENT_AGENT")) {
+    return true;
+  }
+  if (envTruthy("CLINE_ACTIVE") || envTruthy("GOOSE_TERMINAL") || envTruthy("OPENCLAW")) {
+    return true;
+  }
+  if (envTruthy("COPILOT_ALLOW_ALL") || envTruthy("COPILOT_MODEL")) return true;
+  return false;
+}
+function resolveSiluzanClientRuntime() {
+  if (isSiluzanAgentEnv()) return "siluzan_agent";
+  const override = runtimeOverrideFromEnv();
+  if (override) return override;
+  if (looksLikeThirdPartyAgentEnv()) return "agent";
+  return "cli";
+}
+function resolveCompanySourceType(raw = process.env[DEERFLOW_AGENT_ENV]) {
+  const trimmed = raw?.trim();
+  if (!trimmed) return void 0;
+  if (trimmed === "Ctaiad") return "Ctaiad";
+  const key = trimmed.toLowerCase();
+  if (key === "ctaiad" || key === "ctaiad_agent") {
+    return SILUZAN_AGENT_COMPANY_SOURCE_TYPE;
+  }
+  return void 0;
+}
+function getSiluzanSkillVersion() {
+  return (_resolveVersion?.() ?? "0.0.0").trim() || "0.0.0";
+}
+function buildSiluzanClientIdentityHeaders() {
+  const client = getSiluzanClientProduct();
+  const runtime = resolveSiluzanClientRuntime();
+  const version = getSiluzanSkillVersion();
+  const headers = {
+    "X-Siluzan-Client": client,
+    "X-Siluzan-Runtime": runtime,
+    "X-Siluzan-Skill-Version": version,
+    "User-Agent": `${client}/${version}`
+  };
+  const companySource = resolveCompanySourceType();
+  if (companySource) {
+    headers["X-Company-Source-Type"] = companySource;
+  }
+  return headers;
+}
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var MAX_RESPONSE_BYTES = 50 * 1024 * 1024;
+var httpsAgent = new https.Agent({
+  keepAlive: true,
+  keepAliveMsecs: 3e4,
+  maxSockets: 16,
+  maxFreeSockets: 8,
+  scheduling: "lifo"
+});
+var httpAgent = new http.Agent({
+  keepAlive: true,
+  keepAliveMsecs: 3e4,
+  maxSockets: 16,
+  maxFreeSockets: 8,
+  scheduling: "lifo"
+});
+var PERF_PREFIX = "[SILUZAN_HTTP_PERF]";
+function isPerfEnabled() {
+  const v = process.env.SILUZAN_HTTP_PERF;
+  return v === "1" || v === "true";
+}
+function emitPerf(record) {
+  try {
+    process.stderr.write(`${PERF_PREFIX} ${JSON.stringify(record)}
+`);
+  } catch {
+  }
+}
+function rawRequest(url, options) {
+  const perfOn = isPerfEnabled();
+  const t0 = perfOn ? performance.now() : 0;
+  const method = options.method ?? "GET";
+  return new Promise((resolve5, reject) => {
+    const parsed = new URL(url);
+    const transport = parsed.protocol === "https:" ? https : http;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxBytes = options.maxResponseBytes ?? MAX_RESPONSE_BYTES;
+    const isHttps = parsed.protocol === "https:";
+    const headers = {
+      ...buildSiluzanClientIdentityHeaders(),
+      ...options.headers
+    };
+    if (process.env.SILUZAN_DEBUG_HEADERS === "1" || process.env.SILUZAN_DEBUG_HEADERS === "true") {
+      try {
+        process.stderr.write(
+          `[SILUZAN_DEBUG_HEADERS] ${method} ${url}
+  X-Company-Source-Type=${headers["X-Company-Source-Type"] ?? "(missing)"}
+  X-Siluzan-Runtime=${headers["X-Siluzan-Runtime"] ?? "(missing)"}
+  X-Siluzan-Client=${headers["X-Siluzan-Client"] ?? "(missing)"}
+  X-Siluzan-Skill-Version=${headers["X-Siluzan-Skill-Version"] ?? "(missing)"}
+`
+        );
+      } catch {
+      }
+    }
+    const reqOpts = {
+      hostname: parsed.hostname,
+      port: parsed.port || (isHttps ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method,
+      headers,
+      timeout: timeoutMs || void 0,
+      agent: isHttps ? httpsAgent : httpAgent
+    };
+    const req = transport.request(reqOpts, (res) => {
+      const encoding = (res.headers["content-encoding"] ?? "").toString().toLowerCase().trim();
+      let stream = res;
+      if (encoding === "gzip" || encoding === "x-gzip") {
+        stream = res.pipe(zlib.createGunzip());
+      } else if (encoding === "deflate") {
+        stream = res.pipe(zlib.createInflate());
+      } else if (encoding === "br") {
+        stream = res.pipe(zlib.createBrotliDecompress());
+      }
+      const handleStreamError = (err) => {
+        res.destroy();
+        if (perfOn) {
+          emitPerf({
+            method,
+            url,
+            status: res.statusCode ?? 0,
+            elapsedMs: performance.now() - t0,
+            bytes: 0,
+            ok: false,
+            error: `decompress error: ${err.message}`
+          });
+        }
+        reject(new Error(`\u54CD\u5E94\u89E3\u538B\u5931\u8D25\uFF08${encoding || "identity"}\uFF09\uFF1A${err.message}`));
+      };
+      if (stream !== res) stream.on("error", handleStreamError);
+      res.on("error", handleStreamError);
+      let data = "";
+      let byteLen = 0;
+      stream.setEncoding("utf8");
+      stream.on("data", (chunk) => {
+        byteLen += Buffer.byteLength(chunk, "utf8");
+        if (maxBytes && byteLen > maxBytes) {
+          res.destroy();
+          if (perfOn) {
+            emitPerf({
+              method,
+              url,
+              status: res.statusCode ?? 0,
+              elapsedMs: performance.now() - t0,
+              bytes: byteLen,
+              ok: false,
+              error: "response body exceeded limit"
+            });
+          }
+          reject(
+            new Error(`\u54CD\u5E94\u4F53\u8D85\u8FC7\u4E0A\u9650\uFF08${(maxBytes / 1024 / 1024).toFixed(0)} MB\uFF09\uFF0C\u5DF2\u4E2D\u65AD\u8FDE\u63A5`)
+          );
+          return;
+        }
+        data += chunk;
+      });
+      stream.on("end", () => {
+        const headers2 = {};
+        for (const [key, val] of Object.entries(res.headers)) {
+          if (val !== void 0) {
+            headers2[key.toLowerCase()] = Array.isArray(val) ? val[0] : val;
+          }
+        }
+        const status = res.statusCode ?? 0;
+        if (perfOn) {
+          emitPerf({
+            method,
+            url,
+            status,
+            elapsedMs: performance.now() - t0,
+            bytes: byteLen,
+            ok: status >= 200 && status < 300
+          });
+        }
+        resolve5({ status, text: data, headers: headers2 });
+      });
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      if (perfOn) {
+        emitPerf({
+          method,
+          url,
+          status: 0,
+          elapsedMs: performance.now() - t0,
+          bytes: 0,
+          ok: false,
+          error: "timeout"
+        });
+      }
+      reject(new Error(`\u8BF7\u6C42\u8D85\u65F6\uFF08${(timeoutMs / 1e3).toFixed(0)} \u79D2\uFF09\uFF1A${method} ${url}`));
+    });
+    req.on("error", (err) => {
+      if (perfOn) {
+        emitPerf({
+          method,
+          url,
+          status: 0,
+          elapsedMs: performance.now() - t0,
+          bytes: 0,
+          ok: false,
+          error: err.message
+        });
+      }
+      reject(err);
+    });
+    if (options.body) req.write(options.body);
+    req.end();
+  });
+}
+function redactSensitive(input) {
+  let output = input;
+  output = output.replace(/(Bearer\s+)[^\s",]+/gi, "$1***");
+  output = output.replace(
+    /("?(?:apiKey|authToken|accessToken|refreshToken|token|authorization)"?\s*[:=]\s*"?)([^"\s,}]+)/gi,
+    "$1***"
+  );
+  return output;
+}
+var DEFAULT_DETAIL_MAX = 400;
+var VERBOSE_DETAIL_MAX = 800;
+function trimDetail(text, maxLen) {
+  const t = text.trim();
+  if (t.length <= maxLen) return t;
+  return `${t.slice(0, maxLen)}\u2026`;
+}
+function messageFromJsonValue(value) {
+  if (typeof value === "string" && value.trim()) return value.trim();
+  if (Array.isArray(value)) {
+    const parts = value.map((item) => messageFromJsonValue(item)).filter((item) => Boolean(item));
+    return parts.length > 0 ? parts.join("; ") : void 0;
+  }
+  if (!value || typeof value !== "object") return void 0;
+  const rec = value;
+  if (rec.errors && typeof rec.errors === "object" && !Array.isArray(rec.errors)) {
+    const msgs = [];
+    for (const [field, raw] of Object.entries(rec.errors)) {
+      if (Array.isArray(raw)) {
+        for (const item of raw) {
+          const msg = messageFromJsonValue(item);
+          if (msg) msgs.push(`${field}: ${msg}`);
+        }
+      } else {
+        const msg = messageFromJsonValue(raw);
+        if (msg) msgs.push(`${field}: ${msg}`);
+      }
+    }
+    if (msgs.length > 0) return msgs.join("; ");
+  }
+  for (const key of [
+    "detail",
+    "message",
+    "Message",
+    "error",
+    "Error",
+    "errorMessage",
+    "ErrorMessage",
+    "title",
+    "Title",
+    "reason",
+    "Reason"
+  ]) {
+    const msg = messageFromJsonValue(rec[key]);
+    if (msg) return msg;
+  }
+  return void 0;
+}
+function extractHttpErrorDetail(rawBody) {
+  const text = rawBody?.trim();
+  if (!text) return void 0;
+  if (text.startsWith('"')) {
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed === "string" && parsed.trim()) return parsed.trim();
+    } catch {
+    }
+  }
+  if (text.startsWith("{") || text.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(text);
+      const msg = messageFromJsonValue(parsed);
+      if (msg) return msg;
+    } catch {
+    }
+  }
+  if (text.startsWith("<")) return void 0;
+  return text;
+}
+function formatHttpError(status, rawBody, opts) {
+  const verbose = opts?.verbose === true;
+  const maxLen = verbose ? VERBOSE_DETAIL_MAX : DEFAULT_DETAIL_MAX;
+  const parsed = extractHttpErrorDetail(rawBody);
+  if (parsed) {
+    return `HTTP ${status}\uFF1A${trimDetail(redactSensitive(parsed), maxLen)}`;
+  }
+  if (verbose && rawBody.trim()) {
+    return `HTTP ${status}\uFF1A${trimDetail(redactSensitive(rawBody), maxLen)}`;
+  }
+  return `HTTP ${status}\uFF08\u54CD\u5E94\u65E0\u53EF\u7528\u9519\u8BEF\u8BE6\u60C5\uFF1B\u53EF\u52A0 --verbose \u67E5\u770B\u539F\u59CB\u54CD\u5E94\uFF09`;
+}
+function buildAuthHeaders(config) {
+  return buildSiluzanAuthHeaders(config);
+}
+async function apiFetch(url, config, options = {}, verbose = false) {
+  const method = options.method ?? "GET";
+  const reqHeaders = {
+    "Content-Type": "application/json",
+    "Accept-Language": "zh-CN",
+    // 声明支持 gzip/deflate/br；服务端不支持则按 identity 返回，rawRequest 会原样收取
+    "Accept-Encoding": "gzip, deflate, br",
+    ...buildAuthHeaders(config),
+    // dataPermission 仅 TSO 使用；CSO 未设置时为空字符串，服务端忽略该头
+    Datapermission: config.dataPermission ?? "",
+    ...options.headers ?? {}
+  };
+  const body = typeof options.body === "string" ? options.body : void 0;
+  const res = await rawRequest(url, {
+    method,
+    headers: reqHeaders,
+    body
+  });
+  const text = res.text;
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error(formatHttpError(res.status, text, { verbose }));
+  }
+  if (!text.trim()) return null;
+  try {
+    return parseJsonWithStringIds(text);
+  } catch {
+    if (verbose) {
+      console.error(`  \u26A0\uFE0F  \u54CD\u5E94\u975E JSON\uFF0C\u539F\u59CB\u5185\u5BB9\uFF1A${redactSensitive(text).slice(0, 200)}`);
+    }
+    return text;
+  }
+}
+function getCurrentVersion(importMetaUrl) {
+  try {
+    const __dirname2 = path2.dirname(fileURLToPath(importMetaUrl));
+    const pkgPath = path2.join(__dirname2, "..", "package.json");
+    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function npmDistTagForBuildEnv(buildEnv) {
+  return buildEnv === "test" ? "beta" : "latest";
+}
+function npmMinRequiredTagForBuildEnv(buildEnv) {
+  return buildEnv === "test" ? "min-required-beta" : "min-required";
+}
+function isNewer(a, b) {
+  return import_semver.default.gt(b, a) === true;
+}
+async function fetchNpmVersion(pkgName, tag, timeoutMs = 4e3) {
+  try {
+    const url = `https://registry.npmjs.org/${pkgName}/${tag}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(url, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function defaultRunMinRequiredGlobalInstall(ctx) {
+  if (process.env.SILUZAN_SKIP_AUTO_GLOBAL_INSTALL === "1") {
+    return { ok: false, stderr: "SILUZAN_SKIP_AUTO_GLOBAL_INSTALL=1" };
+  }
+  const spec = `${ctx.pkgName}@${ctx.tag}`;
+  return await new Promise((resolve5) => {
+    const child = spawn("npm", ["install", "-g", spec, "--no-fund", "--no-audit"], {
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("error", (err) => {
+      resolve5({ ok: false, stderr: err instanceof Error ? err.message : String(err) });
+    });
+    child.on("close", (code, signal) => {
+      if (code === 0) {
+        resolve5({ ok: true });
+      } else {
+        const sig = signal ? ` signal=${signal}` : "";
+        resolve5({ ok: false, stderr: `exit code ${code}${sig}` });
+      }
+    });
+  });
+}
+function createVersionNotifier(opts) {
+  const {
+    pkgName,
+    binName,
+    cachePrefix,
+    resolveTag,
+    forceUpdateExtra = "",
+    updateAvailableExtra = "",
+    runMinRequiredGlobalInstall = defaultRunMinRequiredGlobalInstall,
+    getCurrentVersion: getCurrentVersion22,
+    mergeWriteConfig,
+    readConfigRaw
+  } = opts;
+  const KEY_LATEST_STABLE = `${cachePrefix}LatestStable`;
+  const KEY_LATEST_BETA = `${cachePrefix}LatestBeta`;
+  const KEY_MIN_STABLE = `${cachePrefix}MinRequiredStable`;
+  const KEY_MIN_BETA = `${cachePrefix}MinRequiredBeta`;
+  const KEY_LAST_NOTIFIED = `${cachePrefix}LastNotified`;
+  const KEY_FETCH_AT_MAIN = `${cachePrefix}VersionFetchAtMain`;
+  const KEY_FETCH_AT_MIN = `${cachePrefix}VersionFetchAtMin`;
+  const HOURS_24 = 24 * 60 * 60 * 1e3;
+  const TTL_MAIN_TAG_MS = 60 * 60 * 1e3;
+  const TTL_MIN_REQUIRED_MS = HOURS_24;
+  async function fetchVersionByTag(tag, cacheKey, fetchAtKey, cfg, maxAgeMs) {
+    const lastAt = cfg[fetchAtKey];
+    if (typeof lastAt === "string" && cacheKey in cfg) {
+      const lastMs = new Date(lastAt).getTime();
+      if (Date.now() - lastMs < maxAgeMs) {
+        const v = cfg[cacheKey];
+        const sv = typeof v === "string" && v ? v : null;
+        return { version: sv, hitNetwork: false };
+      }
+    }
+    const version = await fetchNpmVersion(pkgName, tag);
+    return { version, hitNetwork: true };
+  }
+  async function notifyIfOutdated2() {
+    try {
+      const current = getCurrentVersion22();
+      const tag = resolveTag(current);
+      const isBeta = tag === "beta";
+      const latestCacheKey = isBeta ? KEY_LATEST_BETA : KEY_LATEST_STABLE;
+      const minCacheKey = isBeta ? KEY_MIN_BETA : KEY_MIN_STABLE;
+      const minTag = npmMinRequiredTagForBuildEnv(isBeta ? "test" : "production");
+      const cfg = readConfigRaw();
+      const [mainRes, minRes] = await Promise.all([
+        fetchVersionByTag(tag, latestCacheKey, KEY_FETCH_AT_MAIN, cfg, TTL_MAIN_TAG_MS),
+        fetchVersionByTag(minTag, minCacheKey, KEY_FETCH_AT_MIN, cfg, TTL_MIN_REQUIRED_MS)
+      ]);
+      const latest = mainRes.version;
+      const minRequired = minRes.version;
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      const cacheUpdates = {
+        [latestCacheKey]: latest ?? "",
+        [minCacheKey]: minRequired ?? ""
+      };
+      if (mainRes.hitNetwork) cacheUpdates[KEY_FETCH_AT_MAIN] = nowIso;
+      if (minRes.hitNetwork) cacheUpdates[KEY_FETCH_AT_MIN] = nowIso;
+      await mergeWriteConfig(cacheUpdates);
+      const lastNotified = typeof cfg[KEY_LAST_NOTIFIED] === "string" ? new Date(cfg[KEY_LAST_NOTIFIED]).getTime() : 0;
+      if (Date.now() - lastNotified < HOURS_24) return;
+      const tagLabel = isBeta ? "\uFF08\u6D4B\u8BD5\u7248\uFF09" : "\uFF08\u6B63\u5F0F\u7248\uFF09";
+      if (minRequired && isNewer(current, minRequired)) {
+        await mergeWriteConfig({ [KEY_LAST_NOTIFIED]: (/* @__PURE__ */ new Date()).toISOString() });
+        console.log(
+          `
+[SILUZAN_FORCE_UPDATE] \u5F53\u524D\u7248\u672C ${current} \u5DF2\u4F4E\u4E8E\u6700\u4F4E\u8981\u6C42 ${minRequired}${tagLabel}
+\u26D4 \u6B63\u5728\u81EA\u52A8\u6267\u884C\uFF1Anpm install -g ${pkgName}@${tag}
+` + (forceUpdateExtra ? forceUpdateExtra + "\n" : "")
+        );
+        const installResult = await runMinRequiredGlobalInstall({ pkgName, tag });
+        if (installResult.ok) {
+          console.log(
+            `
+[SILUZAN_AUTO_GLOBAL_INSTALL_OK] \u5168\u5C40\u5B89\u88C5\u5DF2\u5B8C\u6210\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C\u672C\u547D\u4EE4\u4EE5\u52A0\u8F7D\u65B0\u7248\u672C ${pkgName}@${tag}\u3002
+`
+          );
+        } else {
+          console.log(
+            `
+[SILUZAN_AUTO_GLOBAL_INSTALL_FAILED] \u81EA\u52A8\u5168\u5C40\u5B89\u88C5\u5931\u8D25\uFF1A${installResult.stderr ?? "unknown"}
+\u8BF7\u624B\u52A8\u6267\u884C\uFF1Anpm install -g ${pkgName}@${tag}
+\u6216\uFF1A${binName} update
+` + (forceUpdateExtra ? forceUpdateExtra + "\n" : "")
+          );
+        }
+        return;
+      }
+      if (latest && isNewer(current, latest)) {
+        await mergeWriteConfig({ [KEY_LAST_NOTIFIED]: (/* @__PURE__ */ new Date()).toISOString() });
+        console.log(
+          `
+[SILUZAN_UPDATE_AVAILABLE] \u53D1\u73B0\u65B0\u7248\u672C ${latest}${tagLabel}\uFF08\u5F53\u524D ${current}\uFF09
+\u{1F4A1} Agent \u8BF7\u7ACB\u5373\u6267\u884C\uFF1A${binName} update
+   \u6216\u624B\u52A8\uFF1Anpm install -g ${pkgName}@${tag}
+` + (updateAvailableExtra ? updateAvailableExtra + "\n" : "")
+        );
+      }
+    } catch {
+    }
+  }
+  async function fetchLatestVersion2() {
+    const current = getCurrentVersion22();
+    const tag = resolveTag(current);
+    return fetchNpmVersion(pkgName, tag);
+  }
+  return { notifyIfOutdated: notifyIfOutdated2, fetchLatestVersion: fetchLatestVersion2 };
+}
+var TABLE_CELL_PIPE = "\uFF5C";
+function sanitizeTableCell(value) {
+  return String(value ?? "").replace(/\r\n|\r|\n/g, " ").replace(/\|/g, TABLE_CELL_PIPE);
+}
+var ASCII_TABLE_CHARS = {
+  top: "-",
+  "top-mid": "+",
+  "top-left": "+",
+  "top-right": "+",
+  bottom: "-",
+  "bottom-mid": "+",
+  "bottom-left": "+",
+  "bottom-right": "+",
+  left: "|",
+  "left-mid": "+",
+  mid: "-",
+  "mid-mid": "+",
+  right: "|",
+  "right-mid": "+",
+  middle: "|"
+};
+function printCliTable(rows, columns, options) {
+  if (rows.length === 0) return;
+  const plain = options?.plain !== false;
+  const indent = options?.indent ?? "  ";
+  const printLine = options?.printLine ?? ((msg) => {
+    console.log(msg);
+  });
+  const table = new Table({
+    head: columns.map((c) => c.header),
+    chars: plain ? { ...ASCII_TABLE_CHARS } : void 0,
+    style: plain ? { head: [], border: [] } : void 0
+  });
+  for (const r of rows) {
+    table.push(columns.map((c) => sanitizeTableCell(r[c.key])));
+  }
+  for (const line of table.toString().split("\n")) {
+    printLine(indent + line);
+  }
+}
+function installProcessHandlers() {
+  process.on("uncaughtException", (err) => {
+    console.error(`
+\u274C \u672A\u6355\u83B7\u7684\u5F02\u5E38\uFF1A${err.message}`);
+    if (process.argv.includes("--verbose")) console.error(err.stack);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    console.error(`
+\u274C \u672A\u5904\u7406\u7684\u5F02\u6B65\u9519\u8BEF\uFF1A${msg}`);
+    if (process.argv.includes("--verbose") && reason instanceof Error) {
+      console.error(reason.stack);
+    }
+    process.exit(1);
+  });
+}
+function printAuthMissingHelp(binName) {
+  if (isSiluzanAgentEnv()) {
+    console.error(
+      "\n\u274C Siluzan Agent \u73AF\u5883\u4E2D\u672A\u627E\u5230\u8BA4\u8BC1\u51ED\u636E\u3002\n\nAgent \u6C99\u7BB1\u5E94\u901A\u8FC7\u73AF\u5883\u53D8\u91CF\u6CE8\u5165\u4EE5\u4E0B\u4EFB\u610F\u4E00\u79CD\uFF08\u65E0\u9700 login\uFF09\uFF1A\n  SILUZAN_API_KEY=<YOUR_API_KEY>\n  SILUZAN_AUTH_TOKEN=<YOUR_TOKEN>\n\n\u8BF7\u68C0\u67E5 Agent \u8FD0\u884C\u65F6\u662F\u5426\u5DF2\u8BBE\u7F6E IS_SILUZAN_AGENT_ENV=true \u5E76\u5B8C\u6210\u51ED\u636E\u6CE8\u5165\u3002\n"
+    );
+    process.exit(1);
+  }
+  console.error(
+    `
+\u274C \u672A\u627E\u5230\u8BA4\u8BC1\u51ED\u636E\u3002\u8BF7\u9009\u62E9\u4EE5\u4E0B\u4EFB\u610F\u4E00\u79CD\u65B9\u5F0F\uFF1A
+
+\u8BF7\u4F7F\u7528\u624B\u673A\u53F7\u91CD\u65B0\u767B\u5F55
+${binName} send-login-code --phone <YOUR_PHONE>
+`,
+    `\u7136\u540E\u4F7F\u7528\u6536\u5230\u7684\u9A8C\u8BC1\u7801\u5B8C\u6210\u767B\u5F55
+${binName} login --phone <YOUR_PHONE> --code <YOUR_CODE>
+`
+  );
+  process.exit(1);
+}
+var MIN_SEGMENT_BYTES = 256 * 1024;
+var MAX_SEGMENT_BYTES = 50 * 1024 * 1024;
+var MAX_RETENTION_DAYS = 366 * 5;
+var PRUNE_THROTTLE_MS = 60 * 60 * 1e3;
+var MAX_SNAPSHOT_FILE_BYTES = 2 * 1024 * 1024;
+var API_KEY_SERVICE_VALUES = {
+  CSO: 0,
+  TSO: 1,
+  CUT: 2
+};
+function deriveSsoBaseUrl(anyApiBase) {
+  try {
+    const u = new URL(anyApiBase);
+    u.hostname = u.hostname.replace(/^(tso-api|cso|api)/, "sso");
+    return u.origin;
+  } catch {
+    return "https://sso.siluzan.com";
+  }
+}
+function deriveCsoApiBaseUrl(anyApiBase) {
+  try {
+    const u = new URL(anyApiBase);
+    u.hostname = u.hostname.replace(/^(tso-api|api)/, "cso");
+    return u.origin;
+  } catch {
+    return "https://cso.siluzan.com";
+  }
+}
+function normalizeChinaPhone(input) {
+  if (!input) return input;
+  const cleaned = input.replace(/[\s\-()\u00A0]/g, "");
+  if (/^\+861\d{10}$/.test(cleaned)) {
+    return cleaned;
+  }
+  if (/^861\d{10}$/.test(cleaned)) {
+    return `+${cleaned}`;
+  }
+  if (/^00861\d{10}$/.test(cleaned)) {
+    return `+${cleaned.slice(2)}`;
+  }
+  if (/^1\d{10}$/.test(cleaned)) {
+    return `+86${cleaned}`;
+  }
+  return cleaned;
+}
+function isValidChinaPhone(input) {
+  return /^\+861\d{10}$/.test(normalizeChinaPhone(input));
+}
+async function sendPhoneLoginCode(opts) {
+  const phone = normalizeChinaPhone(opts.phone);
+  const url = `${opts.ssoBaseUrl}/Account/SendVaildCode?Phone=${encodeURIComponent(
+    phone
+  )}&RandStr=&Iicket=`;
+  if (opts.verbose) {
+    process.stderr.write(`[phone-login] GET ${url}
+`);
+  }
+  const res = await rawRequest(url, {
+    method: "GET",
+    headers: {
+      Accept: "application/json",
+      "Accept-Language": "zh-CN"
+    }
+  });
+  if (res.status < 200 || res.status >= 300) {
+    return { ok: false, message: `HTTP ${res.status}` };
+  }
+  let body;
+  try {
+    body = JSON.parse(res.text);
+  } catch {
+    return { ok: false, message: `\u54CD\u5E94\u975E JSON\uFF1A${res.text.slice(0, 120)}` };
+  }
+  const state = (body.State ?? body.state ?? "").toLowerCase();
+  const message = body.Message ?? body.message ?? "";
+  return { ok: state === "ok", message };
+}
+async function loginByPhoneCode(opts) {
+  const phone = normalizeChinaPhone(opts.phone);
+  const url = `${opts.ssoBaseUrl}/Account/LoginByMiniCode?phone=${encodeURIComponent(
+    phone
+  )}&code=${encodeURIComponent(opts.code)}&key=`;
+  if (opts.verbose) {
+    process.stderr.write(`[phone-login] GET ${url}
+`);
+  }
+  const res = await rawRequest(url, {
+    method: "GET",
+    headers: {
+      Accept: "application/json",
+      "Accept-Language": "zh-CN"
+    }
+  });
+  if (opts.verbose) {
+    process.stderr.write(
+      `[phone-login] LoginByMiniCode HTTP ${res.status} body=${res.text.slice(0, 500)}
+`
+    );
+  }
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error(`\u767B\u5F55\u5931\u8D25\uFF1AHTTP ${res.status}`);
+  }
+  let body;
+  try {
+    body = JSON.parse(res.text);
+  } catch {
+    throw new Error(`\u767B\u5F55\u54CD\u5E94\u975E JSON\uFF1A${res.text.slice(0, 120)}`);
+  }
+  const errMsg = body.msg ?? body.Msg ?? "";
+  if (!body.token || typeof body.token === "string") {
+    throw new Error(errMsg || "\u767B\u5F55\u5931\u8D25\uFF08\u540E\u7AEF\u672A\u8FD4\u56DE\u539F\u56E0\uFF09");
+  }
+  const token = body.token;
+  const isError = token.isError ?? token.IsError ?? false;
+  if (isError) {
+    const err = token.errorDescription ?? token.ErrorDescription ?? token.error ?? token.Error ?? "\u672A\u77E5\u9519\u8BEF";
+    throw new Error(`OAuth \u5931\u8D25\uFF1A${err}`);
+  }
+  let accessToken = token.accessToken ?? token.access_token ?? "";
+  let tokenType = token.tokenType ?? token.token_type ?? "Bearer";
+  let expiresIn = token.expiresIn ?? token.expires_in;
+  if (!accessToken) {
+    const rawJson = token.raw ?? token.Raw;
+    if (rawJson && typeof rawJson === "string") {
+      try {
+        const parsed = JSON.parse(rawJson);
+        accessToken = parsed.access_token ?? "";
+        tokenType = parsed.token_type ?? tokenType;
+        expiresIn = parsed.expires_in ?? expiresIn;
+      } catch {
+      }
+    }
+  }
+  if (!accessToken) {
+    throw new Error(
+      `\u767B\u5F55\u54CD\u5E94\u7F3A\u5C11 access_token\uFF08\u54CD\u5E94\u5B57\u6BB5\uFF1A${Object.keys(token).join(", ") || "\u65E0"}\uFF09`
+    );
+  }
+  return { accessToken, tokenType, expiresIn };
+}
+async function createApiKeyByBearer(opts) {
+  if (opts.allowedServices.length === 0) {
+    throw new Error("createApiKey \u81F3\u5C11\u9700\u8981\u4F20\u5165\u4E00\u4E2A allowedServices");
+  }
+  if (opts.validDays === void 0 && opts.expiresAt === void 0) {
+    throw new Error("createApiKey \u5FC5\u987B\u6307\u5B9A validDays \u6216 expiresAt");
+  }
+  const body = JSON.stringify({
+    name: opts.name,
+    validDays: opts.validDays,
+    expiresAt: opts.expiresAt,
+    allowedServices: opts.allowedServices.map((s) => API_KEY_SERVICE_VALUES[s])
+  });
+  const url = `${opts.csoBaseUrl}/cso/v1/apikey`;
+  if (opts.verbose) {
+    process.stderr.write(`[phone-login] POST ${url} body=${body}
+`);
+  }
+  const res = await rawRequest(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "Accept-Language": "zh-CN",
+      Authorization: `Bearer ${opts.bearerToken}`,
+      "Content-Length": String(Buffer.byteLength(body, "utf8"))
+    },
+    body
+  });
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error(`\u521B\u5EFA API Key \u5931\u8D25\uFF1AHTTP ${res.status}\uFF08${res.text.slice(0, 200)}\uFF09`);
+  }
+  let json;
+  try {
+    json = JSON.parse(res.text);
+  } catch {
+    throw new Error(`\u521B\u5EFA API Key \u54CD\u5E94\u975E JSON\uFF1A${res.text.slice(0, 120)}`);
+  }
+  const code = json.code ?? json.Code;
+  if (code !== 1) {
+    throw new Error(`\u521B\u5EFA API Key \u5931\u8D25\uFF1A${json.message ?? json.Message ?? "\u672A\u77E5\u9519\u8BEF"}`);
+  }
+  const data = json.data ?? json.Data;
+  if (!data?.rawKey) {
+    throw new Error("\u521B\u5EFA API Key \u54CD\u5E94\u7F3A\u5C11 rawKey \u5B57\u6BB5");
+  }
+  return data;
+}
+async function issueApiKeyWithPhoneCode(opts) {
+  const code = opts.code?.trim() ?? "";
+  if (!code) {
+    throw new Error("\u9A8C\u8BC1\u7801\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const tokenInfo = await loginByPhoneCode({
+    ssoBaseUrl: opts.ssoBaseUrl,
+    phone: opts.phone,
+    code,
+    verbose: opts.verbose
+  });
+  const apiKey = await createApiKeyByBearer({
+    csoBaseUrl: opts.csoBaseUrl,
+    bearerToken: tokenInfo.accessToken,
+    name: opts.apiKeyName,
+    validDays: opts.validDays ?? (opts.expiresAt ? void 0 : 90),
+    expiresAt: opts.expiresAt,
+    allowedServices: opts.allowedServices,
+    verbose: opts.verbose
+  });
+  return apiKey;
+}
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as fs4 from "fs/promises";
+import * as fsSync from "fs";
+import * as os2 from "os";
+import * as path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/templates/load-templates.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+async function getSkillFiles(skillDir) {
+  const out = {};
+  async function walk(dir, prefix) {
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    for (const ent of entries) {
+      const rel = prefix ? `${prefix}/${ent.name}` : ent.name;
+      const full = path3.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        await walk(full, rel);
+      } else {
+        out[rel] = await fs3.readFile(full, "utf8");
+      }
+    }
+  }
+  await walk(skillDir, "");
+  return out;
+}
+
+// src/commands/init.ts
+var __dirname = path4.dirname(fileURLToPath2(import.meta.url));
+var SKILL_DIR_NAME = "siluzan-website";
+var PROJECT_DIRS = {
+  agents: (cwd) => path4.join(cwd, ".agents", "skills", SKILL_DIR_NAME),
+  cursor: (cwd) => path4.join(cwd, ".cursor", "skills", SKILL_DIR_NAME),
+  claude: (cwd) => path4.join(cwd, ".claude", "skills", SKILL_DIR_NAME),
+  windsurf: (cwd) => path4.join(cwd, ".windsurf", "skills", SKILL_DIR_NAME),
+  gemini: (cwd) => path4.join(cwd, ".gemini", "skills", SKILL_DIR_NAME),
+  codex: (cwd) => path4.join(cwd, ".codex", "skills", SKILL_DIR_NAME),
+  opencode: (cwd) => path4.join(cwd, ".opencode", "skills", SKILL_DIR_NAME),
+  kilo: (cwd) => path4.join(cwd, ".kilo", "skills", SKILL_DIR_NAME),
+  openclaw: (cwd) => path4.join(cwd, "skills", SKILL_DIR_NAME),
+  workbuddy: (cwd) => path4.join(cwd, ".workbuddy", "skills", SKILL_DIR_NAME),
+  deerflow: (cwd) => path4.join(cwd, "skills", "public", SKILL_DIR_NAME)
+};
+var GLOBAL_DIRS = {
+  agents: (home) => path4.join(home, ".agents", "skills", SKILL_DIR_NAME),
+  cursor: (home) => path4.join(home, ".cursor", "skills", SKILL_DIR_NAME),
+  claude: (home) => path4.join(home, ".claude", "skills", SKILL_DIR_NAME),
+  windsurf: (home) => path4.join(home, ".codeium", "windsurf", "skills", SKILL_DIR_NAME),
+  gemini: (home) => path4.join(home, ".gemini", "skills", SKILL_DIR_NAME),
+  codex: (home) => path4.join(home, ".codex", "skills", SKILL_DIR_NAME),
+  opencode: (home) => path4.join(home, ".config", "opencode", "skills", SKILL_DIR_NAME),
+  kilo: (home) => path4.join(home, ".kilo", "skills", SKILL_DIR_NAME),
+  openclaw: (home) => path4.join(home, ".openclaw", "skills", SKILL_DIR_NAME),
+  workbuddy: (home) => path4.join(home, ".workbuddy", "skills", SKILL_DIR_NAME)
+};
+var ALL_PLATFORM_KEYS = Object.keys(PROJECT_DIRS);
+function parseTargets(raw) {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "all") {
+    return ALL_PLATFORM_KEYS.map((k) => ({ keys: [k], isGlobal: false }));
+  }
+  const parts = normalized.split(",").map((s) => s.trim());
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of parts) {
+    let key = p;
+    let isGlobal = false;
+    if (p === "openclaw-workspace") {
+      key = "openclaw";
+    } else if (p === "openclaw-global") {
+      key = "openclaw";
+      isGlobal = true;
+    } else if (p === "workbuddy-workspace") {
+      key = "workbuddy";
+    } else if (p === "workbuddy-global") {
+      key = "workbuddy";
+      isGlobal = true;
+    }
+    if (!ALL_PLATFORM_KEYS.includes(key)) {
+      console.error(
+        `\u672A\u77E5\u5E73\u53F0: ${p}\u3002\u53EF\u9009: ${ALL_PLATFORM_KEYS.join(", ")}, openclaw-workspace, openclaw-global, workbuddy-workspace, workbuddy-global, all`
+      );
+      process.exitCode = 1;
+      return [];
+    }
+    const uid = `${key}:${isGlobal}`;
+    if (!seen.has(uid)) {
+      seen.add(uid);
+      results.push({ keys: [key], isGlobal });
+    }
+  }
+  return results;
+}
+function skillRoot() {
+  return path4.join(__dirname, "skill");
+}
+function saveInstalledTargets(newEntries) {
+  const CONFIG_FILE3 = path4.join(os2.homedir(), ".siluzan", "config.json");
+  try {
+    fsSync.mkdirSync(path4.dirname(CONFIG_FILE3), { recursive: true });
+    let existing = {};
+    if (fsSync.existsSync(CONFIG_FILE3)) {
+      existing = JSON.parse(fsSync.readFileSync(CONFIG_FILE3, "utf8"));
+    }
+    const prev = Array.isArray(existing.websiteInstalledTargets) ? existing.websiteInstalledTargets : [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const e of [...prev, ...newEntries]) {
+      merged.set(`${e.target}::${e.cwd}::${e.dir ?? ""}`, e);
+    }
+    fsSync.writeFileSync(
+      CONFIG_FILE3,
+      JSON.stringify({ ...existing, websiteInstalledTargets: [...merged.values()] }, null, 2),
+      "utf8"
+    );
+    if (process.platform !== "win32") {
+      fsSync.chmodSync(CONFIG_FILE3, 384);
+    }
+  } catch {
+  }
+}
+async function writeSkillFilesToDir(destDir, skillFiles, force) {
+  await fs4.mkdir(destDir, { recursive: true });
+  let anyWritten = false;
+  for (const [relativePath, content] of Object.entries(skillFiles)) {
+    const fullPath = path4.join(destDir, relativePath);
+    await fs4.mkdir(path4.dirname(fullPath), { recursive: true });
+    try {
+      await fs4.access(fullPath);
+      if (!force) {
+        console.warn(`\u8DF3\u8FC7\uFF08\u5DF2\u5B58\u5728\uFF0C\u4F7F\u7528 --force \u8986\u76D6\uFF09: ${fullPath}`);
+        continue;
+      }
+    } catch {
+    }
+    await fs4.writeFile(fullPath, content, "utf8");
+    console.log(`\u5DF2\u5199\u5165: ${fullPath}`);
+    anyWritten = true;
+  }
+  return anyWritten;
+}
+async function runInit(options) {
+  const home = os2.homedir();
+  const skillFiles = await getSkillFiles(skillRoot());
+  const installedEntries = [];
+  if (options.dir) {
+    const destDir = path4.resolve(options.cwd, options.dir);
+    console.log(`\u5B89\u88C5\u76EE\u6807\u76EE\u5F55\uFF1A${destDir}`);
+    const anyWritten = await writeSkillFilesToDir(destDir, skillFiles, options.force);
+    if (anyWritten) {
+      installedEntries.push({ target: "custom", cwd: "", dir: destDir });
+    }
+  } else if (options.global) {
+    for (const key of ALL_PLATFORM_KEYS) {
+      if (key === "deerflow") continue;
+      const destDir = GLOBAL_DIRS[key](home);
+      console.log(`[${key} global] \u2192 ${destDir}`);
+      const anyWritten = await writeSkillFilesToDir(destDir, skillFiles, options.force);
+      if (anyWritten) {
+        installedEntries.push({ target: `${key}-global`, cwd: "" });
+      }
+    }
+  } else {
+    const targets = parseTargets(options.aiTargets);
+    if (targets.length === 0) return;
+    for (const entry of targets) {
+      for (const key of entry.keys) {
+        const destDir = entry.isGlobal ? GLOBAL_DIRS[key](home) : PROJECT_DIRS[key](options.cwd);
+        const label = entry.isGlobal ? `${key} global` : key;
+        console.log(`[${label}] \u2192 ${destDir}`);
+        const anyWritten = await writeSkillFilesToDir(destDir, skillFiles, options.force);
+        if (anyWritten) {
+          installedEntries.push({
+            target: entry.isGlobal ? `${key}-global` : key,
+            cwd: entry.isGlobal ? "" : options.cwd
+          });
+        }
+      }
+    }
+  }
+  if (installedEntries.length > 0) {
+    saveInstalledTargets(installedEntries);
+  }
+  console.log("\n\u4E0B\u4E00\u6B65\uFF1A");
+  console.log("1. \u82E5\u5C1A\u672A\u767B\u5F55\uFF1Asiluzan-website login");
+  console.log("2. \u5217\u51FA\u7AD9\u70B9\uFF1Asiluzan-website sites list");
+  console.log("3. CLI \u5347\u7EA7\u540E\u8FD0\u884C\uFF1Asiluzan-website update");
+}
+function register(program2) {
+  program2.command("init").description("\u5C06 Website Skill \u6587\u4EF6\u5199\u5165 AI \u52A9\u624B\u76EE\u5F55").option(
+    "-a, --ai <targets>",
+    "\u76EE\u6807\u5E73\u53F0\uFF0C\u9017\u53F7\u5206\u9694\uFF1Acursor,claude,agents,windsurf,gemini,codex,opencode,kilo,openclaw,workbuddy,deerflow,all",
+    "all"
+  ).option("-d, --dir <path>", "\u5C06 Skill \u6587\u4EF6\u76F4\u63A5\u5199\u5165\u6307\u5B9A\u76EE\u5F55\uFF0C\u4E0E --ai/--global \u4E92\u65A5").option("-g, --global", "\u5199\u5165\u6240\u6709\u5E73\u53F0\u7684\u5168\u5C40 skill \u76EE\u5F55", false).option("-f, --force", "\u8986\u76D6\u5DF2\u5B58\u5728\u7684 Skill \u6587\u4EF6", false).action(async (opts) => {
+    await runInit({
+      cwd: process.cwd(),
+      aiTargets: opts.ai,
+      dir: opts.dir,
+      global: Boolean(opts.global),
+      force: Boolean(opts.force)
+    });
+  });
+}
+
+// src/commands/update.ts
+import * as fs5 from "fs";
+import * as os3 from "os";
+import * as path5 from "path";
+import { spawnSync } from "child_process";
+
+// src/config/defaults.ts
+var BUILD_ENV = "test";
+var DEFAULT_API_BASE = "https://api-ci.siluzan.com";
+var DEFAULT_CSO_BASE = "https://cso-ci.siluzan.com";
+var DEFAULT_WEB_BASE = "https://www-ci.siluzan.com";
+var DEFAULT_SITE_STAGE = "ci";
+
+// src/utils/version.ts
+var PKG_NAME = "siluzan-website-cli";
+var BIN_NAME = "siluzan-website";
+var CACHE_PREFIX = "_website";
+function getCurrentVersion2() {
+  return getCurrentVersion(import.meta.url);
+}
+var notifier = createVersionNotifier({
+  pkgName: PKG_NAME,
+  binName: BIN_NAME,
+  cachePrefix: CACHE_PREFIX,
+  resolveTag: () => npmDistTagForBuildEnv(BUILD_ENV),
+  getCurrentVersion: getCurrentVersion2,
+  mergeWriteConfig: (updates) => mergeWriteSharedConfig(updates),
+  readConfigRaw: () => readSharedConfigRaw()
+});
+var notifyIfOutdated = notifier.notifyIfOutdated;
+var fetchLatestVersion = notifier.fetchLatestVersion;
+
+// src/commands/update.ts
+var CONFIG_FILE2 = path5.join(os3.homedir(), ".siluzan", "config.json");
+var PKG_NAME2 = "siluzan-website-cli";
+function readInstalledTargets() {
+  try {
+    const cfg = JSON.parse(fs5.readFileSync(CONFIG_FILE2, "utf8"));
+    return Array.isArray(cfg.websiteInstalledTargets) ? cfg.websiteInstalledTargets : [];
+  } catch {
+    return [];
+  }
+}
+function isNpmGlobalInstall() {
+  try {
+    const result = spawnSync("npm", ["list", "-g", "--depth=0", PKG_NAME2], {
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    return Boolean(result.stdout?.includes(PKG_NAME2));
+  } catch {
+    return false;
+  }
+}
+async function runUpdate(options) {
+  const current = getCurrentVersion2();
+  console.log(`
+\u5F53\u524D\u7248\u672C\uFF1A${current}`);
+  const npmTag = npmDistTagForBuildEnv(BUILD_ENV);
+  console.log(`\u6B63\u5728\u67E5\u8BE2 npm registry\uFF08dist-tag\uFF1A${npmTag}\uFF09\u2026`);
+  const latest = await fetchLatestVersion();
+  if (!latest) {
+    console.warn("\u26A0\uFE0F  \u65E0\u6CD5\u8BBF\u95EE npm registry\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u540E\u91CD\u8BD5\u3002");
+    console.warn("   \u82E5\u9700\u5F3A\u5236\u91CD\u65B0\u5B89\u88C5\u5F53\u524D\u7248\u672C\uFF0C\u52A0 --force \u53C2\u6570\u3002");
+    if (!options.force) {
+      process.exit(1);
+    }
+  } else {
+    console.log(`\u6700\u65B0\u7248\u672C\uFF1A${latest}`);
+  }
+  const shouldUpdate = options.force || (latest ? isNewer(current, latest) : false);
+  if (!shouldUpdate && latest && !options.force) {
+    console.log("\n\u2705 \u5DF2\u662F\u6700\u65B0\u7248\u672C\uFF0C\u65E0\u9700\u66F4\u65B0 CLI\u3002");
+    console.log("   \u5982\u9700\u5F3A\u5236\u91CD\u65B0\u521D\u59CB\u5316 skill \u6587\u4EF6\uFF0C\u53EF\u52A0 --force \u53C2\u6570\u3002");
+  }
+  const targetVersion = latest ?? current;
+  if (shouldUpdate && latest) {
+    console.log(`
+\u2B06\uFE0F  \u6B63\u5728\u66F4\u65B0 CLI \u81F3 ${targetVersion} \u2026`);
+  } else if (options.force) {
+    console.log(`
+\u{1F504} \u5F3A\u5236\u91CD\u65B0\u5B89\u88C5\u5F53\u524D\u7248\u672C ${current} \u2026`);
+  }
+  if ((shouldUpdate || options.force) && isNpmGlobalInstall()) {
+    try {
+      const result = spawnSync("npm", ["install", "-g", `${PKG_NAME2}@${targetVersion}`], {
+        stdio: "inherit",
+        shell: false
+      });
+      if (result.status !== 0) {
+        throw new Error(`npm install \u9000\u51FA\u7801\uFF1A${result.status ?? "unknown"}`);
+      }
+      console.log("\n\u2705 CLI \u66F4\u65B0\u6210\u529F\uFF01");
+    } catch (e) {
+      console.error(`
+\u274C npm \u5B89\u88C5\u5931\u8D25\uFF1A${e.message}`);
+      console.error("   \u5982\u679C\u662F\u6743\u9650\u95EE\u9898\uFF0C\u5C1D\u8BD5\u52A0 sudo\uFF08Unix\uFF09\u6216\u4EE5\u7BA1\u7406\u5458\u8EAB\u4EFD\u8FD0\u884C\u3002");
+      process.exit(1);
+    }
+  } else if (shouldUpdate || options.force) {
+    console.log(
+      "\n\u26A0\uFE0F  \u68C0\u6D4B\u5230 CLI \u5E76\u975E\u901A\u8FC7 npm \u5168\u5C40\u5B89\u88C5\uFF08\u53EF\u80FD\u662F\u672C\u5730\u5F00\u53D1\u6A21\u5F0F\uFF09\u3002\n   \u8DF3\u8FC7 npm \u66F4\u65B0\uFF0C\u4EC5\u91CD\u65B0\u521D\u59CB\u5316 skill \u6587\u4EF6\u3002\n   \u82E5\u9700\u6B63\u5F0F\u5B89\u88C5\uFF0C\u8BF7\u8FD0\u884C\uFF1Anpm install -g siluzan-website-cli"
+    );
+  }
+  if (options.skipInit) return;
+  const targets = readInstalledTargets();
+  if (targets.length === 0) {
+    console.log(
+      "\n\u26A0\uFE0F  \u672A\u627E\u5230\u4E0A\u6B21\u5B89\u88C5\u8BB0\u5F55\u3002\n   \u8BF7\u624B\u52A8\u8FD0\u884C\uFF1Asiluzan-website init --ai <\u5E73\u53F0> --force\n"
+    );
+    return;
+  }
+  console.log(`
+\u{1F504} \u6B63\u5728\u66F4\u65B0 ${targets.length} \u5904 skill \u5B89\u88C5\u4F4D\u7F6E \u2026`);
+  let failCount = 0;
+  for (const entry of targets) {
+    const label = entry.target === "custom" ? entry.dir ?? "unknown" : entry.target;
+    const cwd = entry.cwd || os3.homedir();
+    console.log(`
+  [${label}]`);
+    try {
+      if (entry.target === "custom" && entry.dir) {
+        await runInit({
+          cwd: os3.homedir(),
+          aiTargets: "",
+          dir: entry.dir,
+          force: true
+        });
+      } else {
+        await runInit({
+          cwd,
+          aiTargets: entry.target,
+          force: true
+        });
+      }
+    } catch (e) {
+      failCount++;
+      console.error(`  \u274C \u66F4\u65B0\u5931\u8D25\uFF1A${e.message}`);
+    }
+  }
+  if (failCount > 0) {
+    console.error(
+      `
+\u26A0\uFE0F  ${targets.length} \u5904\u5B89\u88C5\u4F4D\u7F6E\u4E2D\u6709 ${failCount} \u5904\u66F4\u65B0\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u4E0A\u65B9\u9519\u8BEF\u4FE1\u606F\u3002`
+    );
+    process.exit(1);
+  }
+  console.log("\n\u2705 \u5168\u90E8 skill \u6587\u4EF6\u5DF2\u5237\u65B0\u3002");
+  console.log("   \u5982\u679C AI \u52A9\u624B\u6B63\u5728\u8FD0\u884C\uFF0C\u5EFA\u8BAE\u91CD\u542F\u4EE5\u4F7F\u65B0 skill \u6587\u4EF6\u751F\u6548\u3002\n");
+}
+function register2(program2) {
+  program2.command("update").description("\u68C0\u67E5\u5E76\u66F4\u65B0 siluzan-website-cli\uFF0C\u540C\u6B65\u5237\u65B0\u5DF2\u5B89\u88C5 Skill \u6587\u4EF6").option("--force", "\u8DF3\u8FC7\u7248\u672C\u6BD4\u8F83\uFF0C\u5F3A\u5236\u91CD\u65B0\u5B89\u88C5\u5E76\u5237\u65B0 skill \u6587\u4EF6", false).option("--skip-init", "\u4EC5\u66F4\u65B0 CLI\uFF0C\u4E0D\u91CD\u65B0\u521D\u59CB\u5316 skill \u6587\u4EF6", false).action(async (opts) => {
+    await runUpdate({ force: opts.force, skipInit: opts.skipInit });
+  });
+}
+
+// src/commands/login.ts
+import * as readline from "readline";
+import * as os4 from "os";
+function parseAllowedServices(raw) {
+  const allowed = ["CSO", "TSO", "CUT"];
+  if (!raw) return ["CSO", "TSO", "CUT"];
+  const parts = raw.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean);
+  const result = [];
+  for (const p of parts) {
+    if (!allowed.includes(p)) {
+      throw new Error(`\u672A\u77E5\u670D\u52A1\u540D\u300C${p}\u300D\uFF0C\u53EF\u9009\uFF1A${allowed.join(" / ")}`);
+    }
+    if (!result.includes(p)) result.push(p);
+  }
+  if (result.length === 0) throw new Error("--services \u81F3\u5C11\u9700\u8981\u6307\u5B9A\u4E00\u4E2A\u670D\u52A1");
+  return result;
+}
+function defaultApiKeyName() {
+  let host = "unknown";
+  try {
+    host = os4.hostname() || "unknown";
+  } catch {
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return `CLI - ${host} - ${today}`;
+}
+function validateAndNormalizePhone(rawInput) {
+  const rawPhone = rawInput?.trim() ?? "";
+  if (!isValidChinaPhone(rawPhone)) {
+    console.error(
+      "\n\u274C \u624B\u673A\u53F7\u683C\u5F0F\u9519\u8BEF\uFF1A\u4EC5\u652F\u6301\u4E2D\u56FD\u5927\u9646\u624B\u673A\u53F7\uFF0C\u53EF\u5E26\u6216\u4E0D\u5E26 +86\uFF08\u5982 13800138000\uFF09\u3002\n"
+    );
+    process.exit(1);
+  }
+  return normalizeChinaPhone(rawPhone);
+}
+function resolveSsoCsoBase() {
+  const apiBase = process.env.SILUZAN_WEBSITE_API_BASE ?? DEFAULT_API_BASE;
+  const ssoBaseUrl = deriveSsoBaseUrl(apiBase);
+  const csoBaseUrl = process.env.SILUZAN_CSO_BASE ?? DEFAULT_CSO_BASE ?? deriveCsoApiBaseUrl(apiBase);
+  return { ssoBaseUrl, csoBaseUrl };
+}
+async function runSendLoginCode(opts) {
+  if (skipAuthSetupInAgentEnv("siluzan-website send-login-code")) return;
+  const phone = validateAndNormalizePhone(opts.phone);
+  const { ssoBaseUrl } = resolveSsoCsoBase();
+  console.log("\n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("  Siluzan Website \u53D1\u9001\u767B\u5F55\u77ED\u4FE1\u9A8C\u8BC1\u7801");
+  console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  console.log(`  \u624B\u673A\u53F7 : ${phone}`);
+  console.log(`  SSO    : ${ssoBaseUrl}
+`);
+  console.log("\u2192 \u6B63\u5728\u5411\u624B\u673A\u53D1\u9001\u9A8C\u8BC1\u7801...");
+  const r = await sendPhoneLoginCode({ ssoBaseUrl, phone, verbose: opts.verbose });
+  if (!r.ok) {
+    console.error(`
+\u274C \u77ED\u4FE1\u9A8C\u8BC1\u7801\u53D1\u9001\u5931\u8D25\uFF1A${r.message || "(\u540E\u7AEF\u672A\u8FD4\u56DE\u539F\u56E0)"}
+`);
+    process.exit(1);
+  }
+  console.log("\u2713 \u9A8C\u8BC1\u7801\u5DF2\u53D1\u9001\uFF0810 \u5206\u949F\u5185\u6709\u6548\uFF09\u3002\n");
+  console.log("\u4E0B\u4E00\u6B65\uFF1A\n");
+  console.log(`  siluzan-website login --phone ${phone} --code <6\u4F4D\u9A8C\u8BC1\u7801>
+`);
+}
+async function runPhoneLogin(opts) {
+  const phone = validateAndNormalizePhone(opts.phone);
+  const code = opts.code?.trim() ?? "";
+  if (!code) {
+    console.error("\n\u274C \u7F3A\u5C11 --code\u3002\u8BF7\u6309\u4E24\u6BB5\u5F0F\u6267\u884C\uFF1A\n");
+    console.error(`  1) siluzan-website send-login-code --phone ${phone}`);
+    console.error(`  2) siluzan-website login --phone ${phone} --code <6\u4F4D\u9A8C\u8BC1\u7801>
+`);
+    process.exit(1);
+  }
+  let allowedServices;
+  try {
+    allowedServices = parseAllowedServices(opts.services);
+  } catch (e) {
+    console.error(`
+\u274C ${e instanceof Error ? e.message : String(e)}
+`);
+    process.exit(1);
+    return;
+  }
+  const { ssoBaseUrl, csoBaseUrl } = resolveSsoCsoBase();
+  const apiKeyName = opts.name ?? defaultApiKeyName();
+  console.log("\n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("  Siluzan Website \u767B\u5F55\uFF08\u624B\u673A\u53F7 \u2192 API Key\uFF09");
+  console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  console.log(`  \u624B\u673A\u53F7 : ${phone}`);
+  console.log("\u2192 \u6B63\u5728\u6821\u9A8C\u9A8C\u8BC1\u7801\u5E76\u521B\u5EFA API Key...");
+  try {
+    const created = await issueApiKeyWithPhoneCode({
+      ssoBaseUrl,
+      csoBaseUrl,
+      phone,
+      code,
+      apiKeyName,
+      validDays: opts.expiresAt ? void 0 : opts.validDays ?? 90,
+      expiresAt: opts.expiresAt,
+      allowedServices,
+      verbose: opts.verbose
+    });
+    writeSharedConfig({ apiKey: created.rawKey });
+    console.log("\n\u2705 \u767B\u5F55\u6210\u529F\uFF0CAPI Key \u5DF2\u4FDD\u5B58");
+    console.log(`  Key ID     : ${created.id}`);
+    console.log(`  Key (\u8131\u654F) : ${maskSecret(created.rawKey)}`);
+    console.log(`  \u914D\u7F6E\u6587\u4EF6   : ${CONFIG_FILE}`);
+    console.log("\n\u73B0\u5728\u53EF\u4EE5\u8FD0\u884C\uFF1Asiluzan-website sites list\n");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`
+\u274C \u767B\u5F55\u5931\u8D25\uFF1A${msg}`);
+    if (/手机未注册|未注册/.test(msg)) {
+      console.error(`
+  \u8BF7\u5148\u5728\u7F51\u9875\u6CE8\u518C\uFF1A${DEFAULT_WEB_BASE}
+`);
+    }
+    process.exit(1);
+  }
+}
+async function runLogin(opts = {}) {
+  if (skipAuthSetupInAgentEnv("siluzan-website login")) return;
+  if (opts.apiKey !== void 0) {
+    const key = opts.apiKey.trim();
+    if (!key) {
+      console.error("\n\u274C API Key \u4E0D\u80FD\u4E3A\u7A7A\u3002\n");
+      process.exit(1);
+    }
+    writeSharedConfig({ apiKey: key });
+    console.log(`
+\u2705 API Key \u5DF2\u4FDD\u5B58\uFF08${maskSecret(key)}\uFF09`);
+    console.log(`   \u914D\u7F6E\u6587\u4EF6\uFF1A${CONFIG_FILE}
+`);
+    return;
+  }
+  if (opts.phone !== void 0) {
+    await runPhoneLogin(opts);
+    return;
+  }
+  const shared = readSharedConfig();
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = (q) => new Promise((res) => rl.question(q, (a) => res(a.trim())));
+  console.log("\n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("  Siluzan Website \u767B\u5F55\uFF08API Key\uFF09");
+  console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  console.log("Skill / Agent \u53EA\u652F\u6301 API Key\u3002\u63A8\u8350\u624B\u673A\u53F7\u4E24\u6BB5\u5F0F\uFF1A");
+  console.log("  siluzan-website send-login-code --phone <\u624B\u673A\u53F7>");
+  console.log("  siluzan-website login --phone <\u624B\u673A\u53F7> --code <\u9A8C\u8BC1\u7801>\n");
+  console.log(`\u6216\u524D\u5F80 ${DEFAULT_WEB_BASE}/v3/foreign_trade/settings/apiKeyManagement \u521B\u5EFA\u540E\u7C98\u8D34\u3002
+`);
+  if (shared.apiKey) {
+    console.log(`\u5DF2\u68C0\u6D4B\u5230 API Key\uFF08${maskSecret(shared.apiKey)}\uFF09\u3002`);
+    const ans = await prompt("\u662F\u5426\u8986\u76D6\uFF1F(y/N) ");
+    if (ans.toLowerCase() !== "y") {
+      rl.close();
+      console.log("\n\u5DF2\u53D6\u6D88\u3002\n");
+      return;
+    }
+  }
+  let apiKey = "";
+  for (let i = 0; i < 3; i++) {
+    const input = await prompt("\u7C98\u8D34 API Key\uFF1A");
+    if (input) {
+      apiKey = input;
+      break;
+    }
+    console.log("\u274C API Key \u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u8BF7\u91CD\u8BD5");
+  }
+  rl.close();
+  if (!apiKey) {
+    console.error("\n\u274C \u591A\u6B21\u8F93\u5165\u65E0\u6548\u3002\n");
+    process.exit(1);
+  }
+  writeSharedConfig({ apiKey });
+  console.log(`
+\u2705 API Key \u5DF2\u4FDD\u5B58\uFF08${maskSecret(apiKey)}\uFF09`);
+  console.log("   \u73B0\u5728\u53EF\u4EE5\u8FD0\u884C\uFF1Asiluzan-website sites list\n");
+}
+function register3(program2) {
+  program2.command("login").description("\u767B\u5F55\u5E76\u4FDD\u5B58 API Key\uFF08\u4E0E CSO/TSO \u5171\u7528 ~/.siluzan/config.json\uFF09").option("--api-key <key>", "\u76F4\u63A5\u4FDD\u5B58 API Key").option("--phone <phone>", "\u624B\u673A\u53F7\u767B\u5F55\uFF08\u9700\u914D\u5408 --code\uFF09").option("--code <code>", "\u77ED\u4FE1\u9A8C\u8BC1\u7801").option("--name <name>", "\u81EA\u52A8\u521B\u5EFA\u7684 API Key \u540D\u79F0").option("--valid-days <days>", "API Key \u6709\u6548\u671F\u5929\u6570", parseInt).option("--expires-at <iso>", "API Key \u7EDD\u5BF9\u8FC7\u671F\u65F6\u95F4").option("--services <services>", "API Key \u670D\u52A1\u5217\u8868\uFF0C\u9ED8\u8BA4 CSO,TSO,CUT").option("--verbose", "\u8F93\u51FA\u767B\u5F55 HTTP URL", false).action(async (opts) => {
+    await runLogin(opts);
+  });
+  program2.command("send-login-code").description("\u53D1\u9001\u624B\u673A\u53F7\u767B\u5F55\u77ED\u4FE1\u9A8C\u8BC1\u7801\uFF08\u4E24\u6BB5\u5F0F\u767B\u5F55\u7B2C 1 \u6B65\uFF09").requiredOption("--phone <phone>", "\u4E2D\u56FD\u5927\u9646\u624B\u673A\u53F7").option("--verbose", "\u8F93\u51FA\u767B\u5F55 HTTP URL", false).action(async (opts) => {
+    await runSendLoginCode(opts);
+  });
+}
+
+// src/commands/config.ts
+function cmdConfigShow() {
+  const shared = readSharedConfig();
+  const { apiKey: effectiveApiKeyRaw } = resolveSiluzanCredentials({
+    configApiKey: shared.apiKey,
+    configAuthToken: shared.authToken
+  });
+  const effectiveApiKey = effectiveApiKeyRaw ?? "";
+  const envApiKey = process.env.SILUZAN_API_KEY;
+  if (!effectiveApiKey) {
+    if (isSiluzanAgentEnv()) {
+      console.log(
+        "\nSiluzan Agent \u73AF\u5883\u3002\u51ED\u636E\u5E94\u7531\u6C99\u7BB1\u6CE8\u5165 SILUZAN_API_KEY\uFF0C\u65E0\u9700 login\u3002\n"
+      );
+      return;
+    }
+    console.log(
+      `
+\u5C1A\u672A\u914D\u7F6E API Key\u3002
+
+   \u6CE8\u518C\uFF1A${DEFAULT_WEB_BASE}
+   \u767B\u5F55\uFF1Asiluzan-website login
+   \u6216\u73AF\u5883\u53D8\u91CF\uFF1ASILUZAN_API_KEY
+`
+    );
+    return;
+  }
+  const apiBaseUrl = process.env.SILUZAN_WEBSITE_API_BASE ?? DEFAULT_API_BASE;
+  console.log("\n\u5F53\u524D\u914D\u7F6E\uFF1A");
+  console.log(`  apiBaseUrl : ${apiBaseUrl}`);
+  const src = envApiKey ? "env:SILUZAN_API_KEY" : "config.json";
+  console.log(`  apiKey     : ${maskSecret(effectiveApiKey)}  [${src}]  \u2190 Skill \u552F\u4E00\u9274\u6743\u65B9\u5F0F`);
+  console.log(`
+\u914D\u7F6E\u6587\u4EF6\uFF1A${CONFIG_FILE}
+`);
+}
+function cmdConfigSet(opts) {
+  if (skipAuthSetupInAgentEnv("siluzan-website config set")) return;
+  if (!opts.apiKey) {
+    console.error("\n\u274C \u8BF7\u63D0\u4F9B --api-key\n");
+    process.exit(1);
+  }
+  writeSharedConfig({ apiKey: opts.apiKey });
+  console.log(`
+\u2705 \u914D\u7F6E\u5DF2\u4FDD\u5B58\u5230 ${CONFIG_FILE}`);
+  console.log(`   apiKey: ${maskSecret(opts.apiKey)}
+`);
+}
+function register4(program2) {
+  const configCmd = program2.command("config").description("\u67E5\u770B\u6216\u8BBE\u7F6E API Key\uFF08~/.siluzan/config.json\uFF0C\u4E0E CSO/TSO \u5171\u7528\uFF09");
+  configCmd.command("show").description("\u5C55\u793A\u5F53\u524D\u5DF2\u4FDD\u5B58\u7684\u914D\u7F6E\uFF08\u51ED\u636E\u8131\u654F\uFF09").action(() => cmdConfigShow());
+  configCmd.command("set").description("\u4FDD\u5B58 API Key").option("--api-key <key>", "API Key").action((opts) => {
+    cmdConfigSet({ apiKey: opts.apiKey });
+  });
+  configCmd.command("clear").description("\u6E05\u7A7A\u5DF2\u4FDD\u5B58\u7684\u51ED\u636E").action(() => {
+    if (skipAuthSetupInAgentEnv("siluzan-website config clear")) return;
+    clearSharedConfig();
+    console.log(`
+\u2705 \u51ED\u636E\u5DF2\u6E05\u7A7A\uFF08${CONFIG_FILE}\uFF09
+`);
+  });
+}
+
+// src/utils/auth.ts
+function loadConfig() {
+  const shared = readSharedConfig();
+  const { apiKey } = resolveSiluzanCredentials({
+    configApiKey: shared.apiKey,
+    configAuthToken: shared.authToken
+  });
+  if (!apiKey) {
+    printAuthMissingHelp("siluzan-website");
+  }
+  const apiBaseUrl = process.env.SILUZAN_WEBSITE_API_BASE ?? DEFAULT_API_BASE;
+  const csoBaseUrl = process.env.SILUZAN_CSO_BASE ?? DEFAULT_CSO_BASE;
+  const apiErr = validateBaseUrl(apiBaseUrl);
+  if (apiErr) {
+    console.error(`
+\u274C apiBaseUrl \u4E0D\u5408\u6CD5\uFF1A${apiErr}`);
+    process.exit(1);
+  }
+  const csoErr = validateBaseUrl(csoBaseUrl);
+  if (csoErr) {
+    console.error(`
+\u274C csoBaseUrl \u4E0D\u5408\u6CD5\uFF1A${csoErr}`);
+    process.exit(1);
+  }
+  return {
+    apiBaseUrl,
+    csoBaseUrl,
+    authToken: "",
+    apiKey,
+    dataPermission: process.env.SILUZAN_DATA_PERMISSION ?? shared.dataPermission
+  };
+}
+function apiFetch2(url, config, options = {}, verbose = false) {
+  return apiFetch(url, config, options, verbose);
+}
+
+// src/utils/site-url.ts
+function normalizeRegion(raw) {
+  const value = (raw ?? "").trim().toLowerCase();
+  if (value === "cn" || value === "\u4E2D\u56FD") return "cn";
+  if (value === "us" || value === "\u7F8E\u56FD") return "us";
+  return "";
+}
+function resolvePlatformSiteUrl(guid, region, stage = DEFAULT_SITE_STAGE) {
+  const normalized = normalizeRegion(region);
+  if (!guid || !normalized) return "";
+  if (normalized === "cn") {
+    return `https://${guid}-${stage}.cn.siluzan.com`;
+  }
+  return `https://${guid}-${stage}.admin.mysiluzan.com`;
+}
+function trimTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+
+// src/commands/sites.ts
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function readString(obj, key) {
+  if (!obj) return "";
+  const v = obj[key];
+  return typeof v === "string" ? v : v == null ? "" : String(v);
+}
+function normalizeSiteItem(raw) {
+  const item = asRecord(raw);
+  if (!item) return null;
+  const inner = asRecord(item.s) ?? item;
+  const guid = readString(inner, "guid") || readString(item, "guid");
+  if (!guid) return null;
+  const region = readString(inner, "region") || readString(item, "region");
+  return {
+    guid,
+    name: readString(inner, "name") || readString(item, "name") || guid,
+    region,
+    siteState: readString(inner, "siteState") || readString(item, "siteState"),
+    url: resolvePlatformSiteUrl(guid, region),
+    accepted: typeof item.accepted === "boolean" ? item.accepted : void 0
+  };
+}
+function unwrapSiteList(raw) {
+  if (Array.isArray(raw)) return raw;
+  const obj = asRecord(raw);
+  if (!obj) return [];
+  if (Array.isArray(obj.data)) return obj.data;
+  const data = asRecord(obj.data);
+  if (data) {
+    if (Array.isArray(data.items)) return data.items;
+    if (Array.isArray(data.list)) return data.list;
+  }
+  if (Array.isArray(obj.items)) return obj.items;
+  if (Array.isArray(obj.list)) return obj.list;
+  return [];
+}
+async function fetchMySites(config, options = {}) {
+  const params = new URLSearchParams({
+    pageNo: "1",
+    pageSize: "10000"
+  });
+  if (options.query) params.set("query", options.query);
+  const url = `${config.apiBaseUrl}/query/profile/steward-individual/all-sites?${params.toString()}`;
+  const raw = await apiFetch2(url, config, {}, options.verbose);
+  return unwrapSiteList(raw).map(normalizeSiteItem).filter((s) => Boolean(s));
+}
+async function resolveSite(config, opts) {
+  if (opts.url?.trim()) {
+    const url = opts.url.trim().replace(/\/+$/, "");
+    return {
+      guid: opts.site?.trim() || "",
+      name: url,
+      region: "",
+      siteState: "",
+      url
+    };
+  }
+  const key = opts.site?.trim();
+  if (!key) {
+    console.error("\n\u274C \u8BF7\u63D0\u4F9B --site <guid \u6216\u7AD9\u70B9\u540D> \u6216 --url <\u7AD9\u70B9\u5730\u5740>\n");
+    process.exit(1);
+  }
+  const sites = await fetchMySites(config, { verbose: opts.verbose });
+  const exact = sites.find((s) => s.guid === key);
+  if (exact) return exact;
+  const nameHits = sites.filter((s) => s.name.toLowerCase().includes(key.toLowerCase()));
+  if (nameHits.length === 1) return nameHits[0];
+  if (nameHits.length > 1) {
+    console.error(`
+\u274C \u7AD9\u70B9\u540D\u300C${key}\u300D\u5339\u914D\u5230 ${nameHits.length} \u4E2A\uFF0C\u8BF7\u6539\u7528 --site <guid>\uFF1A`);
+    for (const s of nameHits) console.error(`   ${s.guid}  ${s.name}`);
+    console.error();
+    process.exit(1);
+  }
+  console.error(`
+\u274C \u672A\u627E\u5230\u7AD9\u70B9\u300C${key}\u300D\u3002\u5148\u8FD0\u884C siluzan-website sites list \u786E\u8BA4 guid\u3002
+`);
+  process.exit(1);
+}
+async function runSitesList(options) {
+  const config = loadConfig();
+  let sites;
+  try {
+    sites = await fetchMySites(config, { query: options.query, verbose: options.verbose });
+  } catch (e) {
+    console.error(`
+\u274C \u83B7\u53D6\u7AD9\u70B9\u5217\u8868\u5931\u8D25\uFF1A${e.message}`);
+    if (!options.verbose) console.error("   \u52A0 --verbose \u53EF\u67E5\u770B\u8BE6\u7EC6\u9519\u8BEF");
+    process.exit(1);
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ total: sites.length, sites }, null, 2));
+    return;
+  }
+  if (sites.length === 0) {
+    console.log("\n\u5F53\u524D\u8D26\u53F7\u4E0B\u6CA1\u6709 WordPress \u7AD9\u70B9\u3002");
+    return;
+  }
+  const columns = [
+    { key: "guid", header: "guid" },
+    { key: "name", header: "\u540D\u79F0" },
+    { key: "region", header: "\u533A\u57DF" },
+    { key: "siteState", header: "\u72B6\u6001" },
+    { key: "url", header: "\u5E73\u53F0\u5730\u5740" }
+  ];
+  const rows = sites.map((s) => ({
+    guid: s.guid,
+    name: s.name,
+    region: s.region,
+    siteState: s.siteState || "-",
+    url: s.url || "-"
+  }));
+  console.log(`
+\u7AD9\u70B9\u5217\u8868\uFF08\u5171 ${sites.length} \u4E2A\uFF09
+`);
+  printCliTable(rows, columns);
+  console.log("\n\u540E\u7EED\uFF1Asiluzan-website pages list --site <guid>\n");
+}
+function register5(program2) {
+  const sites = program2.command("sites").description("WordPress \u7AD9\u70B9\u67E5\u8BE2");
+  sites.command("list").description("\u5217\u51FA\u5F53\u524D\u8D26\u53F7\u4E0B\u7684 WordPress \u7AD9\u70B9").option("-q, --query <keyword>", "\u6309\u540D\u79F0\u641C\u7D22").option("--json", "\u8F93\u51FA JSON", false).option("--verbose", "\u8F93\u51FA\u8BF7\u6C42\u8BE6\u60C5", false).action(async (opts) => {
+    await runSitesList(opts);
+  });
+}
+
+// src/commands/pages.ts
+import * as fs6 from "fs";
+function pageTitle(page) {
+  if (typeof page.title === "string") return page.title;
+  return page.title?.rendered ?? "";
+}
+function readTextOption(inline, filePath) {
+  if (filePath) {
+    try {
+      return fs6.readFileSync(filePath, "utf8");
+    } catch (e) {
+      console.error(`
+\u274C \u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6 ${filePath}\uFF1A${e.message}
+`);
+      process.exit(1);
+    }
+  }
+  return inline ?? "";
+}
+async function runPagesList(opts) {
+  const config = loadConfig();
+  const site = await resolveSite(config, opts);
+  const base = trimTrailingSlash(site.url);
+  const api = `${base}/wp-json/wp/v2/pages?per_page=100&status=publish,draft,private,pending`;
+  let pages;
+  try {
+    pages = await apiFetch2(api, config, {}, opts.verbose);
+  } catch (e) {
+    console.error(`
+\u274C \u83B7\u53D6\u9875\u9762\u5931\u8D25\uFF1A${e.message}`);
+    console.error(`   \u7AD9\u70B9\uFF1A${base}`);
+    process.exit(1);
+    return;
+  }
+  if (!Array.isArray(pages)) {
+    console.error("\n\u274C \u7AD9\u70B9\u8FD4\u56DE\u7684\u9875\u9762\u5217\u8868\u683C\u5F0F\u5F02\u5E38\n");
+    process.exit(1);
+  }
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          site: { guid: site.guid, name: site.name, url: site.url },
+          total: pages.length,
+          pages: pages.map((p) => ({
+            id: p.id,
+            title: pageTitle(p),
+            slug: p.slug ?? "",
+            status: p.status ?? "",
+            link: p.link ?? "",
+            modified: p.modified ?? ""
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (pages.length === 0) {
+    console.log(`
+\u7AD9\u70B9 ${site.name} \u6682\u65E0\u9875\u9762\u3002\u53EF\u7528 pages add \u65B0\u589E\u3002
+`);
+    return;
+  }
+  const columns = [
+    { key: "id", header: "id" },
+    { key: "title", header: "\u6807\u9898" },
+    { key: "status", header: "\u72B6\u6001" },
+    { key: "link", header: "\u94FE\u63A5" }
+  ];
+  console.log(`
+${site.name} \u9875\u9762\uFF08${pages.length}\uFF09
+`);
+  printCliTable(
+    pages.map((p) => ({
+      id: String(p.id),
+      title: pageTitle(p) || "(\u65E0\u6807\u9898)",
+      status: p.status ?? "-",
+      link: p.link ?? "-"
+    })),
+    columns
+  );
+  console.log();
+}
+async function runPagesWrite(mode, opts) {
+  const config = loadConfig();
+  const site = await resolveSite(config, opts);
+  const base = trimTrailingSlash(site.url);
+  const title = opts.title?.trim() ?? "";
+  const content = readTextOption(opts.content, opts.contentFile);
+  if (mode === "add" && !title) {
+    console.error("\n\u274C \u65B0\u589E\u9875\u9762\u5FC5\u987B\u63D0\u4F9B --title\n");
+    process.exit(1);
+  }
+  if (!content.trim()) {
+    console.error("\n\u274C \u8BF7\u7528 --content \u6216 --content-file \u63D0\u4F9B HTML \u6B63\u6587\n");
+    process.exit(1);
+  }
+  const body = {
+    content,
+    import_mode: "preserve"
+  };
+  if (title) body.title = title;
+  const css = readTextOption(opts.css, opts.cssFile);
+  if (css) body._custom_css = css;
+  const js = readTextOption(opts.js, opts.jsFile);
+  if (js) body._custom_javascript = js;
+  if (mode === "add") body.post_type = opts.postType?.trim() || "page";
+  const api = mode === "add" ? `${base}/wp-json/zionbuilder/v1/pages/add-visual-edit` : `${base}/wp-json/zionbuilder/v1/pages/${opts.id}/save-visual-edit`;
+  if (mode === "update" && !opts.id) {
+    console.error("\n\u274C \u66F4\u65B0\u9875\u9762\u5FC5\u987B\u63D0\u4F9B --id\uFF08\u5148 pages list \u67E5 id\uFF09\n");
+    process.exit(1);
+  }
+  let result;
+  try {
+    result = await apiFetch2(
+      api,
+      config,
+      { method: "POST", body: JSON.stringify(body) },
+      opts.verbose
+    );
+  } catch (e) {
+    console.error(`
+\u274C ${mode === "add" ? "\u65B0\u589E" : "\u66F4\u65B0"}\u9875\u9762\u5931\u8D25\uFF1A${e.message}
+`);
+    process.exit(1);
+    return;
+  }
+  if (result.error || result.success === false) {
+    console.error(`
+\u274C ${result.error || result.message || "\u7AD9\u70B9\u62D2\u7EDD\u4FDD\u5B58"}
+`);
+    process.exit(1);
+  }
+  console.log(mode === "add" ? "\n\u2705 \u9875\u9762\u5DF2\u521B\u5EFA" : "\n\u2705 \u9875\u9762\u5DF2\u66F4\u65B0");
+  if (result.post_id) console.log(`   post_id : ${result.post_id}`);
+  if (result.url) console.log(`   url     : ${result.url}`);
+  console.log(`   \u7AD9\u70B9    : ${base}
+`);
+}
+function register6(program2) {
+  const pages = program2.command("pages").description("WordPress \u9875\u9762\uFF08zionbuilder visual-edit\uFF09");
+  pages.command("list").description("\u5217\u51FA\u7AD9\u70B9\u9875\u9762").option("-s, --site <guidOrName>", "\u7AD9\u70B9 guid \u6216\u540D\u79F0").option("--url <url>", "\u76F4\u63A5\u6307\u5B9A\u7AD9\u70B9\u5730\u5740\uFF08\u8DF3\u8FC7 all-sites\uFF09").option("--json", "\u8F93\u51FA JSON", false).option("--verbose", "\u8F93\u51FA\u8BF7\u6C42\u8BE6\u60C5", false).action(async (opts) => {
+    await runPagesList(opts);
+  });
+  pages.command("add").description("\u7528 HTML \u65B0\u589E\u9875\u9762\uFF08\u8D70 add-visual-edit\uFF0C\u4F1A\u76F4\u63A5\u53D1\u5E03\uFF09").option("-s, --site <guidOrName>", "\u7AD9\u70B9 guid \u6216\u540D\u79F0").option("--url <url>", "\u76F4\u63A5\u6307\u5B9A\u7AD9\u70B9\u5730\u5740").option("-t, --title <title>", "\u9875\u9762\u6807\u9898").option("-c, --content <html>", "HTML \u6B63\u6587").option("--content-file <path>", "\u4ECE\u6587\u4EF6\u8BFB\u53D6 HTML \u6B63\u6587").option("--css <css>", "\u9644\u52A0 CSS").option("--css-file <path>", "\u4ECE\u6587\u4EF6\u8BFB\u53D6 CSS").option("--js <js>", "\u9644\u52A0 JS").option("--js-file <path>", "\u4ECE\u6587\u4EF6\u8BFB\u53D6 JS").option("--post-type <type>", "\u6587\u7AE0\u7C7B\u578B\uFF0C\u9ED8\u8BA4 page", "page").option("--verbose", "\u8F93\u51FA\u8BF7\u6C42\u8BE6\u60C5", false).action(async (opts) => {
+    await runPagesWrite("add", opts);
+  });
+  pages.command("update").description("\u7528 HTML \u8986\u76D6\u5DF2\u6709\u9875\u9762\uFF08\u8D70 save-visual-edit\uFF0C\u4F1A\u76F4\u63A5\u53D1\u5E03\uFF09").option("-s, --site <guidOrName>", "\u7AD9\u70B9 guid \u6216\u540D\u79F0").option("--url <url>", "\u76F4\u63A5\u6307\u5B9A\u7AD9\u70B9\u5730\u5740").requiredOption("--id <id>", "\u9875\u9762 ID").option("-t, --title <title>", "\u65B0\u6807\u9898\uFF08\u53EF\u7701\u7565\uFF09").option("-c, --content <html>", "HTML \u6B63\u6587").option("--content-file <path>", "\u4ECE\u6587\u4EF6\u8BFB\u53D6 HTML \u6B63\u6587").option("--css <css>", "\u9644\u52A0 CSS").option("--css-file <path>", "\u4ECE\u6587\u4EF6\u8BFB\u53D6 CSS").option("--js <js>", "\u9644\u52A0 JS").option("--js-file <path>", "\u4ECE\u6587\u4EF6\u8BFB\u53D6 JS").option("--verbose", "\u8F93\u51FA\u8BF7\u6C42\u8BE6\u60C5", false).action(async (opts) => {
+    await runPagesWrite("update", opts);
+  });
+}
+
+// src/commands/plugins.ts
+function pluginName(item) {
+  if (typeof item.name === "string") return item.name;
+  return item.name?.raw || item.name?.rendered || item.plugin || "";
+}
+async function resolveTarget(opts) {
+  const config = loadConfig();
+  const site = await resolveSite(config, opts);
+  return { config, site, base: trimTrailingSlash(site.url) };
+}
+async function runPluginsList(opts) {
+  const { config, site, base } = await resolveTarget(opts);
+  const api = `${base}/wp-json/wp/v2/plugins`;
+  let plugins;
+  try {
+    plugins = await apiFetch2(api, config, {}, opts.verbose);
+  } catch (e) {
+    console.error(`
+\u274C \u83B7\u53D6\u5DF2\u88C5\u63D2\u4EF6\u5931\u8D25\uFF1A${e.message}
+`);
+    process.exit(1);
+    return;
+  }
+  if (!Array.isArray(plugins)) {
+    console.error("\n\u274C \u7AD9\u70B9\u8FD4\u56DE\u7684\u63D2\u4EF6\u5217\u8868\u683C\u5F0F\u5F02\u5E38\n");
+    process.exit(1);
+  }
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          site: { guid: site.guid, name: site.name, url: site.url },
+          total: plugins.length,
+          plugins: plugins.map((p) => ({
+            plugin: p.plugin ?? "",
+            name: pluginName(p),
+            status: p.status ?? "",
+            version: p.version ?? ""
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (plugins.length === 0) {
+    console.log(`
+\u7AD9\u70B9 ${site.name} \u672A\u8FD4\u56DE\u63D2\u4EF6\u3002
+`);
+    return;
+  }
+  const columns = [
+    { key: "plugin", header: "plugin" },
+    { key: "name", header: "\u540D\u79F0" },
+    { key: "status", header: "\u72B6\u6001" },
+    { key: "version", header: "\u7248\u672C" }
+  ];
+  console.log(`
+${site.name} \u5DF2\u88C5\u63D2\u4EF6\uFF08${plugins.length}\uFF09
+`);
+  printCliTable(
+    plugins.map((p) => ({
+      plugin: p.plugin ?? "-",
+      name: pluginName(p) || "-",
+      status: p.status ?? "-",
+      version: p.version ?? "-"
+    })),
+    columns
+  );
+  console.log();
+}
+async function runPluginsCatalog(opts) {
+  const { config, site, base } = await resolveTarget(opts);
+  const api = `${base}/wp-json/siluzan-helper/v1/plugins/catalog`;
+  let res;
+  try {
+    res = await apiFetch2(api, config, {}, opts.verbose);
+  } catch (e) {
+    console.error(`
+\u274C \u83B7\u53D6\u63D2\u4EF6\u76EE\u5F55\u5931\u8D25\uFF1A${e.message}`);
+    console.error("   \u9700\u8981\u7AD9\u70B9\u5DF2\u90E8\u7F72\u5E26 REST \u7684 siluzan-helper-plugin\u3002\n");
+    process.exit(1);
+    return;
+  }
+  const items = Array.isArray(res.items) ? res.items : [];
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        { site: { guid: site.guid, name: site.name, url: site.url }, total: items.length, items },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (items.length === 0) {
+    console.log(`
+\u7AD9\u70B9 ${site.name} \u7684\u4E1D\u8DEF\u8D5E\u63D2\u4EF6\u76EE\u5F55\u4E3A\u7A7A\u3002
+`);
+    return;
+  }
+  const columns = [
+    { key: "slug", header: "slug" },
+    { key: "name", header: "\u540D\u79F0" },
+    { key: "new_version", header: "\u76EE\u5F55\u7248\u672C" },
+    { key: "installed", header: "\u5DF2\u88C5" },
+    { key: "active", header: "\u542F\u7528" }
+  ];
+  console.log(`
+${site.name} \u53EF\u5B89\u88C5\u76EE\u5F55\uFF08${items.length}\uFF09
+`);
+  printCliTable(
+    items.map((p) => ({
+      slug: p.slug || p.plugin || "-",
+      name: p.name || "-",
+      new_version: p.new_version || "-",
+      installed: p.installed ? "yes" : "no",
+      active: p.active ? "yes" : "no"
+    })),
+    columns
+  );
+  console.log("\n\u5B89\u88C5\uFF1Asiluzan-website plugins install --site <guid> --slug <slug>\n");
+}
+async function runPluginsInstall(opts) {
+  const slug = opts.slug?.trim() ?? "";
+  if (!slug) {
+    console.error("\n\u274C \u8BF7\u63D0\u4F9B --slug\uFF08\u5148 plugins catalog \u67E5\u770B\u53EF\u88C5\u5217\u8868\uFF09\n");
+    process.exit(1);
+  }
+  const { config, site, base } = await resolveTarget(opts);
+  const api = `${base}/wp-json/siluzan-helper/v1/plugins/install`;
+  let result;
+  try {
+    result = await apiFetch2(
+      api,
+      config,
+      { method: "POST", body: JSON.stringify({ slug }) },
+      opts.verbose
+    );
+  } catch (e) {
+    console.error(`
+\u274C \u5B89\u88C5\u5931\u8D25\uFF1A${e.message}
+`);
+    process.exit(1);
+    return;
+  }
+  if (!result.success) {
+    console.error(`
+\u274C ${result.message || "\u5B89\u88C5\u88AB\u7AD9\u70B9\u62D2\u7EDD"}
+`);
+    process.exit(1);
+  }
+  console.log(result.already ? "\n\u2705 \u63D2\u4EF6\u5DF2\u5728\u7AD9\u70B9\u4E0A\uFF08\u5DF2\u542F\u7528\uFF09" : "\n\u2705 \u63D2\u4EF6\u5DF2\u5B89\u88C5\u5E76\u542F\u7528");
+  if (result.plugin) console.log(`   plugin : ${result.plugin}`);
+  if (result.message) console.log(`   \u8BF4\u660E   : ${result.message}`);
+  console.log(`   \u7AD9\u70B9   : ${site.name} (${base})
+`);
+  try {
+    await runPluginsList({ site: site.guid || opts.site, url: site.url, verbose: opts.verbose });
+  } catch {
+  }
+}
+function register7(program2) {
+  const plugins = program2.command("plugins").description("WordPress \u63D2\u4EF6\uFF1A\u5217\u51FA\u3001\u76EE\u5F55\u3001\u5B89\u88C5");
+  plugins.command("list").description("\u5217\u51FA\u7AD9\u70B9\u5DF2\u5B89\u88C5\u63D2\u4EF6").option("-s, --site <guidOrName>", "\u7AD9\u70B9 guid \u6216\u540D\u79F0").option("--url <url>", "\u76F4\u63A5\u6307\u5B9A\u7AD9\u70B9\u5730\u5740").option("--json", "\u8F93\u51FA JSON", false).option("--verbose", "\u8F93\u51FA\u8BF7\u6C42\u8BE6\u60C5", false).action(async (opts) => {
+    await runPluginsList(opts);
+  });
+  plugins.command("catalog").description("\u5217\u51FA\u4E1D\u8DEF\u8D5E\u63D2\u4EF6\u76EE\u5F55\uFF08\u53EF\u5B89\u88C5\u5217\u8868\uFF09").option("-s, --site <guidOrName>", "\u7AD9\u70B9 guid \u6216\u540D\u79F0").option("--url <url>", "\u76F4\u63A5\u6307\u5B9A\u7AD9\u70B9\u5730\u5740").option("--json", "\u8F93\u51FA JSON", false).option("--verbose", "\u8F93\u51FA\u8BF7\u6C42\u8BE6\u60C5", false).action(async (opts) => {
+    await runPluginsCatalog(opts);
+  });
+  plugins.command("install").description("\u4ECE\u4E1D\u8DEF\u8D5E\u76EE\u5F55\u5B89\u88C5\u5E76\u542F\u7528\u63D2\u4EF6\uFF08\u5199\u64CD\u4F5C\uFF0C\u4F1A\u7ACB\u523B\u751F\u6548\uFF09").option("-s, --site <guidOrName>", "\u7AD9\u70B9 guid \u6216\u540D\u79F0").option("--url <url>", "\u76F4\u63A5\u6307\u5B9A\u7AD9\u70B9\u5730\u5740").requiredOption("--slug <slug>", "\u76EE\u5F55\u4E2D\u7684 slug \u6216 plugin \u8DEF\u5F84").option("--verbose", "\u8F93\u51FA\u8BF7\u6C42\u8BE6\u60C5", false).action(async (opts) => {
+    await runPluginsInstall(opts);
+  });
+}
+
+// src/index.ts
+installProcessHandlers();
+var program = new Command();
+program.name("siluzan-website").description("Siluzan WordPress \u7AD9\u70B9\u7BA1\u7406\uFF1A\u5217\u51FA\u7AD9\u70B9\u3001\u65B0\u589E/\u7F16\u8F91\u9875\u9762\u3001\u67E5\u770B\u63D2\u4EF6").version(getCurrentVersion2());
+var REGISTRARS = [
+  register,
+  register2,
+  register3,
+  register4,
+  register5,
+  register6,
+  register7
+];
+for (const reg of REGISTRARS) reg(program);
+program.parse();
+var activeCmd = process.argv[2];
+if (activeCmd !== "update") {
+  notifyIfOutdated().catch(() => {
+  });
+}