alink-cli 0.4.2 → 0.5.0

package/dist/daemon.js

@@ -2271,7 +2271,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2809,7 +2809,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes2(16).toString("base64");
+      const key = randomBytes3(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -3702,12 +3702,1082 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// node_modules/qrcode-terminal/vendor/QRCode/QRMode.js
+var require_QRMode = __commonJS({
+  "node_modules/qrcode-terminal/vendor/QRCode/QRMode.js"(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({
+  "node_modules/qrcode-terminal/vendor/QRCode/QR8bitByte.js"(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({
+  "node_modules/qrcode-terminal/vendor/QRCode/QRMath.js"(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({
+  "node_modules/qrcode-terminal/vendor/QRCode/QRPolynomial.js"(exports, module) {
+    var QRMath = require_QRMath();
+    function QRPolynomial(num, shift) {
+      if (num.length === void 0) {
+        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({
+  "node_modules/qrcode-terminal/vendor/QRCode/QRMaskPattern.js"(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({
+  "node_modules/qrcode-terminal/vendor/QRCode/QRUtil.js"(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({
+  "node_modules/qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel.js"(exports, module) {
+    module.exports = {
+      L: 1,
+      M: 0,
+      Q: 3,
+      H: 2
+    };
+  }
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRRSBlock.js
+var require_QRRSBlock = __commonJS({
+  "node_modules/qrcode-terminal/vendor/QRCode/QRRSBlock.js"(exports, module) {
+    var QRErrorCorrectLevel = require_QRErrorCorrectLevel();
+    function QRRSBlock(totalCount, dataCount) {
+      this.totalCount = totalCount;
+      this.dataCount = dataCount;
+    }
+    QRRSBlock.RS_BLOCK_TABLE = [
+      // L
+      // M
+      // Q
+      // H
+      // 1
+      [1, 26, 19],
+      [1, 26, 16],
+      [1, 26, 13],
+      [1, 26, 9],
+      // 2
+      [1, 44, 34],
+      [1, 44, 28],
+      [1, 44, 22],
+      [1, 44, 16],
+      // 3
+      [1, 70, 55],
+      [1, 70, 44],
+      [2, 35, 17],
+      [2, 35, 13],
+      // 4		
+      [1, 100, 80],
+      [2, 50, 32],
+      [2, 50, 24],
+      [4, 25, 9],
+      // 5
+      [1, 134, 108],
+      [2, 67, 43],
+      [2, 33, 15, 2, 34, 16],
+      [2, 33, 11, 2, 34, 12],
+      // 6
+      [2, 86, 68],
+      [4, 43, 27],
+      [4, 43, 19],
+      [4, 43, 15],
+      // 7		
+      [2, 98, 78],
+      [4, 49, 31],
+      [2, 32, 14, 4, 33, 15],
+      [4, 39, 13, 1, 40, 14],
+      // 8
+      [2, 121, 97],
+      [2, 60, 38, 2, 61, 39],
+      [4, 40, 18, 2, 41, 19],
+      [4, 40, 14, 2, 41, 15],
+      // 9
+      [2, 146, 116],
+      [3, 58, 36, 2, 59, 37],
+      [4, 36, 16, 4, 37, 17],
+      [4, 36, 12, 4, 37, 13],
+      // 10		
+      [2, 86, 68, 2, 87, 69],
+      [4, 69, 43, 1, 70, 44],
+      [6, 43, 19, 2, 44, 20],
+      [6, 43, 15, 2, 44, 16],
+      // 11
+      [4, 101, 81],
+      [1, 80, 50, 4, 81, 51],
+      [4, 50, 22, 4, 51, 23],
+      [3, 36, 12, 8, 37, 13],
+      // 12
+      [2, 116, 92, 2, 117, 93],
+      [6, 58, 36, 2, 59, 37],
+      [4, 46, 20, 6, 47, 21],
+      [7, 42, 14, 4, 43, 15],
+      // 13
+      [4, 133, 107],
+      [8, 59, 37, 1, 60, 38],
+      [8, 44, 20, 4, 45, 21],
+      [12, 33, 11, 4, 34, 12],
+      // 14
+      [3, 145, 115, 1, 146, 116],
+      [4, 64, 40, 5, 65, 41],
+      [11, 36, 16, 5, 37, 17],
+      [11, 36, 12, 5, 37, 13],
+      // 15
+      [5, 109, 87, 1, 110, 88],
+      [5, 65, 41, 5, 66, 42],
+      [5, 54, 24, 7, 55, 25],
+      [11, 36, 12],
+      // 16
+      [5, 122, 98, 1, 123, 99],
+      [7, 73, 45, 3, 74, 46],
+      [15, 43, 19, 2, 44, 20],
+      [3, 45, 15, 13, 46, 16],
+      // 17
+      [1, 135, 107, 5, 136, 108],
+      [10, 74, 46, 1, 75, 47],
+      [1, 50, 22, 15, 51, 23],
+      [2, 42, 14, 17, 43, 15],
+      // 18
+      [5, 150, 120, 1, 151, 121],
+      [9, 69, 43, 4, 70, 44],
+      [17, 50, 22, 1, 51, 23],
+      [2, 42, 14, 19, 43, 15],
+      // 19
+      [3, 141, 113, 4, 142, 114],
+      [3, 70, 44, 11, 71, 45],
+      [17, 47, 21, 4, 48, 22],
+      [9, 39, 13, 16, 40, 14],
+      // 20
+      [3, 135, 107, 5, 136, 108],
+      [3, 67, 41, 13, 68, 42],
+      [15, 54, 24, 5, 55, 25],
+      [15, 43, 15, 10, 44, 16],
+      // 21
+      [4, 144, 116, 4, 145, 117],
+      [17, 68, 42],
+      [17, 50, 22, 6, 51, 23],
+      [19, 46, 16, 6, 47, 17],
+      // 22
+      [2, 139, 111, 7, 140, 112],
+      [17, 74, 46],
+      [7, 54, 24, 16, 55, 25],
+      [34, 37, 13],
+      // 23
+      [4, 151, 121, 5, 152, 122],
+      [4, 75, 47, 14, 76, 48],
+      [11, 54, 24, 14, 55, 25],
+      [16, 45, 15, 14, 46, 16],
+      // 24
+      [6, 147, 117, 4, 148, 118],
+      [6, 73, 45, 14, 74, 46],
+      [11, 54, 24, 16, 55, 25],
+      [30, 46, 16, 2, 47, 17],
+      // 25
+      [8, 132, 106, 4, 133, 107],
+      [8, 75, 47, 13, 76, 48],
+      [7, 54, 24, 22, 55, 25],
+      [22, 45, 15, 13, 46, 16],
+      // 26
+      [10, 142, 114, 2, 143, 115],
+      [19, 74, 46, 4, 75, 47],
+      [28, 50, 22, 6, 51, 23],
+      [33, 46, 16, 4, 47, 17],
+      // 27
+      [8, 152, 122, 4, 153, 123],
+      [22, 73, 45, 3, 74, 46],
+      [8, 53, 23, 26, 54, 24],
+      [12, 45, 15, 28, 46, 16],
+      // 28
+      [3, 147, 117, 10, 148, 118],
+      [3, 73, 45, 23, 74, 46],
+      [4, 54, 24, 31, 55, 25],
+      [11, 45, 15, 31, 46, 16],
+      // 29
+      [7, 146, 116, 7, 147, 117],
+      [21, 73, 45, 7, 74, 46],
+      [1, 53, 23, 37, 54, 24],
+      [19, 45, 15, 26, 46, 16],
+      // 30
+      [5, 145, 115, 10, 146, 116],
+      [19, 75, 47, 10, 76, 48],
+      [15, 54, 24, 25, 55, 25],
+      [23, 45, 15, 25, 46, 16],
+      // 31
+      [13, 145, 115, 3, 146, 116],
+      [2, 74, 46, 29, 75, 47],
+      [42, 54, 24, 1, 55, 25],
+      [23, 45, 15, 28, 46, 16],
+      // 32
+      [17, 145, 115],
+      [10, 74, 46, 23, 75, 47],
+      [10, 54, 24, 35, 55, 25],
+      [19, 45, 15, 35, 46, 16],
+      // 33
+      [17, 145, 115, 1, 146, 116],
+      [14, 74, 46, 21, 75, 47],
+      [29, 54, 24, 19, 55, 25],
+      [11, 45, 15, 46, 46, 16],
+      // 34
+      [13, 145, 115, 6, 146, 116],
+      [14, 74, 46, 23, 75, 47],
+      [44, 54, 24, 7, 55, 25],
+      [59, 46, 16, 1, 47, 17],
+      // 35
+      [12, 151, 121, 7, 152, 122],
+      [12, 75, 47, 26, 76, 48],
+      [39, 54, 24, 14, 55, 25],
+      [22, 45, 15, 41, 46, 16],
+      // 36
+      [6, 151, 121, 14, 152, 122],
+      [6, 75, 47, 34, 76, 48],
+      [46, 54, 24, 10, 55, 25],
+      [2, 45, 15, 64, 46, 16],
+      // 37
+      [17, 152, 122, 4, 153, 123],
+      [29, 74, 46, 14, 75, 47],
+      [49, 54, 24, 10, 55, 25],
+      [24, 45, 15, 46, 46, 16],
+      // 38
+      [4, 152, 122, 18, 153, 123],
+      [13, 74, 46, 32, 75, 47],
+      [48, 54, 24, 14, 55, 25],
+      [42, 45, 15, 32, 46, 16],
+      // 39
+      [20, 147, 117, 4, 148, 118],
+      [40, 75, 47, 7, 76, 48],
+      [43, 54, 24, 22, 55, 25],
+      [10, 45, 15, 67, 46, 16],
+      // 40
+      [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 === void 0) {
+        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 void 0;
+      }
+    };
+    module.exports = QRRSBlock;
+  }
+});
+
+// node_modules/qrcode-terminal/vendor/QRCode/QRBitBuffer.js
+var require_QRBitBuffer = __commonJS({
+  "node_modules/qrcode-terminal/vendor/QRCode/QRBitBuffer.js"(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({
+  "node_modules/qrcode-terminal/vendor/QRCode/index.js"(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({
+  "node_modules/qrcode-terminal/lib/main.js"(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 qrcode2 = new QRCode(-1, this.error);
+        qrcode2.addData(input);
+        qrcode2.make();
+        var output = "";
+        if (opts && opts.small) {
+          var BLACK = true, WHITE = false;
+          var moduleCount = qrcode2.getModuleCount();
+          var moduleData = qrcode2.modules.slice();
+          var oddRow = moduleCount % 2 === 1;
+          if (oddRow) {
+            moduleData.push(fill(moduleCount, WHITE));
+          }
+          var platte = {
+            WHITE_ALL: "\u2588",
+            WHITE_BLACK: "\u2580",
+            BLACK_WHITE: "\u2584",
+            BLACK_ALL: " "
+          };
+          var borderTop = repeat(platte.BLACK_WHITE).times(moduleCount + 3);
+          var borderBottom = repeat(platte.WHITE_BLACK).times(moduleCount + 3);
+          output += borderTop + "\n";
+          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 + "\n";
+          }
+          if (!oddRow) {
+            output += borderBottom;
+          }
+        } else {
+          var border = repeat(white).times(qrcode2.getModuleCount() + 3);
+          output += border + "\n";
+          qrcode2.modules.forEach(function(row2) {
+            output += white;
+            output += row2.map(toCell).join("");
+            output += white + "\n";
+          });
+          output += border;
+        }
+        if (cb) cb(output);
+        else console.log(output);
+      },
+      setErrorLevel: function(error) {
+        this.error = QRErrorCorrectLevel[error] || this.error;
+      }
+    };
+  }
+});
+
 // src/main.ts
 import { spawn as spawn3 } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { readFileSync as readFileSync4, readdirSync as readdirSync3, realpathSync, rmSync as rmSync2, statSync } from "node:fs";
-import { constants as osConstants, homedir as homedir5, hostname } from "node:os";
-import { join as join5, resolve } from "node:path";
+import { randomBytes as randomBytes2, randomUUID } from "node:crypto";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync as readdirSync4, realpathSync, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { constants as osConstants, homedir as homedir6, hostname } from "node:os";
+import { join as join6, resolve } from "node:path";
 import { parseArgs as nodeParseArgs } from "node:util";
 
 // node_modules/ws/wrapper.mjs
@@ -3720,6 +4790,9 @@ var import_subprotocol = __toESM(require_subprotocol(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 
+// src/main.ts
+var import_qrcode_terminal = __toESM(require_main(), 1);
+
 // src/env.ts
 import { spawn } from "node:child_process";
 import { existsSync, readdirSync } from "node:fs";
@@ -3882,6 +4955,63 @@ function probeClaudeModels() {
   }
   return names;
 }
+async function runWithApproval(opts) {
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+  const ac = new AbortController();
+  if (opts.signal.aborted) ac.abort();
+  else opts.signal.addEventListener("abort", () => ac.abort(), { once: true });
+  const parseLine = createClaudeParser(opts.onEvent);
+  let resultError;
+  let resultCode = 0;
+  try {
+    const q = query({
+      prompt: opts.prompt,
+      options: {
+        // Send-for-approval grading is the CLI's own (§1.1): default prompts
+        // for dangerous ops, auto-allows Read/Glob/Grep.
+        permissionMode: "default",
+        // The suspend/approve hook. SDK deny REQUIRES a message string — the
+        // steer note (or a default) lands there and the agent sees it next.
+        canUseTool: async (toolName, input) => {
+          const decision = await opts.requestPermission(toolName, input);
+          if (decision.behavior === "deny") {
+            return { behavior: "deny", message: decision.note ?? "\u7528\u6237\u5728\u624B\u673A\u4E0A\u62D2\u7EDD\u4E86\u672C\u6B21\u64CD\u4F5C" };
+          }
+          return { behavior: "allow", updatedInput: input };
+        },
+        // Keep token-level streaming (the stream_event → text/thinking path).
+        includePartialMessages: true,
+        cwd: opts.cwd,
+        ...opts.resumeId ? { resume: opts.resumeId } : {},
+        ...opts.model ? { model: opts.model } : {},
+        // The SDK does NOT read filesystem config by default — declare the
+        // sources explicitly so CLAUDE.md / settings.json behave like a direct
+        // CLI run (§1.1 坑).
+        settingSources: ["user", "project", "local"],
+        // Run the user's probed claude, not the SDK's bundled copy — keeps
+        // model/login state identical to a direct run (§3.5).
+        pathToClaudeCodeExecutable: opts.bin,
+        abortController: ac
+      }
+    });
+    for await (const msg of q) {
+      parseLine(JSON.stringify(msg));
+      if (msg.type === "result") {
+        const r = msg;
+        if (r.is_error) {
+          resultCode = 1;
+          resultError = typeof r.result === "string" && r.result ? r.result : r.subtype ?? "claude run failed";
+        } else {
+          resultCode = 0;
+        }
+      }
+    }
+  } catch (err) {
+    if (ac.signal.aborted) return { code: 143 };
+    return { code: 1, error: err instanceof Error ? err.message : String(err) };
+  }
+  return { code: resultCode, ...resultError ? { error: resultError } : {} };
+}
 var claude = {
   id: "claude",
   label: "Claude Code",
@@ -3907,7 +5037,8 @@ var claude = {
     ],
     stdin: prompt
   }),
-  createParser: createClaudeParser
+  createParser: createClaudeParser,
+  runWithApproval
 };
 
 // src/adapters/codex.ts
@@ -4007,16 +5138,118 @@ var codex = {
   // above (this system already trusts the agent fully once it's running),
   // but never exercised end-to-end because of an account rate limit
   // during development — verify before relying on it.
-  buildInvocation: (prompt, resumeId, model) => {
+  // Approval-mode (M1, approval-design §1.2): codex has no runWithApproval
+  // yet (app-server integration is M2), so under --approval it still spawns —
+  // but the resume path MUST NOT carry the naked bypass flag. The cost is
+  // that a resume tool call needing approval fails honestly instead of
+  // silently bypassing; fresh runs already have the workspace-write sandbox.
+  buildInvocation: (prompt, resumeId, model, opts) => {
     const m = model ? ["-m", model] : [];
     return {
-      args: resumeId ? ["exec", "resume", resumeId, "-", "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox", ...m] : ["exec", "--json", "--skip-git-repo-check", "--sandbox", "workspace-write", ...m],
+      args: resumeId ? [
+        "exec",
+        "resume",
+        resumeId,
+        "-",
+        "--json",
+        "--skip-git-repo-check",
+        ...opts?.approval ? [] : ["--dangerously-bypass-approvals-and-sandbox"],
+        ...m
+      ] : ["exec", "--json", "--skip-git-repo-check", "--sandbox", "workspace-write", ...m],
       stdin: prompt
     };
   },
   createParser: createCodexParser
 };
 
+// src/adapters/gemini-core.ts
+function createGeminiParser(emit) {
+  let lastSessionId = null;
+  return (line) => {
+    const obj = parseJsonLine(line);
+    if (!obj || typeof obj.type !== "string") return;
+    switch (obj.type) {
+      case "init":
+        if (typeof obj.session_id === "string" && obj.session_id !== lastSessionId) {
+          lastSessionId = obj.session_id;
+          emit({ type: "session", id: obj.session_id });
+        }
+        return;
+      case "message":
+        if (obj.role === "assistant" && typeof obj.content === "string" && obj.content) {
+          emit({ type: "text", text: obj.content });
+        }
+        return;
+      case "tool_use":
+        if (typeof obj.tool_id === "string") {
+          emit({ type: "tool_use", id: obj.tool_id, name: String(obj.tool_name ?? "tool"), input: obj.parameters ?? null });
+        }
+        return;
+      case "tool_result":
+        if (typeof obj.tool_id === "string") {
+          const content = typeof obj.output === "string" ? obj.output : obj.error?.message ?? "";
+          emit({ type: "tool_result", toolUseId: obj.tool_id, content, isError: obj.status === "error" });
+        }
+        return;
+      case "error":
+        if (typeof obj.message === "string" && obj.message) {
+          emit({ type: "error", message: obj.message });
+        }
+        return;
+      case "result":
+        if (obj.status === "error" && typeof obj.error?.message === "string" && obj.error.message) {
+          emit({ type: "error", message: obj.error.message });
+        }
+        return;
+    }
+  };
+}
+
+// src/adapters/gemini.ts
+var gemini = {
+  id: "gemini",
+  label: "Gemini CLI",
+  // Suggested chips; gemini accepts any model id its account exposes via -m.
+  // No config file reliably lists the active model, so there is no probe.
+  models: ["gemini-2.5-pro", "gemini-2.5-flash"],
+  buildInvocation: (prompt, resumeId, model) => {
+    if (resumeId) {
+      throw new Error(
+        'Gemini CLI cannot resume a specific session in headless mode: its --resume flag takes only "latest" or a numeric index, not a session id. Start a new conversation instead.'
+      );
+    }
+    const m = model ? ["-m", model] : [];
+    return {
+      // Prompt on argv (like joycode) so headless mode is unambiguous even if
+      // stdin/TTY detection differs; stdin is left empty by the daemon.
+      args: ["-p", prompt, "-o", "stream-json", "--approval-mode", "yolo", ...m]
+    };
+  },
+  createParser: createGeminiParser
+};
+
+// src/adapters/iflow.ts
+function createIflowParser(emit) {
+  return (line) => {
+    emit({ type: "text", text: line + "\n" });
+  };
+}
+var iflow = {
+  id: "iflow",
+  label: "iFlow CLI",
+  models: ["Qwen3-Coder", "Kimi-K2", "DeepSeek-V3"],
+  buildInvocation: (prompt, resumeId, model) => {
+    if (resumeId) {
+      throw new Error(
+        "iFlow CLI cannot resume a specific session here: its headless mode emits no session id (no stream-json output yet, see iflow-ai/iflow-cli#239), so there is no id to reattach to. Start a new conversation instead."
+      );
+    }
+    const m = model ? ["-m", model] : [];
+    return { args: ["-p", prompt, "--yolo", ...m] };
+  },
+  createParser: createIflowParser
+};
+
 // src/adapters/joycode.ts
 async function probeJoycodeModels(bin) {
   const out = await captureCommand(bin, ["models"], 5e3);
@@ -4045,10 +5278,22 @@ var joycode = {
   // Putting flags after `resume` is a usage error (unlike codex's
   // `exec resume <id> -` word order). stdin feeding is unverified, so
   // fresh runs also pass the prompt via argv for consistency.
-  buildInvocation: (prompt, resumeId, model) => {
+  // Approval-mode (M1, approval-design §1.2): same treatment as codex — no
+  // runWithApproval yet, so under --approval the resume path drops the naked
+  // bypass flag (honest failure over silent bypass).
+  buildInvocation: (prompt, resumeId, model, opts) => {
     const m = model ? ["-m", model] : [];
     return {
-      args: resumeId ? ["exec", "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox", ...m, "resume", resumeId, prompt] : ["exec", "--json", "--skip-git-repo-check", "--sandbox", "workspace-write", ...m, prompt]
+      args: resumeId ? [
+        "exec",
+        "--json",
+        "--skip-git-repo-check",
+        ...opts?.approval ? [] : ["--dangerously-bypass-approvals-and-sandbox"],
+        ...m,
+        "resume",
+        resumeId,
+        prompt
+      ] : ["exec", "--json", "--skip-git-repo-check", "--sandbox", "workspace-write", ...m, prompt]
     };
   },
   // Shares codex's parser (isomorphic JSONL), but with a JoyCode-flavored
@@ -4056,8 +5301,32 @@ var joycode = {
   createParser: (emit) => createCodexParser(emit, "Your JoyCode CLI is out of date for this model \u2014 upgrade it (or pick a model your current version supports), then retry.")
 };
 
+// src/adapters/qwen.ts
+var qwen = {
+  id: "qwen",
+  label: "Qwen Code",
+  models: ["qwen3-coder-plus", "qwen3-coder-flash"],
+  buildInvocation: (prompt, resumeId, model) => {
+    const m = model ? ["-m", model] : [];
+    return {
+      // `-r <sessionId>` resumes by id (verified via `qwen --help`); a fresh
+      // run omits it. Prompt on argv to force headless mode unambiguously.
+      args: [
+        "-p",
+        prompt,
+        "-o",
+        "stream-json",
+        "--yolo",
+        ...m,
+        ...resumeId ? ["-r", resumeId] : []
+      ]
+    };
+  },
+  createParser: createGeminiParser
+};
+
 // src/adapters/index.ts
-var REGISTRY = [claude, codex, joycode];
+var REGISTRY = [claude, codex, joycode, gemini, qwen, iflow];
 function detectAgents() {
   return REGISTRY.flatMap((def) => {
     const bin = resolveBin(def.id);
@@ -4068,6 +5337,108 @@ function getAgent(id) {
   return detectAgents().find((a) => a.id === id) ?? null;
 }
 
+// src/approval.ts
+function defaultDeps() {
+  return {
+    setInterval: (fn, ms) => {
+      const t = setInterval(fn, ms);
+      t.unref?.();
+      return t;
+    },
+    clearInterval: (t) => clearInterval(t),
+    randomId: () => globalThis.crypto?.randomUUID ? globalThis.crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    log: (m) => console.log(m)
+  };
+}
+var RunApprovals = class {
+  constructor(opts) {
+    this.opts = opts;
+    const d = defaultDeps();
+    this.deps = { ...d, ...opts.deps };
+  }
+  pending = /* @__PURE__ */ new Map();
+  deps;
+  get sessionKey() {
+    return this.opts.conversationId ?? this.opts.requestId;
+  }
+  // The function handed to the adapter (ApprovalRunOpts.requestPermission).
+  // Resolves only when a decision lands — or never, if the run dies first
+  // (超时不自动放行, §3.3): there is no timeout path that resolves.
+  requestPermission(tool, input) {
+    const grants = this.opts.sessionGrants.get(this.sessionKey);
+    if (grants?.has(tool)) {
+      this.deps.log(`[approval] requestId=${this.opts.requestId} tool=${tool} auto-allowed (session grant)`);
+      return Promise.resolve({ behavior: "allow" });
+    }
+    const approvalId = this.deps.randomId();
+    return new Promise((resolve2) => {
+      const entry = { tool, input, resolve: resolve2 };
+      this.pending.set(approvalId, entry);
+      this.opts.callbacks.sendRequest({ approvalId, tool, input, renotify: false });
+      if (this.opts.renotifyMs > 0) {
+        entry.timer = this.deps.setInterval(
+          () => this.opts.callbacks.sendRequest({ approvalId, tool, input, renotify: true }),
+          this.opts.renotifyMs
+        );
+      }
+      this.deps.log(`[approval] requestId=${this.opts.requestId} approvalId=${approvalId} tool=${tool} suspended, awaiting decision`);
+    });
+  }
+  // Apply a decision from a permission_response (§2.4). Idempotent: an unknown
+  // / already-decided approvalId is a logged no-op (returns false), so repeated
+  // or multi-device taps are harmless. `note` must already be plaintext.
+  resolve(approvalId, decision, note) {
+    const entry = this.pending.get(approvalId);
+    if (!entry) {
+      this.deps.log(`[approval] permission_response approvalId=${approvalId} ignored (unknown / already decided / stale)`);
+      return false;
+    }
+    this.pending.delete(approvalId);
+    if (entry.timer) this.deps.clearInterval(entry.timer);
+    if (decision === "allow_session") {
+      let set = this.opts.sessionGrants.get(this.sessionKey);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        this.opts.sessionGrants.set(this.sessionKey, set);
+      }
+      set.add(entry.tool);
+    }
+    this.opts.callbacks.emitResult({ approvalId, decision, note });
+    entry.resolve(decision === "deny" ? { behavior: "deny", note } : { behavior: "allow" });
+    this.deps.log(`[approval] requestId=${this.opts.requestId} approvalId=${approvalId} decided=${decision}`);
+    return true;
+  }
+  // Run is dying (cancel / ws close / normal end): clear every pending timer
+  // and drop the pending map. Suspended promises are simply abandoned — the
+  // SDK run is being aborted, so nothing awaits them (§3.3 / §3.7). No decision
+  // is fabricated: 超时/断线不自动放行.
+  abort() {
+    for (const [, entry] of this.pending) {
+      if (entry.timer) this.deps.clearInterval(entry.timer);
+    }
+    const n = this.pending.size;
+    this.pending.clear();
+    if (n) this.deps.log(`[approval] requestId=${this.opts.requestId} aborted ${n} pending approval(s)`);
+  }
+  hasPending(approvalId) {
+    return this.pending.has(approvalId);
+  }
+  get pendingCount() {
+    return this.pending.size;
+  }
+};
+var APPROVAL_INPUT_MAX_BYTES = 16 * 1024;
+function capApprovalInput(input) {
+  let bytes;
+  try {
+    bytes = Buffer.byteLength(JSON.stringify(input) ?? "", "utf-8");
+  } catch {
+    return { input: { _truncated: true }, inputTruncated: true };
+  }
+  if (bytes > APPROVAL_INPUT_MAX_BYTES) return { input: { _truncated: true }, inputTruncated: true };
+  return { input, inputTruncated: false };
+}
+
 // src/e2e.ts
 import { createCipheriv, createDecipheriv, createHash, hkdfSync, randomBytes } from "node:crypto";
 var SALT = Buffer.from("agentlink", "utf-8");
@@ -4182,6 +5553,8 @@ function putConversation(patch) {
   if (sessionId !== void 0) merged.sessionId = sessionId;
   const archived = typeof patch.archived === "boolean" ? patch.archived : existing?.archived;
   if (archived === true) merged.archived = true;
+  const takeover = typeof patch.takeover === "boolean" ? patch.takeover : existing?.takeover;
+  if (takeover === true) merged.takeover = true;
   if (!merged.agent || !merged.dir || !merged.title || !merged.createdAt || !merged.lastActiveAt) {
     return { error: "creating a conversation requires agent, dir, title, createdAt and lastActiveAt" };
   }
@@ -4327,6 +5700,306 @@ function history(conversationId) {
   return runs;
 }
 
+// src/sessions.ts
+import { closeSync, openSync, readdirSync as readdirSync3, readSync, readFileSync as readFileSync4, statSync } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
+
+// ../core/src/session-archive.ts
+function resultText2(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => c && c.type === "text" ? String(c.text ?? "") : JSON.stringify(c)).join("\n");
+  }
+  return content === void 0 ? "" : JSON.stringify(content);
+}
+function userText(message) {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const b of content) {
+    if (b && typeof b === "object" && b.type === "text" && typeof b.text === "string") {
+      parts.push(b.text);
+    }
+  }
+  return parts.join("\n");
+}
+function isHumanPrompt(message) {
+  const content = message.content;
+  if (typeof content === "string") return content.trim().length > 0;
+  if (!Array.isArray(content)) return false;
+  return content.some((b) => b && typeof b === "object" && b.type === "text" && String(b.text ?? "").trim().length > 0);
+}
+function toolResultEvents(message) {
+  const content = message.content;
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const b of content) {
+    if (b && typeof b === "object" && b.type === "tool_result") {
+      const block = b;
+      out.push({
+        type: "tool_result",
+        toolUseId: String(block.tool_use_id ?? ""),
+        content: resultText2(block.content),
+        isError: Boolean(block.is_error)
+      });
+    }
+  }
+  return out;
+}
+function assistantEvents(message) {
+  const content = message.content;
+  if (!Array.isArray(content)) return { events: [], omitted: 0 };
+  const out = [];
+  let omitted = 0;
+  for (const b of content) {
+    if (!b || typeof b !== "object") {
+      omitted++;
+      continue;
+    }
+    const block = b;
+    if (block.type === "text" && typeof block.text === "string" && block.text) {
+      out.push({ type: "text", text: block.text });
+    } else if (block.type === "thinking" && typeof block.thinking === "string" && block.thinking) {
+      out.push({ type: "thinking", text: block.thinking });
+    } else if (block.type === "tool_use") {
+      out.push({ type: "tool_use", id: String(block.id ?? ""), name: String(block.name ?? ""), input: block.input ?? null });
+    }
+  }
+  return { events: out, omitted };
+}
+function tsOf(obj) {
+  const t = obj.timestamp;
+  if (typeof t === "number" && Number.isFinite(t)) return t;
+  if (typeof t === "string") {
+    const ms = Date.parse(t);
+    if (Number.isFinite(ms)) return ms;
+  }
+  return void 0;
+}
+function parseClaudeArchive(text, opts) {
+  const maxTurns = opts?.maxTurns ?? Infinity;
+  const turns = [];
+  let current = null;
+  let sessionId;
+  let cwd;
+  let omitted = 0;
+  const openTurn = (prompt, startedAt) => {
+    current = { prompt, events: [], ...startedAt !== void 0 ? { startedAt } : {} };
+    turns.push(current);
+  };
+  for (const raw of text.split("\n")) {
+    if (!raw.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(raw);
+    } catch {
+      omitted++;
+      continue;
+    }
+    if (!obj || typeof obj !== "object") {
+      omitted++;
+      continue;
+    }
+    if (typeof obj.sessionId === "string" && !sessionId) sessionId = obj.sessionId;
+    if (typeof obj.cwd === "string" && !cwd) cwd = obj.cwd;
+    const type = obj.type;
+    const message = obj.message;
+    if (type === "user" && message && typeof message === "object") {
+      const msg = message;
+      if (isHumanPrompt(msg)) {
+        openTurn(userText(msg), tsOf(obj));
+      } else {
+        if (!current) openTurn("", tsOf(obj));
+        current.events.push(...toolResultEvents(msg));
+      }
+    } else if (type === "assistant" && message && typeof message === "object") {
+      if (!current) openTurn("", tsOf(obj));
+      const { events, omitted: skipped } = assistantEvents(message);
+      current.events.push(...events);
+      omitted += skipped;
+    }
+  }
+  let truncatedEarlier = false;
+  let kept = turns;
+  if (turns.length > maxTurns) {
+    kept = turns.slice(turns.length - maxTurns);
+    truncatedEarlier = true;
+  }
+  return { sessionId, cwd, turns: kept, omitted, truncatedEarlier };
+}
+function claudeArchiveMeta(headText, tailText) {
+  let sessionId;
+  let cwd;
+  let title = "";
+  for (const raw of headText.split("\n")) {
+    if (!raw.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (typeof obj.sessionId === "string" && !sessionId) sessionId = obj.sessionId;
+    if (typeof obj.cwd === "string" && !cwd) cwd = obj.cwd;
+    if (!title && obj.type === "user" && obj.message && typeof obj.message === "object") {
+      const msg = obj.message;
+      if (isHumanPrompt(msg)) title = firstLine(userText(msg));
+    }
+    if (sessionId && cwd && title) break;
+  }
+  let lastLine = "";
+  const tailLines = tailText.split("\n").filter((l) => l.trim());
+  for (let i = tailLines.length - 1; i >= 0 && !lastLine; i--) {
+    let obj;
+    try {
+      obj = JSON.parse(tailLines[i]);
+    } catch {
+      continue;
+    }
+    if ((obj.type === "assistant" || obj.type === "user") && obj.message && typeof obj.message === "object") {
+      const msg = obj.message;
+      const text = obj.type === "assistant" ? assistantText(msg) : isHumanPrompt(msg) ? userText(msg) : "";
+      if (text.trim()) lastLine = firstLine(text);
+    }
+  }
+  return { ...sessionId ? { sessionId } : {}, ...cwd ? { cwd } : {}, title, lastLine };
+}
+function assistantText(message) {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const b of content) {
+    if (b && typeof b === "object" && b.type === "text" && typeof b.text === "string") {
+      parts.push(b.text);
+    }
+  }
+  return parts.join(" ");
+}
+function firstLine(s) {
+  const line = s.split("\n").find((l) => l.trim()) ?? "";
+  return line.trim();
+}
+
+// src/sessions.ts
+function claudeProjectsDir() {
+  const base = process.env.AGENTLINK_CLAUDE_HOME || join5(homedir5(), ".claude");
+  return join5(base, "projects");
+}
+var META_SLICE_BYTES = 64 * 1024;
+var MAX_SESSIONS = 40;
+var MAX_HISTORY_TURNS = 40;
+var SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+function readHeadTail(path, size) {
+  if (size <= META_SLICE_BYTES * 2) {
+    const whole = readFileSync4(path, "utf-8");
+    return { head: whole, tail: whole };
+  }
+  const fd = openSync(path, "r");
+  try {
+    const headBuf = Buffer.alloc(META_SLICE_BYTES);
+    readSync(fd, headBuf, 0, META_SLICE_BYTES, 0);
+    const tailBuf = Buffer.alloc(META_SLICE_BYTES);
+    readSync(fd, tailBuf, 0, META_SLICE_BYTES, size - META_SLICE_BYTES);
+    const tail = tailBuf.toString("utf-8");
+    return { head: headBuf.toString("utf-8"), tail: tail.slice(tail.indexOf("\n") + 1) };
+  } finally {
+    closeSync(fd);
+  }
+}
+function scanClaudeSessions() {
+  const root = claudeProjectsDir();
+  let projectDirs;
+  try {
+    projectDirs = readdirSync3(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join5(root, e.name));
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  for (const dir of projectDirs) {
+    let entries;
+    try {
+      entries = readdirSync3(dir).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const file = join5(dir, name);
+      try {
+        const st = statSync(file);
+        if (!st.isFile() || st.size === 0) continue;
+        candidates.push({ file, sessionId: name.replace(/\.jsonl$/, ""), mtime: st.mtimeMs, size: st.size });
+      } catch {
+      }
+    }
+  }
+  candidates.sort((a, b) => b.mtime - a.mtime);
+  const sessions = [];
+  for (const c of candidates.slice(0, MAX_SESSIONS)) {
+    let meta;
+    try {
+      const { head, tail } = readHeadTail(c.file, c.size);
+      meta = claudeArchiveMeta(head, tail);
+    } catch {
+      continue;
+    }
+    sessions.push({
+      agent: "claude",
+      sessionId: c.sessionId,
+      ...meta.cwd ? { cwd: meta.cwd } : {},
+      title: meta.title || "(\u65E0\u6807\u9898\u4F1A\u8BDD)",
+      lastLine: meta.lastLine,
+      mtime: Math.round(c.mtime)
+    });
+  }
+  return sessions;
+}
+function findClaudeArchive(sessionId) {
+  const root = claudeProjectsDir();
+  const target = `${sessionId}.jsonl`;
+  let projectDirs;
+  try {
+    projectDirs = readdirSync3(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return null;
+  }
+  for (const d of projectDirs) {
+    const file = join5(root, d, target);
+    try {
+      if (statSync(file).isFile()) return file;
+    } catch {
+    }
+  }
+  return null;
+}
+function claudeSessionHistory(agent, sessionId) {
+  if (agent !== "claude") return { error: `session takeover supports claude only in M1 (got "${agent}")` };
+  if (!SESSION_ID_RE.test(sessionId)) return { error: "malformed sessionId" };
+  const file = findClaudeArchive(sessionId);
+  if (!file) return { error: `no archive found for session "${sessionId}"` };
+  let text;
+  try {
+    text = readFileSync4(file, "utf-8");
+  } catch (err) {
+    return { error: `cannot read archive: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const parsed = parseClaudeArchive(text, { maxTurns: MAX_HISTORY_TURNS });
+  const runs = parsed.turns.map((turn, i) => ({
+    runId: `${sessionId}~${i}`,
+    agent: "claude",
+    prompt: turn.prompt,
+    ...parsed.cwd ? { cwd: parsed.cwd } : {},
+    sessionId,
+    startedAt: turn.startedAt ?? 0,
+    status: "done",
+    truncated: false,
+    events: turn.events
+  }));
+  return { runs, truncatedEarlier: parsed.truncatedEarlier };
+}
+
 // src/tunnel.ts
 import { spawn as spawn2 } from "node:child_process";
 import { connect } from "node:net";
@@ -4425,10 +6098,16 @@ async function startTunnel(hubPort) {
 var PROTOCOL_VERSION = 1;
 function usage(error) {
   if (error) console.error(`[daemon] ${error}`);
-  console.error(`usage: alink-cli [--hub <ws(s)://host[:port]>] [--token <token>] [--dir <path>]...`);
+  console.error(`usage: alink-cli [--hub <ws(s)://host[:port]>] [--token <token>] [--dir <path>]... [--approval] [--approval-renotify <min>]`);
+  console.error(`       alink-cli --pair [--hub <wss://multi hub>] [--dir <path>]...`);
   console.error(`       alink-cli --tunnel [--port <local hub port>] [--token <token>] [--dir <path>]...`);
+  console.error(`       (--pair = QR pairing: bind this credential-less machine by scanning the terminal QR)`);
   console.error(`       (--tunnel = start a local hub + a free Cloudflare quick tunnel, all in one command)`);
   console.error(`       (the token may also be supplied via the AGENTLINK_TOKEN env var; --token wins)`);
+  console.error(`       (--approval = controlled-permission mode: sensitive tool calls suspend and await`);
+  console.error(`        phone approval \u2014 M1 supports claude only; env AGENTLINK_APPROVAL=1 equivalent)`);
+  console.error(`       (--approval-renotify <min> = re-push interval for a pending approval, default 5, 0 = off;`);
+  console.error(`        env AGENTLINK_APPROVAL_RENOTIFY_MIN)`);
   process.exit(1);
 }
 function parseArgs(argv) {
@@ -4441,7 +6120,10 @@ function parseArgs(argv) {
         token: { type: "string" },
         dir: { type: "string", multiple: true },
         tunnel: { type: "boolean" },
-        port: { type: "string" }
+        port: { type: "string" },
+        pair: { type: "boolean" },
+        approval: { type: "boolean" },
+        "approval-renotify": { type: "string" }
       },
       strict: true,
       allowPositionals: false
@@ -4451,21 +6133,148 @@ function parseArgs(argv) {
   }
   if (values.tunnel && values.hub) usage("--tunnel starts its own local hub; it cannot be combined with --hub");
   if (values.port && !values.tunnel) usage("--port only applies to --tunnel mode (it is the LOCAL hub's port)");
+  if (values.pair && values.tunnel) usage("--pair binds to a multi-tenant hub; it cannot be combined with --tunnel");
+  if (values.pair && values.token) usage("--pair mints a fresh credential via scanning; it cannot be combined with --token");
   const port = values.port === void 0 ? 8080 : Number(values.port);
   if (!Number.isInteger(port) || port <= 0 || port > 65535) usage(`invalid --port "${values.port}" (expected 1-65535)`);
   const dirs = (values.dir ?? []).map((d) => resolve(d));
   if (dirs.length === 0) dirs.push(process.cwd());
+  const envApproval = process.env.AGENTLINK_APPROVAL === "1" || process.env.AGENTLINK_APPROVAL === "true";
+  const approval = values.approval ?? envApproval;
+  const renotifyRaw = values["approval-renotify"] ?? (process.env.AGENTLINK_APPROVAL_RENOTIFY_MIN || void 0);
+  const approvalRenotifyMin = renotifyRaw === void 0 ? 5 : Number(renotifyRaw);
+  if (!Number.isInteger(approvalRenotifyMin) || approvalRenotifyMin < 0) {
+    usage(`invalid --approval-renotify "${renotifyRaw}" (expected a non-negative integer, minutes; 0 = off)`);
+  }
   return {
     // Credential precedence: --token > AGENTLINK_TOKEN env > generated UUID
-    // (an empty env var counts as absent).
+    // (an empty env var counts as absent). In --pair mode this resolved token
+    // is ignored — pairing mints the credential.
     token: values.token ?? (process.env.AGENTLINK_TOKEN || void 0) ?? randomUUID(),
     hub: values.hub ?? (values.tunnel ? `ws://localhost:${port}` : "ws://localhost:8080"),
     dirs,
     tunnel: values.tunnel ?? false,
-    port
+    port,
+    pair: values.pair ?? false,
+    approval,
+    approvalRenotifyMin
   };
 }
-var { token: RAW_TOKEN, hub: HUB, dirs: DIRS, tunnel: TUNNEL, port: TUNNEL_PORT } = parseArgs(process.argv.slice(2));
+var ARGS = parseArgs(process.argv.slice(2));
+var {
+  hub: HUB,
+  dirs: DIRS,
+  tunnel: TUNNEL,
+  port: TUNNEL_PORT,
+  pair: PAIR,
+  approval: APPROVAL,
+  approvalRenotifyMin: APPROVAL_RENOTIFY_MIN
+} = ARGS;
+var STATE_DIR2 = process.env.AGENTLINK_STATE_DIR || join6(homedir6(), ".agentlink");
+var CREDENTIAL_FILE = join6(STATE_DIR2, "credential");
+var PAIR_BACKOFF_BASE_MS = 1e3;
+var PAIR_BACKOFF_MAX_MS = 3e4;
+var STARTED_AT = Date.now();
+var STATUS_MID;
+function writeStatus(state, extra = {}) {
+  try {
+    mkdirSync2(STATE_DIR2, { recursive: true });
+    writeFileSync2(
+      join6(STATE_DIR2, "status.json"),
+      JSON.stringify({
+        pid: process.pid,
+        state,
+        hub: HUB,
+        daemonVersion: ownVersion(),
+        startedAt: STARTED_AT,
+        ts: Date.now(),
+        ...STATUS_MID !== void 0 ? { machineId: STATUS_MID } : {},
+        ...extra
+      })
+    );
+  } catch {
+  }
+}
+function persistCredential(token) {
+  mkdirSync2(STATE_DIR2, { recursive: true });
+  writeFileSync2(CREDENTIAL_FILE, token, { mode: 384 });
+  chmodSync2(CREDENTIAL_FILE, 384);
+}
+async function pairForCredential() {
+  const enckey = randomBytes2(32).toString("base64url");
+  const code = randomBytes2(16).toString("base64url");
+  const pairString = `alp1.${code}.${enckey}`;
+  const pairUrl = `${HUB}/daemon?pair=${encodeURIComponent(code)}&host=${encodeURIComponent(hostname())}&v=${PROTOCOL_VERSION}`;
+  console.log(`[daemon] \u672C\u673A\u5C1A\u672A\u7ED1\u5B9A \u2014\u2014 \u8FDB\u5165\u914D\u5BF9\u6A21\u5F0F\uFF0C\u8FDE\u63A5 ${HUB} ...`);
+  writeStatus("pairing");
+  let printed = false;
+  let attempts = 0;
+  const token = await new Promise((resolveClaim) => {
+    const attempt = () => {
+      const ws = new import_websocket.default(pairUrl, { handshakeTimeout: 15e3 });
+      let sawPending = false;
+      ws.on("message", (raw) => {
+        let msg;
+        try {
+          msg = JSON.parse(raw.toString());
+        } catch {
+          return;
+        }
+        if (msg.type === "pair_pending") {
+          sawPending = true;
+          attempts = 0;
+          if (printed) {
+            console.log(`[daemon] \u914D\u5BF9\u901A\u9053\u5DF2\u91CD\u8FDE\uFF0C\u4E8C\u7EF4\u7801\u4ECD\u7136\u6709\u6548\uFF0C\u7EE7\u7EED\u7B49\u5F85\u626B\u7801...`);
+            return;
+          }
+          printed = true;
+          console.log(``);
+          console.log(`  \u7528\u624B\u673A AgentLink \u7684\u300C\u6DFB\u52A0\u673A\u5668\u300D\u626B\u63CF\u4E0B\u9762\u7684\u4E8C\u7EF4\u7801\uFF0C\u5373\u53EF\u7ED1\u5B9A\u8FD9\u53F0\u7535\u8111\uFF1A`);
+          console.log(``);
+          import_qrcode_terminal.default.generate(pairString, { small: true });
+          console.log(``);
+          console.log(`  \u65E0\u6CD5\u626B\u7801\u65F6\uFF0C\u4E5F\u53EF\u5728\u624B\u673A\u4E0A\u624B\u52A8\u7C98\u8D34\u914D\u5BF9\u4E32\uFF1A`);
+          console.log(``);
+          console.log(`    ${pairString}`);
+          console.log(``);
+          console.log(`  \u5BC6\u94A5\u6307\u7EB9 ${fingerprint(enckey)} \u2014\u2014 \u52A0\u5BC6\u5BC6\u94A5\u521A\u5728\u8FD9\u53F0\u7535\u8111\u4E0A\u751F\u6210\uFF0C`);
+          console.log(`  \u53EA\u968F\u4E8C\u7EF4\u7801\u8FDB\u5165\u4F60\u7684\u624B\u673A\uFF0C\u4E0D\u7ECF\u8FC7\u7F51\u7EDC\u4E0E\u670D\u52A1\u5668\u3002\u7B49\u5F85\u626B\u7801...`);
+          return;
+        }
+        if (msg.type === "claimed" && typeof msg.token === "string" && msg.token.startsWith("al1.")) {
+          ws.removeAllListeners("close");
+          ws.close();
+          resolveClaim(`${msg.token}.${enckey}`);
+        }
+      });
+      ws.on("error", (err) => {
+        console.error(`[daemon] \u914D\u5BF9\u8FDE\u63A5\u51FA\u9519: ${err.message}`);
+      });
+      ws.on("close", () => {
+        if (!sawPending && attempts === 2) {
+          console.error(
+            `[daemon] hub \u4E00\u76F4\u6CA1\u6709\u5E94\u7B54\u914D\u5BF9 \u2014\u2014 \u5B83\u53EF\u80FD\u8FD8\u4E0D\u652F\u6301\u626B\u7801\u914D\u5BF9\uFF08\u5347\u7EA7\uFF1Anpx agentlink-hub@latest\uFF09\uFF0C\u6216 --hub \u6307\u5411\u4E86 single \u6A21\u5F0F\u7684 hub\u3002\u4ECD\u5728\u91CD\u8BD5...`
+          );
+        }
+        const cap = Math.min(PAIR_BACKOFF_BASE_MS * 2 ** attempts, PAIR_BACKOFF_MAX_MS);
+        attempts++;
+        setTimeout(attempt, Math.floor(cap / 2 + Math.random() * (cap / 2)));
+      });
+    };
+    attempt();
+  });
+  try {
+    persistCredential(token);
+    console.log(`[daemon] \u5DF2\u7ED1\u5B9A\u5230\u4F60\u7684\u8D26\u53F7 \u2014\u2014 \u51ED\u8BC1\u5DF2\u4FDD\u5B58\u5230 ${CREDENTIAL_FILE}\uFF080600\uFF09\uFF0C\u4E4B\u540E\u88F8\u8DD1 npx alink-cli \u76F4\u63A5\u590D\u7528\u3002`);
+  } catch (err) {
+    console.error(
+      `[daemon] \u51ED\u8BC1\u5199\u5165 ${CREDENTIAL_FILE} \u5931\u8D25\uFF08${err instanceof Error ? err.message : err}\uFF09\u2014\u2014 \u672C\u6B21\u4ECD\u53EF\u7528\uFF0C\u4F46\u4E0B\u6B21\u542F\u52A8\u9700\u8981\u91CD\u65B0\u914D\u5BF9\u3002`
+    );
+  }
+  return token;
+}
+writeStatus("starting");
+var RAW_TOKEN = PAIR ? await pairForCredential() : ARGS.token;
 function fingerprint2(secret) {
   return `${secret.slice(0, 8)}\u2026`;
 }
@@ -4489,6 +6298,7 @@ function parseCredential(raw) {
 }
 var CRED = parseCredential(RAW_TOKEN);
 var TOKEN = CRED.wireToken;
+STATUS_MID = CRED.machineId;
 var ENCKEY = CRED.multi ? CRED.enckey : void 0;
 if (CRED.multi) {
   console.log(`[daemon] multi-tenant credential ${fingerprint2(TOKEN)}${CRED.machineId ? ` (machine ${CRED.machineId})` : ""}`);
@@ -4514,7 +6324,7 @@ function resolveDir(p) {
     };
   }
   try {
-    if (!statSync(real).isDirectory()) return { error: `"${p}" is not a directory` };
+    if (!statSync2(real).isDirectory()) return { error: `"${p}" is not a directory` };
   } catch (err) {
     return {
       error: err.code === "EACCES" ? `permission denied for "${p}"` : `cannot access "${p}"`
@@ -4524,7 +6334,7 @@ function resolveDir(p) {
 }
 function ownVersion() {
   try {
-    return JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf-8")).version;
+    return JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf-8")).version;
   } catch {
     return "0.0.0";
   }
@@ -4552,11 +6362,21 @@ async function probeAgents() {
         def.probeModels ? def.probeModels(bin) : Promise.resolve([])
       ]);
       const models = [.../* @__PURE__ */ new Set([...probed, ...def.models])];
-      return { id: def.id, label: def.label, detected: true, bin, models, ...version ? { version } : {} };
+      return {
+        id: def.id,
+        label: def.label,
+        detected: true,
+        bin,
+        models,
+        ...version ? { version } : {},
+        ...APPROVAL && def.runWithApproval ? { approval: true } : {}
+      };
     })
   );
 }
 var running = /* @__PURE__ */ new Map();
+var approvalRuns = /* @__PURE__ */ new Map();
+var sessionGrants = /* @__PURE__ */ new Map();
 function send(ws, obj) {
   if (ws.readyState === import_websocket.default.OPEN) ws.send(JSON.stringify(obj));
 }
@@ -4592,8 +6412,6 @@ function handleRun(ws, { requestId, agent: agentId, prompt: rawPrompt, sessionId
     if (!real) return fail(`cwd rejected: ${error}`);
     runCwd = real;
   }
-  const invocation = adapter.buildInvocation(prompt, sessionId, typeof model === "string" && model ? model : void 0);
-  console.log(`[daemon] requestId=${requestId} spawning ${adapter.bin} ${invocation.args.join(" ")} (cwd=${runCwd})`);
   const recorder = recordRun(conversationId, {
     runId: requestId,
     agent: agentId,
@@ -4601,6 +6419,32 @@ function handleRun(ws, { requestId, agent: agentId, prompt: rawPrompt, sessionId
     ...cwd !== void 0 ? { cwd } : {},
     ...typeof model === "string" && model ? { model } : {}
   });
+  if (APPROVAL && adapter.runWithApproval) {
+    runWithApprovalPath(ws, {
+      requestId,
+      adapter,
+      prompt,
+      sessionId,
+      runCwd,
+      model: typeof model === "string" && model ? model : void 0,
+      conversationId,
+      notifyDetail,
+      recorder
+    });
+    return;
+  }
+  let invocation;
+  try {
+    invocation = adapter.buildInvocation(
+      prompt,
+      sessionId,
+      typeof model === "string" && model ? model : void 0,
+      { approval: APPROVAL }
+    );
+  } catch (err) {
+    return fail(err instanceof Error ? err.message : String(err));
+  }
+  console.log(`[daemon] requestId=${requestId} spawning ${adapter.bin} ${invocation.args.join(" ")} (cwd=${runCwd})`);
   const child = spawn3(adapter.bin, invocation.args, { cwd: runCwd, env: spawnEnv() });
   running.set(requestId, child);
   child.stdin.on("error", () => {
@@ -4653,8 +6497,139 @@ function handleRun(ws, { requestId, agent: agentId, prompt: rawPrompt, sessionId
     send(ws, { type: "done", requestId, code: null, error: err.message });
   });
 }
+var NOTIFY_TITLE_MAX = 200;
+function approvalNotify(tool, input) {
+  let firstLine2 = "";
+  try {
+    firstLine2 = (JSON.stringify(input) ?? "").split("\n")[0] ?? "";
+  } catch {
+    firstLine2 = "";
+  }
+  return { title: `\u5BA1\u6279\uFF1A${tool}`.slice(0, NOTIFY_TITLE_MAX), summary: firstLine2.slice(0, NOTIFY_SUMMARY_MAX) };
+}
+function runWithApprovalPath(ws, opts) {
+  const { requestId, adapter, recorder } = opts;
+  console.log(`[daemon] requestId=${requestId} starting ${adapter.id} via SDK (approval mode, cwd=${opts.runCwd})`);
+  let lastText;
+  const emitEvent = (evt) => {
+    if (evt.type === "text" && evt.text) lastText = evt.text;
+    if (ENCKEY) {
+      const capped = truncateEventContent(evt);
+      const envelope = encryptEvent(ENCKEY, capped);
+      recorder?.event(capped, envelope);
+      send(ws, { type: "event", requestId, event: envelope });
+      return envelope;
+    }
+    recorder?.event(evt);
+    send(ws, { type: "event", requestId, event: evt });
+    return evt;
+  };
+  const approvals = new RunApprovals({
+    requestId,
+    conversationId: opts.conversationId,
+    renotifyMs: APPROVAL_RENOTIFY_MIN * 6e4,
+    sessionGrants,
+    callbacks: {
+      sendRequest: ({ approvalId, tool, input, renotify }) => {
+        const { input: cappedInput, inputTruncated } = capApprovalInput(input);
+        const evt = { type: "permission_request", id: approvalId, tool, input: cappedInput, inputTruncated };
+        let wireEvent;
+        if (ENCKEY) {
+          const capped = truncateEventContent(evt);
+          wireEvent = encryptEvent(ENCKEY, capped);
+          if (!renotify) recorder?.event(capped, wireEvent);
+        } else {
+          wireEvent = evt;
+          if (!renotify) recorder?.event(evt);
+        }
+        send(ws, {
+          type: "permission_request",
+          requestId,
+          approvalId,
+          event: wireEvent,
+          // Opt-in plaintext detail (§2.3): tool name + first input line,
+          // ≤200 chars — same channel discipline as done.notify.
+          ...opts.notifyDetail === true ? { notify: approvalNotify(tool, input) } : {},
+          ...renotify ? { renotify: true } : {}
+        });
+      },
+      emitResult: ({ approvalId, decision, note }) => {
+        emitEvent({ type: "permission_result", id: approvalId, decision, ...note !== void 0 ? { note } : {} });
+      }
+    }
+  });
+  const controller = new AbortController();
+  approvalRuns.set(requestId, { controller, approvals });
+  void opts.adapter.runWithApproval({
+    prompt: opts.prompt,
+    resumeId: opts.sessionId,
+    model: opts.model,
+    cwd: opts.runCwd,
+    bin: adapter.bin,
+    onEvent: (evt) => void emitEvent(evt),
+    requestPermission: (tool, input) => approvals.requestPermission(tool, input),
+    signal: controller.signal
+  }).then(
+    ({ code, error }) => ({ code, error }),
+    (err) => ({ code: 1, error: err instanceof Error ? err.message : String(err) })
+  ).then(({ code, error }) => {
+    approvals.abort();
+    approvalRuns.delete(requestId);
+    const done = {
+      type: "done",
+      requestId,
+      code
+    };
+    if (error) done.error = error;
+    if (opts.notifyDetail === true) done.notify = { title: adapter.id, summary: notifySummary(lastText) };
+    console.log(`[daemon] requestId=${requestId} closed code=${code}${error ? ` error=${error}` : ""} (approval mode)`);
+    recorder?.done(code, error);
+    send(ws, done);
+  });
+}
+function handlePermissionResponse(msg) {
+  const run = approvalRuns.get(msg.requestId);
+  if (!run) {
+    console.log(`[daemon] permission_response requestId=${msg.requestId} ignored (no approval run in flight)`);
+    return;
+  }
+  const decision = msg.decision;
+  if (decision !== "allow" && decision !== "allow_session" && decision !== "deny") {
+    console.log(`[daemon] permission_response approvalId=${msg.approvalId} ignored (bad decision)`);
+    return;
+  }
+  let note;
+  if (typeof msg.note === "string" && msg.note) {
+    note = msg.note;
+    if (ENCKEY) {
+      try {
+        const parsed = JSON.parse(msg.note);
+        if (isEnvelope(parsed)) {
+          const decoded = decryptEnvelope(ENCKEY, parsed);
+          note = typeof decoded === "string" ? decoded : void 0;
+        }
+      } catch {
+      }
+    }
+  } else if (msg.note && typeof msg.note === "object" && ENCKEY && isEnvelope(msg.note)) {
+    try {
+      const decoded = decryptEnvelope(ENCKEY, msg.note);
+      note = typeof decoded === "string" ? decoded : void 0;
+    } catch {
+      note = void 0;
+    }
+  }
+  run.approvals.resolve(msg.approvalId, decision, note);
+}
 var SIGKILL_GRACE_MS = 2e3;
 function handleCancel(requestId) {
+  const approvalRun = approvalRuns.get(requestId);
+  if (approvalRun) {
+    console.log(`[daemon] cancel requestId=${requestId} \u2014 aborting SDK run`);
+    approvalRun.approvals.abort();
+    approvalRun.controller.abort();
+    return;
+  }
   const child = running.get(requestId);
   if (!child) {
     console.log(`[daemon] cancel requestId=${requestId} ignored (unknown or already finished)`);
@@ -4678,7 +6653,7 @@ function handleListdir(ws, { requestId, path }) {
   const { real, error } = resolveDir(path);
   if (!real) return reply([], error);
   try {
-    const dirs = readdirSync3(real, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => join5(real, e.name)).sort();
+    const dirs = readdirSync4(real, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => join6(real, e.name)).sort();
     reply(dirs);
   } catch (err) {
     reply(
@@ -4708,6 +6683,31 @@ function handleConvClear(ws, requestId) {
 function handleHistory(ws, requestId, conversationId) {
   send(ws, { type: "history_result", requestId, runs: history(conversationId) });
 }
+function handleScanSessions(ws, requestId) {
+  let sessions;
+  try {
+    const list = scanClaudeSessions();
+    sessions = ENCKEY ? encryptEvent(ENCKEY, list) : list;
+  } catch (err) {
+    return send(ws, { type: "scan_sessions_result", requestId, sessions: ENCKEY ? void 0 : [], error: err instanceof Error ? err.message : String(err) });
+  }
+  send(ws, { type: "scan_sessions_result", requestId, sessions });
+}
+function handleSessionHistory(ws, requestId, agent, sessionId) {
+  if (typeof agent !== "string" || typeof sessionId !== "string") {
+    return send(ws, { type: "session_history_result", requestId, runs: [], error: "malformed session_history: agent and sessionId are required" });
+  }
+  const result = claudeSessionHistory(agent, sessionId);
+  if ("error" in result) {
+    return send(ws, { type: "session_history_result", requestId, runs: [], error: result.error });
+  }
+  const runs = ENCKEY ? result.runs.map((r) => ({
+    ...r,
+    prompt: encryptEvent(ENCKEY, r.prompt),
+    events: r.events.map((e) => encryptEvent(ENCKEY, truncateEventContent(e)))
+  })) : result.runs;
+  send(ws, { type: "session_history_result", requestId, runs, truncatedEarlier: result.truncatedEarlier });
+}
 var PUBLIC_BASE = null;
 var stopTunnel = null;
 if (TUNNEL) {
@@ -4716,12 +6716,21 @@ if (TUNNEL) {
   stopTunnel = t.stop;
   console.log(`[daemon] tunnel ready: ${PUBLIC_BASE}`);
 }
-process.on("exit", () => stopTunnel?.());
+process.on("exit", (code) => {
+  writeStatus("stopped", { code });
+  stopTunnel?.();
+});
 process.on("SIGINT", () => process.exit(130));
 process.on("SIGTERM", () => process.exit(143));
 var agents = await probeAgents();
 var detected = agents.filter((a) => a.detected);
 console.log(`[daemon] detected agents: ${detected.length ? detected.map((a) => a.id).join(", ") : "(none)"}`);
+if (APPROVAL) {
+  const capable = agents.filter((a) => a.approval).map((a) => a.id);
+  console.log(
+    `[daemon] approval mode ON (renotify ${APPROVAL_RENOTIFY_MIN === 0 ? "off" : `${APPROVAL_RENOTIFY_MIN}min`}) \u2014 controlled agents: ${capable.length ? capable.join(", ") : "(none: no detected agent supports approval yet)"}`
+  );
+}
 var url = `${HUB}/daemon?token=${encodeURIComponent(TOKEN)}&v=${PROTOCOL_VERSION}`;
 var urlForLog = `${HUB}/daemon?token=${fingerprint2(TOKEN)}&v=${PROTOCOL_VERSION}`;
 var BACKOFF_BASE_MS = 1e3;
@@ -4777,8 +6786,14 @@ function connect2() {
         failures = 0;
         armPingWatchdog();
         console.log(`[daemon] hub says hello (protocol v${msg.v}, hub ${msg.hubVersion ?? "?"})`);
-        send(ws, { type: "register", hostname: hostname(), daemonVersion: ownVersion(), dirs: DIRS, home: homedir5(), agents, e2e: CRED.enckey !== void 0 });
+        if (APPROVAL && !(Array.isArray(msg.features) && msg.features.includes("approval"))) {
+          console.error(
+            `[daemon] WARNING: --approval is on but the hub at ${HUB} (${msg.hubVersion ?? "unknown version"}) predates approval support \u2014 suspended tool calls will get NO push notification and NO card. Upgrade the hub (npx agentlink-hub@latest).`
+          );
+        }
+        send(ws, { type: "register", hostname: hostname(), daemonVersion: ownVersion(), dirs: DIRS, home: homedir6(), agents, e2e: CRED.enckey !== void 0 });
         console.log(`[daemon] registered. Waiting for work pushed from the hub...`);
+        writeStatus("connected");
         if (printedLink) return;
         printedLink = true;
         if (CRED.multi) {
@@ -4797,6 +6812,8 @@ function connect2() {
       handleRun(ws, msg);
     } else if (msg.type === "cancel" && typeof msg.requestId === "string") {
       handleCancel(msg.requestId);
+    } else if (msg.type === "permission_response" && typeof msg.requestId === "string" && typeof msg.approvalId === "string") {
+      handlePermissionResponse(msg);
     } else if (msg.type === "listdir" && typeof msg.requestId === "string") {
       handleListdir(ws, msg);
     } else if (msg.type === "conv_list" && typeof msg.requestId === "string") {
@@ -4809,6 +6826,10 @@ function connect2() {
       handleConvClear(ws, msg.requestId);
     } else if (msg.type === "history" && typeof msg.requestId === "string") {
       handleHistory(ws, msg.requestId, msg.conversationId);
+    } else if (msg.type === "scan_sessions" && typeof msg.requestId === "string") {
+      handleScanSessions(ws, msg.requestId);
+    } else if (msg.type === "session_history" && typeof msg.requestId === "string") {
+      handleSessionHistory(ws, msg.requestId, msg.agent, msg.sessionId);
     } else {
       console.log(`[daemon] ignoring message with unknown shape: ${raw}`);
     }
@@ -4824,10 +6845,15 @@ function connect2() {
       child.kill();
     }
     running.clear();
+    for (const [requestId, run] of approvalRuns) {
+      console.log(`[daemon] aborting in-flight approval requestId=${requestId} (hub connection closed)`);
+      run.approvals.abort();
+      run.controller.abort();
+    }
+    approvalRuns.clear();
     if (code === 4403) {
-      const credentialFile = join5(process.env.AGENTLINK_STATE_DIR || join5(homedir5(), ".agentlink"), "credential");
       try {
-        rmSync2(credentialFile, { force: true });
+        rmSync2(CREDENTIAL_FILE, { force: true });
       } catch {
       }
       console.error(`[daemon] this machine was removed from your AgentLink console (close 4403). The locally saved credential has been deleted; add the machine again to reconnect.`);
@@ -4853,6 +6879,7 @@ function connect2() {
     failures++;
     const detail = code ? ` (code ${code}${reason?.length ? `, ${reason}` : ""})` : "";
     console.error(`[daemon] connection to hub closed${detail} \u2014 reconnecting in ${(delay / 1e3).toFixed(1)}s (attempt ${failures})`);
+    writeStatus("reconnecting", { attempt: failures });
     setTimeout(connect2, delay);
   });
 }