@agentunion/fastaun-browser 0.4.2 → 0.4.4

package/_packed_docs/protocol/README.md

@@ -29,7 +29,7 @@ AUN 是 ACP 协议的 2.0 版本，采用 WebSocket + JSON-RPC 2.0 定义 Agent
 | 文档 | 命名空间 | 内容 |
 |------|---------|------|
 | [01-身份与凭证协议-auth.md](01-身份与凭证协议-auth.md) | `auth.*` | AID 创建、两阶段登录、证书生命周期、JWT Token 机制 |
-| [03-Gateway-连接模式.md](03-Gateway-连接模式.md) | `auth.connect` | Gateway 模式连接流程、auth.connect 握手、心跳重连 |
+| [03-Gateway-连接模式.md](03-Gateway-连接模式.md) | `auth.connect` | Gateway 模式连接流程、auth.connect 握手、心跳重连 |
 | [04-Peer-子协议.md](04-Peer-子协议.md) | `peer.*` | 对等认证四步握手、证书链验证、nonce 签名规则 |
 | [05-Relay-子协议.md](05-Relay-子协议.md) | `relay.*` | 中继注册与转发、透明封装、与 peer.* 的关系 |
 

package/_packed_docs/protocol/aun-docs-guide.md

@@ -14,7 +14,7 @@ AUN 协议采用**主协议 + 子协议**架构：
 
 子协议文档
 ├── 01-身份与凭证协议-auth.md  ← auth.* 方法、JWT Token
-├── 03-Gateway-连接模式.md     ← Gateway 模式、auth.connect
+├── 03-Gateway-连接模式.md     ← Gateway 模式、auth.connect
 ├── 04-Peer-子协议.md          ← peer.* 对等认证
 └── 05-Relay-子协议.md         ← relay.* 中继传输
 

package/_packed_docs/protocol//351/231/204/345/275/225A-/346/234/257/350/257/255/350/241/250.md

@@ -163,21 +163,21 @@ JWT Header 中的密钥标识，用于指出该 token 是由哪一把签名密
 - **Event**：服务端主动推送的事件，需要客户端响应
 - **Notification**：单向通知，不需要响应
 
-### auth.connect
-Gateway 模式的 WebSocket 会话初始化方法。用于提交认证凭证、协商协议版本并建立连接级上下文。
-
-**参数**：
-- `nonce`：Gateway challenge 下发的一次性随机数
-- `auth`：认证方式与凭证
-- `protocol.min/max`：客户端支持的协议版本范围
-- `device.id/type`：设备信息
-- `client`：客户端实例信息
-- `delivery_mode`：连接级投递语义
-- `capabilities`：客户端能力声明
-
-**说明**：
-- `auth.connect` 成功后 Gateway 返回协商后的 `protocol` 与服务端 `capabilities`，连接进入 READY 状态
-- 当前 `capabilities` 语义是客户端能力声明和服务端能力公告，不等同于完整双向能力协商
+### auth.connect
+Gateway 模式的 WebSocket 会话初始化方法。用于提交认证凭证、协商协议版本并建立连接级上下文。
+
+**参数**：
+- `nonce`：Gateway challenge 下发的一次性随机数
+- `auth`：认证方式与凭证
+- `protocol.min/max`：客户端支持的协议版本范围
+- `device.id/type`：设备信息
+- `client`：客户端实例信息
+- `delivery_mode`：连接级投递语义
+- `capabilities`：客户端能力声明
+
+**说明**：
+- `auth.connect` 成功后 Gateway 返回协商后的 `protocol` 与服务端 `capabilities`，连接进入 READY 状态
+- 当前 `capabilities` 语义是客户端能力声明和服务端能力公告，不等同于完整双向能力协商
 
 ### Mode（连接模式）
 指当前连接采用的接入方式。AUN 主协议定义三种平级 mode：

package/_packed_docs/protocol//351/231/204/345/275/225B-/346/211/251/345/261/225/346/200/247/346/214/207/345/215/227.md

@@ -2,9 +2,9 @@
 
 > **本文档为非规范性内容**：提供 AUN 协议扩展机制的设计原则，不是协议强制要求。
 
-## B.1 可选命名空间
-
-服务端通过 `hello-ok.result.capabilities.namespaces` 公告可用命名空间；客户端侧需要声明的扩展能力通过 `auth.connect.params.capabilities` 扩展：
+## B.1 可选命名空间
+
+服务端通过 `hello-ok.result.capabilities.namespaces` 公告可用命名空间；客户端侧需要声明的扩展能力通过 `auth.connect.params.capabilities` 扩展：
 
 - `group.*`: 群组管理
 - `storage.*`: 文件存储
@@ -69,7 +69,7 @@ gateway:
 **核心原则**：
 1. **向后兼容**：扩展不能破坏现有协议
 2. **可选实现**：客户端可以选择不实现扩展
-3. **能力声明与公告**：通过 `auth.connect` 声明客户端能力，通过 `hello-ok` 公告服务端能力；需要双向协商的扩展必须单独定义交集规则
+3. **能力声明与公告**：通过 `auth.connect` 声明客户端能力，通过 `hello-ok` 公告服务端能力；需要双向协商的扩展必须单独定义交集规则
 4. **文档清晰**：明确标注哪些是核心协议，哪些是扩展
 
 **不推荐的扩展**：

package/_packed_docs/protocol//351/231/204/345/275/225J-/345/256/242/346/210/267/347/253/257/346/216/245/345/205/245/347/244/272/344/276/213.md

@@ -7,40 +7,40 @@
 ```javascript
 // 1. 连接 Gateway
 const ws = new WebSocket('wss://gateway.example.com/aun');
-let msgId = 1;
-let token = null;
-let gatewayNonce = null;
-let savedClientNonce = null;  // 保存 client_nonce 用于验证 Auth 服务签名
-let savedRequestId = null;
-
-ws.onopen = () => {
-  // Gateway 会先推送 challenge；收到后再发 auth.* / auth.connect
-};
-
-// 处理响应和事件
-ws.onmessage = async (event) => {
-  const msg = JSON.parse(event.data);
-
-  // challenge：保存 Gateway nonce，然后开始 auth.* 两阶段登录
-  if (msg.method === 'challenge') {
-    gatewayNonce = msg.params.nonce;
-
-    // 步骤1：发送 login_aid1（必需字段：aid, cert, request_id, client_nonce）
-    savedRequestId = `req-${Date.now()}`;
-    savedClientNonce = crypto.randomUUID();
-    ws.send(JSON.stringify({
-      jsonrpc: '2.0',
-      id: msgId++,
-      method: 'auth.aid_login1',
-      params: {
-        aid: 'alice.aid.pub',
-        cert: loadCert(),               // PEM 格式证书（必需）
-        request_id: savedRequestId,     // 关联两阶段登录（必需）
-        client_nonce: savedClientNonce   // 客户端随机 nonce（必需）
-      }
-    }));
-    return;
-  }
+let msgId = 1;
+let token = null;
+let gatewayNonce = null;
+let savedClientNonce = null;  // 保存 client_nonce 用于验证 Auth 服务签名
+let savedRequestId = null;
+
+ws.onopen = () => {
+  // Gateway 会先推送 challenge；收到后再发 auth.* / auth.connect
+};
+
+// 处理响应和事件
+ws.onmessage = async (event) => {
+  const msg = JSON.parse(event.data);
+
+  // challenge：保存 Gateway nonce，然后开始 auth.* 两阶段登录
+  if (msg.method === 'challenge') {
+    gatewayNonce = msg.params.nonce;
+
+    // 步骤1：发送 login_aid1（必需字段：aid, cert, request_id, client_nonce）
+    savedRequestId = `req-${Date.now()}`;
+    savedClientNonce = crypto.randomUUID();
+    ws.send(JSON.stringify({
+      jsonrpc: '2.0',
+      id: msgId++,
+      method: 'auth.aid_login1',
+      params: {
+        aid: 'alice.aid.pub',
+        cert: loadCert(),               // PEM 格式证书（必需）
+        request_id: savedRequestId,     // 关联两阶段登录（必需）
+        client_nonce: savedClientNonce   // 客户端随机 nonce（必需）
+      }
+    }));
+    return;
+  }
 
   // login_aid1 响应：返回 nonce + client_nonce_signature + auth_cert
   if (msg.result && msg.result.nonce && msg.result.client_nonce_signature) {
@@ -70,24 +70,24 @@ ws.onmessage = async (event) => {
   if (msg.result && msg.result.token && !msg.result.authenticated) {
     token = msg.result.token;
 
-    // 步骤3：用 token 调用 auth.connect 完成 Gateway 模式会话初始化
-    ws.send(JSON.stringify({
-      jsonrpc: '2.0',
-      id: msgId++,
-      method: 'auth.connect',
-      params: {
-        nonce: gatewayNonce,
-        auth: { method: 'kite_token', token },
-        protocol: {min: '1.0', max: '1.0'},
-        device: {id: 'browser-dev-001', type: 'browser'},
-        client: {name: 'MyApp', version: '1.0.0'},
-        capabilities: {e2ee: true, group_e2ee: true}
-      }
-    }));
-  }
-
-  // auth.connect 响应（连接已认证）
-  if (msg.result && msg.result.authenticated) {
+    // 步骤3：用 token 调用 auth.connect 完成 Gateway 模式会话初始化
+    ws.send(JSON.stringify({
+      jsonrpc: '2.0',
+      id: msgId++,
+      method: 'auth.connect',
+      params: {
+        nonce: gatewayNonce,
+        auth: { method: 'kite_token', token },
+        protocol: {min: '1.0', max: '1.0'},
+        device: {id: 'browser-dev-001', type: 'browser'},
+        client: {name: 'MyApp', version: '1.0.0'},
+        capabilities: {e2ee: true, group_e2ee: true}
+      }
+    }));
+  }
+
+  // auth.connect 响应（连接已认证）
+  if (msg.result && msg.result.authenticated) {
     console.log('Authenticated as:', msg.result.identity.aid);
 
     // 现在可以调用所有方法
@@ -133,9 +133,9 @@ ws.send(JSON.stringify({
           content_type: 'application/pdf'
         }
       ]
-    }
-  }
-}));
+    }
+  }
+}));
 ```
 
 ### 12.2 Gateway 模式：移动应用完整流程（iOS）
@@ -144,34 +144,34 @@ ws.send(JSON.stringify({
 // 1. 连接 Gateway
 var request = URLRequest(url: URL(string: "wss://gateway.example.com/aun")!)
 let ws = WebSocket(request: request)
-var msgId = 1
-var token: String?
-var gatewayNonce: String?
-var savedClientNonce: String?
-var savedRequestId: String?
-
-// 2. 连接成功后，等待 Gateway challenge，再调用 auth.* 获取 token
-ws.onConnected = {
-    // no-op: Gateway 会主动推送 challenge
-}
-
-// 3. 处理响应和事件
-ws.onMessage = { message in
-    if let challenge = message as? ChallengeMessage {
-        gatewayNonce = challenge.nonce
-        savedRequestId = UUID().uuidString
-        savedClientNonce = UUID().uuidString
-        ws.send(jsonrpc: "2.0", id: msgId, method: "auth.aid_login1",
-               params: [
-                   "aid": "alice.aid.pub",
-                   "cert": loadCert(),                    // PEM 格式证书（必需）
-                   "request_id": savedRequestId!,         // 关联两阶段登录（必需）
-                   "client_nonce": savedClientNonce!       // 客户端随机 nonce（必需）
-               ])
-        msgId += 1
-        return
-    }
-
+var msgId = 1
+var token: String?
+var gatewayNonce: String?
+var savedClientNonce: String?
+var savedRequestId: String?
+
+// 2. 连接成功后，等待 Gateway challenge，再调用 auth.* 获取 token
+ws.onConnected = {
+    // no-op: Gateway 会主动推送 challenge
+}
+
+// 3. 处理响应和事件
+ws.onMessage = { message in
+    if let challenge = message as? ChallengeMessage {
+        gatewayNonce = challenge.nonce
+        savedRequestId = UUID().uuidString
+        savedClientNonce = UUID().uuidString
+        ws.send(jsonrpc: "2.0", id: msgId, method: "auth.aid_login1",
+               params: [
+                   "aid": "alice.aid.pub",
+                   "cert": loadCert(),                    // PEM 格式证书（必需）
+                   "request_id": savedRequestId!,         // 关联两阶段登录（必需）
+                   "client_nonce": savedClientNonce!       // 客户端随机 nonce（必需）
+               ])
+        msgId += 1
+        return
+    }
+
     // login_aid1 响应：返回 nonce + client_nonce_signature + auth_cert
     if let loginResp = message as? LoginAid1Response {
         // 验证 Auth 服务身份：用 auth_cert 公钥验证 client_nonce_signature
@@ -198,21 +198,21 @@ ws.onMessage = { message in
     if let loginResp = message as? LoginAid2Response {
         token = loginResp.token
 
-        // 用 token 调用 auth.connect 完成 Gateway 模式会话初始化
-        let connectParams: [String: Any] = [
-            "nonce": gatewayNonce!,
-            "auth": ["method": "kite_token", "token": token!],
-            "protocol": ["min": "1.0", "max": "1.0"],
-            "device": ["id": "ios-dev-001", "type": "mobile"],
-            "client": ["name": "MyApp", "version": "1.0.0"],
-            "capabilities": ["e2ee": true, "group_e2ee": true]
-        ]
-        ws.send(jsonrpc: "2.0", id: msgId, method: "auth.connect", params: connectParams)
-        msgId += 1
-    }
-
-    // auth.connect 响应（连接已认证）
-    if let response = message as? AuthConnectResponse, response.authenticated {
+        // 用 token 调用 auth.connect 完成 Gateway 模式会话初始化
+        let connectParams: [String: Any] = [
+            "nonce": gatewayNonce!,
+            "auth": ["method": "kite_token", "token": token!],
+            "protocol": ["min": "1.0", "max": "1.0"],
+            "device": ["id": "ios-dev-001", "type": "mobile"],
+            "client": ["name": "MyApp", "version": "1.0.0"],
+            "capabilities": ["e2ee": true, "group_e2ee": true]
+        ]
+        ws.send(jsonrpc: "2.0", id: msgId, method: "auth.connect", params: connectParams)
+        msgId += 1
+    }
+
+    // auth.connect 响应（连接已认证）
+    if let response = message as? AuthConnectResponse, response.authenticated {
         print("Authenticated as: \(response.identity.aid)")
 
         // 现在可以调用所有方法

package/_packed_docs/protocol//351/231/204/345/275/225M-JWT/350/256/244/350/257/201/345/256/236/347/216/260/346/214/207/345/215/227.md

@@ -55,11 +55,11 @@ eyJhbGciOiJFUzM4NCIsInR5cCI6IkpXVCJ9.eyJhaWQiOiJhbGljZS5haWQucHViIiwiaWF0IjoxNzA
 **所有 AUN 服务端实现**：
 
 ```
-1. 服务收到请求（携带 JWT token）
-   ↓
-2. 提取 token
-   - WebSocket: 从 `auth.connect.params.auth.token` 中获取
-   - 连接状态：token 验证后存储在连接上下文
+1. 服务收到请求（携带 JWT token）
+   ↓
+2. 提取 token
+   - WebSocket: 从 `auth.connect.params.auth.token` 中获取
+   - 连接状态：token 验证后存储在连接上下文
    ↓
 3. 解析 token
    - Base64 解码 Header 和 Payload
@@ -158,47 +158,47 @@ const token = response.token;
 
 ### M.3.2 Token 使用示例
 
-Token 统一通过 `auth.connect` 消息传递。每次 WebSocket 连接（包括重连）都必须在收到 Gateway `challenge` 后调用 `auth.connect`：
-
-```javascript
-function sendAuthConnect(ws, nonce, token) {
-  ws.send(JSON.stringify({
-    jsonrpc: '2.0',
-    id: 1,
-    method: 'auth.connect',
-    params: {
-      nonce,
-      auth: { method: 'kite_token', token },
-      protocol: { min: '1.0', max: '1.0' },
-      device: { id: 'dev-001', type: 'browser' },
-      client: { name: 'MyApp', version: '1.0.0' },
-      capabilities: { e2ee: true, group_e2ee: true }
-    }
-  }));
-}
-
-// 首次登录：先调用 auth.* 获取 token，再 auth.connect
-const ws = new WebSocket('wss://gateway.example.com/aun');
-ws.onmessage = async (event) => {
-  const msg = JSON.parse(event.data);
-  if (msg.method !== 'challenge') return;
-
-  // 1. 在 auth.connect 之前调用 auth.* 获取 token
-  const token = await loginFlow(ws); // login_aid1 + login_aid2
-
-  // 2. 用 token 调用 auth.connect 完成会话初始化
-  sendAuthConnect(ws, msg.params.nonce, token);
-};
-
-// 重连：直接用已有 token 调用 auth.connect
-const ws2 = new WebSocket('wss://gateway.example.com/aun');
-ws2.onmessage = (event) => {
-  const msg = JSON.parse(event.data);
-  if (msg.method === 'challenge') {
-    sendAuthConnect(ws2, msg.params.nonce, saved_jwt_token);
-  }
-};
-```
+Token 统一通过 `auth.connect` 消息传递。每次 WebSocket 连接（包括重连）都必须在收到 Gateway `challenge` 后调用 `auth.connect`：
+
+```javascript
+function sendAuthConnect(ws, nonce, token) {
+  ws.send(JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'auth.connect',
+    params: {
+      nonce,
+      auth: { method: 'kite_token', token },
+      protocol: { min: '1.0', max: '1.0' },
+      device: { id: 'dev-001', type: 'browser' },
+      client: { name: 'MyApp', version: '1.0.0' },
+      capabilities: { e2ee: true, group_e2ee: true }
+    }
+  }));
+}
+
+// 首次登录：先调用 auth.* 获取 token，再 auth.connect
+const ws = new WebSocket('wss://gateway.example.com/aun');
+ws.onmessage = async (event) => {
+  const msg = JSON.parse(event.data);
+  if (msg.method !== 'challenge') return;
+
+  // 1. 在 auth.connect 之前调用 auth.* 获取 token
+  const token = await loginFlow(ws); // login_aid1 + login_aid2
+
+  // 2. 用 token 调用 auth.connect 完成会话初始化
+  sendAuthConnect(ws, msg.params.nonce, token);
+};
+
+// 重连：直接用已有 token 调用 auth.connect
+const ws2 = new WebSocket('wss://gateway.example.com/aun');
+ws2.onmessage = (event) => {
+  const msg = JSON.parse(event.data);
+  if (msg.method === 'challenge') {
+    sendAuthConnect(ws2, msg.params.nonce, saved_jwt_token);
+  }
+};
+```
 
 **优势**：
 - Token 不出现在 URL、服务器日志和浏览器历史中