weacpx 0.1.0

package/dist/cli.js

@@ -0,0 +1,3224 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRMode.js
+var require_QRMode = __commonJS((exports, module) => {
+  module.exports = {
+    MODE_NUMBER: 1 << 0,
+    MODE_ALPHA_NUM: 1 << 1,
+    MODE_8BIT_BYTE: 1 << 2,
+    MODE_KANJI: 1 << 3
+  };
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QR8bitByte.js
+var require_QR8bitByte = __commonJS((exports, module) => {
+  var QRMode = require_QRMode();
+  function QR8bitByte(data) {
+    this.mode = QRMode.MODE_8BIT_BYTE;
+    this.data = data;
+  }
+  QR8bitByte.prototype = {
+    getLength: function() {
+      return this.data.length;
+    },
+    write: function(buffer) {
+      for (var i = 0;i < this.data.length; i++) {
+        buffer.put(this.data.charCodeAt(i), 8);
+      }
+    }
+  };
+  module.exports = QR8bitByte;
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRMath.js
+var require_QRMath = __commonJS((exports, module) => {
+  var QRMath = {
+    glog: function(n) {
+      if (n < 1) {
+        throw new Error("glog(" + n + ")");
+      }
+      return QRMath.LOG_TABLE[n];
+    },
+    gexp: function(n) {
+      while (n < 0) {
+        n += 255;
+      }
+      while (n >= 256) {
+        n -= 255;
+      }
+      return QRMath.EXP_TABLE[n];
+    },
+    EXP_TABLE: new Array(256),
+    LOG_TABLE: new Array(256)
+  };
+  for (i = 0;i < 8; i++) {
+    QRMath.EXP_TABLE[i] = 1 << i;
+  }
+  var i;
+  for (i = 8;i < 256; i++) {
+    QRMath.EXP_TABLE[i] = QRMath.EXP_TABLE[i - 4] ^ QRMath.EXP_TABLE[i - 5] ^ QRMath.EXP_TABLE[i - 6] ^ QRMath.EXP_TABLE[i - 8];
+  }
+  var i;
+  for (i = 0;i < 255; i++) {
+    QRMath.LOG_TABLE[QRMath.EXP_TABLE[i]] = i;
+  }
+  var i;
+  module.exports = QRMath;
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRPolynomial.js
+var require_QRPolynomial = __commonJS((exports, module) => {
+  var QRMath = require_QRMath();
+  function QRPolynomial(num, shift) {
+    if (num.length === undefined) {
+      throw new Error(num.length + "/" + shift);
+    }
+    var offset = 0;
+    while (offset < num.length && num[offset] === 0) {
+      offset++;
+    }
+    this.num = new Array(num.length - offset + shift);
+    for (var i = 0;i < num.length - offset; i++) {
+      this.num[i] = num[i + offset];
+    }
+  }
+  QRPolynomial.prototype = {
+    get: function(index) {
+      return this.num[index];
+    },
+    getLength: function() {
+      return this.num.length;
+    },
+    multiply: function(e) {
+      var num = new Array(this.getLength() + e.getLength() - 1);
+      for (var i = 0;i < this.getLength(); i++) {
+        for (var j = 0;j < e.getLength(); j++) {
+          num[i + j] ^= QRMath.gexp(QRMath.glog(this.get(i)) + QRMath.glog(e.get(j)));
+        }
+      }
+      return new QRPolynomial(num, 0);
+    },
+    mod: function(e) {
+      if (this.getLength() - e.getLength() < 0) {
+        return this;
+      }
+      var ratio = QRMath.glog(this.get(0)) - QRMath.glog(e.get(0));
+      var num = new Array(this.getLength());
+      for (var i = 0;i < this.getLength(); i++) {
+        num[i] = this.get(i);
+      }
+      for (var x = 0;x < e.getLength(); x++) {
+        num[x] ^= QRMath.gexp(QRMath.glog(e.get(x)) + ratio);
+      }
+      return new QRPolynomial(num, 0).mod(e);
+    }
+  };
+  module.exports = QRPolynomial;
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRMaskPattern.js
+var require_QRMaskPattern = __commonJS((exports, module) => {
+  module.exports = {
+    PATTERN000: 0,
+    PATTERN001: 1,
+    PATTERN010: 2,
+    PATTERN011: 3,
+    PATTERN100: 4,
+    PATTERN101: 5,
+    PATTERN110: 6,
+    PATTERN111: 7
+  };
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRUtil.js
+var require_QRUtil = __commonJS((exports, module) => {
+  var QRMode = require_QRMode();
+  var QRPolynomial = require_QRPolynomial();
+  var QRMath = require_QRMath();
+  var QRMaskPattern = require_QRMaskPattern();
+  var QRUtil = {
+    PATTERN_POSITION_TABLE: [
+      [],
+      [6, 18],
+      [6, 22],
+      [6, 26],
+      [6, 30],
+      [6, 34],
+      [6, 22, 38],
+      [6, 24, 42],
+      [6, 26, 46],
+      [6, 28, 50],
+      [6, 30, 54],
+      [6, 32, 58],
+      [6, 34, 62],
+      [6, 26, 46, 66],
+      [6, 26, 48, 70],
+      [6, 26, 50, 74],
+      [6, 30, 54, 78],
+      [6, 30, 56, 82],
+      [6, 30, 58, 86],
+      [6, 34, 62, 90],
+      [6, 28, 50, 72, 94],
+      [6, 26, 50, 74, 98],
+      [6, 30, 54, 78, 102],
+      [6, 28, 54, 80, 106],
+      [6, 32, 58, 84, 110],
+      [6, 30, 58, 86, 114],
+      [6, 34, 62, 90, 118],
+      [6, 26, 50, 74, 98, 122],
+      [6, 30, 54, 78, 102, 126],
+      [6, 26, 52, 78, 104, 130],
+      [6, 30, 56, 82, 108, 134],
+      [6, 34, 60, 86, 112, 138],
+      [6, 30, 58, 86, 114, 142],
+      [6, 34, 62, 90, 118, 146],
+      [6, 30, 54, 78, 102, 126, 150],
+      [6, 24, 50, 76, 102, 128, 154],
+      [6, 28, 54, 80, 106, 132, 158],
+      [6, 32, 58, 84, 110, 136, 162],
+      [6, 26, 54, 82, 110, 138, 166],
+      [6, 30, 58, 86, 114, 142, 170]
+    ],
+    G15: 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0,
+    G18: 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0,
+    G15_MASK: 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1,
+    getBCHTypeInfo: function(data) {
+      var d = data << 10;
+      while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15) >= 0) {
+        d ^= QRUtil.G15 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15);
+      }
+      return (data << 10 | d) ^ QRUtil.G15_MASK;
+    },
+    getBCHTypeNumber: function(data) {
+      var d = data << 12;
+      while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18) >= 0) {
+        d ^= QRUtil.G18 << QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18);
+      }
+      return data << 12 | d;
+    },
+    getBCHDigit: function(data) {
+      var digit = 0;
+      while (data !== 0) {
+        digit++;
+        data >>>= 1;
+      }
+      return digit;
+    },
+    getPatternPosition: function(typeNumber) {
+      return QRUtil.PATTERN_POSITION_TABLE[typeNumber - 1];
+    },
+    getMask: function(maskPattern, i, j) {
+      switch (maskPattern) {
+        case QRMaskPattern.PATTERN000:
+          return (i + j) % 2 === 0;
+        case QRMaskPattern.PATTERN001:
+          return i % 2 === 0;
+        case QRMaskPattern.PATTERN010:
+          return j % 3 === 0;
+        case QRMaskPattern.PATTERN011:
+          return (i + j) % 3 === 0;
+        case QRMaskPattern.PATTERN100:
+          return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
+        case QRMaskPattern.PATTERN101:
+          return i * j % 2 + i * j % 3 === 0;
+        case QRMaskPattern.PATTERN110:
+          return (i * j % 2 + i * j % 3) % 2 === 0;
+        case QRMaskPattern.PATTERN111:
+          return (i * j % 3 + (i + j) % 2) % 2 === 0;
+        default:
+          throw new Error("bad maskPattern:" + maskPattern);
+      }
+    },
+    getErrorCorrectPolynomial: function(errorCorrectLength) {
+      var a = new QRPolynomial([1], 0);
+      for (var i = 0;i < errorCorrectLength; i++) {
+        a = a.multiply(new QRPolynomial([1, QRMath.gexp(i)], 0));
+      }
+      return a;
+    },
+    getLengthInBits: function(mode, type) {
+      if (1 <= type && type < 10) {
+        switch (mode) {
+          case QRMode.MODE_NUMBER:
+            return 10;
+          case QRMode.MODE_ALPHA_NUM:
+            return 9;
+          case QRMode.MODE_8BIT_BYTE:
+            return 8;
+          case QRMode.MODE_KANJI:
+            return 8;
+          default:
+            throw new Error("mode:" + mode);
+        }
+      } else if (type < 27) {
+        switch (mode) {
+          case QRMode.MODE_NUMBER:
+            return 12;
+          case QRMode.MODE_ALPHA_NUM:
+            return 11;
+          case QRMode.MODE_8BIT_BYTE:
+            return 16;
+          case QRMode.MODE_KANJI:
+            return 10;
+          default:
+            throw new Error("mode:" + mode);
+        }
+      } else if (type < 41) {
+        switch (mode) {
+          case QRMode.MODE_NUMBER:
+            return 14;
+          case QRMode.MODE_ALPHA_NUM:
+            return 13;
+          case QRMode.MODE_8BIT_BYTE:
+            return 16;
+          case QRMode.MODE_KANJI:
+            return 12;
+          default:
+            throw new Error("mode:" + mode);
+        }
+      } else {
+        throw new Error("type:" + type);
+      }
+    },
+    getLostPoint: function(qrCode) {
+      var moduleCount = qrCode.getModuleCount();
+      var lostPoint = 0;
+      var row = 0;
+      var col = 0;
+      for (row = 0;row < moduleCount; row++) {
+        for (col = 0;col < moduleCount; col++) {
+          var sameCount = 0;
+          var dark = qrCode.isDark(row, col);
+          for (var r = -1;r <= 1; r++) {
+            if (row + r < 0 || moduleCount <= row + r) {
+              continue;
+            }
+            for (var c = -1;c <= 1; c++) {
+              if (col + c < 0 || moduleCount <= col + c) {
+                continue;
+              }
+              if (r === 0 && c === 0) {
+                continue;
+              }
+              if (dark === qrCode.isDark(row + r, col + c)) {
+                sameCount++;
+              }
+            }
+          }
+          if (sameCount > 5) {
+            lostPoint += 3 + sameCount - 5;
+          }
+        }
+      }
+      for (row = 0;row < moduleCount - 1; row++) {
+        for (col = 0;col < moduleCount - 1; col++) {
+          var count = 0;
+          if (qrCode.isDark(row, col))
+            count++;
+          if (qrCode.isDark(row + 1, col))
+            count++;
+          if (qrCode.isDark(row, col + 1))
+            count++;
+          if (qrCode.isDark(row + 1, col + 1))
+            count++;
+          if (count === 0 || count === 4) {
+            lostPoint += 3;
+          }
+        }
+      }
+      for (row = 0;row < moduleCount; row++) {
+        for (col = 0;col < moduleCount - 6; col++) {
+          if (qrCode.isDark(row, col) && !qrCode.isDark(row, col + 1) && qrCode.isDark(row, col + 2) && qrCode.isDark(row, col + 3) && qrCode.isDark(row, col + 4) && !qrCode.isDark(row, col + 5) && qrCode.isDark(row, col + 6)) {
+            lostPoint += 40;
+          }
+        }
+      }
+      for (col = 0;col < moduleCount; col++) {
+        for (row = 0;row < moduleCount - 6; row++) {
+          if (qrCode.isDark(row, col) && !qrCode.isDark(row + 1, col) && qrCode.isDark(row + 2, col) && qrCode.isDark(row + 3, col) && qrCode.isDark(row + 4, col) && !qrCode.isDark(row + 5, col) && qrCode.isDark(row + 6, col)) {
+            lostPoint += 40;
+          }
+        }
+      }
+      var darkCount = 0;
+      for (col = 0;col < moduleCount; col++) {
+        for (row = 0;row < moduleCount; row++) {
+          if (qrCode.isDark(row, col)) {
+            darkCount++;
+          }
+        }
+      }
+      var ratio = Math.abs(100 * darkCount / moduleCount / moduleCount - 50) / 5;
+      lostPoint += ratio * 10;
+      return lostPoint;
+    }
+  };
+  module.exports = QRUtil;
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel.js
+var require_QRErrorCorrectLevel = __commonJS((exports, module) => {
+  module.exports = {
+    L: 1,
+    M: 0,
+    Q: 3,
+    H: 2
+  };
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRRSBlock.js
+var require_QRRSBlock = __commonJS((exports, module) => {
+  var QRErrorCorrectLevel = require_QRErrorCorrectLevel();
+  function QRRSBlock(totalCount, dataCount) {
+    this.totalCount = totalCount;
+    this.dataCount = dataCount;
+  }
+  QRRSBlock.RS_BLOCK_TABLE = [
+    [1, 26, 19],
+    [1, 26, 16],
+    [1, 26, 13],
+    [1, 26, 9],
+    [1, 44, 34],
+    [1, 44, 28],
+    [1, 44, 22],
+    [1, 44, 16],
+    [1, 70, 55],
+    [1, 70, 44],
+    [2, 35, 17],
+    [2, 35, 13],
+    [1, 100, 80],
+    [2, 50, 32],
+    [2, 50, 24],
+    [4, 25, 9],
+    [1, 134, 108],
+    [2, 67, 43],
+    [2, 33, 15, 2, 34, 16],
+    [2, 33, 11, 2, 34, 12],
+    [2, 86, 68],
+    [4, 43, 27],
+    [4, 43, 19],
+    [4, 43, 15],
+    [2, 98, 78],
+    [4, 49, 31],
+    [2, 32, 14, 4, 33, 15],
+    [4, 39, 13, 1, 40, 14],
+    [2, 121, 97],
+    [2, 60, 38, 2, 61, 39],
+    [4, 40, 18, 2, 41, 19],
+    [4, 40, 14, 2, 41, 15],
+    [2, 146, 116],
+    [3, 58, 36, 2, 59, 37],
+    [4, 36, 16, 4, 37, 17],
+    [4, 36, 12, 4, 37, 13],
+    [2, 86, 68, 2, 87, 69],
+    [4, 69, 43, 1, 70, 44],
+    [6, 43, 19, 2, 44, 20],
+    [6, 43, 15, 2, 44, 16],
+    [4, 101, 81],
+    [1, 80, 50, 4, 81, 51],
+    [4, 50, 22, 4, 51, 23],
+    [3, 36, 12, 8, 37, 13],
+    [2, 116, 92, 2, 117, 93],
+    [6, 58, 36, 2, 59, 37],
+    [4, 46, 20, 6, 47, 21],
+    [7, 42, 14, 4, 43, 15],
+    [4, 133, 107],
+    [8, 59, 37, 1, 60, 38],
+    [8, 44, 20, 4, 45, 21],
+    [12, 33, 11, 4, 34, 12],
+    [3, 145, 115, 1, 146, 116],
+    [4, 64, 40, 5, 65, 41],
+    [11, 36, 16, 5, 37, 17],
+    [11, 36, 12, 5, 37, 13],
+    [5, 109, 87, 1, 110, 88],
+    [5, 65, 41, 5, 66, 42],
+    [5, 54, 24, 7, 55, 25],
+    [11, 36, 12],
+    [5, 122, 98, 1, 123, 99],
+    [7, 73, 45, 3, 74, 46],
+    [15, 43, 19, 2, 44, 20],
+    [3, 45, 15, 13, 46, 16],
+    [1, 135, 107, 5, 136, 108],
+    [10, 74, 46, 1, 75, 47],
+    [1, 50, 22, 15, 51, 23],
+    [2, 42, 14, 17, 43, 15],
+    [5, 150, 120, 1, 151, 121],
+    [9, 69, 43, 4, 70, 44],
+    [17, 50, 22, 1, 51, 23],
+    [2, 42, 14, 19, 43, 15],
+    [3, 141, 113, 4, 142, 114],
+    [3, 70, 44, 11, 71, 45],
+    [17, 47, 21, 4, 48, 22],
+    [9, 39, 13, 16, 40, 14],
+    [3, 135, 107, 5, 136, 108],
+    [3, 67, 41, 13, 68, 42],
+    [15, 54, 24, 5, 55, 25],
+    [15, 43, 15, 10, 44, 16],
+    [4, 144, 116, 4, 145, 117],
+    [17, 68, 42],
+    [17, 50, 22, 6, 51, 23],
+    [19, 46, 16, 6, 47, 17],
+    [2, 139, 111, 7, 140, 112],
+    [17, 74, 46],
+    [7, 54, 24, 16, 55, 25],
+    [34, 37, 13],
+    [4, 151, 121, 5, 152, 122],
+    [4, 75, 47, 14, 76, 48],
+    [11, 54, 24, 14, 55, 25],
+    [16, 45, 15, 14, 46, 16],
+    [6, 147, 117, 4, 148, 118],
+    [6, 73, 45, 14, 74, 46],
+    [11, 54, 24, 16, 55, 25],
+    [30, 46, 16, 2, 47, 17],
+    [8, 132, 106, 4, 133, 107],
+    [8, 75, 47, 13, 76, 48],
+    [7, 54, 24, 22, 55, 25],
+    [22, 45, 15, 13, 46, 16],
+    [10, 142, 114, 2, 143, 115],
+    [19, 74, 46, 4, 75, 47],
+    [28, 50, 22, 6, 51, 23],
+    [33, 46, 16, 4, 47, 17],
+    [8, 152, 122, 4, 153, 123],
+    [22, 73, 45, 3, 74, 46],
+    [8, 53, 23, 26, 54, 24],
+    [12, 45, 15, 28, 46, 16],
+    [3, 147, 117, 10, 148, 118],
+    [3, 73, 45, 23, 74, 46],
+    [4, 54, 24, 31, 55, 25],
+    [11, 45, 15, 31, 46, 16],
+    [7, 146, 116, 7, 147, 117],
+    [21, 73, 45, 7, 74, 46],
+    [1, 53, 23, 37, 54, 24],
+    [19, 45, 15, 26, 46, 16],
+    [5, 145, 115, 10, 146, 116],
+    [19, 75, 47, 10, 76, 48],
+    [15, 54, 24, 25, 55, 25],
+    [23, 45, 15, 25, 46, 16],
+    [13, 145, 115, 3, 146, 116],
+    [2, 74, 46, 29, 75, 47],
+    [42, 54, 24, 1, 55, 25],
+    [23, 45, 15, 28, 46, 16],
+    [17, 145, 115],
+    [10, 74, 46, 23, 75, 47],
+    [10, 54, 24, 35, 55, 25],
+    [19, 45, 15, 35, 46, 16],
+    [17, 145, 115, 1, 146, 116],
+    [14, 74, 46, 21, 75, 47],
+    [29, 54, 24, 19, 55, 25],
+    [11, 45, 15, 46, 46, 16],
+    [13, 145, 115, 6, 146, 116],
+    [14, 74, 46, 23, 75, 47],
+    [44, 54, 24, 7, 55, 25],
+    [59, 46, 16, 1, 47, 17],
+    [12, 151, 121, 7, 152, 122],
+    [12, 75, 47, 26, 76, 48],
+    [39, 54, 24, 14, 55, 25],
+    [22, 45, 15, 41, 46, 16],
+    [6, 151, 121, 14, 152, 122],
+    [6, 75, 47, 34, 76, 48],
+    [46, 54, 24, 10, 55, 25],
+    [2, 45, 15, 64, 46, 16],
+    [17, 152, 122, 4, 153, 123],
+    [29, 74, 46, 14, 75, 47],
+    [49, 54, 24, 10, 55, 25],
+    [24, 45, 15, 46, 46, 16],
+    [4, 152, 122, 18, 153, 123],
+    [13, 74, 46, 32, 75, 47],
+    [48, 54, 24, 14, 55, 25],
+    [42, 45, 15, 32, 46, 16],
+    [20, 147, 117, 4, 148, 118],
+    [40, 75, 47, 7, 76, 48],
+    [43, 54, 24, 22, 55, 25],
+    [10, 45, 15, 67, 46, 16],
+    [19, 148, 118, 6, 149, 119],
+    [18, 75, 47, 31, 76, 48],
+    [34, 54, 24, 34, 55, 25],
+    [20, 45, 15, 61, 46, 16]
+  ];
+  QRRSBlock.getRSBlocks = function(typeNumber, errorCorrectLevel) {
+    var rsBlock = QRRSBlock.getRsBlockTable(typeNumber, errorCorrectLevel);
+    if (rsBlock === undefined) {
+      throw new Error("bad rs block @ typeNumber:" + typeNumber + "/errorCorrectLevel:" + errorCorrectLevel);
+    }
+    var length = rsBlock.length / 3;
+    var list = [];
+    for (var i = 0;i < length; i++) {
+      var count = rsBlock[i * 3 + 0];
+      var totalCount = rsBlock[i * 3 + 1];
+      var dataCount = rsBlock[i * 3 + 2];
+      for (var j = 0;j < count; j++) {
+        list.push(new QRRSBlock(totalCount, dataCount));
+      }
+    }
+    return list;
+  };
+  QRRSBlock.getRsBlockTable = function(typeNumber, errorCorrectLevel) {
+    switch (errorCorrectLevel) {
+      case QRErrorCorrectLevel.L:
+        return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];
+      case QRErrorCorrectLevel.M:
+        return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];
+      case QRErrorCorrectLevel.Q:
+        return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];
+      case QRErrorCorrectLevel.H:
+        return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];
+      default:
+        return;
+    }
+  };
+  module.exports = QRRSBlock;
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRBitBuffer.js
+var require_QRBitBuffer = __commonJS((exports, module) => {
+  function QRBitBuffer() {
+    this.buffer = [];
+    this.length = 0;
+  }
+  QRBitBuffer.prototype = {
+    get: function(index) {
+      var bufIndex = Math.floor(index / 8);
+      return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) == 1;
+    },
+    put: function(num, length) {
+      for (var i = 0;i < length; i++) {
+        this.putBit((num >>> length - i - 1 & 1) == 1);
+      }
+    },
+    getLengthInBits: function() {
+      return this.length;
+    },
+    putBit: function(bit) {
+      var bufIndex = Math.floor(this.length / 8);
+      if (this.buffer.length <= bufIndex) {
+        this.buffer.push(0);
+      }
+      if (bit) {
+        this.buffer[bufIndex] |= 128 >>> this.length % 8;
+      }
+      this.length++;
+    }
+  };
+  module.exports = QRBitBuffer;
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/index.js
+var require_QRCode = __commonJS((exports, module) => {
+  var QR8bitByte = require_QR8bitByte();
+  var QRUtil = require_QRUtil();
+  var QRPolynomial = require_QRPolynomial();
+  var QRRSBlock = require_QRRSBlock();
+  var QRBitBuffer = require_QRBitBuffer();
+  function QRCode(typeNumber, errorCorrectLevel) {
+    this.typeNumber = typeNumber;
+    this.errorCorrectLevel = errorCorrectLevel;
+    this.modules = null;
+    this.moduleCount = 0;
+    this.dataCache = null;
+    this.dataList = [];
+  }
+  QRCode.prototype = {
+    addData: function(data) {
+      var newData = new QR8bitByte(data);
+      this.dataList.push(newData);
+      this.dataCache = null;
+    },
+    isDark: function(row, col) {
+      if (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) {
+        throw new Error(row + "," + col);
+      }
+      return this.modules[row][col];
+    },
+    getModuleCount: function() {
+      return this.moduleCount;
+    },
+    make: function() {
+      if (this.typeNumber < 1) {
+        var typeNumber = 1;
+        for (typeNumber = 1;typeNumber < 40; typeNumber++) {
+          var rsBlocks = QRRSBlock.getRSBlocks(typeNumber, this.errorCorrectLevel);
+          var buffer = new QRBitBuffer;
+          var totalDataCount = 0;
+          for (var i = 0;i < rsBlocks.length; i++) {
+            totalDataCount += rsBlocks[i].dataCount;
+          }
+          for (var x = 0;x < this.dataList.length; x++) {
+            var data = this.dataList[x];
+            buffer.put(data.mode, 4);
+            buffer.put(data.getLength(), QRUtil.getLengthInBits(data.mode, typeNumber));
+            data.write(buffer);
+          }
+          if (buffer.getLengthInBits() <= totalDataCount * 8)
+            break;
+        }
+        this.typeNumber = typeNumber;
+      }
+      this.makeImpl(false, this.getBestMaskPattern());
+    },
+    makeImpl: function(test, maskPattern) {
+      this.moduleCount = this.typeNumber * 4 + 17;
+      this.modules = new Array(this.moduleCount);
+      for (var row = 0;row < this.moduleCount; row++) {
+        this.modules[row] = new Array(this.moduleCount);
+        for (var col = 0;col < this.moduleCount; col++) {
+          this.modules[row][col] = null;
+        }
+      }
+      this.setupPositionProbePattern(0, 0);
+      this.setupPositionProbePattern(this.moduleCount - 7, 0);
+      this.setupPositionProbePattern(0, this.moduleCount - 7);
+      this.setupPositionAdjustPattern();
+      this.setupTimingPattern();
+      this.setupTypeInfo(test, maskPattern);
+      if (this.typeNumber >= 7) {
+        this.setupTypeNumber(test);
+      }
+      if (this.dataCache === null) {
+        this.dataCache = QRCode.createData(this.typeNumber, this.errorCorrectLevel, this.dataList);
+      }
+      this.mapData(this.dataCache, maskPattern);
+    },
+    setupPositionProbePattern: function(row, col) {
+      for (var r = -1;r <= 7; r++) {
+        if (row + r <= -1 || this.moduleCount <= row + r)
+          continue;
+        for (var c = -1;c <= 7; c++) {
+          if (col + c <= -1 || this.moduleCount <= col + c)
+            continue;
+          if (0 <= r && r <= 6 && (c === 0 || c === 6) || 0 <= c && c <= 6 && (r === 0 || r === 6) || 2 <= r && r <= 4 && 2 <= c && c <= 4) {
+            this.modules[row + r][col + c] = true;
+          } else {
+            this.modules[row + r][col + c] = false;
+          }
+        }
+      }
+    },
+    getBestMaskPattern: function() {
+      var minLostPoint = 0;
+      var pattern = 0;
+      for (var i = 0;i < 8; i++) {
+        this.makeImpl(true, i);
+        var lostPoint = QRUtil.getLostPoint(this);
+        if (i === 0 || minLostPoint > lostPoint) {
+          minLostPoint = lostPoint;
+          pattern = i;
+        }
+      }
+      return pattern;
+    },
+    createMovieClip: function(target_mc, instance_name, depth) {
+      var qr_mc = target_mc.createEmptyMovieClip(instance_name, depth);
+      var cs = 1;
+      this.make();
+      for (var row = 0;row < this.modules.length; row++) {
+        var y = row * cs;
+        for (var col = 0;col < this.modules[row].length; col++) {
+          var x = col * cs;
+          var dark = this.modules[row][col];
+          if (dark) {
+            qr_mc.beginFill(0, 100);
+            qr_mc.moveTo(x, y);
+            qr_mc.lineTo(x + cs, y);
+            qr_mc.lineTo(x + cs, y + cs);
+            qr_mc.lineTo(x, y + cs);
+            qr_mc.endFill();
+          }
+        }
+      }
+      return qr_mc;
+    },
+    setupTimingPattern: function() {
+      for (var r = 8;r < this.moduleCount - 8; r++) {
+        if (this.modules[r][6] !== null) {
+          continue;
+        }
+        this.modules[r][6] = r % 2 === 0;
+      }
+      for (var c = 8;c < this.moduleCount - 8; c++) {
+        if (this.modules[6][c] !== null) {
+          continue;
+        }
+        this.modules[6][c] = c % 2 === 0;
+      }
+    },
+    setupPositionAdjustPattern: function() {
+      var pos = QRUtil.getPatternPosition(this.typeNumber);
+      for (var i = 0;i < pos.length; i++) {
+        for (var j = 0;j < pos.length; j++) {
+          var row = pos[i];
+          var col = pos[j];
+          if (this.modules[row][col] !== null) {
+            continue;
+          }
+          for (var r = -2;r <= 2; r++) {
+            for (var c = -2;c <= 2; c++) {
+              if (Math.abs(r) === 2 || Math.abs(c) === 2 || r === 0 && c === 0) {
+                this.modules[row + r][col + c] = true;
+              } else {
+                this.modules[row + r][col + c] = false;
+              }
+            }
+          }
+        }
+      }
+    },
+    setupTypeNumber: function(test) {
+      var bits = QRUtil.getBCHTypeNumber(this.typeNumber);
+      var mod;
+      for (var i = 0;i < 18; i++) {
+        mod = !test && (bits >> i & 1) === 1;
+        this.modules[Math.floor(i / 3)][i % 3 + this.moduleCount - 8 - 3] = mod;
+      }
+      for (var x = 0;x < 18; x++) {
+        mod = !test && (bits >> x & 1) === 1;
+        this.modules[x % 3 + this.moduleCount - 8 - 3][Math.floor(x / 3)] = mod;
+      }
+    },
+    setupTypeInfo: function(test, maskPattern) {
+      var data = this.errorCorrectLevel << 3 | maskPattern;
+      var bits = QRUtil.getBCHTypeInfo(data);
+      var mod;
+      for (var v = 0;v < 15; v++) {
+        mod = !test && (bits >> v & 1) === 1;
+        if (v < 6) {
+          this.modules[v][8] = mod;
+        } else if (v < 8) {
+          this.modules[v + 1][8] = mod;
+        } else {
+          this.modules[this.moduleCount - 15 + v][8] = mod;
+        }
+      }
+      for (var h = 0;h < 15; h++) {
+        mod = !test && (bits >> h & 1) === 1;
+        if (h < 8) {
+          this.modules[8][this.moduleCount - h - 1] = mod;
+        } else if (h < 9) {
+          this.modules[8][15 - h - 1 + 1] = mod;
+        } else {
+          this.modules[8][15 - h - 1] = mod;
+        }
+      }
+      this.modules[this.moduleCount - 8][8] = !test;
+    },
+    mapData: function(data, maskPattern) {
+      var inc = -1;
+      var row = this.moduleCount - 1;
+      var bitIndex = 7;
+      var byteIndex = 0;
+      for (var col = this.moduleCount - 1;col > 0; col -= 2) {
+        if (col === 6)
+          col--;
+        while (true) {
+          for (var c = 0;c < 2; c++) {
+            if (this.modules[row][col - c] === null) {
+              var dark = false;
+              if (byteIndex < data.length) {
+                dark = (data[byteIndex] >>> bitIndex & 1) === 1;
+              }
+              var mask = QRUtil.getMask(maskPattern, row, col - c);
+              if (mask) {
+                dark = !dark;
+              }
+              this.modules[row][col - c] = dark;
+              bitIndex--;
+              if (bitIndex === -1) {
+                byteIndex++;
+                bitIndex = 7;
+              }
+            }
+          }
+          row += inc;
+          if (row < 0 || this.moduleCount <= row) {
+            row -= inc;
+            inc = -inc;
+            break;
+          }
+        }
+      }
+    }
+  };
+  QRCode.PAD0 = 236;
+  QRCode.PAD1 = 17;
+  QRCode.createData = function(typeNumber, errorCorrectLevel, dataList) {
+    var rsBlocks = QRRSBlock.getRSBlocks(typeNumber, errorCorrectLevel);
+    var buffer = new QRBitBuffer;
+    for (var i = 0;i < dataList.length; i++) {
+      var data = dataList[i];
+      buffer.put(data.mode, 4);
+      buffer.put(data.getLength(), QRUtil.getLengthInBits(data.mode, typeNumber));
+      data.write(buffer);
+    }
+    var totalDataCount = 0;
+    for (var x = 0;x < rsBlocks.length; x++) {
+      totalDataCount += rsBlocks[x].dataCount;
+    }
+    if (buffer.getLengthInBits() > totalDataCount * 8) {
+      throw new Error("code length overflow. (" + buffer.getLengthInBits() + ">" + totalDataCount * 8 + ")");
+    }
+    if (buffer.getLengthInBits() + 4 <= totalDataCount * 8) {
+      buffer.put(0, 4);
+    }
+    while (buffer.getLengthInBits() % 8 !== 0) {
+      buffer.putBit(false);
+    }
+    while (true) {
+      if (buffer.getLengthInBits() >= totalDataCount * 8) {
+        break;
+      }
+      buffer.put(QRCode.PAD0, 8);
+      if (buffer.getLengthInBits() >= totalDataCount * 8) {
+        break;
+      }
+      buffer.put(QRCode.PAD1, 8);
+    }
+    return QRCode.createBytes(buffer, rsBlocks);
+  };
+  QRCode.createBytes = function(buffer, rsBlocks) {
+    var offset = 0;
+    var maxDcCount = 0;
+    var maxEcCount = 0;
+    var dcdata = new Array(rsBlocks.length);
+    var ecdata = new Array(rsBlocks.length);
+    for (var r = 0;r < rsBlocks.length; r++) {
+      var dcCount = rsBlocks[r].dataCount;
+      var ecCount = rsBlocks[r].totalCount - dcCount;
+      maxDcCount = Math.max(maxDcCount, dcCount);
+      maxEcCount = Math.max(maxEcCount, ecCount);
+      dcdata[r] = new Array(dcCount);
+      for (var i = 0;i < dcdata[r].length; i++) {
+        dcdata[r][i] = 255 & buffer.buffer[i + offset];
+      }
+      offset += dcCount;
+      var rsPoly = QRUtil.getErrorCorrectPolynomial(ecCount);
+      var rawPoly = new QRPolynomial(dcdata[r], rsPoly.getLength() - 1);
+      var modPoly = rawPoly.mod(rsPoly);
+      ecdata[r] = new Array(rsPoly.getLength() - 1);
+      for (var x = 0;x < ecdata[r].length; x++) {
+        var modIndex = x + modPoly.getLength() - ecdata[r].length;
+        ecdata[r][x] = modIndex >= 0 ? modPoly.get(modIndex) : 0;
+      }
+    }
+    var totalCodeCount = 0;
+    for (var y = 0;y < rsBlocks.length; y++) {
+      totalCodeCount += rsBlocks[y].totalCount;
+    }
+    var data = new Array(totalCodeCount);
+    var index = 0;
+    for (var z = 0;z < maxDcCount; z++) {
+      for (var s = 0;s < rsBlocks.length; s++) {
+        if (z < dcdata[s].length) {
+          data[index++] = dcdata[s][z];
+        }
+      }
+    }
+    for (var xx = 0;xx < maxEcCount; xx++) {
+      for (var t = 0;t < rsBlocks.length; t++) {
+        if (xx < ecdata[t].length) {
+          data[index++] = ecdata[t][xx];
+        }
+      }
+    }
+    return data;
+  };
+  module.exports = QRCode;
+});
+
+// node_modules/qrcode-terminal/lib/main.js
+var require_main = __commonJS((exports, module) => {
+  var QRCode = require_QRCode();
+  var QRErrorCorrectLevel = require_QRErrorCorrectLevel();
+  var black = "\x1B[40m  \x1B[0m";
+  var white = "\x1B[47m  \x1B[0m";
+  var toCell = function(isBlack) {
+    return isBlack ? black : white;
+  };
+  var repeat = function(color) {
+    return {
+      times: function(count) {
+        return new Array(count).join(color);
+      }
+    };
+  };
+  var fill = function(length, value) {
+    var arr = new Array(length);
+    for (var i = 0;i < length; i++) {
+      arr[i] = value;
+    }
+    return arr;
+  };
+  module.exports = {
+    error: QRErrorCorrectLevel.L,
+    generate: function(input, opts, cb) {
+      if (typeof opts === "function") {
+        cb = opts;
+        opts = {};
+      }
+      var qrcode = new QRCode(-1, this.error);
+      qrcode.addData(input);
+      qrcode.make();
+      var output = "";
+      if (opts && opts.small) {
+        var BLACK = true, WHITE = false;
+        var moduleCount = qrcode.getModuleCount();
+        var moduleData = qrcode.modules.slice();
+        var oddRow = moduleCount % 2 === 1;
+        if (oddRow) {
+          moduleData.push(fill(moduleCount, WHITE));
+        }
+        var platte = {
+          WHITE_ALL: "█",
+          WHITE_BLACK: "▀",
+          BLACK_WHITE: "▄",
+          BLACK_ALL: " "
+        };
+        var borderTop = repeat(platte.BLACK_WHITE).times(moduleCount + 3);
+        var borderBottom = repeat(platte.WHITE_BLACK).times(moduleCount + 3);
+        output += borderTop + `
+`;
+        for (var row = 0;row < moduleCount; row += 2) {
+          output += platte.WHITE_ALL;
+          for (var col = 0;col < moduleCount; col++) {
+            if (moduleData[row][col] === WHITE && moduleData[row + 1][col] === WHITE) {
+              output += platte.WHITE_ALL;
+            } else if (moduleData[row][col] === WHITE && moduleData[row + 1][col] === BLACK) {
+              output += platte.WHITE_BLACK;
+            } else if (moduleData[row][col] === BLACK && moduleData[row + 1][col] === WHITE) {
+              output += platte.BLACK_WHITE;
+            } else {
+              output += platte.BLACK_ALL;
+            }
+          }
+          output += platte.WHITE_ALL + `
+`;
+        }
+        if (!oddRow) {
+          output += borderBottom;
+        }
+      } else {
+        var border = repeat(white).times(qrcode.getModuleCount() + 3);
+        output += border + `
+`;
+        qrcode.modules.forEach(function(row2) {
+          output += white;
+          output += row2.map(toCell).join("");
+          output += white + `
+`;
+        });
+        output += border;
+      }
+      if (cb)
+        cb(output);
+      else
+        console.log(output);
+    },
+    setErrorLevel: function(error) {
+      this.error = QRErrorCorrectLevel[error] || this.error;
+    }
+  };
+});
+
+// src/weixin-sdk.ts
+var exports_weixin_sdk = {};
+__export(exports_weixin_sdk, {
+  loadWeixinSdk: () => loadWeixinSdk,
+  buildWeixinSdkSourceCandidates: () => buildWeixinSdkSourceCandidates,
+  buildWeixinSdkImportCandidates: () => buildWeixinSdkImportCandidates
+});
+function buildWeixinSdkImportCandidates(explicitPath, _moduleUrl = import.meta.url) {
+  const candidates = [];
+  if (explicitPath) {
+    candidates.push(explicitPath);
+  }
+  candidates.push("weixin-agent-sdk");
+  return candidates;
+}
+function buildWeixinSdkSourceCandidates(explicitPath, _moduleUrl = import.meta.url) {
+  if (explicitPath) {
+    return [explicitPath];
+  }
+  return [];
+}
+async function loadWeixinSdk() {
+  const candidates = buildWeixinSdkImportCandidates(process.env.WEACPX_WEIXIN_SDK, import.meta.url);
+  const errors = [];
+  for (const candidate of candidates) {
+    try {
+      return await import(candidate);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`${candidate}: ${message}`);
+    }
+  }
+  throw new Error([
+    "Unable to load weixin-agent-sdk.",
+    "Tried:",
+    ...errors.map((entry) => `- ${entry}`),
+    'Set WEACPX_WEIXIN_SDK to a local SDK entry file, or install the "weixin-agent-sdk" package.'
+  ].join(`
+`));
+}
+
+// src/login.ts
+var exports_login = {};
+__export(exports_login, {
+  main: () => main,
+  loginWithQrRendering: () => loginWithQrRendering
+});
+async function loadQrLoginSupport() {
+  const candidates = buildWeixinSdkSourceCandidates(process.env.WEACPX_WEIXIN_SDK);
+  for (const candidate of candidates) {
+    try {
+      const sourceUrl = candidate.startsWith("file:") ? candidate : new URL(candidate, import.meta.url).href;
+      const accounts = await import(new URL("./src/auth/accounts.ts", sourceUrl).href);
+      const loginQr = await import(new URL("./src/auth/login-qr.ts", sourceUrl).href);
+      return { accounts, loginQr };
+    } catch {}
+  }
+  return null;
+}
+async function loginWithQrRendering() {
+  const support = await loadQrLoginSupport();
+  if (!support) {
+    const { login } = await loadWeixinSdk();
+    await login();
+    return;
+  }
+  const { accounts, loginQr } = support;
+  const apiBaseUrl = accounts.DEFAULT_BASE_URL;
+  console.log("正在启动微信扫码登录...");
+  const startResult = await loginQr.startWeixinLoginWithQr({
+    apiBaseUrl,
+    botType: loginQr.DEFAULT_ILINK_BOT_TYPE
+  });
+  if (!startResult.qrcodeUrl) {
+    throw new Error(startResult.message);
+  }
+  console.log(`
+使用微信扫描以下二维码，以完成连接：
+`);
+  await new Promise((resolve) => {
+    import_qrcode_terminal.default.generate(startResult.qrcodeUrl, { small: true }, (qr) => {
+      console.log(qr);
+      resolve();
+    });
+  });
+  console.log(`
+等待扫码...
+`);
+  const waitResult = await loginQr.waitForWeixinLogin({
+    sessionKey: startResult.sessionKey,
+    apiBaseUrl,
+    timeoutMs: 480000,
+    botType: loginQr.DEFAULT_ILINK_BOT_TYPE
+  });
+  if (!waitResult.connected || !waitResult.botToken || !waitResult.accountId) {
+    throw new Error(waitResult.message);
+  }
+  const normalizedId = accounts.normalizeAccountId(waitResult.accountId);
+  accounts.saveWeixinAccount(normalizedId, {
+    token: waitResult.botToken,
+    baseUrl: waitResult.baseUrl,
+    userId: waitResult.userId
+  });
+  accounts.registerWeixinAccountId(normalizedId);
+  console.log(`
+✅ 与微信连接成功！`);
+}
+async function main() {
+  await loginWithQrRendering();
+}
+var import_qrcode_terminal;
+var init_login = __esm(async () => {
+  import_qrcode_terminal = __toESM(require_main(), 1);
+  if (false) {}
+});
+
+// src/config/agent-templates.ts
+function getAgentTemplate(name) {
+  const template = TEMPLATES[name];
+  if (!template) {
+    return null;
+  }
+  return {
+    ...template
+  };
+}
+function listAgentTemplates() {
+  return Object.keys(TEMPLATES);
+}
+var TEMPLATES;
+var init_agent_templates = __esm(() => {
+  TEMPLATES = {
+    codex: {
+      driver: "codex"
+    },
+    claude: {
+      driver: "claude"
+    }
+  };
+});
+
+// src/formatting/render-text.ts
+function renderHelpText() {
+  return [
+    "可用命令：",
+    "/agents",
+    "/agent add <codex|claude>",
+    "/agent rm <name>",
+    "/workspaces",
+    "/workspace 或 /ws",
+    "/ws new <name> -d <path>",
+    "/workspace rm <name>",
+    "/sessions",
+    "/session 或 /ss",
+    "/ss <agent> -d <path>",
+    "/ss new <agent> -d <path>",
+    "/ss new <alias> -a <name> --ws <name>",
+    "/ss attach <alias> -a <name> --ws <name> --name <transport-session>",
+    "/use <alias>",
+    "/status",
+    "/cancel 或 /stop"
+  ].join(`
+`);
+}
+function renderAgents(config) {
+  const names = Object.keys(config.agents);
+  if (names.length === 0) {
+    return "还没有注册任何 Agent。";
+  }
+  return ["已注册的 Agent：", ...names.map((name) => `- ${name}`)].join(`
+`);
+}
+function renderWorkspaces(config) {
+  const names = Object.entries(config.workspaces);
+  if (names.length === 0) {
+    return "还没有注册任何工作区。";
+  }
+  return ["已注册的工作区：", ...names.map(([name, workspace]) => `- ${name}: ${workspace.cwd}`)].join(`
+`);
+}
+
+// src/logging/app-logger.ts
+import { appendFile, mkdir as mkdir5, readdir, rename, rm as rm4, stat } from "node:fs/promises";
+import { basename, dirname as dirname4, join as join2 } from "node:path";
+function createNoopAppLogger() {
+  return {
+    debug: async () => {},
+    info: async () => {},
+    error: async () => {},
+    cleanup: async () => {}
+  };
+}
+function createAppLogger(options) {
+  const now = options.now ?? (() => new Date);
+  return {
+    debug: async (event, message, context) => {
+      await writeLog("debug", event, message, context);
+    },
+    info: async (event, message, context) => {
+      await writeLog("info", event, message, context);
+    },
+    error: async (event, message, context) => {
+      await writeLog("error", event, message, context);
+    },
+    cleanup: async () => {
+      await cleanupExpiredRotatedLogs(options.filePath, options.retentionDays, now);
+    }
+  };
+  async function writeLog(level, event, message, context = {}) {
+    if (LEVEL_ORDER[level] > LEVEL_ORDER[options.level]) {
+      return;
+    }
+    const line = formatLogLine(now(), level, event, message, context);
+    await mkdir5(dirname4(options.filePath), { recursive: true });
+    await rotateIfNeeded(options.filePath, Buffer.byteLength(line), options.maxSizeBytes, options.maxFiles);
+    await appendFile(options.filePath, line, "utf8");
+  }
+}
+async function rotateIfNeeded(filePath, incomingSize, maxSizeBytes, maxFiles) {
+  let currentSize = 0;
+  try {
+    currentSize = (await stat(filePath)).size;
+  } catch (error) {
+    if (!isMissingFileError(error)) {
+      throw error;
+    }
+  }
+  if (currentSize + incomingSize <= maxSizeBytes) {
+    return;
+  }
+  if (currentSize === 0) {
+    return;
+  }
+  if (maxFiles <= 0) {
+    await rm4(filePath, { force: true });
+    return;
+  }
+  await rm4(`${filePath}.${maxFiles}`, { force: true });
+  for (let index = maxFiles - 1;index >= 1; index -= 1) {
+    const source = `${filePath}.${index}`;
+    try {
+      await rename(source, `${filePath}.${index + 1}`);
+    } catch (error) {
+      if (!isMissingFileError(error)) {
+        throw error;
+      }
+    }
+  }
+  await rename(filePath, `${filePath}.1`);
+}
+async function cleanupExpiredRotatedLogs(filePath, retentionDays, now) {
+  const parentDir = dirname4(filePath);
+  const prefix = `${basename(filePath)}.`;
+  const cutoff = now().getTime() - retentionDays * 24 * 60 * 60 * 1000;
+  let files = [];
+  try {
+    files = await readdir(parentDir);
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return;
+    }
+    throw error;
+  }
+  for (const file of files) {
+    if (!file.startsWith(prefix) || !/^\d+$/.test(file.slice(prefix.length))) {
+      continue;
+    }
+    const candidate = join2(parentDir, file);
+    const details = await stat(candidate);
+    if (details.mtime.getTime() < cutoff) {
+      await rm4(candidate, { force: true });
+    }
+  }
+}
+function formatLogLine(time, level, event, message, context) {
+  const fields = Object.entries(context).filter(([, value]) => value !== undefined).map(([key, value]) => `${key}=${formatValue(value)}`);
+  const suffix = fields.length > 0 ? ` ${fields.join(" ")}` : "";
+  return `${time.toISOString()} ${level.toUpperCase()} ${event} message=${formatValue(message)}${suffix}
+`;
+}
+function formatValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var LEVEL_ORDER;
+var init_app_logger = __esm(() => {
+  LEVEL_ORDER = {
+    error: 0,
+    info: 1,
+    debug: 2
+  };
+});
+
+// src/commands/parse-command.ts
+function parseCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return { kind: "prompt", text: trimmed };
+  }
+  const parts = tokenizeCommand(trimmed);
+  const command = normalizeCommand(parts[0] ?? "");
+  if (command === "/help")
+    return { kind: "help" };
+  if (command === "/agents")
+    return { kind: "agents" };
+  if (command === "/workspaces")
+    return { kind: "workspaces" };
+  if (command === "/sessions")
+    return { kind: "sessions" };
+  if (command === "/status")
+    return { kind: "status" };
+  if (command === "/cancel")
+    return { kind: "cancel" };
+  if (command === "/session" && parts.length === 1)
+    return { kind: "sessions" };
+  if (command === "/workspace" && parts.length === 1)
+    return { kind: "workspaces" };
+  if (command === "/use" && parts[1]) {
+    return { kind: "session.use", alias: parts[1] };
+  }
+  if (command === "/agent" && parts[1] === "add" && parts[2]) {
+    return { kind: "agent.add", template: parts[2] };
+  }
+  if (command === "/agent" && parts[1] === "rm" && parts[2]) {
+    return { kind: "agent.rm", name: parts[2] };
+  }
+  if (command === "/workspace" && parts[1] === "new" && parts[2]) {
+    const name = parts[2];
+    let cwd = "";
+    for (let index = 3;index < parts.length; index += 1) {
+      if (parts[index] === "--cwd" || parts[index] === "-d") {
+        cwd = parts[index + 1] ?? "";
+        index += 1;
+      }
+    }
+    return { kind: "workspace.new", name, cwd };
+  }
+  if (command === "/workspace" && parts[1] === "rm" && parts[2]) {
+    return { kind: "workspace.rm", name: parts[2] };
+  }
+  if (command === "/session" && parts[1] === "new" && parts[2]) {
+    if (hasAnyFlag(parts, ["--agent", "-a"])) {
+      const alias = parts[2];
+      let agent = "";
+      let workspace = "";
+      for (let index = 3;index < parts.length; index += 1) {
+        if (parts[index] === "--agent" || parts[index] === "-a") {
+          agent = parts[index + 1] ?? "";
+          index += 1;
+        } else if (parts[index] === "--ws" || parts[index] === "-ws") {
+          workspace = parts[index + 1] ?? "";
+          index += 1;
+        }
+      }
+      return { kind: "session.new", alias, agent, workspace };
+    }
+    const cwd = readFlagValue(parts, ["--cwd", "-d"]);
+    if (cwd) {
+      return { kind: "session.shortcut.new", agent: parts[2], cwd };
+    }
+  }
+  if (command === "/session" && parts[1] && parts[1] !== "new" && parts[1] !== "attach") {
+    const cwd = readFlagValue(parts, ["--cwd", "-d"]);
+    if (cwd) {
+      return { kind: "session.shortcut", agent: parts[1], cwd };
+    }
+  }
+  if (command === "/session" && parts[1] === "attach" && parts[2]) {
+    const alias = parts[2];
+    let agent = "";
+    let workspace = "";
+    let transportSession = "";
+    for (let index = 3;index < parts.length; index += 1) {
+      if (parts[index] === "--agent" || parts[index] === "-a") {
+        agent = parts[index + 1] ?? "";
+        index += 1;
+      } else if (parts[index] === "--ws" || parts[index] === "-ws") {
+        workspace = parts[index + 1] ?? "";
+        index += 1;
+      } else if (parts[index] === "--name") {
+        transportSession = parts[index + 1] ?? "";
+        index += 1;
+      }
+    }
+    return { kind: "session.attach", alias, agent, workspace, transportSession };
+  }
+  return { kind: "prompt", text: trimmed };
+}
+function hasAnyFlag(parts, flags) {
+  return parts.some((part) => flags.includes(part));
+}
+function readFlagValue(parts, flags) {
+  for (let index = 0;index < parts.length; index += 1) {
+    if (flags.includes(parts[index] ?? "")) {
+      return parts[index + 1] ?? "";
+    }
+  }
+  return "";
+}
+function normalizeCommand(command) {
+  if (command === "/ss")
+    return "/session";
+  if (command === "/ws")
+    return "/workspace";
+  if (command === "/stop")
+    return "/cancel";
+  return command;
+}
+function tokenizeCommand(input) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  for (const char of input) {
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+
+// src/commands/command-router.ts
+import { access } from "node:fs/promises";
+import { basename as basename2, normalize } from "node:path";
+
+class CommandRouter {
+  sessions;
+  transport;
+  config;
+  configStore;
+  logger;
+  constructor(sessions, transport, config, configStore, logger) {
+    this.sessions = sessions;
+    this.transport = transport;
+    this.config = config;
+    this.configStore = configStore;
+    this.logger = logger ?? createNoopAppLogger();
+  }
+  async handle(chatKey, input) {
+    const startedAt = Date.now();
+    const command = parseCommand(input);
+    await this.logger.debug("command.parsed", "parsed inbound command", {
+      chatKey,
+      kind: command.kind
+    });
+    return await this.executeCommand(chatKey, command.kind, startedAt, async () => {
+      switch (command.kind) {
+        case "help":
+          return { text: renderHelpText() };
+        case "agents":
+          return { text: this.config ? renderAgents(this.config) : "No config loaded." };
+        case "agent.add": {
+          if (!this.config || !this.configStore) {
+            return { text: "当前没有加载可写入的配置。" };
+          }
+          const template = getAgentTemplate(command.template);
+          if (!template) {
+            return { text: `暂不支持这个 Agent 模板。当前可用：${listAgentTemplates().join("、")}` };
+          }
+          const updated = await this.configStore.upsertAgent(command.template, template);
+          this.replaceConfig(updated);
+          return { text: `Agent「${command.template}」已保存` };
+        }
+        case "agent.rm": {
+          if (!this.config || !this.configStore) {
+            return { text: "当前没有加载可写入的配置。" };
+          }
+          if (!this.config.agents[command.name]) {
+            return { text: "没有找到这个 Agent。" };
+          }
+          const updated = await this.configStore.removeAgent(command.name);
+          this.replaceConfig(updated);
+          return { text: `Agent「${command.name}」已删除` };
+        }
+        case "workspaces":
+          return { text: this.config ? renderWorkspaces(this.config) : "No config loaded." };
+        case "workspace.new": {
+          if (!this.config || !this.configStore) {
+            return { text: "当前没有加载可写入的配置。" };
+          }
+          if (!await pathExists(command.cwd)) {
+            return { text: `工作区路径不存在：${command.cwd}` };
+          }
+          const updated = await this.configStore.upsertWorkspace(command.name, command.cwd);
+          this.replaceConfig(updated);
+          return { text: `工作区「${command.name}」已保存` };
+        }
+        case "workspace.rm": {
+          if (!this.config || !this.configStore) {
+            return { text: "当前没有加载可写入的配置。" };
+          }
+          const updated = await this.configStore.removeWorkspace(command.name);
+          this.replaceConfig(updated);
+          return { text: `工作区「${command.name}」已删除` };
+        }
+        case "sessions": {
+          const sessions = await this.sessions.listSessions(chatKey);
+          if (sessions.length === 0) {
+            return { text: "还没有会话。请先执行 /session new <alias> --agent <name> --ws <name>。" };
+          }
+          return {
+            text: [
+              "会话列表：",
+              ...sessions.map((session) => `- ${session.alias} (${session.agent} @ ${session.workspace})${session.isCurrent ? " [当前]" : ""}`)
+            ].join(`
+`)
+          };
+        }
+        case "session.new": {
+          const session = this.sessions.resolveSession(command.alias, command.agent, command.workspace, `${command.workspace}:${command.alias}`);
+          try {
+            await this.ensureTransportSession(session);
+            const exists = await this.checkTransportSession(session);
+            if (!exists) {
+              return this.renderSessionCreationVerificationError(session);
+            }
+          } catch (error) {
+            return this.renderSessionCreationError(session, error);
+          }
+          await this.sessions.attachSession(command.alias, command.agent, command.workspace, session.transportSession);
+          await this.sessions.useSession(chatKey, command.alias);
+          await this.logger.info("session.created", "created and selected logical session", {
+            alias: command.alias,
+            agent: command.agent,
+            workspace: command.workspace
+          });
+          return { text: `会话「${command.alias}」已创建并切换` };
+        }
+        case "session.shortcut":
+          return await this.handleSessionShortcut(chatKey, command.agent, command.cwd, false);
+        case "session.shortcut.new":
+          return await this.handleSessionShortcut(chatKey, command.agent, command.cwd, true);
+        case "session.attach": {
+          const attached = this.sessions.resolveSession(command.alias, command.agent, command.workspace, command.transportSession);
+          const exists = await this.checkTransportSession(attached);
+          if (!exists) {
+            return {
+              text: [
+                "没有找到可绑定的已有会话。",
+                `请确认会话名是否正确，然后重新执行：/session attach ${command.alias} --agent ${command.agent} --ws ${command.workspace} --name <会话名>`
+              ].join(`
+`)
+            };
+          }
+          await this.sessions.attachSession(command.alias, command.agent, command.workspace, command.transportSession);
+          await this.sessions.useSession(chatKey, command.alias);
+          await this.logger.info("session.attached", "attached existing transport session", {
+            alias: command.alias,
+            agent: command.agent,
+            workspace: command.workspace,
+            transportSession: command.transportSession
+          });
+          return { text: `会话「${command.alias}」已绑定并切换` };
+        }
+        case "session.use":
+          await this.sessions.useSession(chatKey, command.alias);
+          await this.logger.info("session.selected", "selected logical session", {
+            alias: command.alias,
+            chatKey
+          });
+          return { text: `已切换到会话「${command.alias}」` };
+        case "status": {
+          const session = await this.sessions.getCurrentSession(chatKey);
+          if (!session) {
+            return { text: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。" };
+          }
+          return {
+            text: [
+              "当前会话：",
+              `- 名称：${session.alias}`,
+              `- Agent：${session.agent}`,
+              `- 工作区：${session.workspace}`
+            ].join(`
+`)
+          };
+        }
+        case "cancel": {
+          const session = await this.sessions.getCurrentSession(chatKey);
+          if (!session) {
+            return { text: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。" };
+          }
+          try {
+            const result = await this.cancelTransportSession(session);
+            return { text: result.message || "cancelled" };
+          } catch (error) {
+            return this.renderTransportError(session, error);
+          }
+        }
+        case "prompt": {
+          const session = await this.sessions.getCurrentSession(chatKey);
+          if (!session) {
+            return { text: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。" };
+          }
+          try {
+            const reply = await this.promptTransportSession(session, command.text);
+            return { text: reply.text };
+          } catch (error) {
+            return this.renderTransportError(session, error);
+          }
+        }
+      }
+    });
+  }
+  async handleSessionShortcut(chatKey, agent, cwdInput, createNew) {
+    if (!this.config || !this.configStore) {
+      return { text: "当前没有加载可写入的配置。" };
+    }
+    const cwd = normalizePathForWorkspace(cwdInput);
+    if (!await pathExists(cwd)) {
+      return { text: `工作区路径不存在：${cwdInput}` };
+    }
+    const workspace = await this.resolveShortcutWorkspace(cwd);
+    await this.logger.info("session.shortcut.workspace", "resolved shortcut workspace", {
+      workspace: workspace.name,
+      cwd: workspace.cwd,
+      reused: workspace.reused
+    });
+    const baseAlias = `${workspace.name}:${agent}`;
+    const alias = createNew ? await this.allocateUniqueSessionAlias(baseAlias, chatKey) : baseAlias;
+    if (!createNew && await this.hasLogicalSession(alias, chatKey)) {
+      await this.sessions.useSession(chatKey, alias);
+      await this.logger.info("session.shortcut.reused", "reused existing logical session", {
+        alias,
+        workspace: workspace.name,
+        agent
+      });
+      return {
+        text: [
+          `已切换到会话「${alias}」`,
+          `- 复用工作区：${workspace.name}`,
+          `- 复用会话：${alias}`
+        ].join(`
+`)
+      };
+    }
+    const session = this.sessions.resolveSession(alias, agent, workspace.name, `${workspace.name}:${alias}`);
+    try {
+      await this.ensureTransportSession(session);
+      const exists = await this.checkTransportSession(session);
+      if (!exists) {
+        return this.renderShortcutSessionCreationError(workspace, alias);
+      }
+    } catch {
+      return this.renderShortcutSessionCreationError(workspace, alias);
+    }
+    await this.sessions.attachSession(alias, agent, workspace.name, session.transportSession);
+    await this.sessions.useSession(chatKey, alias);
+    await this.logger.info("session.shortcut.created", "created new logical session from shortcut", {
+      alias,
+      workspace: workspace.name,
+      agent,
+      workspaceReused: workspace.reused
+    });
+    return {
+      text: [
+        `已创建并切换到会话「${alias}」`,
+        workspace.reused ? `- 复用工作区：${workspace.name}` : `- 新增工作区：${workspace.name} -> ${workspace.cwd}`,
+        `- 新增会话：${alias}`
+      ].join(`
+`)
+    };
+  }
+  replaceConfig(updated) {
+    if (!this.config) {
+      return;
+    }
+    this.config.transport = { ...updated.transport };
+    this.config.agents = { ...updated.agents };
+    this.config.workspaces = { ...updated.workspaces };
+  }
+  renderTransportError(session, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("No acpx session found")) {
+      return {
+        text: [
+          `当前会话「${session.alias}」暂时不可用。`,
+          `请先在微信里重新执行：/session new ${session.alias} --agent ${session.agent} --ws ${session.workspace}`,
+          `如果你要绑定一个已有会话，再执行：/session attach ${session.alias} --agent ${session.agent} --ws ${session.workspace} --name <会话名>`
+        ].join(`
+`)
+      };
+    }
+    throw error;
+  }
+  renderSessionCreationError(session, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("timed out") && message.includes("sessions new")) {
+      return this.renderSessionCreationVerificationError(session);
+    }
+    throw error;
+  }
+  renderSessionCreationVerificationError(session) {
+    return {
+      text: [
+        "当前还不能直接在微信里创建新会话。",
+        `请先准备好一个已有会话，然后在微信里执行：/session attach ${session.alias} --agent ${session.agent} --ws ${session.workspace} --name <会话名>`
+      ].join(`
+`)
+    };
+  }
+  async resolveShortcutWorkspace(cwd) {
+    const existingByPath = Object.entries(this.config?.workspaces ?? {}).find(([, workspace]) => sameWorkspacePath(workspace.cwd, cwd));
+    if (existingByPath) {
+      return {
+        name: existingByPath[0],
+        cwd: existingByPath[1].cwd,
+        reused: true
+      };
+    }
+    const baseName = basename2(cwd);
+    const workspaceName = this.allocateWorkspaceName(baseName, cwd);
+    const updated = await this.configStore.upsertWorkspace(workspaceName, cwd);
+    this.replaceConfig(updated);
+    return {
+      name: workspaceName,
+      cwd,
+      reused: false
+    };
+  }
+  allocateWorkspaceName(baseName, cwd) {
+    if (!this.config?.workspaces[baseName]) {
+      return baseName;
+    }
+    let suffix = 2;
+    while (this.config.workspaces[`${baseName}-${suffix}`]) {
+      suffix += 1;
+    }
+    return `${baseName}-${suffix}`;
+  }
+  async allocateUniqueSessionAlias(baseAlias, chatKey) {
+    if (!await this.hasLogicalSession(baseAlias, chatKey)) {
+      return baseAlias;
+    }
+    let suffix = 2;
+    while (await this.hasLogicalSession(`${baseAlias}-${suffix}`, chatKey)) {
+      suffix += 1;
+    }
+    return `${baseAlias}-${suffix}`;
+  }
+  async hasLogicalSession(alias, chatKey) {
+    const sessions = await this.sessions.listSessions(chatKey);
+    return sessions.some((session) => session.alias === alias);
+  }
+  renderShortcutSessionCreationError(workspace, alias) {
+    return {
+      text: [
+        `会话「${alias}」创建失败。`,
+        workspace.reused ? `- 复用工作区：${workspace.name}` : `- 已新增工作区：${workspace.name} -> ${workspace.cwd}`,
+        "- 会话未创建，请重试。"
+      ].join(`
+`)
+    };
+  }
+  async executeCommand(chatKey, kind, startedAt, operation) {
+    try {
+      const response = await operation();
+      await this.logger.info("command.completed", "completed command handling", {
+        chatKey,
+        kind,
+        durationMs: Date.now() - startedAt
+      });
+      return response;
+    } catch (error) {
+      await this.logger.error("command.failed", "command handling failed", {
+        chatKey,
+        kind,
+        durationMs: Date.now() - startedAt,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async ensureTransportSession(session) {
+    await this.measureTransportCall("ensure_session", session, () => this.transport.ensureSession(session));
+  }
+  async checkTransportSession(session) {
+    return await this.measureTransportCall("has_session", session, () => this.transport.hasSession(session));
+  }
+  async promptTransportSession(session, text) {
+    return await this.measureTransportCall("prompt", session, () => this.transport.prompt(session, text));
+  }
+  async cancelTransportSession(session) {
+    return await this.measureTransportCall("cancel", session, () => this.transport.cancel(session));
+  }
+  async measureTransportCall(operation, session, callback) {
+    const startedAt = Date.now();
+    try {
+      const result = await callback();
+      await this.logger.info(`transport.${operation}`, "transport operation completed", {
+        operation,
+        agent: session.agent,
+        workspace: session.workspace,
+        alias: session.alias,
+        durationMs: Date.now() - startedAt
+      });
+      return result;
+    } catch (error) {
+      await this.logger.error(`transport.${operation}.failed`, "transport operation failed", {
+        operation,
+        agent: session.agent,
+        workspace: session.workspace,
+        alias: session.alias,
+        durationMs: Date.now() - startedAt,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+}
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizePathForWorkspace(path) {
+  return normalize(path);
+}
+function sameWorkspacePath(left, right) {
+  const normalizedLeft = normalizePathForWorkspace(left);
+  const normalizedRight = normalizePathForWorkspace(right);
+  if (process.platform === "win32") {
+    return normalizedLeft.toLowerCase() === normalizedRight.toLowerCase();
+  }
+  return normalizedLeft === normalizedRight;
+}
+var init_command_router = __esm(() => {
+  init_agent_templates();
+  init_app_logger();
+});
+
+// src/config/resolve-agent-command.ts
+function resolveAgentCommand(driver, command) {
+  if (!command) {
+    return;
+  }
+  if (driver === "codex" && isLegacyCodexCommand(command)) {
+    return;
+  }
+  return command;
+}
+function isLegacyCodexCommand(command) {
+  const normalized = command.trim().replaceAll("\\", "/").toLowerCase();
+  return normalized === "./node_modules/.bin/codex-acp" || normalized === "./node_modules/.bin/codex-acp.exe" || normalized.endsWith("/node_modules/.bin/codex-acp") || normalized.endsWith("/node_modules/.bin/codex-acp.exe") || normalized.includes("/@zed-industries/codex-acp/bin/codex-acp.js") || normalized.includes("@zed-industries/codex-acp/bin/codex-acp.js");
+}
+
+// src/config/load-config.ts
+import { readFile as readFile3 } from "node:fs/promises";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+async function loadConfig(path, options = {}) {
+  const raw = JSON.parse(await readFile3(path, "utf8"));
+  return parseConfig(raw, options);
+}
+function parseConfig(raw, options = {}) {
+  if (!isRecord(raw)) {
+    throw new Error("config must be a JSON object");
+  }
+  const transport = raw.transport;
+  if (!isRecord(transport)) {
+    throw new Error("transport must be an object");
+  }
+  if ("type" in transport && transport.type !== "acpx-cli" && transport.type !== "acpx-bridge") {
+    throw new Error("transport.type must be acpx-cli or acpx-bridge");
+  }
+  if ("sessionInitTimeoutMs" in transport && (typeof transport.sessionInitTimeoutMs !== "number" || !Number.isFinite(transport.sessionInitTimeoutMs) || transport.sessionInitTimeoutMs <= 0)) {
+    throw new Error("transport.sessionInitTimeoutMs must be a positive number");
+  }
+  if (!isRecord(raw.agents)) {
+    throw new Error("agents must be an object");
+  }
+  if (!isRecord(raw.workspaces)) {
+    throw new Error("workspaces must be an object");
+  }
+  const logging = raw.logging;
+  if (logging !== undefined && !isRecord(logging)) {
+    throw new Error("logging must be an object");
+  }
+  if (isRecord(logging) && "level" in logging && logging.level !== "error" && logging.level !== "info" && logging.level !== "debug") {
+    throw new Error("logging.level must be error, info, or debug");
+  }
+  for (const field of ["maxSizeBytes", "maxFiles", "retentionDays"]) {
+    if (isRecord(logging) && field in logging && (typeof logging[field] !== "number" || !Number.isFinite(logging[field]) || logging[field] <= 0)) {
+      throw new Error(`logging.${field} must be a positive number`);
+    }
+  }
+  for (const [name, agent] of Object.entries(raw.agents)) {
+    if (!isRecord(agent) || typeof agent.driver !== "string" || agent.driver.length === 0) {
+      throw new Error(`agent "${name}" must define a non-empty driver`);
+    }
+    if ("command" in agent && (typeof agent.command !== "string" || agent.command.length === 0)) {
+      throw new Error(`agent "${name}" command must be a non-empty string`);
+    }
+  }
+  for (const [name, workspace] of Object.entries(raw.workspaces)) {
+    if (!isRecord(workspace) || typeof workspace.cwd !== "string" || workspace.cwd.length === 0) {
+      throw new Error(`workspace "${name}" must define a non-empty cwd`);
+    }
+    if ("allowed_agents" in workspace && (!Array.isArray(workspace.allowed_agents) || workspace.allowed_agents.some((value) => typeof value !== "string"))) {
+      throw new Error(`workspace "${name}" allowed_agents must be an array of strings`);
+    }
+  }
+  const agents = {};
+  for (const [name, agent] of Object.entries(raw.agents)) {
+    const driver = agent.driver;
+    const command = typeof agent.command === "string" ? resolveAgentCommand(driver, agent.command) : undefined;
+    agents[name] = {
+      driver,
+      ...command ? { command } : {}
+    };
+  }
+  const workspaces = {};
+  for (const [name, workspace] of Object.entries(raw.workspaces)) {
+    workspaces[name] = {
+      cwd: workspace.cwd,
+      ...typeof workspace.description === "string" ? { description: workspace.description } : {}
+    };
+  }
+  return {
+    transport: {
+      ...typeof transport.command === "string" ? { command: transport.command } : {},
+      ...typeof transport.sessionInitTimeoutMs === "number" ? { sessionInitTimeoutMs: transport.sessionInitTimeoutMs } : {},
+      type: transport.type ?? "acpx-bridge"
+    },
+    logging: {
+      level: typeof logging?.level === "string" ? logging.level : options.defaultLoggingLevel ?? DEFAULT_LOGGING_CONFIG.level,
+      maxSizeBytes: typeof logging?.maxSizeBytes === "number" ? logging.maxSizeBytes : DEFAULT_LOGGING_CONFIG.maxSizeBytes,
+      maxFiles: typeof logging?.maxFiles === "number" ? logging.maxFiles : DEFAULT_LOGGING_CONFIG.maxFiles,
+      retentionDays: typeof logging?.retentionDays === "number" ? logging.retentionDays : DEFAULT_LOGGING_CONFIG.retentionDays
+    },
+    agents,
+    workspaces
+  };
+}
+var DEFAULT_LOGGING_CONFIG;
+var init_load_config = __esm(() => {
+  DEFAULT_LOGGING_CONFIG = {
+    level: "info",
+    maxSizeBytes: 2 * 1024 * 1024,
+    maxFiles: 5,
+    retentionDays: 7
+  };
+});
+
+// src/config/config-store.ts
+import { mkdir as mkdir6, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname5 } from "node:path";
+
+class ConfigStore {
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  async load() {
+    return await loadConfig(this.path);
+  }
+  async save(config) {
+    await mkdir6(dirname5(this.path), { recursive: true });
+    await writeFile4(this.path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  }
+  async upsertWorkspace(name, cwd, description) {
+    const config = await this.load();
+    const workspace = {
+      cwd,
+      ...description ? { description } : {}
+    };
+    config.workspaces[name] = workspace;
+    await this.save(config);
+    return config;
+  }
+  async removeWorkspace(name) {
+    const config = await this.load();
+    delete config.workspaces[name];
+    await this.save(config);
+    return config;
+  }
+  async upsertAgent(name, agent) {
+    const config = await this.load();
+    config.agents[name] = agent;
+    await this.save(config);
+    return config;
+  }
+  async removeAgent(name) {
+    const config = await this.load();
+    delete config.agents[name];
+    await this.save(config);
+    return config;
+  }
+}
+var init_config_store = __esm(() => {
+  init_load_config();
+});
+
+// src/config/ensure-config.ts
+import { readFile as readFile4 } from "node:fs/promises";
+async function ensureConfigExists(path) {
+  try {
+    await loadConfig(path);
+  } catch (error) {
+    if (!isMissingFileError2(error)) {
+      throw error;
+    }
+    const store = new ConfigStore(path);
+    await store.save(await loadDefaultConfigTemplate());
+  }
+}
+async function loadDefaultConfigTemplate() {
+  const templatePath = new URL("../../config.example.json", import.meta.url);
+  const template = JSON.parse(await readFile4(templatePath, "utf8"));
+  return {
+    ...template,
+    agents: Object.fromEntries(Object.entries(template.agents).map(([name, agent]) => [
+      name,
+      {
+        driver: agent.driver,
+        ...resolveAgentCommand(agent.driver, agent.command) ? { command: resolveAgentCommand(agent.driver, agent.command) } : {}
+      }
+    ])),
+    workspaces: {}
+  };
+}
+function isMissingFileError2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var init_ensure_config = __esm(() => {
+  init_config_store();
+  init_load_config();
+});
+
+// src/config/resolve-acpx-command.ts
+import { readFileSync } from "node:fs";
+import { dirname as dirname6, resolve } from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+function resolveAcpxCommand(options = {}) {
+  if (options.configuredCommand) {
+    return options.configuredCommand;
+  }
+  const platform = options.platform ?? process.platform;
+  const resolvePackageJson = options.resolvePackageJson ?? ((id) => require2.resolve(id));
+  const readPackageJson = options.readPackageJson ?? ((path) => JSON.parse(readFileSync(path, "utf8")));
+  try {
+    const packageJsonPath = resolvePackageJson("acpx/package.json");
+    const pkg = readPackageJson(packageJsonPath);
+    const binPath = typeof pkg.bin === "string" ? pkg.bin : pkg.bin && typeof pkg.bin.acpx === "string" ? pkg.bin.acpx : null;
+    if (binPath) {
+      if (platform === "win32") {
+        return resolve(dirname6(packageJsonPath), "../.bin/acpx.exe");
+      }
+      return resolve(dirname6(packageJsonPath), binPath);
+    }
+  } catch {}
+  return "acpx";
+}
+var require2;
+var init_resolve_acpx_command = __esm(() => {
+  require2 = createRequire2(import.meta.url);
+});
+
+// src/console-agent.ts
+class ConsoleAgent {
+  router;
+  logger;
+  constructor(router, logger) {
+    this.router = router;
+    this.logger = logger ?? createNoopAppLogger();
+  }
+  async chat(request) {
+    if (!request.text.trim()) {
+      return { text: "Empty message." };
+    }
+    await this.logger.info("chat.received", "received inbound chat message", {
+      chatKey: request.conversationId,
+      kind: request.text.trim().startsWith("/") ? "command" : "prompt",
+      text: summarizeText(request.text)
+    });
+    return await this.router.handle(request.conversationId, request.text);
+  }
+}
+function summarizeText(text) {
+  const trimmed = text.trim();
+  if (trimmed.length <= 120) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, 117)}...`;
+}
+var init_console_agent = __esm(() => {
+  init_app_logger();
+});
+
+// src/sessions/session-service.ts
+class SessionService {
+  config;
+  stateStore;
+  state;
+  constructor(config, stateStore, state) {
+    this.config = config;
+    this.stateStore = stateStore;
+    this.state = state;
+  }
+  async createSession(alias, agent, workspace) {
+    return await this.createLogicalSession(alias, agent, workspace, `${workspace}:${alias}`);
+  }
+  resolveSession(alias, agent, workspace, transportSession) {
+    this.validateSession(alias, agent, workspace);
+    return this.toResolvedSession({
+      alias,
+      agent,
+      workspace,
+      transport_session: transportSession,
+      created_at: this.state.sessions[alias]?.created_at ?? new Date().toISOString(),
+      last_used_at: new Date().toISOString()
+    });
+  }
+  async attachSession(alias, agent, workspace, transportSession) {
+    return await this.createLogicalSession(alias, agent, workspace, transportSession);
+  }
+  async useSession(chatKey, alias) {
+    const session = this.state.sessions[alias];
+    if (!session) {
+      throw new Error(`session "${alias}" does not exist`);
+    }
+    session.last_used_at = new Date().toISOString();
+    this.state.chat_contexts[chatKey] = { current_session: alias };
+    await this.persist();
+  }
+  async getCurrentSession(chatKey) {
+    const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
+    if (!currentAlias) {
+      return null;
+    }
+    const session = this.state.sessions[currentAlias];
+    if (!session) {
+      return null;
+    }
+    session.last_used_at = new Date().toISOString();
+    await this.persist();
+    return this.toResolvedSession(session);
+  }
+  async listSessions(chatKey) {
+    const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
+    return Object.values(this.state.sessions).map((session) => ({
+      alias: session.alias,
+      agent: session.agent,
+      workspace: session.workspace,
+      isCurrent: session.alias === currentAlias
+    }));
+  }
+  toResolvedSession(session) {
+    const agentConfig = this.config.agents[session.agent];
+    return {
+      alias: session.alias,
+      agent: session.agent,
+      agentCommand: resolveAgentCommand(agentConfig.driver, agentConfig.command),
+      workspace: session.workspace,
+      transportSession: session.transport_session,
+      cwd: this.config.workspaces[session.workspace].cwd
+    };
+  }
+  async persist() {
+    await this.stateStore.save(this.state);
+  }
+  async createLogicalSession(alias, agent, workspace, transportSession) {
+    this.validateSession(alias, agent, workspace);
+    const existingSession = this.state.sessions[alias];
+    const now = new Date().toISOString();
+    const session = {
+      alias,
+      agent,
+      workspace,
+      transport_session: transportSession,
+      created_at: existingSession?.created_at ?? now,
+      last_used_at: now
+    };
+    this.state.sessions[alias] = session;
+    await this.persist();
+    return this.toResolvedSession(session);
+  }
+  validateSession(alias, agent, workspace) {
+    if (!this.config.workspaces[workspace]) {
+      throw new Error(`workspace "${workspace}" is not registered`);
+    }
+    if (!this.config.agents[agent]) {
+      throw new Error(`agent "${agent}" is not registered`);
+    }
+  }
+}
+var init_session_service = () => {};
+
+// src/state/types.ts
+function createEmptyState() {
+  return {
+    sessions: {},
+    chat_contexts: {}
+  };
+}
+
+// src/state/state-store.ts
+import { mkdir as mkdir7, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname7 } from "node:path";
+
+class StateStore {
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  async load() {
+    try {
+      const content = await readFile5(this.path, "utf8");
+      if (content.trim() === "") {
+        return createEmptyState();
+      }
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return createEmptyState();
+      }
+      throw error;
+    }
+  }
+  async save(state) {
+    await mkdir7(dirname7(this.path), { recursive: true });
+    await writeFile5(this.path, JSON.stringify(state, null, 2));
+  }
+}
+var init_state_store = () => {};
+
+// src/run-console.ts
+var exports_run_console = {};
+__export(exports_run_console, {
+  runConsole: () => runConsole
+});
+async function runConsole(paths, deps) {
+  const runtime = await deps.buildApp(paths);
+  const sdk = await deps.loadWeixinSdk();
+  const setIntervalFn = deps.setInterval ?? ((fn, delay) => setInterval(fn, delay));
+  const clearIntervalFn = deps.clearInterval ?? ((timer) => clearInterval(timer));
+  let heartbeatTimer = null;
+  try {
+    if (deps.daemonRuntime) {
+      await deps.daemonRuntime.start({
+        configPath: paths.configPath,
+        statePath: paths.statePath
+      });
+      heartbeatTimer = setIntervalFn(() => deps.daemonRuntime?.heartbeat(), deps.heartbeatIntervalMs ?? 30000);
+    }
+    await sdk.start(runtime.agent);
+  } finally {
+    if (heartbeatTimer !== null) {
+      clearIntervalFn(heartbeatTimer);
+    }
+    await runtime.dispose();
+    if (deps.daemonRuntime) {
+      await deps.daemonRuntime.stop();
+    }
+  }
+}
+
+// src/transport/acpx-bridge/acpx-bridge-protocol.ts
+function encodeBridgeRequest(request) {
+  return `${JSON.stringify(request)}
+`;
+}
+
+// src/transport/acpx-bridge/acpx-bridge-client.ts
+import { spawn as spawn2 } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+
+class AcpxBridgeClient {
+  writeLine;
+  nextId = 1;
+  pending = new Map;
+  constructor(writeLine) {
+    this.writeLine = writeLine;
+  }
+  request(method, params) {
+    const id = String(this.nextId);
+    this.nextId += 1;
+    return awaitable((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+      this.writeLine(encodeBridgeRequest({
+        id,
+        method,
+        params
+      }));
+    });
+  }
+  handleLine(line) {
+    const response = JSON.parse(line);
+    const pending = this.pending.get(response.id);
+    if (!pending) {
+      return;
+    }
+    this.pending.delete(response.id);
+    if (response.ok) {
+      pending.resolve(response.result);
+      return;
+    }
+    pending.reject(new Error(response.error.message));
+  }
+}
+function buildBridgeSpawnSpec(options) {
+  if (options.execPath.endsWith("bun")) {
+    return {
+      command: options.execPath,
+      args: ["run", options.bridgeEntryPath]
+    };
+  }
+  return {
+    command: options.execPath,
+    args: [options.bridgeEntryPath]
+  };
+}
+async function spawnAcpxBridgeClient(options = {}) {
+  const bridgeEntryPath = options.bridgeEntryPath ?? fileURLToPath(new URL("../../bridge/bridge-main.ts", import.meta.url));
+  const spawnSpec = buildBridgeSpawnSpec({
+    execPath: process.execPath,
+    bridgeEntryPath
+  });
+  const child = spawn2(spawnSpec.command, spawnSpec.args, {
+    cwd: options.cwd ?? process.cwd(),
+    env: {
+      ...process.env,
+      WEACPX_BRIDGE_ACPX_COMMAND: options.acpxCommand ?? "acpx"
+    },
+    stdio: ["pipe", "pipe", "inherit"]
+  });
+  const client = new AcpxBridgeClient((line) => {
+    child.stdin.write(line);
+  });
+  const output = createInterface({
+    input: child.stdout,
+    crlfDelay: Infinity
+  });
+  output.on("line", (line) => {
+    client.handleLine(line);
+  });
+  child.on("exit", () => {
+    output.close();
+  });
+  client.waitUntilReady = async () => {
+    await client.request("ping", {});
+  };
+  client.dispose = async () => {
+    try {
+      await client.request("shutdown", {});
+    } finally {
+      child.stdin.end();
+      child.kill("SIGTERM");
+    }
+  };
+  await client.waitUntilReady();
+  return client;
+}
+function awaitable(executor) {
+  return new Promise((resolve2, reject) => {
+    executor(resolve2, reject);
+  });
+}
+var init_acpx_bridge_client = () => {};
+
+// src/transport/acpx-bridge/acpx-bridge-transport.ts
+class AcpxBridgeTransport {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async ensureSession(session) {
+    await this.client.request("ensureSession", this.toParams(session));
+  }
+  async prompt(session, text) {
+    return await this.client.request("prompt", {
+      ...this.toParams(session),
+      text
+    });
+  }
+  async cancel(session) {
+    return await this.client.request("cancel", this.toParams(session));
+  }
+  async hasSession(session) {
+    const result = await this.client.request("hasSession", this.toParams(session));
+    return result.exists;
+  }
+  async listSessions() {
+    return [];
+  }
+  async dispose() {
+    await this.client.dispose?.();
+  }
+  toParams(session) {
+    return {
+      agent: session.agent,
+      agentCommand: session.agentCommand,
+      cwd: session.cwd,
+      name: session.transportSession
+    };
+  }
+}
+
+// src/transport/acpx-cli/node-pty-helper.ts
+import { chmod as chmodFs } from "node:fs/promises";
+import { dirname as dirname8, join as join3 } from "node:path";
+function resolveNodePtyHelperPath(packageJsonPath, platform, arch) {
+  if (platform === "win32") {
+    return null;
+  }
+  return join3(dirname8(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
+}
+async function ensureNodePtyHelperExecutable(helperPath, chmod = chmodFs) {
+  if (!helperPath) {
+    return;
+  }
+  try {
+    await chmod(helperPath, 493);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+var init_node_pty_helper = () => {};
+
+// src/transport/acpx-cli/acpx-cli-transport.ts
+import { createRequire as createRequire3 } from "node:module";
+import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawnPty } from "node-pty";
+async function defaultRunner(command, args, options) {
+  return await new Promise((resolve2, reject) => {
+    const child = spawn3(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timeoutId = options?.timeoutMs ? setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`acpx command timed out after ${options.timeoutMs}ms: ${renderCommandForError(args)}`));
+    }, options.timeoutMs) : undefined;
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      resolve2({ code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+async function defaultPtyRunner(command, args, options) {
+  const helperPath = resolveNodePtyHelperPath(require3.resolve("node-pty/package.json"), process.platform, process.arch);
+  await ensureNodePtyHelperExecutable(helperPath);
+  return await new Promise((resolve2, reject) => {
+    const child = spawnPty(command, args, {
+      name: "xterm-color",
+      cols: 80,
+      rows: 24,
+      cwd: process.cwd(),
+      env: process.env
+    });
+    let output = "";
+    const timeoutId = options?.timeoutMs ? setTimeout(() => {
+      child.kill();
+      reject(new Error(`acpx command timed out after ${options.timeoutMs}ms: ${renderCommandForError(args)}`));
+    }, options.timeoutMs) : undefined;
+    child.onData((chunk) => {
+      output += chunk;
+    });
+    child.onExit(({ exitCode }) => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      resolve2({ code: exitCode, stdout: output, stderr: "" });
+    });
+  });
+}
+
+class AcpxCliTransport {
+  command;
+  sessionInitTimeoutMs;
+  runCommand;
+  runPtyCommand;
+  constructor(options, runCommand = defaultRunner, runPtyCommand = defaultPtyRunner) {
+    this.command = options.command ?? "acpx";
+    this.sessionInitTimeoutMs = options.sessionInitTimeoutMs ?? 120000;
+    this.runCommand = runCommand;
+    this.runPtyCommand = runPtyCommand;
+  }
+  async ensureSession(session) {
+    const args = this.buildArgs(session, [
+      "sessions",
+      "new",
+      "--name",
+      session.transportSession
+    ]);
+    const runEnsure = session.agentCommand ? this.run : this.runWithPty;
+    await runEnsure.call(this, args, {
+      timeoutMs: this.sessionInitTimeoutMs
+    });
+  }
+  async prompt(session, text) {
+    const output = await this.run(this.buildPromptArgs(session, text));
+    return { text: sanitizePromptText(extractPromptText(output)) };
+  }
+  async cancel(session) {
+    const output = await this.run(this.buildArgs(session, [
+      "cancel",
+      "-s",
+      session.transportSession
+    ]));
+    return {
+      cancelled: true,
+      message: output.trim()
+    };
+  }
+  async hasSession(session) {
+    const result = await this.runCommand(this.command, this.buildArgs(session, [
+      "sessions",
+      "show",
+      session.transportSession
+    ]));
+    return result.code === 0;
+  }
+  async listSessions() {
+    return [];
+  }
+  async run(args, options) {
+    const result = await this.runCommandWithTimeout(this.runCommand, args, options);
+    if (result.code !== 0) {
+      const detail = normalizeCommandError(result) ?? `command failed with exit code ${result.code}`;
+      throw new Error(detail);
+    }
+    return result.stdout;
+  }
+  async runWithPty(args, options) {
+    const result = await this.runCommandWithTimeout(this.runPtyCommand, args, options);
+    if (result.code !== 0) {
+      const detail = normalizeCommandError(result) ?? `command failed with exit code ${result.code}`;
+      throw new Error(detail);
+    }
+    return result.stdout;
+  }
+  async runCommandWithTimeout(runner, args, options) {
+    if (!options?.timeoutMs) {
+      return await runner(this.command, args, undefined);
+    }
+    let timeoutId;
+    return await Promise.race([
+      runner(this.command, args, options).finally(() => {
+        if (timeoutId)
+          clearTimeout(timeoutId);
+      }),
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(`acpx command timed out after ${options.timeoutMs}ms: ${renderCommandForError(args)}`));
+        }, options.timeoutMs);
+      })
+    ]);
+  }
+  buildArgs(session, tail) {
+    const prefix = ["--format", "quiet", "--cwd", session.cwd];
+    if (session.agentCommand) {
+      return [...prefix, "--agent", session.agentCommand, ...tail];
+    }
+    return [...prefix, session.agent, ...tail];
+  }
+  buildPromptArgs(session, text) {
+    const prefix = ["--format", "json", "--json-strict", "--cwd", session.cwd];
+    const tail = ["prompt", "-s", session.transportSession, text];
+    if (session.agentCommand) {
+      return [...prefix, "--agent", session.agentCommand, ...tail];
+    }
+    return [...prefix, session.agent, ...tail];
+  }
+}
+function renderCommandForError(args) {
+  const rendered = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--format") {
+      index += 1;
+      continue;
+    }
+    if (arg === "--cwd") {
+      index += 1;
+      continue;
+    }
+    rendered.push(/\s/.test(arg) || arg.includes(":") ? `"${arg}"` : arg);
+  }
+  return rendered.join(" ");
+}
+function extractPromptText(output) {
+  const lines = output.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+  const messageSegments = [];
+  let currentSegment = "";
+  for (const line of lines) {
+    try {
+      const event = JSON.parse(line);
+      const isMessageChunk = event.method === "session/update" && event.params?.update?.sessionUpdate === "agent_message_chunk" && event.params.update.content?.type === "text" && typeof event.params.update.content.text === "string";
+      if (isMessageChunk) {
+        const chunk = event.params.update.content.text ?? "";
+        if (chunk.length > 0) {
+          currentSegment += chunk;
+        }
+        continue;
+      }
+      if (currentSegment.trim().length > 0) {
+        messageSegments.push(currentSegment.trim());
+      }
+      currentSegment = "";
+    } catch {
+      if (currentSegment.trim().length > 0) {
+        messageSegments.push(currentSegment.trim());
+        currentSegment = "";
+      }
+    }
+  }
+  if (currentSegment.trim().length > 0) {
+    messageSegments.push(currentSegment.trim());
+  }
+  if (messageSegments.length > 0) {
+    return messageSegments[messageSegments.length - 1];
+  }
+  return output.trim();
+}
+function sanitizePromptText(text) {
+  const trimmed = text.trim();
+  const paragraphs = trimmed.split(/\n\s*\n/);
+  if (paragraphs.length < 2) {
+    return trimmed;
+  }
+  const firstParagraph = paragraphs[0].trim().replace(/\s+/g, " ").toLowerCase();
+  if (!looksLikeWorkflowPreamble(firstParagraph)) {
+    return trimmed;
+  }
+  return paragraphs.slice(1).join(`
+
+`).trim();
+}
+function looksLikeWorkflowPreamble(paragraph) {
+  if (!paragraph.startsWith("using ")) {
+    return false;
+  }
+  return paragraph.includes("using-superpowers") || paragraph.includes("repo workflow requirement") || paragraph.includes("workflow requirement") || paragraph.includes("before responding") || paragraph.includes("skill check");
+}
+function normalizeCommandError(result) {
+  const rpcMessages = extractJsonRpcErrorMessages(result.stderr).concat(extractJsonRpcErrorMessages(result.stdout)).filter((message) => message.length > 0);
+  const preferredMessage = [...rpcMessages].reverse().find((message) => message !== "Resource not found");
+  if (preferredMessage) {
+    return preferredMessage;
+  }
+  if (rpcMessages.length > 0) {
+    return rpcMessages[rpcMessages.length - 1] ?? null;
+  }
+  return result.stderr.trim() || result.stdout.trim() || null;
+}
+function extractJsonRpcErrorMessages(output) {
+  return output.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0).flatMap((line) => {
+    try {
+      const payload = JSON.parse(line);
+      if (typeof payload.error?.message === "string" && payload.error.message.length > 0) {
+        return [payload.error.message];
+      }
+    } catch {
+      return [];
+    }
+    return [];
+  });
+}
+var require3;
+var init_acpx_cli_transport = __esm(() => {
+  init_node_pty_helper();
+  require3 = createRequire3(import.meta.url);
+});
+
+// src/main.ts
+var exports_main = {};
+__export(exports_main, {
+  resolveRuntimePaths: () => resolveRuntimePaths,
+  main: () => main2,
+  buildApp: () => buildApp
+});
+import { homedir } from "node:os";
+import { dirname as dirname9, join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+async function buildApp(paths, deps = {}) {
+  await ensureConfigExists(paths.configPath);
+  const configStore = new ConfigStore(paths.configPath);
+  const config = await loadConfig(paths.configPath, {
+    defaultLoggingLevel: deps.defaultLoggingLevel
+  });
+  const logger = createAppLogger({
+    filePath: resolveAppLogPath(paths.configPath),
+    level: config.logging.level,
+    maxSizeBytes: config.logging.maxSizeBytes,
+    maxFiles: config.logging.maxFiles,
+    retentionDays: config.logging.retentionDays,
+    now: deps.loggerNow
+  });
+  await logger.cleanup();
+  const acpxCommand = resolveAcpxCommand({ configuredCommand: config.transport.command });
+  const stateStore = new StateStore(paths.statePath);
+  const state = await stateStore.load();
+  const sessions = new SessionService(config, stateStore, state);
+  const transport = config.transport.type === "acpx-bridge" ? await (deps.createBridgeTransport?.() ?? Promise.resolve(new AcpxBridgeTransport(await spawnAcpxBridgeClient({
+    acpxCommand,
+    bridgeEntryPath: resolveBridgeEntryPath()
+  })))) : deps.createCliTransport?.(acpxCommand) ?? new AcpxCliTransport({ ...config.transport, command: acpxCommand });
+  const router = new CommandRouter(sessions, transport, config, configStore, logger);
+  const agent = new ConsoleAgent(router, logger);
+  return {
+    agent,
+    router,
+    sessions,
+    stateStore,
+    configStore,
+    logger,
+    dispose: async () => {
+      if ("dispose" in transport && typeof transport.dispose === "function") {
+        await transport.dispose();
+      }
+    }
+  };
+}
+async function main2() {
+  const paths = resolveRuntimePaths();
+  try {
+    await runConsole(paths, {
+      buildApp,
+      loadWeixinSdk
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error([
+      "Failed to start weacpx console.",
+      `config: ${paths.configPath}`,
+      `state: ${paths.statePath}`,
+      message
+    ].join(`
+`));
+  }
+}
+function resolveRuntimePaths() {
+  const home = process.env.HOME ?? homedir();
+  if (!home) {
+    throw new Error("Unable to resolve the current user home directory");
+  }
+  return {
+    configPath: process.env.WEACPX_CONFIG ?? `${home}/.weacpx/config.json`,
+    statePath: process.env.WEACPX_STATE ?? `${home}/.weacpx/state.json`
+  };
+}
+function resolveBridgeEntryPath() {
+  if (import.meta.url.includes("/dist/")) {
+    return fileURLToPath2(new URL("./bridge/bridge-main.js", import.meta.url));
+  }
+  return fileURLToPath2(new URL("./bridge/bridge-main.ts", import.meta.url));
+}
+function resolveAppLogPath(configPath) {
+  const rootDir = dirname9(configPath);
+  const runtimeDir = join4(rootDir, "runtime");
+  return join4(runtimeDir, "app.log");
+}
+var init_main = __esm(async () => {
+  init_command_router();
+  init_config_store();
+  init_ensure_config();
+  init_load_config();
+  init_resolve_acpx_command();
+  init_console_agent();
+  init_app_logger();
+  init_session_service();
+  init_state_store();
+  init_acpx_bridge_client();
+  init_acpx_cli_transport();
+  if (false) {}
+});
+
+// src/cli.ts
+import { homedir as homedir2 } from "node:os";
+import { sep } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// src/daemon/create-daemon-controller.ts
+import { mkdir as mkdir3, open } from "node:fs/promises";
+import { spawn } from "node:child_process";
+
+// src/daemon/daemon-controller.ts
+import { mkdir as mkdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+
+// src/daemon/daemon-status.ts
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+class DaemonStatusStore {
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  async load() {
+    try {
+      const content = await readFile(this.path, "utf8");
+      if (content.trim() === "") {
+        return null;
+      }
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async save(status) {
+    await mkdir(dirname(this.path), { recursive: true });
+    await writeFile(this.path, JSON.stringify(status, null, 2));
+  }
+  async clear() {
+    await rm(this.path, { force: true });
+  }
+}
+
+// src/daemon/daemon-controller.ts
+class DaemonController {
+  paths;
+  deps;
+  statusStore;
+  constructor(paths, deps) {
+    this.paths = paths;
+    this.deps = deps;
+    this.statusStore = new DaemonStatusStore(paths.statusFile);
+  }
+  async getStatus() {
+    const pid = await this.loadPid();
+    const status = await this.statusStore.load();
+    if (!pid) {
+      return { state: "stopped" };
+    }
+    if (!this.deps.isProcessRunning(pid)) {
+      await this.clearRuntimeFiles();
+      return { state: "stopped", stale: true };
+    }
+    if (!status) {
+      return { state: "stopped" };
+    }
+    return {
+      state: "running",
+      pid,
+      status
+    };
+  }
+  async start() {
+    const current = await this.getStatus();
+    if (current.state === "running") {
+      return { state: "already-running", pid: current.pid };
+    }
+    const pid = await this.deps.spawnDetached();
+    await this.writePid(pid);
+    return { state: "started", pid };
+  }
+  async stop() {
+    const pid = await this.loadPid();
+    if (!pid) {
+      return { state: "stopped", detail: "not-running" };
+    }
+    if (this.deps.isProcessRunning(pid)) {
+      await this.deps.terminateProcess(pid);
+    }
+    await this.clearRuntimeFiles();
+    return { state: "stopped", detail: "stopped" };
+  }
+  async loadPid() {
+    try {
+      const content = await readFile2(this.paths.pidFile, "utf8");
+      const pid = Number(content.trim());
+      return Number.isFinite(pid) && pid > 0 ? pid : null;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async writePid(pid) {
+    await mkdir2(dirname2(this.paths.pidFile), { recursive: true });
+    await writeFile2(this.paths.pidFile, `${pid}
+`);
+  }
+  async clearRuntimeFiles() {
+    await rm2(this.paths.pidFile, { force: true });
+    await this.statusStore.clear();
+  }
+}
+
+// src/daemon/create-daemon-controller.ts
+function createDaemonController(paths, options) {
+  return new DaemonController(paths, {
+    isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning,
+    spawnDetached: async () => {
+      await mkdir3(paths.runtimeDir, { recursive: true });
+      const stdoutHandle = await open(paths.stdoutLog, "a");
+      const stderrHandle = await open(paths.stderrLog, "a");
+      try {
+        return await (options.spawnProcess ?? defaultSpawnProcess)({
+          command: options.processExecPath,
+          args: [options.cliEntryPath, "run"],
+          options: {
+            cwd: options.cwd,
+            detached: true,
+            env: options.env,
+            stdio: ["ignore", stdoutHandle.fd, stderrHandle.fd],
+            ...(options.platform ?? process.platform) === "win32" ? { windowsHide: true } : {}
+          }
+        });
+      } finally {
+        await stdoutHandle.close();
+        await stderrHandle.close();
+      }
+    },
+    terminateProcess: options.terminateProcess ?? defaultTerminateProcess
+  });
+}
+function defaultIsProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function defaultSpawnProcess(request) {
+  const child = spawn(request.command, request.args, request.options);
+  child.unref();
+  return child.pid ?? 0;
+}
+async function defaultTerminateProcess(pid) {
+  await terminateProcessTree(pid);
+}
+async function terminateProcessTree(pid, platform = process.platform, runCommand = defaultRunProcessCommand) {
+  if (platform === "win32") {
+    try {
+      await runCommand("taskkill", ["/PID", String(pid), "/T", "/F"]);
+    } catch {}
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!defaultIsProcessRunning(pid)) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {}
+}
+async function defaultRunProcessCommand(command, args) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: "ignore" });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+
+// src/daemon/daemon-files.ts
+import { join } from "node:path";
+function resolveDaemonPaths(options) {
+  const runtimeDir = options.runtimeDir ?? join(options.home, ".weacpx", "runtime");
+  return {
+    runtimeDir,
+    pidFile: join(runtimeDir, "daemon.pid"),
+    statusFile: join(runtimeDir, "status.json"),
+    stdoutLog: join(runtimeDir, "stdout.log"),
+    stderrLog: join(runtimeDir, "stderr.log"),
+    appLog: join(runtimeDir, "app.log")
+  };
+}
+
+// src/daemon/daemon-runtime.ts
+import { mkdir as mkdir4, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+class DaemonRuntime {
+  paths;
+  options;
+  statusStore;
+  now;
+  currentStatus = null;
+  constructor(paths, options) {
+    this.paths = paths;
+    this.options = options;
+    this.statusStore = new DaemonStatusStore(paths.statusFile);
+    this.now = options.now ?? (() => new Date().toISOString());
+  }
+  async start(input) {
+    const timestamp = this.now();
+    this.currentStatus = {
+      pid: this.options.pid,
+      started_at: timestamp,
+      heartbeat_at: timestamp,
+      config_path: input.configPath,
+      state_path: input.statePath,
+      app_log: this.paths.appLog,
+      stdout_log: this.paths.stdoutLog,
+      stderr_log: this.paths.stderrLog
+    };
+    await mkdir4(dirname3(this.paths.pidFile), { recursive: true });
+    await writeFile3(this.paths.pidFile, `${this.options.pid}
+`);
+    await this.statusStore.save(this.currentStatus);
+  }
+  async heartbeat() {
+    if (!this.currentStatus) {
+      return;
+    }
+    this.currentStatus = {
+      ...this.currentStatus,
+      heartbeat_at: this.now()
+    };
+    await this.statusStore.save(this.currentStatus);
+  }
+  async stop() {
+    await rm3(this.paths.pidFile, { force: true });
+    await this.statusStore.clear();
+    this.currentStatus = null;
+  }
+}
+
+// src/cli.ts
+var HELP_LINES = ["用法：", "weacpx login", "weacpx run", "weacpx start", "weacpx status", "weacpx stop"];
+async function runCli(args, deps = {}) {
+  const command = args[0];
+  const print = deps.print ?? ((line) => console.log(line));
+  const controller = deps.controller ?? createDefaultController();
+  switch (command) {
+    case "login":
+      await (deps.login ?? defaultLogin)();
+      return 0;
+    case "run":
+      await (deps.run ?? defaultRun)();
+      return 0;
+    case "start": {
+      const result = await controller.start();
+      if (result.state === "already-running") {
+        print("weacpx 已在后台运行");
+        print(`PID: ${result.pid}`);
+        return 0;
+      }
+      print("weacpx 已在后台启动");
+      print(`PID: ${result.pid}`);
+      return 0;
+    }
+    case "status": {
+      const status = await controller.getStatus();
+      if (status.state !== "running") {
+        print("weacpx 未运行");
+        return 0;
+      }
+      print("weacpx 正在运行");
+      print(`PID: ${status.pid}`);
+      print(`Started: ${status.status.started_at}`);
+      print(`Heartbeat: ${status.status.heartbeat_at}`);
+      print(`Config: ${status.status.config_path}`);
+      print(`State: ${status.status.state_path}`);
+      print(`App Log: ${status.status.app_log}`);
+      print(`Stdout: ${status.status.stdout_log}`);
+      print(`Stderr: ${status.status.stderr_log}`);
+      return 0;
+    }
+    case "stop": {
+      const result = await controller.stop();
+      if (result.detail === "not-running") {
+        print("weacpx 未运行");
+        return 0;
+      }
+      print("weacpx 已停止");
+      return 0;
+    }
+    default:
+      for (const line of HELP_LINES) {
+        print(line);
+      }
+      return 1;
+  }
+}
+async function defaultLogin() {
+  const { main: main3 } = await init_login().then(() => exports_login);
+  await main3();
+}
+async function defaultRun() {
+  const [{ buildApp: buildApp2, resolveRuntimePaths: resolveRuntimePaths2 }, { loadWeixinSdk: loadWeixinSdk2 }, { runConsole: runConsole2 }] = await Promise.all([
+    init_main().then(() => exports_main),
+    Promise.resolve().then(() => exports_weixin_sdk),
+    Promise.resolve().then(() => exports_run_console)
+  ]);
+  const runtimePaths = resolveRuntimePaths2();
+  const daemonPaths = resolveDaemonPaths({ home: requireHome() });
+  const daemonRuntime = new DaemonRuntime(daemonPaths, { pid: process.pid });
+  await runConsole2(runtimePaths, {
+    buildApp: (paths) => buildApp2(paths, {
+      defaultLoggingLevel: resolveCliEntryPath().includes(`${sep}src${sep}`) ? "debug" : "info"
+    }),
+    loadWeixinSdk: loadWeixinSdk2,
+    daemonRuntime
+  });
+}
+function createDefaultController() {
+  const daemonPaths = resolveDaemonPaths({ home: requireHome() });
+  return createDaemonController(daemonPaths, {
+    processExecPath: process.execPath,
+    cliEntryPath: resolveCliEntryPath(),
+    cwd: process.cwd(),
+    env: process.env
+  });
+}
+function requireHome() {
+  const home = process.env.HOME ?? homedir2();
+  if (!home) {
+    throw new Error("Unable to resolve the current user home directory");
+  }
+  return home;
+}
+function resolveCliEntryPath() {
+  if (process.argv[1]) {
+    return process.argv[1];
+  }
+  return fileURLToPath3(import.meta.url);
+}
+if (__require.main == __require.module) {
+  process.exitCode = await runCli(process.argv.slice(2));
+}
+export {
+  runCli
+};