@xixka/dsh-hub 0.4.9 → 0.4.11
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +123 -11
- package/lib/buddy-adapter.d.ts +15 -0
- package/lib/buddy-adapter.d.ts.map +1 -1
- package/lib/buddy-adapter.js +17 -1
- package/lib/buddy-adapter.js.map +1 -1
- package/lib/buddy.d.ts +23 -0
- package/lib/buddy.d.ts.map +1 -1
- package/lib/buddy.js +27 -0
- package/lib/buddy.js.map +1 -1
- package/lib/chromium-session.d.ts +57 -0
- package/lib/chromium-session.d.ts.map +1 -1
- package/lib/chromium-session.js +128 -3
- package/lib/chromium-session.js.map +1 -1
- package/lib/client/jet-hub.js +75 -17938
- package/lib/doubao-login.d.ts +20 -0
- package/lib/doubao-login.d.ts.map +1 -1
- package/lib/doubao-login.js +21 -64
- package/lib/doubao-login.js.map +1 -1
- package/lib/doubao-signin.d.ts +32 -0
- package/lib/doubao-signin.d.ts.map +1 -1
- package/lib/doubao-signin.js +37 -38
- package/lib/doubao-signin.js.map +1 -1
- package/lib/index.d.ts +1 -0
- package/lib/index.d.ts.map +1 -1
- package/lib/index.js +57 -4
- package/lib/index.js.map +1 -1
- package/lib/jet-hub-rpc.d.ts +24 -0
- package/lib/jet-hub-rpc.d.ts.map +1 -1
- package/lib/jet-hub-rpc.js +45 -0
- package/lib/jet-hub-rpc.js.map +1 -1
- package/lib/llm-register-compat.d.ts +50 -0
- package/lib/llm-register-compat.d.ts.map +1 -1
- package/lib/llm-register-compat.js +78 -1
- package/lib/llm-register-compat.js.map +1 -1
- package/lib/lobsterai-adapter.d.ts +98 -4
- package/lib/lobsterai-adapter.d.ts.map +1 -1
- package/lib/lobsterai-adapter.js +275 -7
- package/lib/lobsterai-adapter.js.map +1 -1
- package/lib/login.d.ts +8 -2
- package/lib/login.d.ts.map +1 -1
- package/lib/login.js +11 -50
- package/lib/login.js.map +1 -1
- package/lib/loomy-adapter.d.ts.map +1 -1
- package/lib/loomy-adapter.js +56 -3
- package/lib/loomy-adapter.js.map +1 -1
- package/lib/model-promotions.d.ts +147 -1
- package/lib/model-promotions.d.ts.map +1 -1
- package/lib/model-promotions.js +336 -11
- package/lib/model-promotions.js.map +1 -1
- package/lib/openai-compat.d.ts.map +1 -1
- package/lib/openai-compat.js +21 -1
- package/lib/openai-compat.js.map +1 -1
- package/lib/promotion-tooltip.d.ts +108 -0
- package/lib/promotion-tooltip.d.ts.map +1 -0
- package/lib/promotion-tooltip.js +165 -0
- package/lib/promotion-tooltip.js.map +1 -0
- package/lib/qoder-adapter.d.ts +17 -0
- package/lib/qoder-adapter.d.ts.map +1 -1
- package/lib/qoder-adapter.js +24 -0
- package/lib/qoder-adapter.js.map +1 -1
- package/lib/raccoon-adapter.d.ts +6 -0
- package/lib/raccoon-adapter.d.ts.map +1 -1
- package/lib/raccoon-adapter.js +43 -0
- package/lib/raccoon-adapter.js.map +1 -1
- package/lib/raccoon-auth.d.ts +2 -1
- package/lib/raccoon-auth.d.ts.map +1 -1
- package/lib/raccoon-auth.js +2 -1
- package/lib/raccoon-auth.js.map +1 -1
- package/lib/raccoon-authorize.d.ts +311 -0
- package/lib/raccoon-authorize.d.ts.map +1 -0
- package/lib/raccoon-authorize.js +698 -0
- package/lib/raccoon-authorize.js.map +1 -0
- package/lib/raccoon-login-page.d.ts +15 -0
- package/lib/raccoon-login-page.d.ts.map +1 -1
- package/lib/raccoon-login-page.js +346 -15
- package/lib/raccoon-login-page.js.map +1 -1
- package/lib/raccoon-product.d.ts +3 -3
- package/lib/raccoon-product.d.ts.map +1 -1
- package/lib/raccoon-product.js +59 -11
- package/lib/raccoon-product.js.map +1 -1
- package/lib/system-ca-trust.d.ts +6 -0
- package/lib/system-ca-trust.d.ts.map +1 -0
- package/lib/system-ca-trust.js +88 -0
- package/lib/system-ca-trust.js.map +1 -0
- package/lib/trae-adapter.d.ts +33 -0
- package/lib/trae-adapter.d.ts.map +1 -1
- package/lib/trae-adapter.js +66 -0
- package/lib/trae-adapter.js.map +1 -1
- package/lib/trae.d.ts +78 -0
- package/lib/trae.d.ts.map +1 -1
- package/lib/trae.js +111 -0
- package/lib/trae.js.map +1 -1
- package/package.json +4 -1
|
@@ -0,0 +1,698 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Raccoon Work 的**浏览器授权**登录(官方客户端自己的那条链)。
|
|
3
|
+
*
|
|
4
|
+
* ## 为什么要有这个模块
|
|
5
|
+
*
|
|
6
|
+
* 官方桌面端 2026-11-05 的构建**不再走扫码确认页**:它开的是 `/authorize`
|
|
7
|
+
* 授权页(系统浏览器),用户在**网页里**完成登录(手机号 / 微信扫码 —— 那是
|
|
8
|
+
* 页面自己的一张**活的**二维码,与已死的 `/login/mp` 不是同一张),
|
|
9
|
+
* 确认后页面申请一枚**一次性** `authorization_code`,再把它**投递回调用方**:
|
|
10
|
+
* 要么是注册过的 `office-raccoon://` 自定义协议(只有官方 App 能收),
|
|
11
|
+
* 要么是 **`127.0.0.1:<port>` 上的回环接收端**(Windows/Linux 兼容形态,
|
|
12
|
+
* 第三方可以自己托管)。
|
|
13
|
+
*
|
|
14
|
+
* ⚠️ **本仓为什么必须走回环形态**:`office-raccoon://` 是宿主 Node 进程
|
|
15
|
+
* **收不到**的自定义协议回调。而本仓原先的扫码链**已经死了** ——
|
|
16
|
+
* 扫码确认页 `/login/mp` 自 2026-11-04 起**全部 404**(含微信 UA),
|
|
17
|
+
* 而**签发本身是成功的** ⇒ 用户扫进去只看到一个 404 页,零报错。
|
|
18
|
+
* 本模块是那半条死链的**替代**:官方客户端的授权页 + 回环接收端 + 换码。
|
|
19
|
+
*
|
|
20
|
+
* ## 机制参照,不是抄端口
|
|
21
|
+
*
|
|
22
|
+
* 线上的事实取自三处(2026-11-17 实测):
|
|
23
|
+
*
|
|
24
|
+
* 1. 官网 `/authorize` 页**在线**(HTTP 200,且把它收到的
|
|
25
|
+
* `login_source` / `appname` / `desktop_callback` / `redirect` / `state`
|
|
26
|
+
* **原样回显**进页面上下文);
|
|
27
|
+
* 2. 该页 chunk 里的**解析器规则**(见下「官方页自己的规则」);
|
|
28
|
+
* 3. 换码端点 `POST /api/web/auth/v1/login_with_authorization_code` ——
|
|
29
|
+
* 实测一枚瞎编的 code 回 **HTTP 400 `{code:200035}`**(= 官方常量
|
|
30
|
+
* `AUTHORIZATION_CODE_NOT_FOUND`),证明端点与错误码都还在。
|
|
31
|
+
*
|
|
32
|
+
* ## 官方页自己的规则(我们逐条前置校验)
|
|
33
|
+
*
|
|
34
|
+
* 页面的解析器(chunk `app/(identity)/authorize/page-…js`)要求:
|
|
35
|
+
*
|
|
36
|
+
* - `redirect` 必须匹配 `^http://127\.0\.0\.1:[1-9][0-9]{3,4}/auth/callback$`
|
|
37
|
+
* (端口 4~5 位、首位非 0),且端口落在 1024..65535;
|
|
38
|
+
* - `state` 必须是 **64 位小写 hex**;
|
|
39
|
+
* - `login_source` 存在时**必须**是 `desktop`;
|
|
40
|
+
* - `desktop_callback` 存在时**必须**是 `loopback`,且此时
|
|
41
|
+
* `login_source` 必为 `desktop`、`ide` 必为空、`redirect` 必过上面那条;
|
|
42
|
+
* - 参数名**只能**取自 `{login_source, appname, state, redirect, ide, org,
|
|
43
|
+
* lang, desktop_callback}` —— 多一个键整条链接就作废。
|
|
44
|
+
*
|
|
45
|
+
* ⇒ 一个页面会拒收的 URL **不该**拿给用户(那是个没有下一步的死路)。
|
|
46
|
+
* 所以 {@link buildRaccoonAuthorizeUrl} 在**发出之前**就按这些规则自查。
|
|
47
|
+
*
|
|
48
|
+
* ## 回环接收端的七条规则(官方接收端的规则逐条重述)
|
|
49
|
+
*
|
|
50
|
+
* 授权码是一次性凭据,而一个敞开的接收端就是「凭据交换漏洞」 ⇒ 七条检查
|
|
51
|
+
* **一条都不能少**:GET-only、`Host` 等于我们自己的 authority、来源地址是
|
|
52
|
+
* 回环、存在的 `Origin` 必须等于网关 origin、存在的 `Sec-Fetch-Dest`
|
|
53
|
+
* 必须是 `document`、路径与查询键严格受限、`state` 常量时间比对通过。
|
|
54
|
+
*
|
|
55
|
+
* ## 凭据的边界
|
|
56
|
+
*
|
|
57
|
+
* 换码的结果**只**回到调用方(换码成功后由登录页流程落进 DSH 凭据服务)。
|
|
58
|
+
* 本模块**不打印**任何凭据值:失败结果只带**原因词**,不带报文原文
|
|
59
|
+
* (报文可能回显那枚 code)。
|
|
60
|
+
*
|
|
61
|
+
* @module dsh-providers-hub/raccoon-authorize
|
|
62
|
+
*/
|
|
63
|
+
import { randomBytes, timingSafeEqual } from 'node:crypto';
|
|
64
|
+
import { execFile } from 'node:child_process';
|
|
65
|
+
import { createServer } from 'node:http';
|
|
66
|
+
import { RACCOON_API_BASE, RACCOON_REQUEST_TIMEOUT_MS, decodeJwtExpMs, } from './raccoon.js';
|
|
67
|
+
import { RACCOON } from './raccoon-product.js';
|
|
68
|
+
/**
|
|
69
|
+
* 网关 origin —— 本模块构造的每条 URL 都以它为底。
|
|
70
|
+
*
|
|
71
|
+
* ⚠️ **重导出**(不是只 import):调用方与测试都要拿它当「授权页 origin」和
|
|
72
|
+
* 「`Origin` 头必须等于的那个值」,而这个模块**就是**这条链的定义处 ⇒
|
|
73
|
+
* 从这里导出才是**单一真相源**(从别处 import 会让「改了常量、这边没改」
|
|
74
|
+
* 成为可能)。
|
|
75
|
+
*/
|
|
76
|
+
export { RACCOON_API_BASE };
|
|
77
|
+
/** 官方客户端在系统浏览器里打开的授权页路径。 */
|
|
78
|
+
export const RACCOON_AUTHORIZE_PATH = '/authorize';
|
|
79
|
+
/**
|
|
80
|
+
* 回环接收端的回调路径 —— **由官方页面写死**,不可改。
|
|
81
|
+
*
|
|
82
|
+
* 页面投递时用的参数名在 desktop 形态下是 **`code`**(非 desktop 才是
|
|
83
|
+
* `authorization_code`;见页面 chunk 的
|
|
84
|
+
* `r.searchParams.set(e.desktop ? "code" : "authorization_code", t)`)。
|
|
85
|
+
*/
|
|
86
|
+
export const RACCOON_LOOPBACK_CALLBACK_PATH = '/auth/callback';
|
|
87
|
+
/**
|
|
88
|
+
* 授权页上显示的「申请授权的应用」名。
|
|
89
|
+
*
|
|
90
|
+
* 官方客户端自己的 `DESKTOP_AUTH_PARAMS` 字面量(desktopLogin.js),
|
|
91
|
+
* 也是 2026-11-17 那次真机授权**成功走完**时用的名字。
|
|
92
|
+
*
|
|
93
|
+
* ⚠️ 官方页的解析器对三个 appname 有白名单(办公小浣熊客户端 / 商汤小浣熊
|
|
94
|
+
* 客户端 / Office Raccoon),其余名字**也能解析**,但确认文案会照抄
|
|
95
|
+
* 那个**未知字符串** ⇒ 页面上一句「此应用希望使用你的账号登录」会变成
|
|
96
|
+
* 一句没头没尾的话。故默认用**实测走通的那个**。
|
|
97
|
+
*/
|
|
98
|
+
export const RACCOON_AUTH_APPNAME = '办公小浣熊客户端';
|
|
99
|
+
/**
|
|
100
|
+
* 网关的「这枚授权码不存在 / 已过期 / 已消费」错误码。
|
|
101
|
+
*
|
|
102
|
+
* 实测(2026-11-17):一枚瞎编的 code 打
|
|
103
|
+
* `POST /api/web/auth/v1/login_with_authorization_code` ⇒ HTTP 400
|
|
104
|
+
* `{"code":200035,"message":"authorization_code_not_found_error"}`。
|
|
105
|
+
* 官方客户端的常量 `AUTHORIZATION_CODE_NOT_FOUND` 是**同一个值**。
|
|
106
|
+
*
|
|
107
|
+
* ⚠️ 这是**唯一**的出路:重发同一枚码没有任何用处,只能**重开一轮**。
|
|
108
|
+
*/
|
|
109
|
+
export const RACCOON_AUTHORIZATION_CODE_NOT_FOUND = 200035;
|
|
110
|
+
/**
|
|
111
|
+
* 回环等待的默认时限(毫秒)。
|
|
112
|
+
*
|
|
113
|
+
* 官方回环自己的默认值(`timeoutMs ?? 300000`)。一次「网页里重新登录」
|
|
114
|
+
* (含手机号验证码)能从容落在这五分钟内。
|
|
115
|
+
*/
|
|
116
|
+
export const RACCOON_AUTHORIZE_TIMEOUT_MS = 5 * 60 * 1000;
|
|
117
|
+
/**
|
|
118
|
+
* IAM 令牌必须带的 `iss`。
|
|
119
|
+
*
|
|
120
|
+
* 官方客户端算的是 `new URL(LOGIN_URL).host + "/iam"` —— **裸 host、无 scheme**。
|
|
121
|
+
* ⚠️ **无 scheme 这件事是承重的**:`iss` 是**等值**比较,若按带 scheme 的
|
|
122
|
+
* 严格等值去比,会**误拒每一枚真令牌**。
|
|
123
|
+
*/
|
|
124
|
+
export const RACCOON_IAM_ISSUER = `${new URL(RACCOON_API_BASE).host}/iam`;
|
|
125
|
+
/**
|
|
126
|
+
* 回环 redirect 的机器可判形状:官方页面自己那条正则。
|
|
127
|
+
*
|
|
128
|
+
* 页面会拒收的 redirect 会**解析失败**并只在**投递那一刻**才炸 ⇒ 那种
|
|
129
|
+
* URL 是一个「看着能点、点了没反应」的死路。所以**发出之前**就拒。
|
|
130
|
+
*/
|
|
131
|
+
const RACCOON_LOOPBACK_REDIRECT_RE = /^http:\/\/127\.0\.0\.1:[1-9][0-9]{3,4}\/auth\/callback$/;
|
|
132
|
+
/**
|
|
133
|
+
* 回调 URL 的**总长度上限**。
|
|
134
|
+
*
|
|
135
|
+
* ## 为什么是 4096 而不是官方的 8192
|
|
136
|
+
*
|
|
137
|
+
* 官方接收端写的是 `rawUrl.length > 8192`。但**在我们这儿那个上限是够不着的**:
|
|
138
|
+
* Node 的 `maxHeaderSize: 8192`(**含**请求行与方法/版本/Host 等头)在 URL
|
|
139
|
+
* 长到约 **8160** 时就会先回 **431 Request Header Fields Too Large**
|
|
140
|
+
* (实测:URL 长 8150 → 200、8160 → 431)⇒ **任何长于 8192 的 URL 根本到不了
|
|
141
|
+
* 我们的处理器** ⇒ 写 8192 等于**一条永远走不到的死代码**(本仓反复记过
|
|
142
|
+
* 「判据够不着 ⇒ 等于没有」)。
|
|
143
|
+
*
|
|
144
|
+
* ⇒ 取 **4096**:既**真的**在 Node 的 431 之前(⇒ 这条判据**有牙**、
|
|
145
|
+
* 能被单测打到),又远高于任何**正常**回调的长度
|
|
146
|
+
* (路径 13 + `code` ≤ 4096 + `state` 64 + 分隔符 ≈ 4200 —— 嗯,正好在
|
|
147
|
+
* 边界上,所以 code 那条 4096 的上限与它**同量级**,两条腿合起来把
|
|
148
|
+
* 「畸形超长」挡在门外)。
|
|
149
|
+
*
|
|
150
|
+
* ⚠️ 代价要说清:**一条 code 极长(接近 4096)的合法回调**可能被这条 URL
|
|
151
|
+
* 上限拒掉。但那种 code 上游自己也不会签发(官方对 code 的上限也是 4096,
|
|
152
|
+
* 而带 64 位 state 与路径后总量必然更小)⇒ 实际不可达。
|
|
153
|
+
*/
|
|
154
|
+
export const RACCOON_CALLBACK_URL_MAX_LENGTH = 4096;
|
|
155
|
+
/**
|
|
156
|
+
* 单个 socket 的空闲超时(毫秒)—— 官方接收端同款(20000)。
|
|
157
|
+
*
|
|
158
|
+
* ⚠️ **可注入**(`options.socketTimeoutMs`):20 秒在单测里没法等 ⇒
|
|
159
|
+
* 没有注入点,那条判据就**够不着**(变异验证会如实报「无牙」——
|
|
160
|
+
* 那不是判据没用,是**够不着**)。
|
|
161
|
+
*/
|
|
162
|
+
export const RACCOON_SOCKET_TIMEOUT_MS = 20_000;
|
|
163
|
+
/**
|
|
164
|
+
* 官方页面解析器接受**全部**的参数名。
|
|
165
|
+
*
|
|
166
|
+
* ⚠️ 多一个键 ⇒ 整条链接作废(页面判 `null`)。所以构造时**只**放这几个。
|
|
167
|
+
*/
|
|
168
|
+
const RACCOON_AUTHORIZE_PARAM_NAMES = Object.freeze([
|
|
169
|
+
'login_source',
|
|
170
|
+
'appname',
|
|
171
|
+
'state',
|
|
172
|
+
'redirect',
|
|
173
|
+
'ide',
|
|
174
|
+
'org',
|
|
175
|
+
'lang',
|
|
176
|
+
'desktop_callback',
|
|
177
|
+
]);
|
|
178
|
+
/** 读一个字符串字段(非字符串 / 缺字段 → 兜底)。 */
|
|
179
|
+
function readString(value, fallback) {
|
|
180
|
+
return typeof value === 'string' ? value : fallback;
|
|
181
|
+
}
|
|
182
|
+
/**
|
|
183
|
+
* 判断一枚令牌**是不是** IAM 形态 —— 官方 `iamToken.js` 的规则:
|
|
184
|
+
* `iss` 以 `/iam` 结尾。
|
|
185
|
+
*
|
|
186
|
+
* ⚠️ **不验签**:签名由服务端负责校验;这里只决定**走成功门的哪一半**。
|
|
187
|
+
*
|
|
188
|
+
* @param token - 候选 JWT。
|
|
189
|
+
* @returns 是否 IAM 形态。
|
|
190
|
+
*/
|
|
191
|
+
export function isRaccoonIamToken(token) {
|
|
192
|
+
if (typeof token !== 'string' || token === '')
|
|
193
|
+
return false;
|
|
194
|
+
const parts = token.split('.');
|
|
195
|
+
if (parts.length < 2)
|
|
196
|
+
return false;
|
|
197
|
+
try {
|
|
198
|
+
const payload = JSON.parse(Buffer.from(parts[1] ?? '', 'base64url').toString('utf8'));
|
|
199
|
+
if (typeof payload !== 'object' || payload === null)
|
|
200
|
+
return false;
|
|
201
|
+
const iss = payload.iss;
|
|
202
|
+
return typeof iss === 'string' && iss.endsWith('/iam');
|
|
203
|
+
}
|
|
204
|
+
catch {
|
|
205
|
+
return false;
|
|
206
|
+
}
|
|
207
|
+
}
|
|
208
|
+
/**
|
|
209
|
+
* 官方 `iamTokenIsValid` 的重述:同一个 issuer、非空 `sub`、未来的有限 `exp`
|
|
210
|
+
* —— 且 `exp` 不能大到让 `new Date(exp*1000)` 不是一个日期。
|
|
211
|
+
*
|
|
212
|
+
* @param token - access token。
|
|
213
|
+
* @param issuer - 期望的 `iss`(默认 {@link RACCOON_IAM_ISSUER})。
|
|
214
|
+
* @returns 是否通过。
|
|
215
|
+
*/
|
|
216
|
+
export function raccoonIamTokenIsValid(token, issuer = RACCOON_IAM_ISSUER) {
|
|
217
|
+
if (typeof token !== 'string' || token === '')
|
|
218
|
+
return false;
|
|
219
|
+
const parts = token.split('.');
|
|
220
|
+
if (parts.length < 2)
|
|
221
|
+
return false;
|
|
222
|
+
try {
|
|
223
|
+
const payload = JSON.parse(Buffer.from(parts[1] ?? '', 'base64url').toString('utf8'));
|
|
224
|
+
if (typeof payload !== 'object' || payload === null)
|
|
225
|
+
return false;
|
|
226
|
+
const claims = payload;
|
|
227
|
+
return claims.iss === issuer
|
|
228
|
+
&& typeof claims.sub === 'string'
|
|
229
|
+
&& claims.sub.trim() !== ''
|
|
230
|
+
&& typeof claims.exp === 'number'
|
|
231
|
+
&& Number.isFinite(claims.exp)
|
|
232
|
+
&& claims.exp > Date.now() / 1000
|
|
233
|
+
&& !Number.isNaN(new Date(claims.exp * 1000).getTime());
|
|
234
|
+
}
|
|
235
|
+
catch {
|
|
236
|
+
return false;
|
|
237
|
+
}
|
|
238
|
+
}
|
|
239
|
+
/**
|
|
240
|
+
* 构造「一次浏览器登录」打开的那条 URL。
|
|
241
|
+
*
|
|
242
|
+
* 每个参数都在**发出之前**按官方页面的规则自查(见文件头「官方页自己的
|
|
243
|
+
* 规则」);不合规就**抛错**(带名字),让调用方能给出一句有下一步的话,
|
|
244
|
+
* 而不是丢一个页面会拒收的链接给用户。
|
|
245
|
+
*
|
|
246
|
+
* @param options
|
|
247
|
+
* @param options.port - 回环端口(整数 1024..65535)。
|
|
248
|
+
* @param options.state - 64 位小写 hex 的 state(公开的 CSRF 令牌)。
|
|
249
|
+
* @param options.appname - 授权页显示的应用名(默认 {@link RACCOON_AUTH_APPNAME})。
|
|
250
|
+
* @param options.base - 网关 origin(默认 {@link RACCOON_API_BASE})。
|
|
251
|
+
* @returns 完整 URL。
|
|
252
|
+
* @throws {Error} 具名的违规说明。
|
|
253
|
+
*/
|
|
254
|
+
export function buildRaccoonAuthorizeUrl({ port, state, appname = RACCOON_AUTH_APPNAME, base = RACCOON_API_BASE, }) {
|
|
255
|
+
if (typeof port !== 'number' || !Number.isInteger(port) || port < 1024 || port > 65535) {
|
|
256
|
+
throw new Error('authorize: 回环端口必须是 1024..65535 的整数');
|
|
257
|
+
}
|
|
258
|
+
const redirect = `http://127.0.0.1:${port}${RACCOON_LOOPBACK_CALLBACK_PATH}`;
|
|
259
|
+
if (!RACCOON_LOOPBACK_REDIRECT_RE.test(redirect)) {
|
|
260
|
+
throw new Error('authorize: 回环地址必须是 http://127.0.0.1:<4~5 位端口>/auth/callback');
|
|
261
|
+
}
|
|
262
|
+
const expected = readString(state, '');
|
|
263
|
+
if (!/^[a-f0-9]{64}$/.test(expected)) {
|
|
264
|
+
throw new Error('authorize: state 必须是 64 位小写 hex');
|
|
265
|
+
}
|
|
266
|
+
const app = readString(appname, '');
|
|
267
|
+
if (app === '' || app.length > 100) {
|
|
268
|
+
throw new Error('authorize: 应用名必须是 1..100 个字符');
|
|
269
|
+
}
|
|
270
|
+
const origin = readString(base, '') !== '' ? readString(base, '') : RACCOON_API_BASE;
|
|
271
|
+
const url = new URL(origin);
|
|
272
|
+
if (url.protocol !== 'https:') {
|
|
273
|
+
throw new Error('authorize: 网关 origin 必须是 https');
|
|
274
|
+
}
|
|
275
|
+
url.pathname = RACCOON_AUTHORIZE_PATH;
|
|
276
|
+
url.search = '';
|
|
277
|
+
url.searchParams.set('login_source', 'desktop');
|
|
278
|
+
url.searchParams.set('appname', app);
|
|
279
|
+
url.searchParams.set('desktop_callback', 'loopback');
|
|
280
|
+
url.searchParams.set('redirect', redirect);
|
|
281
|
+
url.searchParams.set('state', expected);
|
|
282
|
+
// ⚠️ 自查:造出来的参数名**必须**全在官方白名单里(多一个键整条链接作废)。
|
|
283
|
+
for (const key of url.searchParams.keys()) {
|
|
284
|
+
if (!RACCOON_AUTHORIZE_PARAM_NAMES.includes(key)) {
|
|
285
|
+
throw new Error(`authorize: 参数名 ${key} 不在官方页面的白名单里`);
|
|
286
|
+
}
|
|
287
|
+
}
|
|
288
|
+
return url.toString();
|
|
289
|
+
}
|
|
290
|
+
/**
|
|
291
|
+
* 启动回环接收端 —— 官方 `/authorize` 页的回调落点。
|
|
292
|
+
*
|
|
293
|
+
* 工厂是**异步**的:端口只有在操作系统分配之后才知道(`port 0`),调用方
|
|
294
|
+
* 必须在把 URL 交给浏览器**之前** await 它 —— 那时接收端**已经在听**,
|
|
295
|
+
* 不存在「页面往一个还不是我们的端口上跳」的窗口。
|
|
296
|
+
*
|
|
297
|
+
* ⚠️ 绑不上端口(EADDRINUSE)**不抛**:调用方正处在一个请求里、需要一句
|
|
298
|
+
* 答复,而它报出来的失败是用户**能动作**的(重开一轮)。
|
|
299
|
+
*
|
|
300
|
+
* @param options
|
|
301
|
+
* @param options.port - 指定端口;缺省 / 0 = 由操作系统分配。
|
|
302
|
+
* @param options.state - 64 位 hex;缺省时随机生成。
|
|
303
|
+
* @param options.timeoutMs - 等待时限(默认 {@link RACCOON_AUTHORIZE_TIMEOUT_MS})。
|
|
304
|
+
* @param options.authorizationOrigin - 存在的 `Origin` 头必须等于它(默认网关 origin)。
|
|
305
|
+
* @param options.appname - 授权页的应用名。
|
|
306
|
+
* @param options.base - 网关 origin。
|
|
307
|
+
* @returns 接收端句柄。
|
|
308
|
+
*/
|
|
309
|
+
export async function startRaccoonAuthorizeReceiver(options = {}) {
|
|
310
|
+
const state = options.state !== undefined && options.state !== null
|
|
311
|
+
? readString(options.state, '')
|
|
312
|
+
: randomBytes(32).toString('hex');
|
|
313
|
+
if (!/^[a-f0-9]{64}$/.test(state)) {
|
|
314
|
+
throw new Error('authorize: state 必须是 64 位小写 hex');
|
|
315
|
+
}
|
|
316
|
+
const authorizationOrigin = readString(options.authorizationOrigin, '') !== ''
|
|
317
|
+
? readString(options.authorizationOrigin, '')
|
|
318
|
+
: RACCOON_API_BASE;
|
|
319
|
+
const timeoutMs = typeof options.timeoutMs === 'number'
|
|
320
|
+
&& Number.isFinite(options.timeoutMs)
|
|
321
|
+
&& options.timeoutMs > 0
|
|
322
|
+
? options.timeoutMs
|
|
323
|
+
: RACCOON_AUTHORIZE_TIMEOUT_MS;
|
|
324
|
+
let settled = false;
|
|
325
|
+
let consumed = false;
|
|
326
|
+
let server = null;
|
|
327
|
+
let timer = null;
|
|
328
|
+
// `settleFn` 在 Promise 的 executor 里建(它持有 `resolve`),而调用点在
|
|
329
|
+
// executor 之后 ⇒ TS 会把裸 `let` 的「确定已赋值」重置 ⇒ 调用方看到的是
|
|
330
|
+
// 下面这个 `finish` 包装:一个从头就存在的 const,委托给 executor 建的
|
|
331
|
+
// `settleFn`(直到下一个 tick 才非空)。
|
|
332
|
+
let settleFn = null;
|
|
333
|
+
const finish = (value, hard = true) => {
|
|
334
|
+
settleFn?.(value, hard);
|
|
335
|
+
};
|
|
336
|
+
const result = new Promise((resolve) => {
|
|
337
|
+
// `hard` 会拆掉在途连接(超时、绑不上、用户取消:没人欠它们一个响应)。
|
|
338
|
+
// **成功路径必须软关闭**:浏览器正在读的那个 200 还在半路上,硬拆会让它
|
|
339
|
+
// 报「连接被重置」—— 那是一次**其实成功了**的登录。
|
|
340
|
+
settleFn = (value, hard = true) => {
|
|
341
|
+
if (settled)
|
|
342
|
+
return;
|
|
343
|
+
settled = true;
|
|
344
|
+
if (timer !== null)
|
|
345
|
+
clearTimeout(timer);
|
|
346
|
+
if (server !== null) {
|
|
347
|
+
if (hard)
|
|
348
|
+
server.closeAllConnections?.();
|
|
349
|
+
server.close();
|
|
350
|
+
}
|
|
351
|
+
resolve(value);
|
|
352
|
+
};
|
|
353
|
+
});
|
|
354
|
+
const request = (req, res) => {
|
|
355
|
+
const authority = `127.0.0.1:${portOf()}`;
|
|
356
|
+
const answer = (status, body) => {
|
|
357
|
+
res.writeHead(status, {
|
|
358
|
+
'Content-Type': 'text/plain; charset=utf-8',
|
|
359
|
+
'Cache-Control': 'no-store',
|
|
360
|
+
'Referrer-Policy': 'no-referrer',
|
|
361
|
+
'X-Content-Type-Options': 'nosniff',
|
|
362
|
+
// ⚠️ `Connection: close`(官方接收端同款):这个端口是「等着收凭据」的
|
|
363
|
+
// 一次性口子 ⇒ **每个请求都必须自己断开**。否则 keep-alive 的连接
|
|
364
|
+
// 会**累积**在本机上,而 `maxConnections = 8`(见下)⇒ 第 9 个
|
|
365
|
+
// 正常请求会被**拒**(连接被关)—— 那是一个「真回调进不来」的
|
|
366
|
+
// 可用性缺陷,与安全无关。
|
|
367
|
+
Connection: 'close',
|
|
368
|
+
});
|
|
369
|
+
res.end(body);
|
|
370
|
+
};
|
|
371
|
+
if (settled || consumed) {
|
|
372
|
+
// 一次性:有效回调被取走之后(或接收端已落定),端口对一切回 **409**
|
|
373
|
+
// —— 那枚 code 在上游也是一次性的,第二次投递**不得**再换一次码。
|
|
374
|
+
answer(409, 'used');
|
|
375
|
+
return;
|
|
376
|
+
}
|
|
377
|
+
// 每次拒绝都说**规则的名字**,不说它的输入:`code` 的值是凭据,
|
|
378
|
+
// 不能出现在响应体或日志里。
|
|
379
|
+
let reason = '';
|
|
380
|
+
let code = null;
|
|
381
|
+
try {
|
|
382
|
+
const raw = typeof req.url === 'string' ? req.url : '/';
|
|
383
|
+
if (req.method !== 'GET') {
|
|
384
|
+
reason = 'method';
|
|
385
|
+
}
|
|
386
|
+
else if (req.headers.host !== authority) {
|
|
387
|
+
reason = 'host';
|
|
388
|
+
}
|
|
389
|
+
else if (req.socket.remoteAddress !== '127.0.0.1') {
|
|
390
|
+
reason = 'source';
|
|
391
|
+
// ⚠️ 下面两条都是「**头存在才查**」(缺头一律放行),这是**必需的**,不要按
|
|
392
|
+
// 「安全加固」的直觉改成「必须存在」:官方页面在 desktop 形态用**顶层导航**
|
|
393
|
+
// 投递回调(官方 bundle 里就是 `r.navigate(t)`),而顶层导航**不发 `Origin`**
|
|
394
|
+
// ⇒ 改成必须存在会让真浏览器里 100% 收不到回调。
|
|
395
|
+
}
|
|
396
|
+
else if (typeof req.headers.origin === 'string' && req.headers.origin !== authorizationOrigin) {
|
|
397
|
+
reason = 'origin';
|
|
398
|
+
}
|
|
399
|
+
else if (typeof req.headers['sec-fetch-dest'] === 'string' && req.headers['sec-fetch-dest'] !== 'document') {
|
|
400
|
+
reason = 'fetch-dest';
|
|
401
|
+
}
|
|
402
|
+
else if (raw.length > RACCOON_CALLBACK_URL_MAX_LENGTH) {
|
|
403
|
+
// ⚠️ **整个 URL 的长度上限**(官方接收端有这条:`rawUrl.length > 8192`)。
|
|
404
|
+
// 没有它 ⇒ 一个超长 URL 会被 `new URL()` **完整解析**(内存 + CPU
|
|
405
|
+
// 都归我们),而这条请求本来就只可能带一个 ≤4096 的 code。
|
|
406
|
+
reason = 'length';
|
|
407
|
+
}
|
|
408
|
+
else {
|
|
409
|
+
const url = new URL(raw, `http://${authority}`);
|
|
410
|
+
if (url.origin !== `http://${authority}` || url.pathname !== RACCOON_LOOPBACK_CALLBACK_PATH || url.hash !== '') {
|
|
411
|
+
// ⚠️⚠️ **协议相对 URL(`//evil/…`)在这一格被拒**,而且**是靠
|
|
412
|
+
// `url.origin` 那一腿**:`new URL('//evil/x', 'http://127.0.0.1:P')`
|
|
413
|
+
// 解析出的是 **`http://evil/x`** ⇒ origin 不等 ⇒ 进这一格。
|
|
414
|
+
//
|
|
415
|
+
// ⚠️ **不要**再加一条「`raw.startsWith('//')`」的显式检查:
|
|
416
|
+
// 那是**同义判据**(本仓记过的坑:一文件两套同义判据),
|
|
417
|
+
// 而且它**测不出差别** —— 变异把它去掉,origin 那腿照样拒
|
|
418
|
+
// (实测 14 条变异里那条**无牙**)。要防协议相对 URL,靠的
|
|
419
|
+
// 是 **origin 严格等值**这一腿。
|
|
420
|
+
reason = 'path';
|
|
421
|
+
}
|
|
422
|
+
else {
|
|
423
|
+
const keys = [...url.searchParams.keys()];
|
|
424
|
+
if (keys.some((key) => !(key === 'code' || key === 'state'))
|
|
425
|
+
|| url.searchParams.getAll('state').length !== 1
|
|
426
|
+
|| url.searchParams.getAll('code').length !== 1) {
|
|
427
|
+
reason = 'keys';
|
|
428
|
+
}
|
|
429
|
+
else {
|
|
430
|
+
const receivedState = url.searchParams.get('state') ?? '';
|
|
431
|
+
const receivedCode = (url.searchParams.get('code') ?? '').trim();
|
|
432
|
+
// ⚠️ `^[a-f0-9]{64}$` 这个预判是**承重**的,不是装饰:`timingSafeEqual`
|
|
433
|
+
// 对**不等长**的 Buffer 会抛 `RangeError`,被外层 catch 吞成
|
|
434
|
+
// `rejected: url` ⇒ 拒绝原因词从 `state` 退化成 `url`(诊断信息丢失)。
|
|
435
|
+
// 所以先固定长度,长度不对就直接落 `state`。
|
|
436
|
+
const stateOk = /^[a-f0-9]{64}$/.test(receivedState)
|
|
437
|
+
&& timingSafeEqual(Buffer.from(receivedState), Buffer.from(state));
|
|
438
|
+
const codeOk = receivedCode !== '' && receivedCode.length <= 4096
|
|
439
|
+
&& !/[\x00-\x1f\x7f]/.test(receivedCode);
|
|
440
|
+
if (!stateOk) {
|
|
441
|
+
reason = 'state';
|
|
442
|
+
}
|
|
443
|
+
else if (!codeOk) {
|
|
444
|
+
reason = 'code';
|
|
445
|
+
}
|
|
446
|
+
else {
|
|
447
|
+
code = receivedCode;
|
|
448
|
+
}
|
|
449
|
+
}
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
}
|
|
453
|
+
catch {
|
|
454
|
+
reason = 'url';
|
|
455
|
+
}
|
|
456
|
+
if (code === null) {
|
|
457
|
+
answer(400, `rejected: ${reason === '' ? 'callback' : reason}`);
|
|
458
|
+
return;
|
|
459
|
+
}
|
|
460
|
+
consumed = true;
|
|
461
|
+
// 先把 200 **冲出去**再拆:这里硬拆会把 socket 掐在半截,浏览器会读成
|
|
462
|
+
// 「登录失败」(软关闭让在途响应写完,然后服务才退)。
|
|
463
|
+
answer(200, 'authorized');
|
|
464
|
+
// `code` 离开线路的**唯一**一刻:原样进调用方。
|
|
465
|
+
finish({ ok: true, code }, false);
|
|
466
|
+
};
|
|
467
|
+
let assignedPort = 0;
|
|
468
|
+
const portOf = () => assignedPort;
|
|
469
|
+
timer = setTimeout(() => finish({ ok: false, reason: 'timeout' }), timeoutMs);
|
|
470
|
+
timer.unref?.();
|
|
471
|
+
server = createServer({ maxHeaderSize: 8192 }, request);
|
|
472
|
+
server.on('error', () => finish({ ok: false, reason: 'failed' }));
|
|
473
|
+
// ⚠️⚠️ **三条超时/连接数兜底**(官方接收端同款,2026-11-17 对齐):
|
|
474
|
+
// 官方 `webLoginLoopback.js` 里有 `server.maxConnections = 8` /
|
|
475
|
+
// `headersTimeout = 5000` / `requestTimeout = 10000` /
|
|
476
|
+
// `setTimeout(20000, socket => socket.destroy())`。
|
|
477
|
+
//
|
|
478
|
+
// 没有它们的后果:一个**慢速连接**(不发完整请求头、也不断开)能占住这个
|
|
479
|
+
// 端口直到 5 分钟的整体超时 ⇒ 而这个端口是「等着收凭据」的口子,占住它
|
|
480
|
+
// 不只是资源问题,还是**可用性**问题(真回调进不来)。
|
|
481
|
+
//
|
|
482
|
+
// ⚠️ **socket 超时必须可注入**:20 秒的默认值在单测里没法等 ⇒
|
|
483
|
+
// 注入点让用例能把它压到几百毫秒(否则那条判据**测不到**,
|
|
484
|
+
// 变异验证会如实报「无牙」—— 那不是判据没用,是**够不着**)。
|
|
485
|
+
const socketTimeoutMs = typeof options.socketTimeoutMs === 'number'
|
|
486
|
+
&& Number.isFinite(options.socketTimeoutMs)
|
|
487
|
+
&& options.socketTimeoutMs > 0
|
|
488
|
+
? options.socketTimeoutMs
|
|
489
|
+
: RACCOON_SOCKET_TIMEOUT_MS;
|
|
490
|
+
server.maxConnections = 8;
|
|
491
|
+
server.headersTimeout = 5_000;
|
|
492
|
+
server.requestTimeout = 10_000;
|
|
493
|
+
server.setTimeout(socketTimeoutMs, (socket) => socket.destroy());
|
|
494
|
+
const requestedPort = typeof options.port === 'number'
|
|
495
|
+
&& Number.isInteger(options.port)
|
|
496
|
+
&& options.port > 0
|
|
497
|
+
? options.port
|
|
498
|
+
: 0;
|
|
499
|
+
if (requestedPort !== 0 && (requestedPort < 1024 || requestedPort > 65535)) {
|
|
500
|
+
// 官方页面自己那个范围外的端口**页面会拒收** ⇒ 调用方的 bug,
|
|
501
|
+
// 提前抛是唯一「有下一步」的形状。
|
|
502
|
+
throw new Error('authorize: 请求的端口必须是 0(随机)或 1024..65535');
|
|
503
|
+
}
|
|
504
|
+
await new Promise((resolve, reject) => {
|
|
505
|
+
const onError = (error) => {
|
|
506
|
+
server?.removeListener('error', onError);
|
|
507
|
+
reject(error);
|
|
508
|
+
};
|
|
509
|
+
server?.once('error', onError);
|
|
510
|
+
server?.listen(requestedPort, '127.0.0.1', () => {
|
|
511
|
+
server?.removeListener('error', onError);
|
|
512
|
+
const address = server?.address() ?? null;
|
|
513
|
+
if (address === null || typeof address === 'string') {
|
|
514
|
+
reject(new Error('authorize: 回环端口没有绑上'));
|
|
515
|
+
return;
|
|
516
|
+
}
|
|
517
|
+
assignedPort = address.port;
|
|
518
|
+
resolve();
|
|
519
|
+
});
|
|
520
|
+
}).catch(() => {
|
|
521
|
+
// 绑不上早已把结果落定为 `failed`;调用方拿到的对象仍带着(未绑上的)
|
|
522
|
+
// URL,好让它报一句有下一步的失败,而 `result` 才是真相。
|
|
523
|
+
});
|
|
524
|
+
// 操作系统可能分配一个**页面会拒收**的端口(< 1024)⇒ 整条链是个死路,
|
|
525
|
+
// 落定为 `failed` 且不产出 URL(用户重开一轮即可)。
|
|
526
|
+
const portUsable = assignedPort >= 1024 && assignedPort <= 65535;
|
|
527
|
+
if (!portUsable && assignedPort > 0)
|
|
528
|
+
finish({ ok: false, reason: 'failed' });
|
|
529
|
+
const redirect = `http://127.0.0.1:${assignedPort}${RACCOON_LOOPBACK_CALLBACK_PATH}`;
|
|
530
|
+
let authorizeUrl = '';
|
|
531
|
+
if (portUsable) {
|
|
532
|
+
try {
|
|
533
|
+
authorizeUrl = buildRaccoonAuthorizeUrl({
|
|
534
|
+
port: assignedPort,
|
|
535
|
+
state,
|
|
536
|
+
appname: options.appname,
|
|
537
|
+
base: options.base,
|
|
538
|
+
});
|
|
539
|
+
}
|
|
540
|
+
catch {
|
|
541
|
+
// 防御性分支(理论上不可达):`portUsable` 已经把端口夹在 1024..65535 内,
|
|
542
|
+
// 而官方页面那两条判据(回环 URL 正则 + `1024..65535` 端口范围)在这个区间上
|
|
543
|
+
// 恒真。⚠️ 别把这两条判据读成「一条更窄所以另一条冗余」——回环正则允许
|
|
544
|
+
// `1000..1023` 那类四位端口,是**端口范围判据**把它收窄的,官方 bundle 里
|
|
545
|
+
// 同样两条并存。
|
|
546
|
+
finish({ ok: false, reason: 'failed' });
|
|
547
|
+
}
|
|
548
|
+
}
|
|
549
|
+
return {
|
|
550
|
+
state,
|
|
551
|
+
port: assignedPort,
|
|
552
|
+
redirect,
|
|
553
|
+
authorizeUrl,
|
|
554
|
+
result,
|
|
555
|
+
cancel: () => finish({ ok: false, reason: 'closed' }),
|
|
556
|
+
};
|
|
557
|
+
}
|
|
558
|
+
/**
|
|
559
|
+
* 用系统默认浏览器打开 URL;**永不抛出**。
|
|
560
|
+
*
|
|
561
|
+
* ⚠️⚠️ **绝不能用 `cmd /c start`** —— 它把 URL 里每个 `&` 当命令分隔符,
|
|
562
|
+
* 于是 `?...&...` 会被**截断**在第一个 `&` 上(症状极具误导性:授权页显示
|
|
563
|
+
* 「链接无效」、参数全丢)。`rundll32` **不经过 shell**,参数原样传递
|
|
564
|
+
* (与 `accio-oauth.ts` 的 `openBrowser` 同一处方)。
|
|
565
|
+
*
|
|
566
|
+
* ⚠️ 永不抛出的兑现方式是那个**空回调**:Node 只在 `execFile` **带回调**时
|
|
567
|
+
* 才代为挂上 `'error'` 监听器 ⇒ 那个 `() => {}` 不是装饰,删掉它,
|
|
568
|
+
* `ENOENT` 会变成**未捕获异常**并打挂宿主进程。
|
|
569
|
+
*/
|
|
570
|
+
export function openRaccoonAuthorizePage(url) {
|
|
571
|
+
try {
|
|
572
|
+
if (process.platform === 'win32') {
|
|
573
|
+
execFile('rundll32.exe', ['url.dll,FileProtocolHandler', url], () => { });
|
|
574
|
+
return;
|
|
575
|
+
}
|
|
576
|
+
const cmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
|
|
577
|
+
execFile(cmd, [url], () => { });
|
|
578
|
+
}
|
|
579
|
+
catch {
|
|
580
|
+
// 打开失败不影响流程:调用方会把 URL 显示给用户手动打开。
|
|
581
|
+
}
|
|
582
|
+
}
|
|
583
|
+
/**
|
|
584
|
+
* 用一次性授权码换凭据。
|
|
585
|
+
*
|
|
586
|
+
* 请求形状与官方**逐字节相同**:`POST {authApi}/login_with_authorization_code`,
|
|
587
|
+
* 只带一个 `Content-Type` 头,body 是 `{ authorization_code }`。
|
|
588
|
+
* 网关的 web-auth 这一族用的是**数字** `code === 0` 信封。
|
|
589
|
+
*
|
|
590
|
+
* ## 成功门(官方的那道门,逐字重述)
|
|
591
|
+
*
|
|
592
|
+
* 必须有 `access_token`,**并且**满足**二者之一**:
|
|
593
|
+
*
|
|
594
|
+
* - 一枚**有效**的 IAM 令牌(官方规则:同一 issuer + 非空 `sub` + 未来的
|
|
595
|
+
* `exp`)—— 这一半**不要求**带 refresh;
|
|
596
|
+
* - 或一枚 refresh token(legacy 那一对)。
|
|
597
|
+
*
|
|
598
|
+
* 差一点就是**拒绝 + 具名原因**,**绝不**产出半截凭据(存下半个凭据 = 存下
|
|
599
|
+
* 一个轮换之后什么都不剩的东西)。
|
|
600
|
+
*
|
|
601
|
+
* ⚠️ 上面第一半(IAM 令牌)**不要求** refresh ⇒ 那种凭据落库后
|
|
602
|
+
* `isRaccoonRefreshable()`(`src/raccoon.ts`)为 **false**,账号**不可静默续期**:
|
|
603
|
+
* 续期调度器跳过它(`src/raccoon-auth.ts` 的 `if (!entry.refreshable) continue`),
|
|
604
|
+
* 而推理侧遇到 401/403 时 `refresh()` 会**在发任何网络请求之前**抛
|
|
605
|
+
* `RefreshTokenExpiredError('凭据缺少 refresh_token,请重新登录')`。
|
|
606
|
+
* 这是**有意的**(官方规则如此,且行为诚实、不白烧凭据),但后果用户可见:
|
|
607
|
+
* **到期后必须重新登录**。
|
|
608
|
+
*
|
|
609
|
+
* @param code - 一次性授权码(最多换一次;上游会对重放回 400)。
|
|
610
|
+
* @param options
|
|
611
|
+
* @param options.product - 产品配置(默认 {@link RACCOON})。
|
|
612
|
+
* @param options.fetcher - 注入的 fetch(测试用)。
|
|
613
|
+
* @param options.authApiBase - 换码端点前缀(默认取 `product`)。
|
|
614
|
+
* @param options.iamIssuer - IAM 令牌必须带的 `iss`(默认 {@link RACCOON_IAM_ISSUER})。
|
|
615
|
+
* @param options.signal - 调用方自带的取消信号(缺省时用请求超时)。
|
|
616
|
+
* @returns 换码结果。
|
|
617
|
+
*/
|
|
618
|
+
export async function exchangeRaccoonAuthorizationCode(code, options = {}) {
|
|
619
|
+
const token = readString(code, '').trim();
|
|
620
|
+
if (token === '')
|
|
621
|
+
return { ok: false, reason: 'invalid_response' };
|
|
622
|
+
const product = options.product ?? RACCOON;
|
|
623
|
+
const authApiBase = readString(options.authApiBase, '') !== ''
|
|
624
|
+
? readString(options.authApiBase, '')
|
|
625
|
+
: `${product.apiBase}${product.authApiPrefix}`;
|
|
626
|
+
const iamIssuer = readString(options.iamIssuer, '') !== ''
|
|
627
|
+
? readString(options.iamIssuer, '')
|
|
628
|
+
: RACCOON_IAM_ISSUER;
|
|
629
|
+
const effective = options.fetcher ?? globalThis.fetch;
|
|
630
|
+
let response;
|
|
631
|
+
try {
|
|
632
|
+
response = await effective(`${authApiBase}/login_with_authorization_code`, {
|
|
633
|
+
method: 'POST',
|
|
634
|
+
headers: { 'Content-Type': 'application/json' },
|
|
635
|
+
body: JSON.stringify({ authorization_code: token }),
|
|
636
|
+
// ⚠️ **无条件**挂截止时间,不要按「fetcher 是不是注入的」分支:生产的调用点
|
|
637
|
+
// 恒传 fetcher(`runAuthorizeRound(state, product, deps.fetcher, …)`,而
|
|
638
|
+
// `deps.fetcher = options.fetcher ?? fetch`)⇒ 拿 `options.fetcher === undefined`
|
|
639
|
+
// 当判据会让**生产路径永远没有 signal**,上游把连接挂住时只能白等接收端的
|
|
640
|
+
// 5 分钟超时(实测:注入 fetcher 时 `signalPresent === false`)。
|
|
641
|
+
// 自己管 abort 的调用方用 `options.signal` 覆盖。
|
|
642
|
+
signal: options.signal ?? AbortSignal.timeout(RACCOON_REQUEST_TIMEOUT_MS),
|
|
643
|
+
});
|
|
644
|
+
}
|
|
645
|
+
catch {
|
|
646
|
+
return { ok: false, reason: 'network' };
|
|
647
|
+
}
|
|
648
|
+
let payload;
|
|
649
|
+
try {
|
|
650
|
+
payload = await response.json();
|
|
651
|
+
}
|
|
652
|
+
catch {
|
|
653
|
+
return { ok: false, reason: 'invalid_response' };
|
|
654
|
+
}
|
|
655
|
+
const envelope = payload !== null && typeof payload === 'object' && !Array.isArray(payload)
|
|
656
|
+
? payload
|
|
657
|
+
: {};
|
|
658
|
+
const envelopeCode = typeof envelope.code === 'number' ? envelope.code : (response.status >= 400 ? response.status : 0);
|
|
659
|
+
if (response.status === 401)
|
|
660
|
+
return { ok: false, reason: 'session_dead' };
|
|
661
|
+
if (envelopeCode === RACCOON_AUTHORIZATION_CODE_NOT_FOUND) {
|
|
662
|
+
return { ok: false, reason: 'code_not_found' };
|
|
663
|
+
}
|
|
664
|
+
if (!response.ok || envelopeCode !== 0)
|
|
665
|
+
return { ok: false, reason: 'server_error' };
|
|
666
|
+
const data = envelope.data !== null && typeof envelope.data === 'object' && !Array.isArray(envelope.data)
|
|
667
|
+
? envelope.data
|
|
668
|
+
: {};
|
|
669
|
+
// ⚠️ 判据用 `trim()` 后的值:「恰好是几个空格」不是一枚令牌,但它**穿过**了
|
|
670
|
+
// `readString`(只判 typeof)与原来的 `=== ''`(精确空串)两道判据 ⇒ 一个只有
|
|
671
|
+
// 空白的 `access_token` 会产出「成功」凭据。对令牌而言空白 = 缺失。
|
|
672
|
+
const accessToken = readString(data.access_token, '');
|
|
673
|
+
if (accessToken.trim() === '')
|
|
674
|
+
return { ok: false, reason: 'invalid_response' };
|
|
675
|
+
const iam = isRaccoonIamToken(accessToken);
|
|
676
|
+
if (iam && !raccoonIamTokenIsValid(accessToken, iamIssuer)) {
|
|
677
|
+
return { ok: false, reason: 'token_invalid' };
|
|
678
|
+
}
|
|
679
|
+
const refreshToken = readString(data.refresh_token, '');
|
|
680
|
+
if (!iam && refreshToken.trim() === '') {
|
|
681
|
+
// legacy 那一半**必须**带 refresh(官方规则):否则这枚令牌续不了期,
|
|
682
|
+
// 落地就是一个「过期即死」的账号。⚠️ 用 `trim()`:一枚只有空白的 refresh
|
|
683
|
+
// 同样续不了期(`isRaccoonRefreshable()` 判的虽是非空,但空白串进上游一样失败)。
|
|
684
|
+
return { ok: false, reason: 'refresh_missing' };
|
|
685
|
+
}
|
|
686
|
+
const expMs = decodeJwtExpMs(accessToken);
|
|
687
|
+
const officeIdentity = readString(data.office_identity, '');
|
|
688
|
+
return {
|
|
689
|
+
ok: true,
|
|
690
|
+
credential: {
|
|
691
|
+
access_token: accessToken,
|
|
692
|
+
refresh_token: refreshToken,
|
|
693
|
+
...expMs !== undefined ? { expires_at: String(expMs) } : {},
|
|
694
|
+
...officeIdentity.length > 0 ? { office_identity: officeIdentity } : {},
|
|
695
|
+
},
|
|
696
|
+
};
|
|
697
|
+
}
|
|
698
|
+
//# sourceMappingURL=raccoon-authorize.js.map
|