@wkgeo/cli 0.0.0-stage → 1.0.0
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/CHANGELOG.md +208 -0
- package/LICENSE +21 -0
- package/README.md +1042 -3
- package/SKILL.md +927 -0
- package/lib/ai/client.mjs +161 -0
- package/lib/ai/config.mjs +221 -0
- package/lib/ai/context.mjs +468 -0
- package/lib/ai/log.mjs +53 -0
- package/lib/api.mjs +339 -0
- package/lib/args.mjs +235 -0
- package/lib/cli.mjs +168 -0
- package/lib/cms.mjs +330 -0
- package/lib/commands/ai.mjs +392 -0
- package/lib/commands/apps.mjs +116 -0
- package/lib/commands/auth.mjs +1288 -0
- package/lib/commands/billing.mjs +666 -0
- package/lib/commands/cms.mjs +2533 -0
- package/lib/commands/config-auth.mjs +621 -0
- package/lib/commands/config.mjs +434 -0
- package/lib/commands/dnscred.mjs +428 -0
- package/lib/commands/domainops.mjs +546 -0
- package/lib/commands/domainorder.mjs +439 -0
- package/lib/commands/import.mjs +164 -0
- package/lib/commands/index.mjs +528 -0
- package/lib/commands/logs.mjs +141 -0
- package/lib/commands/orders.mjs +444 -0
- package/lib/commands/overview.mjs +394 -0
- package/lib/commands/plugins.mjs +678 -0
- package/lib/commands/site.mjs +435 -0
- package/lib/commands/siteops.mjs +1012 -0
- package/lib/commands/sites.mjs +905 -0
- package/lib/commands/skill.mjs +119 -0
- package/lib/config.mjs +351 -0
- package/lib/credentials.mjs +160 -0
- package/lib/device-store.mjs +132 -0
- package/lib/device.mjs +464 -0
- package/lib/errors.mjs +299 -0
- package/lib/format.mjs +339 -0
- package/lib/http.mjs +71 -0
- package/lib/index.mjs +44 -0
- package/lib/local-import.mjs +185 -0
- package/lib/login.mjs +1638 -0
- package/lib/oauth-urls.mjs +163 -0
- package/lib/page.mjs +393 -0
- package/lib/pkce.mjs +48 -0
- package/lib/proxy.mjs +454 -0
- package/lib/qr.mjs +31 -0
- package/lib/runtime.mjs +650 -0
- package/lib/site-state.mjs +137 -0
- package/package.json +53 -4
- package/wkgeo.mjs +17 -0
package/lib/login.mjs
ADDED
|
@@ -0,0 +1,1638 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `login`:授权码 + PKCE 的本地回调流程。
|
|
3
|
+
*
|
|
4
|
+
* 完整时序(按本项目的真实实现):
|
|
5
|
+
* 1. CLI 起一个**只监听 127.0.0.1** 的临时 HTTP 服务
|
|
6
|
+
* 2. 生成 code_verifier / S256 challenge / state
|
|
7
|
+
* 3. 打开浏览器到 `authorization_endpoint?client_id&redirect_uri&scope&state&code_challenge…`
|
|
8
|
+
* —— 未登录会先跳登录页,然后回到同意页
|
|
9
|
+
* 4. 用户在页面上点「同意」,页面 POST /api/oauth/consent,服务端签发 code 并跳回 redirect_uri
|
|
10
|
+
* 5. CLI 的本地服务收到 `?code=…&state=…` → **先校验 state**(服务端不校验,这是客户端的活)
|
|
11
|
+
* 6. CLI 用 code + code_verifier 换 token → 写本地凭据(0600)→ 回一个"可以关闭本页"的 HTML
|
|
12
|
+
*
|
|
13
|
+
* 为什么端口默认写死 53682 又要能换:
|
|
14
|
+
* 服务端登记的 redirect_uri 是 `http://127.0.0.1:53682/callback`。
|
|
15
|
+
* 服务端按 RFC 8252 对**回环地址忽略端口**(实测 54321 也匹配),所以端口被占用时
|
|
16
|
+
* 退到随机端口依然能授权成功。这条很重要:用户机器上 53682 被占是常事,
|
|
17
|
+
* 不能因为这个就让他去改客户端配置。
|
|
18
|
+
*
|
|
19
|
+
* 依赖注入(deps)是为了**可测**:offline 单测里把 fetch / 开浏览器 / 端口都替换掉,
|
|
20
|
+
* 就成了一台"假浏览器",可以逐条验证 state 校验、超时、错误页这些分支。
|
|
21
|
+
*
|
|
22
|
+
* ★★ 2026-10-21(老板反馈):**默认就是这条本地回调授权**,`wkgeo login` 不会因为
|
|
23
|
+
* "等了一会儿"自动变成设备码。设备码只在**这几种情况**出现(裁决点在 `commands/auth.mjs`):
|
|
24
|
+
* * 用户显式 `--device` / `--no-wait` / `--device-continue`;
|
|
25
|
+
* * 检测到系统代理且判定回调不可用(默认开,`--no-auto-device` 可关);
|
|
26
|
+
* * 本地回调端口**真的起不来**(`kind = 'listen'`,真实失败兜底;`--no-auto-device` 可关)。
|
|
27
|
+
* 整段等待超时(`kind = 'timeout'`)**只报错**,不再自动改设备码(0.2.2 起取消)。
|
|
28
|
+
*
|
|
29
|
+
* 两个等待窗口(别搞混,`commands/auth.mjs` 靠 `kind` 区分"要不要自动改设备码"):
|
|
30
|
+
* * 可选首轮等待(`--callback-first-wait` / `WKONGAI_CALLBACK_FIRST_WAIT_MS`,
|
|
31
|
+
* ★ **默认关闭**,只有用户显式指定才启用)
|
|
32
|
+
* → 到点抛 `kind = 'callback_first_wait'`;命令层在场时会**并发**启动设备码(仅显式开启时);
|
|
33
|
+
* * `config.loginTimeoutMs`(默认 300 秒,`--timeout` 可调)
|
|
34
|
+
* → 到点抛 `kind = 'timeout'`(整段等待的兜底,也是老板报的那个故障的现场)。
|
|
35
|
+
*
|
|
36
|
+
* ★★ 2026-10-03(老板真机反馈)起,"首轮等待"到点改道时**不再关掉本地回调监听**:
|
|
37
|
+
* 命令层会通过 `deps.handoff` 拿到通知,**并发**去跑设备码那条路,**哪条先成功就用哪条**
|
|
38
|
+
* (详见 `deps.handoff` 的注释;该自愈现在只有显式 `--callback-first-wait` 才会触发)。
|
|
39
|
+
*/
|
|
40
|
+
|
|
41
|
+
import http from 'node:http';
|
|
42
|
+
import { spawn } from 'node:child_process';
|
|
43
|
+
import { win32 as pathWin32 } from 'node:path';
|
|
44
|
+
import { URL } from 'node:url';
|
|
45
|
+
|
|
46
|
+
import { createApi } from './api.mjs';
|
|
47
|
+
import { successPage, errorPage, alreadyDonePage } from './page.mjs';
|
|
48
|
+
import { createVerifier, challengeOf, createState, safeEqual } from './pkce.mjs';
|
|
49
|
+
import { writeCredentials, credentialsFromToken } from './credentials.mjs';
|
|
50
|
+
import { withTrailingSlash } from './config.mjs';
|
|
51
|
+
import { canonicalOauthUrl } from './oauth-urls.mjs';
|
|
52
|
+
import { proxyRiskHint } from './proxy.mjs';
|
|
53
|
+
import { CliError, EXIT } from './errors.mjs';
|
|
54
|
+
|
|
55
|
+
/**
|
|
56
|
+
* 每个平台**依次尝试哪几个程序**打开网址,以及怎么把 URL 传给它。
|
|
57
|
+
*
|
|
58
|
+
* ⚠️⚠️ 为什么必须"多条策略"而不是"一条命令"(老板 2026-10-01 反馈):
|
|
59
|
+
* 老板的 Windows 上**两次"什么都没弹出来"**,而当时 win32 只有一条
|
|
60
|
+
* `rundll32 url.dll,FileProtocolHandler` —— 它既不报错、退出码也是 0,
|
|
61
|
+
* 失败是**完全静默**的。单条命令的可用性取决于这台机器上恰好装了/启用了它;
|
|
62
|
+
* 三条互不依赖的路径同时不可用的概率远低于任意一条。
|
|
63
|
+
* (真客户不会自己复制粘贴网址,所以"自动打开"失败等于流程断掉。)
|
|
64
|
+
*
|
|
65
|
+
* ⚠️⚠️ Windows 这条分支踩过一个真机实测的大坑(2026-10-01):
|
|
66
|
+
* 原来的写法是 `spawn('cmd', ['/c', 'start', '', url])` —— 浏览器**确实弹出来了**,
|
|
67
|
+
* 但打开的是光秃秃的 `/admin/oauth/authorize`(★ 2026-10-02 起授权站是 `/authorize`),
|
|
68
|
+
* **所有 query 参数都没了**,
|
|
69
|
+
* 授权页显示「授权请求不完整」。
|
|
70
|
+
*
|
|
71
|
+
* 机理(必须记住):**在 Windows 的 cmd.exe 里,`&` 是命令分隔符**。
|
|
72
|
+
* `spawn` 不带 `shell: true` 时虽然不经过 shell,但我们**主动**去调了 `cmd.exe` ——
|
|
73
|
+
* 于是 cmd 拿到整条命令行后会**重新解析一遍**:
|
|
74
|
+
* cmd /c start "" https://www.wkongai.cn/admin/oauth/authorize/?client_id=…&redirect_uri=…
|
|
75
|
+
* ↑ 这里被当成命令分隔
|
|
76
|
+
* → cmd 认为第一条命令是 `start "" https://…?client_id=…`(query 只剩第一个参数),
|
|
77
|
+
* `&` 后面的 `redirect_uri=…` / `scope=…` / `state=…` / `code_challenge=…`
|
|
78
|
+
* 被当成**另一条命令**(cmd 报"不是内部或外部命令",用户看不到,因为是隐藏窗口)。
|
|
79
|
+
* 本质上和"手拼 URL 不编码"是同一类坑:URL 交给**另一个命令行解析器**时被二次解释。
|
|
80
|
+
*
|
|
81
|
+
* 修法(现在是三条策略,按顺序试;2026-10-01 又调了一次①的位置 —— 见下面"为什么这么排"):
|
|
82
|
+
* ① `rundll32 url.dll,FileProtocolHandler <url>` —— **最稳的一条,所以排第一**:
|
|
83
|
+
* * 它**不是 shell**:URL 作为独立 argv 传给进程,`&`、`=`、`%` 都只是普通字符
|
|
84
|
+
* (CreateProcess → CommandLineToArgvW,`&` 在这里没有特殊含义);
|
|
85
|
+
* * 所以 URL 是**逐字符原样**落到系统里的,不存在"被另一个命令行解析器二次解释";
|
|
86
|
+
* * rundll32.exe + url.dll 是 Windows 自带,不需要用户装任何东西;
|
|
87
|
+
* * 它也正是之前线上一直在用、真机实测**确实能弹出浏览器**的那条。
|
|
88
|
+
* ② `cmd /c start "" "<url>"` —— 退到第二位做**兜底**(写法与引号**原样保留**):
|
|
89
|
+
* * 能用 `start` 是最贴近"用户双击网址"的路径(走的正是资源管理器里双击 URL
|
|
90
|
+
* 那条注册表路径,对"装了非默认浏览器 / 处理器注册得不规范"的机器命中率最高),
|
|
91
|
+
* 所以它必须留着;引号也**必须留在字符串里**(见下面策略表上的说明)。
|
|
92
|
+
* * 但它的解析路径和①**根本不同**:URL 要先经过 cmd.exe 的命令行解析。
|
|
93
|
+
* 哪怕写了引号,这条路径上仍然有**残余风险**:"命令退出码 0,而 URL 里的 `&`
|
|
94
|
+
* 已经被截断" —— 这是**静默失败**:兜底逻辑根本不会触发,
|
|
95
|
+
* 用户只会看到「授权请求不完整」。所以它只能排在①后面当兜底,绝不能放第一。
|
|
96
|
+
* 另外 args 里的引号还要再经过 Node/libuv 的 Windows 命令行转义,而 `\"` 在 cmd
|
|
97
|
+
* 里的解释与 CommandLineToArgvW 并不一致,也可能出现"看起来加了引号其实还是被拆开"。
|
|
98
|
+
* ③ `powershell -NoProfile -Command "Start-Process '<url>'"` —— 前两条都哑了时的最后一条。
|
|
99
|
+
* 为什么这么排:①(不经 shell、URL 原样)是**最不可能静默失败**的一条,放最前面;
|
|
100
|
+
* ② 虽是"用户双击"路径、命中率最高,却带上面那个残余解析风险,所以只在前一条不可用时
|
|
101
|
+
* 才启用;③ 收尾。这样单条失败**不再等于**整个自动打开失败(这正是这次要修的问题)。
|
|
102
|
+
*/
|
|
103
|
+
/**
|
|
104
|
+
* ★★ 2026-10-21(老板真机反馈「Application not found,浏览器没打开」):Windows 默认处理器
|
|
105
|
+
* 坏了的时候,**不能只依赖 rundll32 / cmd start / powershell**——它们可能报告"应用未找到"
|
|
106
|
+
* 却仍然以退出码 0 结束(静默失败),于是后面的策略根本不会被尝试。
|
|
107
|
+
*
|
|
108
|
+
* ⇒ 在三条通用策略之后追加 **Chrome / Edge 的绝对路径**(不经过任何 shell、不依赖文件关联)。
|
|
109
|
+
* 路径覆盖 32/64 位安装位置与用户级安装(LOCALAPPDATA);某个路径不存在时 spawn 会立刻
|
|
110
|
+
* ENOENT,`openInBrowserWithFallback` 会静默试下一条,不会打扰用户。
|
|
111
|
+
*
|
|
112
|
+
* ⚠️ 顺序保持"默认处理器优先":用户平时登录态在默认浏览器里,直接抢开 Chrome 会让他
|
|
113
|
+
* 重新登录一遍(体验更差)。所以绝对路径只能排在通用策略**之后**当兜底。
|
|
114
|
+
* ⚠️ 这里用 `path.win32.join` 而不是 `path.join`:在非 Windows 上跑单测时也必须拼出
|
|
115
|
+
* Windows 风格路径,否则断言会随运行平台变化。
|
|
116
|
+
*
|
|
117
|
+
* @param {object} [env] 环境变量(默认 process.env;单测可注入确定性的路径)
|
|
118
|
+
* @returns {Array<{label:string, cmd:string, args:(url:string)=>string[]}>}
|
|
119
|
+
*/
|
|
120
|
+
export function windowsAbsoluteBrowserStrategies(env = process.env) {
|
|
121
|
+
const source = env && typeof env === 'object' ? env : {};
|
|
122
|
+
const programFiles = source.ProgramFiles || source.PROGRAMFILES || 'C:\\Program Files';
|
|
123
|
+
const programFilesX86 = source['ProgramFiles(x86)'] || source['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)';
|
|
124
|
+
const localAppData = source.LOCALAPPDATA || source.LocalAppData || '';
|
|
125
|
+
/** 安装根 + 诊断标签:先 Program Files / x86,再用户级 LOCALAPPDATA */
|
|
126
|
+
const roots = [
|
|
127
|
+
{ label: 'Program Files', root: programFiles },
|
|
128
|
+
{ label: 'Program Files (x86)', root: programFilesX86 },
|
|
129
|
+
];
|
|
130
|
+
if (localAppData) roots.push({ label: 'LOCALAPPDATA', root: localAppData });
|
|
131
|
+
const strategies = [];
|
|
132
|
+
// Chrome 在前(老板/大多数国内用户桌面 Chrome 命中率最高),Edge 在后
|
|
133
|
+
for (const { label, root } of roots) {
|
|
134
|
+
strategies.push({
|
|
135
|
+
label: `chrome · ${label}`,
|
|
136
|
+
cmd: pathWin32.join(root, 'Google', 'Chrome', 'Application', 'chrome.exe'),
|
|
137
|
+
args: (url) => [url],
|
|
138
|
+
});
|
|
139
|
+
}
|
|
140
|
+
for (const { label, root } of roots) {
|
|
141
|
+
strategies.push({
|
|
142
|
+
label: `edge · ${label}`,
|
|
143
|
+
cmd: pathWin32.join(root, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
|
|
144
|
+
args: (url) => [url],
|
|
145
|
+
});
|
|
146
|
+
}
|
|
147
|
+
return strategies;
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
/**
|
|
151
|
+
* 通用 Windows 启动器"其实没打开"的输出特征(老板真机报的就是 `Application not found`)。
|
|
152
|
+
*
|
|
153
|
+
* 为什么要看输出而不是只看退出码:`rundll32` / `cmd start` 在文件关联坏掉时可能**退出码 0**,
|
|
154
|
+
* 但 stderr/stdout 里已经写了找不到应用。只信退出码就会把它当成功,绝对路径兜底永远不会触发
|
|
155
|
+
* ——这正是这次要修的那条真机故障。见 `launchStrategy` 的 captureOutput 分支。
|
|
156
|
+
*/
|
|
157
|
+
const WINDOWS_HANDLER_FAILURE_PATTERN =
|
|
158
|
+
/application not found|windows cannot find|cannot find the file|系统找不到|找不到应用程序|不是内部或外部命令|no application is associated/i;
|
|
159
|
+
|
|
160
|
+
export const BROWSER_STRATEGY_TABLE = {
|
|
161
|
+
/**
|
|
162
|
+
* ⚠️⚠️ Windows 第 ② 条(`cmd /c start`)的**引号**是必须的(老板真机踩过,见上面那段记录):
|
|
163
|
+
* `cmd.exe` 里 `&` 是**命令分隔符**,而授权 URL 的 query 里全是 `&`
|
|
164
|
+
* (client_id&redirect_uri&response_type&scope&state&code_challenge…)。
|
|
165
|
+
* 所以必须写成 `start "" "<url>"`,并且**整串(连引号)放进同一个 argv 元素**,
|
|
166
|
+
* 让那对 `"` 真的出现在 cmd 的命令行上。
|
|
167
|
+
* ⛔ **不要**改成 `['/c', 'start', '', url]`:那样 URL 是作为**独立 argv**
|
|
168
|
+
* 交给 cmd 的,cmd 会再解析一遍命令行,`&` 又开始生效 ——
|
|
169
|
+
* 第一个 `&` 之后的内容会被当成"另一条命令",浏览器只拿到光秃秃的
|
|
170
|
+
* `/admin/oauth/authorize`(页面报「授权请求不完整」),cmd 还会因为
|
|
171
|
+
* `redirect_uri=…` 不是可执行命令而返回非零退出码。旧 bug 就是这么来的。
|
|
172
|
+
* 三条里只有②经过 cmd;① rundll32 与 ③ powershell 都不过 shell,
|
|
173
|
+
* URL 里的 `&`、`=`、`%` 都只是普通字符。
|
|
174
|
+
*/
|
|
175
|
+
win32: [
|
|
176
|
+
// ① 最稳的一条:不经任何 shell,URL 作为独立 argv 逐字符原样交给系统(线上实测能弹浏览器的那条)
|
|
177
|
+
{
|
|
178
|
+
label: 'rundll32 url.dll,FileProtocolHandler',
|
|
179
|
+
cmd: 'rundll32',
|
|
180
|
+
args: (url) => ['url.dll,FileProtocolHandler', url],
|
|
181
|
+
captureOutput: true,
|
|
182
|
+
failureOutputPattern: WINDOWS_HANDLER_FAILURE_PATTERN,
|
|
183
|
+
},
|
|
184
|
+
// ② 兜底:命令与引号写法**保持原样**(引号必须在字符串里);它要经 cmd 解析,存在"退出码 0 却截断 URL"的残余风险,所以不排第一
|
|
185
|
+
{
|
|
186
|
+
label: 'cmd /c start',
|
|
187
|
+
cmd: 'cmd',
|
|
188
|
+
args: (url) => ['/c', `start "" "${url}"`],
|
|
189
|
+
captureOutput: true,
|
|
190
|
+
failureOutputPattern: WINDOWS_HANDLER_FAILURE_PATTERN,
|
|
191
|
+
},
|
|
192
|
+
// ③ 前两条都哑了时的最后一条
|
|
193
|
+
{
|
|
194
|
+
label: 'powershell Start-Process',
|
|
195
|
+
cmd: 'powershell',
|
|
196
|
+
args: (url) => ['-NoProfile', '-Command', `Start-Process '${url}'`],
|
|
197
|
+
captureOutput: true,
|
|
198
|
+
failureOutputPattern: WINDOWS_HANDLER_FAILURE_PATTERN,
|
|
199
|
+
},
|
|
200
|
+
// ④~⑨ 默认处理器/文件关联坏掉时的绝对路径兜底(Chrome / Edge,见 windowsAbsoluteBrowserStrategies)
|
|
201
|
+
...windowsAbsoluteBrowserStrategies(),
|
|
202
|
+
],
|
|
203
|
+
darwin: [
|
|
204
|
+
{ label: 'open', cmd: 'open', args: (url) => [url] },
|
|
205
|
+
// 兜底:`open <url>` 是交给 LaunchServices 挑处理器,偶尔挑不出来;指名 Safari 再试一次
|
|
206
|
+
{ label: 'open -a Safari', cmd: 'open', args: (url) => ['-a', 'Safari', url] },
|
|
207
|
+
],
|
|
208
|
+
// linux 以及其它类 unix(freebsd 等):xdg-open 是桌面环境的事实标准,后两条是常见兜底
|
|
209
|
+
linux: [
|
|
210
|
+
{ label: 'xdg-open', cmd: 'xdg-open', args: (url) => [url] },
|
|
211
|
+
{ label: 'sensible-browser', cmd: 'sensible-browser', args: (url) => [url] },
|
|
212
|
+
{ label: 'x-www-browser', cmd: 'x-www-browser', args: (url) => [url] },
|
|
213
|
+
],
|
|
214
|
+
};
|
|
215
|
+
|
|
216
|
+
/** 找不到对应平台时按 linux 处理(xdg-open 在非 Windows/macOS 上最通用) */
|
|
217
|
+
const FALLBACK_STRATEGIES = BROWSER_STRATEGY_TABLE.linux;
|
|
218
|
+
|
|
219
|
+
/** 每条策略最多等多久(3~5 秒区间;为什么超时按"乐观成功"处理见 launchStrategy) */
|
|
220
|
+
export const BROWSER_LAUNCH_TIMEOUT_MS = 4000;
|
|
221
|
+
|
|
222
|
+
/**
|
|
223
|
+
* 历史常量:回调模式「首轮等待」的**旧默认窗口**(180 秒)。
|
|
224
|
+
*
|
|
225
|
+
* ★ 0.2.2 起**不再作为默认值生效**(老板 2026-10-21 反馈):
|
|
226
|
+
* 「默认的也不应该是设备授权,默认的就是那个传统的授权方式(浏览器打开授权页 +
|
|
227
|
+
* 本地 localhost 回调)。设备码是本地读不了/代理时才用的。」
|
|
228
|
+
* ⇒ `wkgeo login` 默认一路等回调(最多 `--timeout`),**不会**因为等太久自动改设备码;
|
|
229
|
+
* 只有用户**显式**写 `--callback-first-wait <秒>` / `WKONGAI_CALLBACK_FIRST_WAIT_MS`
|
|
230
|
+
* 才启用这条可选自愈(显式优先)。
|
|
231
|
+
*
|
|
232
|
+
* ⚠️ 保留这个导出只为**兼容**仍 import 它的外部脚本/旧文档;产品行为以
|
|
233
|
+
* `commands/auth.mjs` 的 `resolveCallbackFirstWaitMs()` 为准(无显式指定时返回 0)。
|
|
234
|
+
* 这个常量本身**不参与任何默认判断**。
|
|
235
|
+
*
|
|
236
|
+
* 历史背景(仍适用于"显式开启"的场景):到点后**不关本地回调监听**,由命令层并发跑设备码,
|
|
237
|
+
* 两条路先到先得(旧版关监听会让用户之后点【同意】看到 ERR_CONNECTION_REFUSED)。
|
|
238
|
+
*
|
|
239
|
+
* @deprecated 0.2.2 起默认关闭;需要"等待到点改设备码"请显式传 `--callback-first-wait`。
|
|
240
|
+
*/
|
|
241
|
+
export const DEFAULT_CALLBACK_FIRST_WAIT_MS = 180_000;
|
|
242
|
+
|
|
243
|
+
/**
|
|
244
|
+
* ★ 设备码那条路**先**拿到令牌之后,本地回调监听再多留多久(毫秒)。
|
|
245
|
+
*
|
|
246
|
+
* 为什么需要:用户很可能在两个标签页之间来回 —— 一边是 CLI 让他打开的授权页(回调模式),
|
|
247
|
+
* 一边是切设备码后让他打开的确认页。设备码先确认成功后,如果**立刻**关掉监听,
|
|
248
|
+
* 他回到那个还开着的授权页点【同意授权】时,浏览器就又是一次
|
|
249
|
+
* `ERR_CONNECTION_REFUSED`(真机截图见过的那一幕,用户会以为授权失败)。
|
|
250
|
+
* 留这一小段时间,迟到的回调会拿到一张「本次登录已经完成」的页面(见 page.mjs 的 alreadyDonePage)。
|
|
251
|
+
*
|
|
252
|
+
* ## 两个刻意的选择
|
|
253
|
+
* * **只给"首轮等待"这条自愈留 grace**:那时候用户很可能正在读授权页、手指就在鼠标上;
|
|
254
|
+
* 而"整段 `--timeout` 用完"(默认 300 秒,授权码本身也就 5 分钟有效期)之后再来的回调,
|
|
255
|
+
* 基本已经换不到令牌了,留监听没有意义 ⇒ 那种情况 grace = 0(立刻收尾)。
|
|
256
|
+
* * **不 await**:`runLogin` 立刻把结果交回命令层(用户马上看到"授权成功"),
|
|
257
|
+
* 监听与这个定时器在后台再活一小会儿,到点(或被那次迟到的回调提前唤醒)就自行关闭。
|
|
258
|
+
* 代价是进程会晚几秒退出 —— 换来的是"用户之后点的那一下不会看到连接被拒绝"。
|
|
259
|
+
*/
|
|
260
|
+
export const DEFAULT_POST_DEVICE_GRACE_MS = 3000;
|
|
261
|
+
|
|
262
|
+
/**
|
|
263
|
+
* 取某个平台要**依次尝试**的策略表。
|
|
264
|
+
* `strategies` 可整体注入 —— 单测靠它构造"前两条失败、第三条成功"和"全失败",
|
|
265
|
+
* 且注入的是**数据**而不是替换整个 `openInBrowser`,这样被测代码还是生产那份。
|
|
266
|
+
*/
|
|
267
|
+
export function strategiesFor(platform, strategies) {
|
|
268
|
+
if (Array.isArray(strategies) && strategies.length > 0) return strategies;
|
|
269
|
+
return BROWSER_STRATEGY_TABLE[platform] || FALLBACK_STRATEGIES;
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
/**
|
|
273
|
+
* 子进程的固定选项:独立进程组(CLI 退出后浏览器继续活着)、不闪黑框。
|
|
274
|
+
*
|
|
275
|
+
* ★ 0.2.4:只有**异步多策略**链路里、且策略声明了 `captureOutput` 时才接管输出
|
|
276
|
+
* (用来识别 Windows 通用启动器"退出码 0 但输出 Application not found"的静默失败)。
|
|
277
|
+
* 同步版 `openInBrowser`(device.mjs 用)必须保持 `stdio:'ignore'` —— 它不消费管道,
|
|
278
|
+
* 接管输出反而可能把子进程的管道缓冲区写满。
|
|
279
|
+
*/
|
|
280
|
+
function browserSpawnOptions(strategy = null, { captureOutput = false } = {}) {
|
|
281
|
+
const capture = captureOutput === true && strategy && strategy.captureOutput === true;
|
|
282
|
+
return {
|
|
283
|
+
stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'ignore',
|
|
284
|
+
detached: true,
|
|
285
|
+
windowsHide: true,
|
|
286
|
+
};
|
|
287
|
+
}
|
|
288
|
+
|
|
289
|
+
/**
|
|
290
|
+
* 打开浏览器(**同步**版,按策略表依次尝试)。
|
|
291
|
+
*
|
|
292
|
+
* 这是 `openInBrowser` 的历史契约,`device.mjs`(设备码模式)与 `lib/index.mjs`
|
|
293
|
+
* 都在用它,所以**返回值必须保持 boolean**、函数必须保持同步。
|
|
294
|
+
* 它只能判断"进程有没有被创建出来"(spawn 同步抛错 → 试下一条),
|
|
295
|
+
* 判断不了退出码 —— 要那份判断请用异步的 `openInBrowserWithFallback`(login 走那条)。
|
|
296
|
+
*
|
|
297
|
+
* 异步失败(进程创建不出来 → 下个 tick emit `error`)时,它会在**后台静默**继续试
|
|
298
|
+
* 后面的策略;只有**全部策略都异步失败**才回调 `onError`(只回调一次,
|
|
299
|
+
* 避免用户看到三遍一模一样的提示)。
|
|
300
|
+
*
|
|
301
|
+
* **永不抛错、永不中断登录**:失败只返回 `false`。
|
|
302
|
+
*
|
|
303
|
+
* @param {string} url 要打开的**完整**授权地址(含 query,逐字符传给系统)
|
|
304
|
+
* @param {object} [opts]
|
|
305
|
+
* @param {string} [opts.platform] 平台(默认 process.platform;测试可注入)
|
|
306
|
+
* @param {Function} [opts.spawnImpl] child_process.spawn(测试可注入,避免真的弹浏览器)
|
|
307
|
+
* @param {Array} [opts.strategies] 策略表(默认按平台取;测试可注入)
|
|
308
|
+
* @param {(e:Error)=>void} [opts.onError] **异步**失败的回调(同步失败直接 return false)
|
|
309
|
+
* @returns {boolean} 是否成功把打开动作交给了系统(乐观判断,见上)
|
|
310
|
+
*/
|
|
311
|
+
export function openInBrowser(url, { platform = process.platform, spawnImpl = spawn, onError, strategies } = {}) {
|
|
312
|
+
const target = typeof url === 'string' ? url.trim() : '';
|
|
313
|
+
// 空地址没有任何可打开的:直接 false,别去 spawn 一个空参数
|
|
314
|
+
if (!target) return false;
|
|
315
|
+
|
|
316
|
+
const list = strategiesFor(platform, strategies);
|
|
317
|
+
|
|
318
|
+
/**
|
|
319
|
+
* `fromAsync` 用来区分两种失败,别把提示打成两遍:
|
|
320
|
+
* * 同步失败(spawn 直接抛):返回值已经是 false,调用方自己会提示"手动复制",
|
|
321
|
+
* 这里**不再**回调 onError;
|
|
322
|
+
* * 异步失败(emit `error`):返回值当时是 true,只能靠 onError 告诉用户"没打开成功"。
|
|
323
|
+
*/
|
|
324
|
+
const attempt = (i, fromAsync, lastError) => {
|
|
325
|
+
if (i >= list.length) {
|
|
326
|
+
if (fromAsync && typeof onError === 'function') onError(lastError);
|
|
327
|
+
return false;
|
|
328
|
+
}
|
|
329
|
+
const strategy = list[i];
|
|
330
|
+
let child;
|
|
331
|
+
try {
|
|
332
|
+
child = spawnImpl(strategy.cmd, strategy.args(target), browserSpawnOptions());
|
|
333
|
+
} catch (e) {
|
|
334
|
+
// spawn 同步抛(参数非法等):不致命,换下一条策略
|
|
335
|
+
return attempt(i + 1, fromAsync, e);
|
|
336
|
+
}
|
|
337
|
+
if (!child) return attempt(i + 1, fromAsync, lastError);
|
|
338
|
+
|
|
339
|
+
/**
|
|
340
|
+
* ⚠️ `error` 监听**必须挂**:spawn 的目标不存在(例如容器里没有 xdg-open)时,
|
|
341
|
+
* Node 会在**下一个 tick** 异步 emit `error`。没有监听者的话 EventEmitter
|
|
342
|
+
* 会把它当未捕获异常**直接崩掉整个 CLI**(登录进程半途而死,用户只看到一段栈)。
|
|
343
|
+
*
|
|
344
|
+
* 挂上之后它同时是"静默降级到下一条策略"的入口 —— 多策略的意义就在这里。
|
|
345
|
+
*/
|
|
346
|
+
if (typeof child.on === 'function') {
|
|
347
|
+
child.on('error', (e) => attempt(i + 1, true, e));
|
|
348
|
+
}
|
|
349
|
+
// detached + unref:浏览器进程不归 CLI 管,CLI 退出后它继续活着
|
|
350
|
+
if (typeof child.unref === 'function') child.unref();
|
|
351
|
+
return true;
|
|
352
|
+
};
|
|
353
|
+
|
|
354
|
+
return attempt(0, false, null);
|
|
355
|
+
}
|
|
356
|
+
|
|
357
|
+
/**
|
|
358
|
+
* 依次尝试策略表里的每一条,**每一条都等结果**(`error` / 退出码 / 超时)再决定下一条。
|
|
359
|
+
* 这是 `login`(本地回调模式)走的那条路 —— 老板要的"每个都检查结果后再决定下一个"。
|
|
360
|
+
*
|
|
361
|
+
* 与同步版的分工:同步版只为 `device.mjs` 保持历史契约(它 await 不了),
|
|
362
|
+
* 这里才拿得到"到底哪几条试过、最后成没成"。
|
|
363
|
+
*
|
|
364
|
+
* **永不抛错**(只 resolve,不 reject):调用方可以放心 await 而不用担心
|
|
365
|
+
* "因为打不开浏览器把登录搞失败"。
|
|
366
|
+
*
|
|
367
|
+
* @param {string} url
|
|
368
|
+
* @param {object} [opts]
|
|
369
|
+
* @param {string} [opts.platform] 平台(默认 process.platform)
|
|
370
|
+
* @param {Function} [opts.spawnImpl] child_process.spawn(测试可注入)
|
|
371
|
+
* @param {Array} [opts.strategies] 策略表(测试可注入,构造"前两条失败、第三条成功")
|
|
372
|
+
* @param {number} [opts.timeoutMs] 单条策略的超时(默认 BROWSER_LAUNCH_TIMEOUT_MS)
|
|
373
|
+
* @param {(info:object)=>void} [opts.onAttempt] 每条策略结束后的回调(--verbose 用)
|
|
374
|
+
* @returns {Promise<{attempted:boolean, opened:boolean, tried:string[], url:string}>}
|
|
375
|
+
*/
|
|
376
|
+
export async function openInBrowserWithFallback(url, opts = {}) {
|
|
377
|
+
const {
|
|
378
|
+
platform = process.platform,
|
|
379
|
+
spawnImpl = spawn,
|
|
380
|
+
strategies,
|
|
381
|
+
timeoutMs = BROWSER_LAUNCH_TIMEOUT_MS,
|
|
382
|
+
onAttempt,
|
|
383
|
+
} = opts;
|
|
384
|
+
|
|
385
|
+
const target = typeof url === 'string' ? url.trim() : '';
|
|
386
|
+
// 空地址:一条策略都不试(`attempted:false` 让上层能如实上报"根本没试")
|
|
387
|
+
if (!target) return { attempted: false, opened: false, tried: [], url: '' };
|
|
388
|
+
|
|
389
|
+
const status = { attempted: true, opened: false, tried: [], url: target };
|
|
390
|
+
for (const strategy of strategiesFor(platform, strategies)) {
|
|
391
|
+
status.tried.push(strategy.label);
|
|
392
|
+
const result = await launchStrategy(strategy, target, spawnImpl, timeoutMs);
|
|
393
|
+
if (typeof onAttempt === 'function') {
|
|
394
|
+
try {
|
|
395
|
+
onAttempt({ label: strategy.label, ok: result.ok, error: result.error, timedOut: result.timedOut === true });
|
|
396
|
+
} catch {
|
|
397
|
+
/* 记日志本身失败绝不能影响"打开浏览器"这件事 */
|
|
398
|
+
}
|
|
399
|
+
}
|
|
400
|
+
if (result.ok) {
|
|
401
|
+
status.opened = true;
|
|
402
|
+
return status;
|
|
403
|
+
}
|
|
404
|
+
// 失败**静默**试下一条(只有 --verbose 才由 onAttempt 记一笔)
|
|
405
|
+
}
|
|
406
|
+
return status;
|
|
407
|
+
}
|
|
408
|
+
|
|
409
|
+
/**
|
|
410
|
+
* 跑**单条**策略:等 `error` / 退出码 / 超时,谁先到谁说了算。**永不 reject**。
|
|
411
|
+
*
|
|
412
|
+
* ⚠️ 超时按"乐观成功"处理(不再试后面的策略):
|
|
413
|
+
* 这些启动器(cmd start / rundll32 / open / xdg-open / Start-Process)都是
|
|
414
|
+
* "把 URL 交给系统就立刻退出"的程序,正常几十~几百毫秒就会 exit;
|
|
415
|
+
* 真拖到 3~5 秒说明它既没报错也没退出(吊住了)。此时再试下一条有把浏览器
|
|
416
|
+
* **开两次**的风险,而多开一个窗口比少开一次更惹人烦 —— 何况网址本来就打印在上面。
|
|
417
|
+
*
|
|
418
|
+
* ⚠️ 超时定时器**故意不 unref**:它就是"保证这次 await 一定会结算"的锚。
|
|
419
|
+
* (子进程是 unref 的,若定时器也 unref,事件循环可能直接空转退出,
|
|
420
|
+
* 这个 Promise 就永远不 resolve,登录会卡死在"打开浏览器"这一步。)
|
|
421
|
+
*/
|
|
422
|
+
function launchStrategy(strategy, target, spawnImpl, timeoutMs) {
|
|
423
|
+
return new Promise((resolve) => {
|
|
424
|
+
let settled = false;
|
|
425
|
+
let timer = null;
|
|
426
|
+
/** ★ 0.2.4:Windows 通用启动器的输出(最多留 4KB,只为识别"Application not found") */
|
|
427
|
+
let output = '';
|
|
428
|
+
let child = null;
|
|
429
|
+
const settle = (result) => {
|
|
430
|
+
if (settled) return;
|
|
431
|
+
settled = true;
|
|
432
|
+
if (timer) clearTimeout(timer);
|
|
433
|
+
// 超时/退出后把管道关掉:否则 pipe 句柄可能把 CLI 的事件循环多吊一会儿
|
|
434
|
+
for (const stream of [child && child.stdout, child && child.stderr]) {
|
|
435
|
+
try {
|
|
436
|
+
if (stream && typeof stream.destroy === 'function') stream.destroy();
|
|
437
|
+
} catch {
|
|
438
|
+
/* 清理失败不影响结论 */
|
|
439
|
+
}
|
|
440
|
+
}
|
|
441
|
+
resolve(result);
|
|
442
|
+
};
|
|
443
|
+
|
|
444
|
+
try {
|
|
445
|
+
child = spawnImpl(
|
|
446
|
+
strategy.cmd,
|
|
447
|
+
strategy.args(target),
|
|
448
|
+
browserSpawnOptions(strategy, { captureOutput: strategy.captureOutput === true }),
|
|
449
|
+
);
|
|
450
|
+
} catch (e) {
|
|
451
|
+
resolve({ ok: false, error: e });
|
|
452
|
+
return;
|
|
453
|
+
}
|
|
454
|
+
if (!child) {
|
|
455
|
+
resolve({ ok: false, error: new Error('spawn 没有返回子进程') });
|
|
456
|
+
return;
|
|
457
|
+
}
|
|
458
|
+
|
|
459
|
+
if (strategy.captureOutput === true) {
|
|
460
|
+
const collect = (chunk) => {
|
|
461
|
+
if (output.length >= 4096) return;
|
|
462
|
+
output += String(chunk).slice(0, 4096 - output.length);
|
|
463
|
+
};
|
|
464
|
+
for (const stream of [child.stdout, child.stderr]) {
|
|
465
|
+
if (stream && typeof stream.on === 'function') {
|
|
466
|
+
// 流错误(管道提前关闭等)不能变成未捕获异常把 CLI 崩掉
|
|
467
|
+
stream.on('error', () => {});
|
|
468
|
+
stream.on('data', collect);
|
|
469
|
+
}
|
|
470
|
+
}
|
|
471
|
+
}
|
|
472
|
+
|
|
473
|
+
timer = setTimeout(() => settle({ ok: true, timedOut: true }), timeoutMs);
|
|
474
|
+
|
|
475
|
+
if (typeof child.on === 'function') {
|
|
476
|
+
// 命令不存在 / 没权限 → 下个 tick 的 error:这条策略算失败,试下一条
|
|
477
|
+
child.on('error', (e) => settle({ ok: false, error: e }));
|
|
478
|
+
// 进程正常退出才算成功:非零退出码意味着"它自己认为没干成"(例如 xdg-open 找不到浏览器)
|
|
479
|
+
child.on('exit', (code, signal) => {
|
|
480
|
+
if (code === 0) {
|
|
481
|
+
/**
|
|
482
|
+
* ★ 0.2.4:退出码 0 **不等于**浏览器真的打开了 —— Windows 上文件关联坏掉时,
|
|
483
|
+
* rundll32 / cmd start 会打出 `Application not found` 却仍然返回 0。
|
|
484
|
+
* 这里把这种"静默失败"识别出来,交给下一条(Chrome/Edge 绝对路径)兜底。
|
|
485
|
+
*/
|
|
486
|
+
const pattern = strategy.failureOutputPattern;
|
|
487
|
+
if (pattern instanceof RegExp && output && pattern.test(output)) {
|
|
488
|
+
return settle({
|
|
489
|
+
ok: false,
|
|
490
|
+
error: new Error(`退出码 0,但输出表明没有打开:${output.trim().replace(/\s+/g, ' ').slice(0, 160)}`),
|
|
491
|
+
});
|
|
492
|
+
}
|
|
493
|
+
return settle({ ok: true });
|
|
494
|
+
}
|
|
495
|
+
settle({ ok: false, error: new Error(`退出码 ${code}${signal ? `(信号 ${signal})` : ''}`) });
|
|
496
|
+
});
|
|
497
|
+
} else {
|
|
498
|
+
// 注入的假子进程连事件接口都没有:只能当"已交给系统"
|
|
499
|
+
settle({ ok: true });
|
|
500
|
+
}
|
|
501
|
+
if (typeof child.unref === 'function') child.unref();
|
|
502
|
+
});
|
|
503
|
+
}
|
|
504
|
+
|
|
505
|
+
/**
|
|
506
|
+
* 把"打开浏览器"的结果统一成事件里的那四个字段(`open_browser`)。
|
|
507
|
+
* 兼容历史注入:老测试注入的是 `() => true` / `() => false` 这种 boolean 返回值。
|
|
508
|
+
*/
|
|
509
|
+
function normalizeOpenStatus(raw, url, skippedReason = null) {
|
|
510
|
+
if (raw && typeof raw === 'object') {
|
|
511
|
+
return {
|
|
512
|
+
attempted: raw.attempted !== false,
|
|
513
|
+
opened: raw.opened === true,
|
|
514
|
+
tried: Array.isArray(raw.tried) ? raw.tried.slice() : [],
|
|
515
|
+
url: typeof raw.url === 'string' && raw.url ? raw.url : url,
|
|
516
|
+
skipped_reason: raw.skipped_reason === undefined ? skippedReason : raw.skipped_reason,
|
|
517
|
+
};
|
|
518
|
+
}
|
|
519
|
+
return { attempted: true, opened: raw === true, tried: [], url, skipped_reason: skippedReason };
|
|
520
|
+
}
|
|
521
|
+
|
|
522
|
+
/**
|
|
523
|
+
* ★★ CI / 非交互环境的判定因子(2026-10-21 老板反馈的直接产物)。
|
|
524
|
+
*
|
|
525
|
+
* ## 真实现场
|
|
526
|
+
* 「别人在 **CI** 里执行 `wkgeo-cli` 的 login,**默认弹出了系统默认浏览器**」
|
|
527
|
+
* —— CI 机器上没有显示器/桌面会话,`rundll32` / `open` / `xdg-open` 要么静默失败,
|
|
528
|
+
* 要么在装了 Xvfb / 桌面残留的 runner 上真的拉起一个窗口(占资源、拖慢、还可能卡住)。
|
|
529
|
+
* CI 里唯一正确的做法是:**只输出授权链接/JSON**,把链接交给有浏览器的人打开。
|
|
530
|
+
*
|
|
531
|
+
* ## 判定(满足任一即"非交互")
|
|
532
|
+
* 1. `process.stdout.isTTY` 为假(管道 / 重定向 / AI 子进程 / CI 日志采集);
|
|
533
|
+
* 2. 存在任一 CI 环境变量(**存在即判定**,不看值;列表见 `CI_ENV_VARS`);
|
|
534
|
+
* 3. `WKONGAI_CLI_NO_BROWSER` 为 `1/true/yes/on`(调用方显式声明"我这没有/不要浏览器")。
|
|
535
|
+
*
|
|
536
|
+
* ⚠️ 这个函数是**纯函数**(只吃注入的 `isTTY` / `env`),单测可以直接构造任意组合,
|
|
537
|
+
* 不必去改真实进程的 TTY,也不会污染 `process.env`。
|
|
538
|
+
*
|
|
539
|
+
* @param {object} [opts]
|
|
540
|
+
* @param {boolean} [opts.isTTY] stdout 是不是终端(生产传 `!!process.stdout.isTTY`)
|
|
541
|
+
* @param {object} [opts.env] 环境变量(生产传 `process.env`;默认空对象)
|
|
542
|
+
* @returns {{nonInteractive:boolean, reason:(string|null)}} `reason` 形如
|
|
543
|
+
* `"stdout_not_tty"` / `"ci_env:GITHUB_ACTIONS"` / `"env:WKONGAI_CLI_NO_BROWSER"`
|
|
544
|
+
*/
|
|
545
|
+
export function detectNonInteractive({ isTTY = false, env = {} } = {}) {
|
|
546
|
+
// ① 不是终端:管道、重定向、AI 子进程都走这条(CI 日志采集也通常不是 TTY)
|
|
547
|
+
if (isTTY !== true) return { nonInteractive: true, reason: 'stdout_not_tty' };
|
|
548
|
+
// ② CI 环境变量:存在即判定(值的含义各家不一,`CI=0` 也出现过,不猜)
|
|
549
|
+
const source = env && typeof env === 'object' ? env : {};
|
|
550
|
+
const ciVar = CI_ENV_VARS.find((name) => Object.prototype.hasOwnProperty.call(source, name) && source[name] !== undefined && source[name] !== null);
|
|
551
|
+
if (ciVar) return { nonInteractive: true, reason: `ci_env:${ciVar}` };
|
|
552
|
+
// ③ 调用方显式声明(给"没有 CI 变量但确实在无浏览器环境"的容器/远程场景用)
|
|
553
|
+
const raw = source[NO_BROWSER_ENV];
|
|
554
|
+
if (raw !== undefined && raw !== null && /^(1|true|yes|on)$/i.test(String(raw).trim())) {
|
|
555
|
+
return { nonInteractive: true, reason: `env:${NO_BROWSER_ENV}` };
|
|
556
|
+
}
|
|
557
|
+
return { nonInteractive: false, reason: null };
|
|
558
|
+
}
|
|
559
|
+
|
|
560
|
+
/** CI 环境变量清单(**存在即判定**;顺序只影响诊断文案里报哪一个) */
|
|
561
|
+
export const CI_ENV_VARS = Object.freeze([
|
|
562
|
+
'CI',
|
|
563
|
+
'GITHUB_ACTIONS',
|
|
564
|
+
'GITLAB_CI',
|
|
565
|
+
'JENKINS_URL',
|
|
566
|
+
'TF_BUILD',
|
|
567
|
+
'BUILDKITE',
|
|
568
|
+
'TEAMCITY_VERSION',
|
|
569
|
+
]);
|
|
570
|
+
|
|
571
|
+
/** 「显式关掉浏览器」的环境变量(值为 `1/true/yes/on` 时生效;与 `--no-browser` 等价的效果) */
|
|
572
|
+
export const NO_BROWSER_ENV = 'WKONGAI_CLI_NO_BROWSER';
|
|
573
|
+
|
|
574
|
+
/** 把 `detectNonInteractive().reason` 翻译成人话(只用于提示文案,不影响判定) */
|
|
575
|
+
export function nonInteractiveReasonText(reason = '') {
|
|
576
|
+
const text = String(reason || '');
|
|
577
|
+
if (text === 'stdout_not_tty') return 'stdout 不是终端(管道 / 重定向 / AI 子进程)';
|
|
578
|
+
if (text.startsWith('ci_env:')) return `检测到 CI 环境变量 ${text.slice('ci_env:'.length)}`;
|
|
579
|
+
if (text.startsWith('env:')) return `环境变量 ${text.slice('env:'.length)} 已开启`;
|
|
580
|
+
return '非交互环境';
|
|
581
|
+
}
|
|
582
|
+
|
|
583
|
+
/**
|
|
584
|
+
* 非交互时可照做的提示:**不会自动打开浏览器** + 两条出路(转给有浏览器的人 / 改用设备码)。
|
|
585
|
+
*
|
|
586
|
+
* 为什么必须打印:非交互场景(CI / 容器 / AI 子进程)里用户看不到任何窗口,
|
|
587
|
+
* 只拿到一行 URL 很容易以为"CLI 卡住了/什么都没发生"。这段提示把"下一步"说死,
|
|
588
|
+
* 而且明确建议 `--device`(CI 里最可靠:不需要 127.0.0.1 回调)。
|
|
589
|
+
*
|
|
590
|
+
* @param {object} [opts]
|
|
591
|
+
* @param {'auth'|'pay'} [opts.kind]
|
|
592
|
+
* @param {string} [opts.reason] `detectNonInteractive().reason`
|
|
593
|
+
* @param {string} [opts.cmdName]
|
|
594
|
+
* @param {string} [opts.url] 收银台/授权链接(`kind:"pay"` 时打印出来,方便直接复制)
|
|
595
|
+
* @returns {string[]}
|
|
596
|
+
*/
|
|
597
|
+
export function nonInteractiveBrowserHintLines({ kind = 'auth', reason = '', cmdName = 'wkgeo', url = '' } = {}) {
|
|
598
|
+
const lead = `ℹ️ 检测到非交互环境(${nonInteractiveReasonText(reason)}):不会自动打开浏览器。`;
|
|
599
|
+
const link = url ? [` ${url}`] : [];
|
|
600
|
+
if (kind === 'pay') {
|
|
601
|
+
return [
|
|
602
|
+
lead,
|
|
603
|
+
...link,
|
|
604
|
+
' 本机(CI / 容器 / 远程)通常没有可用浏览器:请把上面的收银台链接交给用户,让他在自己的浏览器里打开并用微信扫码支付。',
|
|
605
|
+
];
|
|
606
|
+
}
|
|
607
|
+
return [
|
|
608
|
+
lead,
|
|
609
|
+
' 本机(CI / 容器 / 远程)通常没有可用浏览器:请把上面的授权链接转给有浏览器的用户打开。',
|
|
610
|
+
` 若本机无法接收 127.0.0.1 回调(CI / 远程环境),改用 \`${cmdName} login --device\`(设备码模式,不需要回调)。`,
|
|
611
|
+
];
|
|
612
|
+
}
|
|
613
|
+
|
|
614
|
+
/**
|
|
615
|
+
* ★★ 「要不要替用户弹**系统**浏览器」—— **全 CLI 唯一的裁决点**。
|
|
616
|
+
*
|
|
617
|
+
* ## 判定(顺序即优先级;2026-10-21 起加入非交互/CI 检测)
|
|
618
|
+
* 1. `--no-browser`(`noBrowser`,或 `deps.openBrowser === false`)
|
|
619
|
+
* → **不打开**,`skipped_reason: "no_browser"`(压过 `--open-browser`);
|
|
620
|
+
* 2. **非交互 / CI**(`detectNonInteractive`:stdout 非 TTY / CI 环境变量 / `WKONGAI_CLI_NO_BROWSER=1`)
|
|
621
|
+
* → **不打开**,`skipped_reason: "non_interactive"`。
|
|
622
|
+
* ⚠️ 这一条**压过 `--open-browser`**:CI 里绝不允许弹浏览器(老板 2026-10-21 反馈的原话场景)。
|
|
623
|
+
* 要弹就必须在**人类终端**里跑 —— `--open-browser` 只在终端里保留显式语义;
|
|
624
|
+
* 3. `--open-browser`(`forceOpen`)→ 打开(`mode: "forced"`;与终端默认行为等价,保留兼容);
|
|
625
|
+
* 4. 人在终端(`isTTY === true`)→ 打开(`mode: "terminal"`;`--json` 只影响 `mode` 诊断字段);
|
|
626
|
+
* 5. 其余(理论上到不了;兜底仍按 agent 诊断)→ 打开。
|
|
627
|
+
*
|
|
628
|
+
* ## 历史(别再翻回去)
|
|
629
|
+
* * 2026-10-01:曾"AI 场景默认不弹"(`skipped_reason:"non_tty_agent_mode"`)→ 已弃用;
|
|
630
|
+
* * 2026-10-02:老板拍板走传统路线(弹系统浏览器)→ 默认**总是**打开(含 AI 场景);
|
|
631
|
+
* * 2026-10-21:老板真机反馈"CI 里弹了浏览器" ⇒ 恢复"非交互不弹",但**人类终端**保持自动打开。
|
|
632
|
+
* ⇒ 现在 `skipped_reason` 的合法取值是 `"no_browser"` / `"non_interactive"` / `null`。
|
|
633
|
+
* ⚠️ `open_browser` 的**结构没变**:`{attempted, opened, tried, url, skipped_reason}`。
|
|
634
|
+
*
|
|
635
|
+
* ## ⚠️ 绝不允许因为"没打开浏览器"让命令失败
|
|
636
|
+
* 返回 `allow:false` 只是"不弹窗";即使 `allow:true` 而打开失败(`attempted:true, opened:false`),
|
|
637
|
+
* 也只是多打一段**含完整 URL** 的醒目提示(见 `browserFailedHintLines`)——
|
|
638
|
+
* 授权/支付流程**照旧继续等回调、继续轮询**,语义完全不变。
|
|
639
|
+
*
|
|
640
|
+
* @param {object} [opts]
|
|
641
|
+
* @param {boolean} [opts.isTTY] stdout 是不是终端(命令层传 `!!stdout.isTTY`)
|
|
642
|
+
* @param {boolean} [opts.json] 是不是 JSON 输出(只影响 `mode` 诊断字段)
|
|
643
|
+
* @param {boolean} [opts.forceOpen] 用户写了 `--open-browser`
|
|
644
|
+
* @param {boolean} [opts.noBrowser] 用户写了 `--no-browser`(或 deps.openBrowser === false)
|
|
645
|
+
* @param {object} [opts.env] 环境变量(CI 判定用;生产传 `process.env`)
|
|
646
|
+
* @returns {{allow:boolean, mode:'off'|'forced'|'terminal'|'agent', skipped_reason:('no_browser'|'non_interactive'|null)}}
|
|
647
|
+
*/
|
|
648
|
+
export function resolveBrowserIntent({ isTTY = false, json = false, forceOpen = false, noBrowser = false, env = {} } = {}) {
|
|
649
|
+
// ① 用户明确关掉:连 `--open-browser` 也不许把它顶回来(--no-browser 优先)
|
|
650
|
+
if (noBrowser === true) return { allow: false, mode: 'off', skipped_reason: 'no_browser' };
|
|
651
|
+
// ② 非交互 / CI:**只输出链接**,不 spawn 任何浏览器(压过 --open-browser)
|
|
652
|
+
if (detectNonInteractive({ isTTY, env }).nonInteractive) {
|
|
653
|
+
return { allow: false, mode: 'off', skipped_reason: 'non_interactive' };
|
|
654
|
+
}
|
|
655
|
+
// ③ 用户明确要求打开(已在终端里):保留显式语义与兼容
|
|
656
|
+
if (forceOpen === true) return { allow: true, mode: 'forced', skipped_reason: null };
|
|
657
|
+
// ④ 人在终端:保持 CLI 一直以来的体验(这条**不能**破坏)
|
|
658
|
+
if (isTTY === true && json !== true) return { allow: true, mode: 'terminal', skipped_reason: null };
|
|
659
|
+
// ⑤ TTY + --json:人还在终端,照旧打开(`json` 只影响 mode 诊断字段)
|
|
660
|
+
return { allow: true, mode: 'agent', skipped_reason: null };
|
|
661
|
+
}
|
|
662
|
+
|
|
663
|
+
/**
|
|
664
|
+
* ★ 打开成功时的一句话(老板最终拍板走**传统路线**:弹系统浏览器)。
|
|
665
|
+
*
|
|
666
|
+
* 文案的两个要点:
|
|
667
|
+
* 1. **先说结果**(「已为你打开浏览器」)—— 用户第一眼要确认"它到底开了没有";
|
|
668
|
+
* 以前这里写的是「正在打开浏览器…」,打开失败时那句话会让用户以为"还在开";
|
|
669
|
+
* 2. 说清**去那里干什么**(授权 / 支付),别让他回终端猜。
|
|
670
|
+
* "完成后页面会自动关闭 / 没关就手动关掉即可"由调用方紧接着单独打一行
|
|
671
|
+
* (**失败路径**也要同一句话,所以不塞进这一行)。
|
|
672
|
+
*/
|
|
673
|
+
export function browserOpenedText({ kind = 'auth' } = {}) {
|
|
674
|
+
return kind === 'pay'
|
|
675
|
+
? '✅ 已为你打开浏览器,请在那里完成支付(微信扫码)。'
|
|
676
|
+
: '✅ 已为你打开浏览器,请在那里完成授权。';
|
|
677
|
+
}
|
|
678
|
+
|
|
679
|
+
/**
|
|
680
|
+
* ★ 打开失败时的一段**醒目提示**(`⚠️` 起头 + **完整 URL 单独一行**,可直接复制)。
|
|
681
|
+
*
|
|
682
|
+
* 三条硬要求(都是老板反馈里点名的):
|
|
683
|
+
* 1. **醒目**:明确说"没能自动打开",别让用户以为还在打开中;
|
|
684
|
+
* 2. **可操作**:把**完整 URL 原样再打一遍**(就在这段提示里,用户不用往上翻页找),
|
|
685
|
+
* 并说清动作是"复制这一整行 → 粘贴到浏览器地址栏";
|
|
686
|
+
* 3. 说清打开之后干什么(点「同意」/ 用微信扫码),让非技术用户也能走完。
|
|
687
|
+
* 真客户不会自己去找网址,所以这段是"自动打开失败"时唯一能救回流程的东西。
|
|
688
|
+
*
|
|
689
|
+
* @param {string} url 完整地址(逐字符原样打印,方便复制)
|
|
690
|
+
* @param {object} [opts]
|
|
691
|
+
* @param {'auth'|'pay'} [opts.kind]
|
|
692
|
+
* @param {boolean} [opts.agent] AI 场景(非 TTY / `--json`)时追加一句**可选**提示:
|
|
693
|
+
* "若你的 AI 客户端支持内置浏览器,也可以让它在那里打开" ——
|
|
694
|
+
* ⚠️ 只是备选,**不是主路径**(B 路线暂时不做,老板最终选择传统路线)。
|
|
695
|
+
* @param {string} [opts.cause] 失败原因(spawn 报的原文),有就附在第一行括号里,方便排障
|
|
696
|
+
*/
|
|
697
|
+
export function browserFailedHintLines(url, { kind = 'auth', agent = false, cause = '' } = {}) {
|
|
698
|
+
const action = kind === 'pay' ? '支付' : '授权';
|
|
699
|
+
return [
|
|
700
|
+
'',
|
|
701
|
+
`⚠️ 浏览器没能自动打开${cause ? `(${cause})` : ''},请手动复制这个地址到浏览器完成${action}:`,
|
|
702
|
+
` ${url}`,
|
|
703
|
+
kind === 'pay'
|
|
704
|
+
? '(这是我们网站的收银台页面:打开后用微信扫码支付;支付成功后页面会自动尝试关闭,没关就手动关掉即可。)'
|
|
705
|
+
: '(打开后点「同意」即可;授权完成后回到终端。授权成功后页面会自动尝试关闭,没关就手动关掉即可。)',
|
|
706
|
+
...(agent ? ['(若你的 AI 客户端支持内置浏览器,也可以让它在那里打开同一个地址;这只是备选,不是必须的。)'] : []),
|
|
707
|
+
'',
|
|
708
|
+
];
|
|
709
|
+
}
|
|
710
|
+
|
|
711
|
+
/**
|
|
712
|
+
* 「照着念」的一句话 —— 给 AI 端直接转述用(AI 不该自己组织语言,否则很容易漏掉网址)。
|
|
713
|
+
*
|
|
714
|
+
* ## 两种口径(**必须与"到底弹没弹"对得上**,否则 AI 会照着念错话)
|
|
715
|
+
* * 交互终端 / 已尝试打开 → "已为你打开浏览器,请在那里完成授权:<url>…";
|
|
716
|
+
* * 非交互(CI / 管道 / AI 子进程,即 `skipped_reason === "non_interactive"`)→
|
|
717
|
+
* "请打开以下链接完成授权:<url>…"
|
|
718
|
+
* —— 这时屏幕上**什么都没弹**,再说"已为你打开"会让用户以为链接坏了。
|
|
719
|
+
*
|
|
720
|
+
* @param {string} url
|
|
721
|
+
* @param {object} [opts]
|
|
722
|
+
* @param {'auth'|'pay'} [opts.kind]
|
|
723
|
+
* @param {boolean} [opts.agent] ⚠️ **已弃用**(仅为兼容既有调用方而保留):
|
|
724
|
+
* 以前用它切"请在右侧(内置浏览器)…"的口径;B 路线暂停后两种场景话术已统一,
|
|
725
|
+
* 这个入参**不再影响输出**。
|
|
726
|
+
* @param {boolean} [opts.nonInteractive] 非交互环境(`skipped_reason === "non_interactive"`)
|
|
727
|
+
*/
|
|
728
|
+
export function browserPasteText(url, { kind = 'auth', agent = false, nonInteractive = false } = {}) {
|
|
729
|
+
// 已弃用:见上面的参数说明(保留形参只是不想为了一个布尔值去改所有调用方)
|
|
730
|
+
void agent;
|
|
731
|
+
const closingHint = '(完成后页面会自动关闭;没关就手动关掉即可)';
|
|
732
|
+
if (nonInteractive === true) {
|
|
733
|
+
return kind === 'pay'
|
|
734
|
+
? `请打开以下链接完成支付(微信扫码):${url}${closingHint}`
|
|
735
|
+
: `请打开以下链接完成授权:${url}${closingHint}`;
|
|
736
|
+
}
|
|
737
|
+
return kind === 'pay'
|
|
738
|
+
? `已为你打开浏览器,请在那里完成支付(微信扫码):${url}${closingHint}`
|
|
739
|
+
: `已为你打开浏览器,请在那里完成授权:${url}${closingHint}`;
|
|
740
|
+
}
|
|
741
|
+
|
|
742
|
+
/**
|
|
743
|
+
* 默认的"打开浏览器"实现(单独抽出来是为了**可测**)。
|
|
744
|
+
*
|
|
745
|
+
* `deps.spawnImpl` / `deps.platform` 可以注入 —— 这样单测能让"打开失败"真实发生
|
|
746
|
+
* (而不是把 openBrowser 整个换掉,那样就测不到 warn 文案与"不中断"这两件事了)。
|
|
747
|
+
*
|
|
748
|
+
* 两种失败(同步抛 / 异步 emit error)都打**同一段**"请手动复制这个地址…"的醒目提示,
|
|
749
|
+
* 而且提示里**自带完整 URL**(真客户不会往上翻页找地址),并且**都不中断**授权。
|
|
750
|
+
*/
|
|
751
|
+
export function defaultOpenBrowser(deps = {}, log = () => {}) {
|
|
752
|
+
const agent = !(deps.isTTY === true && deps.json !== true);
|
|
753
|
+
return (url) =>
|
|
754
|
+
openInBrowser(url, {
|
|
755
|
+
platform: deps.platform,
|
|
756
|
+
spawnImpl: deps.spawnImpl,
|
|
757
|
+
onError: (e) =>
|
|
758
|
+
log(
|
|
759
|
+
browserFailedHintLines(url, {
|
|
760
|
+
kind: deps.browserHintKind === 'pay' ? 'pay' : 'auth',
|
|
761
|
+
agent,
|
|
762
|
+
cause: (e && e.message) || String(e),
|
|
763
|
+
}).join('\n'),
|
|
764
|
+
),
|
|
765
|
+
});
|
|
766
|
+
}
|
|
767
|
+
|
|
768
|
+
/**
|
|
769
|
+
* `login`(本地回调模式)专用的默认实现:**异步**版,多策略逐条等待结果。
|
|
770
|
+
*
|
|
771
|
+
* ⚠️ 为什么不复用上面的 `defaultOpenBrowser`:`device.mjs`(设备码模式)是**同步**调用它
|
|
772
|
+
* 并拿 boolean 的,那段代码不在本次改动范围内 —— 所以同步版保留原契约不动,
|
|
773
|
+
* login 这条链路上再加一个能 await 结果的版本。两者共用同一张策略表,
|
|
774
|
+
* 差别只在"要不要等退出码"。
|
|
775
|
+
*
|
|
776
|
+
* 失败**不在这里**打印长提示:login 主流程拿到 `opened:false` 后会打印
|
|
777
|
+
* 一段**带完整 URL** 的醒目提示(见 runLogin 第 4 步)。这里只在 `--verbose` 时
|
|
778
|
+
* 逐条记录"哪条策略为什么挂了",方便真机排障。
|
|
779
|
+
*
|
|
780
|
+
* @param {object} deps { platform, spawnImpl, browserStrategies, browserTimeoutMs, verbose }
|
|
781
|
+
* @param {(msg:string)=>void} log
|
|
782
|
+
*/
|
|
783
|
+
export function defaultOpenBrowserAsync(deps = {}, log = () => {}) {
|
|
784
|
+
const verbose = deps.verbose === true;
|
|
785
|
+
return (url) =>
|
|
786
|
+
openInBrowserWithFallback(url, {
|
|
787
|
+
platform: deps.platform,
|
|
788
|
+
spawnImpl: deps.spawnImpl,
|
|
789
|
+
strategies: deps.browserStrategies,
|
|
790
|
+
timeoutMs: deps.browserTimeoutMs,
|
|
791
|
+
onAttempt: verbose
|
|
792
|
+
? ({ label, ok, error, timedOut }) =>
|
|
793
|
+
log(
|
|
794
|
+
ok
|
|
795
|
+
? `[verbose] 打开浏览器:「${label}」${timedOut ? '超时未返回,按已交给系统处理' : '成功'}`
|
|
796
|
+
: `[verbose] 打开浏览器:「${label}」失败(${(error && error.message) || error}),静默试下一条`,
|
|
797
|
+
)
|
|
798
|
+
: undefined,
|
|
799
|
+
});
|
|
800
|
+
}
|
|
801
|
+
|
|
802
|
+
/**
|
|
803
|
+
* 「把一个网址交给用户的浏览器」—— **全 CLI 唯一入口**(login / 钱包充值共用)。
|
|
804
|
+
*
|
|
805
|
+
* ## 为什么必须抽出来(不允许各命令自己 spawn 一份)
|
|
806
|
+
*
|
|
807
|
+
* 打开浏览器这件事踩过的坑全在这个文件顶部(`cmd /c start` 的引号、URL 里的 `&`
|
|
808
|
+
* 被 shell 吃掉、`http.server` 没挂 `error` 监听……)。各命令自己复制一份,
|
|
809
|
+
* 就等于把这些坑再踩一遍,而且**只有其中一份会被修**。
|
|
810
|
+
*
|
|
811
|
+
* 与 `defaultOpenBrowserAsync` 的区别:
|
|
812
|
+
* * `defaultOpenBrowserAsync` 只管"按多策略打开",返回原始结果;
|
|
813
|
+
* * 本函数是**给命令层用的**:把"注入的假实现(测试里返回 boolean)"与
|
|
814
|
+
* "真实现(返回四个字段)"**归一化成同一个状态对象**,并且
|
|
815
|
+
* **吞掉任何异常**(打不开浏览器绝不能把命令搞失败 —— 网址已经打印给用户了)。
|
|
816
|
+
*
|
|
817
|
+
* @param {string} url 要打开的完整网址
|
|
818
|
+
* @param {object} [opts]
|
|
819
|
+
* @param {object} [opts.deps] 运行期依赖 `{ openBrowser, platform, spawnImpl, browserStrategies, browserTimeoutMs, verbose,
|
|
820
|
+
* isTTY, json, forceOpen, noBrowser, env }`
|
|
821
|
+
* @param {(msg:string)=>void} [opts.log] 诊断日志(`--verbose` 用)
|
|
822
|
+
* @returns {Promise<{attempted:boolean, opened:boolean, tried:string[], url:string, skipped_reason:('no_browser'|'non_interactive'|null)}>}
|
|
823
|
+
*/
|
|
824
|
+
export async function openUrlForUser(url, { deps = {}, log = () => {} } = {}) {
|
|
825
|
+
const target = typeof url === 'string' ? url.trim() : '';
|
|
826
|
+
/**
|
|
827
|
+
* ★ 先过**唯一闸门**(见 resolveBrowserIntent):**人在终端默认打开**;
|
|
828
|
+
* `--no-browser` 与 **非交互/CI**(非 TTY / CI 环境变量 / `WKONGAI_CLI_NO_BROWSER=1`)都不打开。
|
|
829
|
+
* ⚠️ 这里是钱包充值那条链路(login 走 runLogin 里的同一个函数),所以两处行为天然一致 ——
|
|
830
|
+
* **不允许**在任何命令里自己判断一遍 TTY 再决定要不要 spawn(那就是复制逻辑,
|
|
831
|
+
* 迟早会出现"授权不弹、支付还弹"这种不一致)。
|
|
832
|
+
*/
|
|
833
|
+
const intent = resolveBrowserIntent({
|
|
834
|
+
isTTY: deps.isTTY === true,
|
|
835
|
+
json: deps.json === true,
|
|
836
|
+
forceOpen: deps.forceOpen === true,
|
|
837
|
+
noBrowser: deps.noBrowser === true || deps.openBrowser === false,
|
|
838
|
+
/** ★ CI / 非交互判定(2026-10-21):管道、CI 环境变量、WKONGAI_CLI_NO_BROWSER 都不弹 */
|
|
839
|
+
env: deps.env && typeof deps.env === 'object' ? deps.env : {},
|
|
840
|
+
});
|
|
841
|
+
if (!intent.allow) {
|
|
842
|
+
// 不弹窗 ≠ 失败:地址照常由调用方打印/放进 JSON,流程一丝不变
|
|
843
|
+
return { attempted: false, opened: false, tried: [], url: target, skipped_reason: intent.skipped_reason };
|
|
844
|
+
}
|
|
845
|
+
const opener =
|
|
846
|
+
typeof deps.openBrowser === 'function'
|
|
847
|
+
? deps.openBrowser
|
|
848
|
+
: defaultOpenBrowserAsync(
|
|
849
|
+
{
|
|
850
|
+
platform: deps.platform,
|
|
851
|
+
spawnImpl: deps.spawnImpl,
|
|
852
|
+
browserStrategies: deps.browserStrategies,
|
|
853
|
+
browserTimeoutMs: deps.browserTimeoutMs,
|
|
854
|
+
verbose: deps.verbose === true,
|
|
855
|
+
},
|
|
856
|
+
log,
|
|
857
|
+
);
|
|
858
|
+
try {
|
|
859
|
+
return normalizeOpenStatus(await opener(target), target);
|
|
860
|
+
} catch (e) {
|
|
861
|
+
// 注入的实现抛错 / 真实现 reject:如实记成"没打开",命令继续往下走
|
|
862
|
+
log(`[verbose] 打开浏览器时抛错(已忽略):${(e && e.message) || e}`);
|
|
863
|
+
return { attempted: true, opened: false, tried: [], url: target, skipped_reason: null };
|
|
864
|
+
}
|
|
865
|
+
}
|
|
866
|
+
|
|
867
|
+
/**
|
|
868
|
+
* 回一个 HTML 页面。
|
|
869
|
+
*
|
|
870
|
+
* 页面本体(成功页 / 各错误页)都在 `./page.mjs` —— 那里是**纯模板**,
|
|
871
|
+
* 单测可以直接断言文案与体积,不必起 server;本文件只负责"发出去"。
|
|
872
|
+
*
|
|
873
|
+
* ⚠️ `Content-Type` 必须显式写 `charset=utf-8`:不写的话浏览器会按**本地
|
|
874
|
+
* 默认编码**猜(中文 Windows 上常猜成 GBK),而这个页面**通篇是中文**,
|
|
875
|
+
* 猜错就是整页乱码 —— 比白屏还糟(用户以为授权坏了)。
|
|
876
|
+
* ⚠️ `Cache-Control: no-store`:回调 URL 里带着一次性授权码,
|
|
877
|
+
* 绝不能被浏览器缓存、也不该留在历史里。
|
|
878
|
+
*/
|
|
879
|
+
function sendHtml(res, status, page) {
|
|
880
|
+
res.writeHead(status, {
|
|
881
|
+
'Content-Type': 'text/html; charset=utf-8',
|
|
882
|
+
'Cache-Control': 'no-store',
|
|
883
|
+
'Content-Length': Buffer.byteLength(page.html),
|
|
884
|
+
});
|
|
885
|
+
res.end(page.html);
|
|
886
|
+
}
|
|
887
|
+
|
|
888
|
+
/**
|
|
889
|
+
* 跑一次登录。
|
|
890
|
+
* @param {object} args
|
|
891
|
+
* @param {object} args.config 已生效的配置(base/clientId/scope/credentialsFile/callback*)
|
|
892
|
+
* @param {(msg:string)=>void} args.log
|
|
893
|
+
* @param {object} [args.deps] { fetchImpl, openBrowser, now, listenPort, callbackFirstWaitMs,
|
|
894
|
+
* spawnImpl, platform, onAuthorizationUrl, proxyRisk, env,
|
|
895
|
+
* ★ isTTY, json, forceBrowser, noBrowser —— 见 resolveBrowserIntent(),
|
|
896
|
+
* ★ handoff, postDeviceGraceMs —— 见下 }
|
|
897
|
+
* ★ `isTTY` / `json` / `forceBrowser`(`--open-browser`)/ `noBrowser`(`--no-browser`)/ `env`(CI 判定)
|
|
898
|
+
* 决定"要不要替用户弹系统浏览器":**人在终端默认打开**;`--no-browser` 与 **非交互/CI**
|
|
899
|
+
* (stdout 非 TTY / CI 环境变量 / `WKONGAI_CLI_NO_BROWSER=1`)都不打开;
|
|
900
|
+
* `--open-browser` 只在终端里保留显式语义 —— 理由见 detectNonInteractive() / resolveBrowserIntent()。
|
|
901
|
+
* `callbackFirstWaitMs` —— 可选的「首轮等待」窗口,**默认 0 = 关闭**(0.2.2 起)。
|
|
902
|
+
* 只有用户显式写了 `--callback-first-wait` / `WKONGAI_CALLBACK_FIRST_WAIT_MS` 时,
|
|
903
|
+
* 命令层才会给非 0 值(见 `commands/auth.mjs` 的 resolveCallbackFirstWaitMs);
|
|
904
|
+
* 传 0 / 不传 / 负数 = 不自愈,一直等满整段 `loginTimeoutMs`。
|
|
905
|
+
* 单测用短窗口(例如 400ms)验证"显式开启后自动改设备码"这条分支。
|
|
906
|
+
* ★★ `handoff` —— **「回调 / 设备码两条路并存」的交接面**(2026-10-03 修 ERR_CONNECTION_REFUSED 时加的)。
|
|
907
|
+
* 调用方(命令层)传一个**可变对象**,两边各填一半:
|
|
908
|
+
* * 调用方**先**填 `handoff.onSwitch(reason)` —— **显式首轮等待**到点时会被调用
|
|
909
|
+
* (`reason` 是 `'callback_first_wait'`),它应当去启动设备码那条路,
|
|
910
|
+
* **不要**在这里结束回调这条路:本地监听由本函数继续持有;
|
|
911
|
+
* ⚠️ 整段 `--timeout` 到点**不会**再调用它(0.2.2 起取消"等太久自动改道")。
|
|
912
|
+
* * 本函数填 `handoff.finishWithDevice(result)` / `handoff.abort(error)` ——
|
|
913
|
+
* 设备码那条路先拿到令牌时调前者(本函数据此收尾,并给"迟到的回调"回一张已完成页),
|
|
914
|
+
* 设备码那条路也失败时调后者(本函数用这个错误结束等待)。
|
|
915
|
+
* ⚠️ **没传 `handoff`(或 `onSwitch` 不是函数)= 旧契约**:显式首轮等待到点直接抛
|
|
916
|
+
* `callback_first_wait` 并在 `finally` 里关掉监听(既有 runLogin 级单测走的就是这条)。
|
|
917
|
+
* `postDeviceGraceMs` —— 设备码先成功后,本地监听再多留多久(默认 `DEFAULT_POST_DEVICE_GRACE_MS`;
|
|
918
|
+
* 只对"显式首轮等待"这条自愈生效;单测注入小值即可确定性地验证"迟到的回调拿到已完成页")。
|
|
919
|
+
*/
|
|
920
|
+
export async function runLogin({ config, log = () => {}, deps = {} }) {
|
|
921
|
+
const fetchImpl = deps.fetchImpl || globalThis.fetch;
|
|
922
|
+
/**
|
|
923
|
+
* ⚠️ 这里必须用 `!== false` 显式判断,不能写 `deps.openBrowser || 默认实现` ——
|
|
924
|
+
* 后来加 `--no-browser` 时传的就是 `openBrowser: false`,`false || 默认` 会**打开浏览器**,
|
|
925
|
+
* 等于开关失效(经典 `||` 陷阱)。同时支持注入一个函数用于测试。
|
|
926
|
+
*
|
|
927
|
+
* ★ 2026-10-01 起:`deps.openBrowser === false` 只是"用户主动关掉"这一种情况;
|
|
928
|
+
* **要不要弹系统浏览器**这件事统一由 `resolveBrowserIntent()` 裁决 ——
|
|
929
|
+
* ★ 2026-10-21 起:**人在终端默认打开**;`--no-browser` 与 **非交互/CI**(非 TTY / CI 环境变量 /
|
|
930
|
+
* `WKONGAI_CLI_NO_BROWSER=1`)都不打开(见 resolveBrowserIntent / detectNonInteractive 的说明)。
|
|
931
|
+
*/
|
|
932
|
+
const browserIntent = resolveBrowserIntent({
|
|
933
|
+
isTTY: deps.isTTY === true,
|
|
934
|
+
json: deps.json === true,
|
|
935
|
+
forceOpen: deps.forceBrowser === true,
|
|
936
|
+
noBrowser: deps.openBrowser === false || deps.noBrowser === true,
|
|
937
|
+
/** ★ CI / 非交互判定(2026-10-21):命令层把 `ctx.env` 透传进来,纯函数在 login.mjs 里 */
|
|
938
|
+
env: deps.env && typeof deps.env === 'object' ? deps.env : {},
|
|
939
|
+
});
|
|
940
|
+
/**
|
|
941
|
+
* ★★ 最终是否自动打开系统浏览器 = **唯一闸门**的结论。
|
|
942
|
+
*
|
|
943
|
+
* ★ 2026-10-21(老板真机反馈「CI 里 login 弹了浏览器」):
|
|
944
|
+
* **人类终端**默认打开;**非交互 / CI**(stdout 非 TTY / CI 环境变量 /
|
|
945
|
+
* `WKONGAI_CLI_NO_BROWSER=1`)与 `--no-browser` 都不打开。
|
|
946
|
+
* `json` / `isTTY` 不再决定"要不要弹"(`json` 只影响 `mode` 诊断字段)。
|
|
947
|
+
* ⚠️ 无论哪种情况,**绝不**因为"没打开浏览器"让登录失败 —— 地址一直完整打印,回调照旧等。
|
|
948
|
+
*/
|
|
949
|
+
const shouldOpenBrowser = browserIntent.allow;
|
|
950
|
+
/**
|
|
951
|
+
* 默认实现走 `defaultOpenBrowserAsync(deps, log)`:**异步多策略**版 —— 把
|
|
952
|
+
* `deps.spawnImpl` / `deps.platform`(以及测试用的 `browserStrategies` /
|
|
953
|
+
* `browserTimeoutMs`)透传给 `openInBrowserWithFallback`,逐条策略等结果,
|
|
954
|
+
* 拿得到"试过哪几条、最后成没成"(`--json` 的 `open_browser` 字段就是它)。
|
|
955
|
+
*
|
|
956
|
+
* ⚠️ 注意这里和 `device.mjs` 用的 `defaultOpenBrowser`(同步版)是**两个**函数:
|
|
957
|
+
* device 那条链路不在本次改动范围内,不能改它的同步 boolean 契约。
|
|
958
|
+
*/
|
|
959
|
+
const openBrowser =
|
|
960
|
+
typeof deps.openBrowser === 'function'
|
|
961
|
+
? deps.openBrowser
|
|
962
|
+
: defaultOpenBrowserAsync({ ...deps, verbose: deps.verbose === true || config.verbose === true }, log);
|
|
963
|
+
const now = deps.now || (() => Date.now());
|
|
964
|
+
/** 回调地址在真正 listen 之后才知道端口;handler 里要用,所以先声明 */
|
|
965
|
+
let redirectUri = '';
|
|
966
|
+
const api = createApi({ config, fetchImpl });
|
|
967
|
+
/**
|
|
968
|
+
* 代理风险(命令层探测后经 `deps.proxyRisk` 透传进来)。
|
|
969
|
+
*
|
|
970
|
+
* ⚠️ 为什么**不在这里**自己探测:探测只需要做一次(runtime 里做了记忆化),
|
|
971
|
+
* 而命令层必须在本流程**开始之前**就拿到结论(先提示、甚至直接改走设备码)。
|
|
972
|
+
* 这里只是把同一份结论织进"回调没等到"的错误提示里 —— 那是老板报的那个故障的现场。
|
|
973
|
+
*/
|
|
974
|
+
const proxyHint = proxyRiskHint(deps.proxyRisk, { cmdName: config.cmdName || 'wkgeo' });
|
|
975
|
+
|
|
976
|
+
/* ---- 1. 发现授权端点(metadata)---- */
|
|
977
|
+
let metadata = null;
|
|
978
|
+
try {
|
|
979
|
+
metadata = await api.metadata();
|
|
980
|
+
} catch (e) {
|
|
981
|
+
// metadata 拉不到不算致命:用兜底地址继续(但要如实告知)
|
|
982
|
+
log(`⚠️ 读取授权服务器元数据失败(${e.message}),改用内置默认授权地址继续`);
|
|
983
|
+
}
|
|
984
|
+
|
|
985
|
+
/**
|
|
986
|
+
* 服务端声明的授权地址;拿不到就用配置基址 + `/authorize` 兜底。
|
|
987
|
+
* (下面紧接着要把它归一化到 canonical 授权站 —— 见 `canonicalOauthUrl()` 的说明)
|
|
988
|
+
*/
|
|
989
|
+
let authorizeBase = (metadata && metadata.authorization_endpoint) || `${config.oauthWebBase}/authorize`;
|
|
990
|
+
|
|
991
|
+
/**
|
|
992
|
+
* ★★ 2026-10-18(域名统一到路径):授权页地址**以配置基址为 canonical**。
|
|
993
|
+
*
|
|
994
|
+
* 服务端 metadata 的 `authorization_endpoint` 由云函数 `oauth` 的 `ADMIN_WEB_BASE`
|
|
995
|
+
* 生成,**线上环境变量里仍是老地址** `https://oauth.wkgeo.com` —— 只改 CLI 的兜底
|
|
996
|
+
* 常量没用,那个字段永远优先。所以这里统一过一道 `canonicalOauthUrl()`:
|
|
997
|
+
* * 平台内的地址 ⇒ 把 pathname 挪到 `config.oauthWebBase`(默认 `https://wkgeo.com/oauth`)下;
|
|
998
|
+
* * 平台外的地址(含 `localhost`,历史上真被坑过)⇒ 回落到配置基址的 `/authorize`。
|
|
999
|
+
* 回滚老站只要设 `WKONGAI_OAUTH_WEB_BASE=https://oauth.wkgeo.com`,不用改代码。
|
|
1000
|
+
*
|
|
1001
|
+
* ⚠️ 下面两步的顺序不能颠倒:
|
|
1002
|
+
* 先归一化(决定"打开哪个站"),再补尾斜杠(决定"302 会不会丢 query")。
|
|
1003
|
+
* 尾斜杠规则见 `withTrailingSlash()` 的说明(托管侧对目录路径 302 且丢 query)。
|
|
1004
|
+
*/
|
|
1005
|
+
const canonicalAuthorize = canonicalOauthUrl(
|
|
1006
|
+
authorizeBase,
|
|
1007
|
+
config.oauthWebBase,
|
|
1008
|
+
{ fallbackPath: '/authorize' },
|
|
1009
|
+
);
|
|
1010
|
+
if (canonicalAuthorize.changed) {
|
|
1011
|
+
log(
|
|
1012
|
+
`⚠️ 服务端返回的授权地址不在当前授权站(${authorizeBase}),` +
|
|
1013
|
+
`已改用 ${config.oauthWebBase} 下的同一路径:${canonicalAuthorize.url}`,
|
|
1014
|
+
);
|
|
1015
|
+
}
|
|
1016
|
+
authorizeBase = canonicalAuthorize.url;
|
|
1017
|
+
|
|
1018
|
+
/**
|
|
1019
|
+
* ★ 授权页地址**从构造时就带尾斜杠**(`…/authorize/?client_id=…`;
|
|
1020
|
+
* 老站是 `/admin/oauth/authorize/?client_id=…`,子域时代是 `/authorize/?…`,
|
|
1021
|
+
* 2026-10-18 路径化后是 `/oauth/authorize/?…`)。
|
|
1022
|
+
*
|
|
1023
|
+
* 为什么:前端是静态导出(每个路由一个目录),托管侧(OSS 静态托管 / 阿里云 ESA)
|
|
1024
|
+
* 对**不带尾斜杠**的目录路径会 302,而那个 302 **不携带 query** ——
|
|
1025
|
+
* 授权参数会在任何 JS 执行之前就被丢光,页面显示「授权请求不完整」。
|
|
1026
|
+
* 这里对**两种来源**都做一次归一化(服务端 metadata 给的 + 我们自己拼的兜底地址):
|
|
1027
|
+
* * 线上 metadata 已修好、会返回带斜杠的地址 → 这一步是无副作用的兜底(不拼出 `//`);
|
|
1028
|
+
* * 但不能假设服务端配置永远正确(本项目真被 `authorization_endpoint` 配成本机地址坑过一次),
|
|
1029
|
+
* 客户端多做一道是**便宜且必要**的防御。
|
|
1030
|
+
* 收口在 `config.mjs` 的 `withTrailingSlash()`(唯一构造入口,有单测钉住)。
|
|
1031
|
+
*/
|
|
1032
|
+
authorizeBase = withTrailingSlash(authorizeBase);
|
|
1033
|
+
|
|
1034
|
+
const ttlSec = Number(metadata && metadata.access_token_ttl_seconds);
|
|
1035
|
+
const onExpiry = (metadata && metadata.on_token_expiry) || 'reauthorize';
|
|
1036
|
+
|
|
1037
|
+
/* ---- 2. PKCE + state ---- */
|
|
1038
|
+
const verifier = createVerifier();
|
|
1039
|
+
const challenge = challengeOf(verifier);
|
|
1040
|
+
const state = createState();
|
|
1041
|
+
|
|
1042
|
+
/* ---- 3. 起本地回调服务(只监听 127.0.0.1)---- */
|
|
1043
|
+
let resolveFlow;
|
|
1044
|
+
let rejectFlow;
|
|
1045
|
+
const flow = new Promise((resolve, reject) => {
|
|
1046
|
+
resolveFlow = resolve;
|
|
1047
|
+
rejectFlow = reject;
|
|
1048
|
+
});
|
|
1049
|
+
/**
|
|
1050
|
+
* ⚠️ 这里挂一个空 catch 是**必须**的:
|
|
1051
|
+
* `finish()` 可能在调用方 `await flow` **之前**就 reject(比如换票失败发生在 HTTP 回调里,
|
|
1052
|
+
* 而调用方此刻还在 await fetch)。Node 16+ 对"无人处理的 rejection"会直接崩进程,
|
|
1053
|
+
* 单测里就表现为"login:换票失败"这条用例莫名其妙地失败。
|
|
1054
|
+
* 挂一个空 catch 只是加一个旁观者,不影响后面正常的 await(仍然会抛)。
|
|
1055
|
+
*/
|
|
1056
|
+
flow.catch(() => {});
|
|
1057
|
+
|
|
1058
|
+
let settled = false;
|
|
1059
|
+
let server;
|
|
1060
|
+
let timer = null;
|
|
1061
|
+
/** ★ 可选首轮等待定时器(仅显式 `--callback-first-wait` 才有):到点 → 让命令层并发跑设备码 */
|
|
1062
|
+
let firstWaitTimer = null;
|
|
1063
|
+
/**
|
|
1064
|
+
* ★★ 交接面(见 deps.handoff 的说明):命令层传进来的可变对象,两边各填一半。
|
|
1065
|
+
* `onSwitch` 由命令层填(到点时启动设备码那条路),`finishWithDevice` / `abort` 由这里填。
|
|
1066
|
+
* ⚠️ `canHandoff === false`(没传/形状不对)= 保持旧契约:到点直接抛错并关监听。
|
|
1067
|
+
*/
|
|
1068
|
+
const handoff = deps.handoff && typeof deps.handoff === 'object' ? deps.handoff : null;
|
|
1069
|
+
const canHandoff = !!(handoff && typeof handoff.onSwitch === 'function');
|
|
1070
|
+
/** 这次自愈是被哪个窗口触发的(只有 `callback_first_wait` 才留 grace,见 DEFAULT_POST_DEVICE_GRACE_MS) */
|
|
1071
|
+
let switchReason = null;
|
|
1072
|
+
/** 设备码那条路**已经**拿到令牌(命令层调 handoff.finishWithDevice 之后为 true) */
|
|
1073
|
+
let deviceDone = false;
|
|
1074
|
+
let deviceResult = null;
|
|
1075
|
+
/** 设备码先成功后,本地监听"再活多久"(毫秒);0 = 立刻收尾 */
|
|
1076
|
+
let postGraceMs = 0;
|
|
1077
|
+
let graceTimer = null;
|
|
1078
|
+
|
|
1079
|
+
const finish = (err, value) => {
|
|
1080
|
+
if (settled) return;
|
|
1081
|
+
settled = true;
|
|
1082
|
+
if (timer) clearTimeout(timer);
|
|
1083
|
+
if (firstWaitTimer) clearTimeout(firstWaitTimer);
|
|
1084
|
+
if (graceTimer) clearTimeout(graceTimer);
|
|
1085
|
+
if (err) rejectFlow(err);
|
|
1086
|
+
else resolveFlow(value);
|
|
1087
|
+
};
|
|
1088
|
+
|
|
1089
|
+
/** 关掉本地监听(grace 结束后或被"迟到的回调"提前唤醒时用) */
|
|
1090
|
+
const closeServer = () =>
|
|
1091
|
+
new Promise((resolve) => {
|
|
1092
|
+
try {
|
|
1093
|
+
// ⚠️ 浏览器可能用 keep-alive 挂着连接,`close()` 会一直等它 —— 直接掐断更干脆
|
|
1094
|
+
if (typeof server.closeAllConnections === 'function') server.closeAllConnections();
|
|
1095
|
+
server.close(() => resolve());
|
|
1096
|
+
} catch {
|
|
1097
|
+
resolve();
|
|
1098
|
+
}
|
|
1099
|
+
});
|
|
1100
|
+
|
|
1101
|
+
/**
|
|
1102
|
+
* ★★ 设备码那条路**先**拿到令牌 → 这里收尾(真机证据与取舍见 DEFAULT_POST_DEVICE_GRACE_MS)。
|
|
1103
|
+
*
|
|
1104
|
+
* 关键点:**不立刻关监听**,而且**不 await** —— 命令层要马上拿到结果去打印"授权成功",
|
|
1105
|
+
* 本地监听在后台再活 `postGraceMs`(或被一次迟到的回调提前唤醒,见 handler 里的 `deviceDone` 分支)。
|
|
1106
|
+
*/
|
|
1107
|
+
if (handoff) {
|
|
1108
|
+
handoff.finishWithDevice = (result) => {
|
|
1109
|
+
if (settled) return;
|
|
1110
|
+
deviceDone = true;
|
|
1111
|
+
deviceResult = result;
|
|
1112
|
+
// 令牌已经到手:这两个窗口的定时器都不再有意义(否则它们会在 grace 期间把流程判成失败)
|
|
1113
|
+
if (timer) {
|
|
1114
|
+
clearTimeout(timer);
|
|
1115
|
+
timer = null;
|
|
1116
|
+
}
|
|
1117
|
+
if (firstWaitTimer) {
|
|
1118
|
+
clearTimeout(firstWaitTimer);
|
|
1119
|
+
firstWaitTimer = null;
|
|
1120
|
+
}
|
|
1121
|
+
postGraceMs = switchReason === 'callback_first_wait' ? Number(deps.postDeviceGraceMs ?? DEFAULT_POST_DEVICE_GRACE_MS) : 0;
|
|
1122
|
+
if (!Number.isFinite(postGraceMs) || postGraceMs < 0) postGraceMs = 0;
|
|
1123
|
+
finish(null, result);
|
|
1124
|
+
};
|
|
1125
|
+
/** 设备码那条路也没走通 → 用命令层给的"两条路都不通"错误结束等待(见 commands/auth.mjs) */
|
|
1126
|
+
handoff.abort = (err) => finish(err);
|
|
1127
|
+
}
|
|
1128
|
+
|
|
1129
|
+
/**
|
|
1130
|
+
* ★ 把"回调这条路没等到结果"**交接**给命令层(只通知、不结束、**不关监听**)。
|
|
1131
|
+
*
|
|
1132
|
+
* 文案与旧版保持一致的关键词(`没收到回调` / `本地回调没有等到结果` / `已自动改用`),
|
|
1133
|
+
* 既有单测与排障文档按这些字样检索;新增的只有"监听继续保留"这句 —— 那正是本次修复的核心。
|
|
1134
|
+
*/
|
|
1135
|
+
const handOff = (reason) => {
|
|
1136
|
+
if (settled || switchReason) return;
|
|
1137
|
+
switchReason = reason;
|
|
1138
|
+
const reasonText = reason === 'callback_first_wait' ? '首轮等待没收到回调' : '等待超时';
|
|
1139
|
+
log('');
|
|
1140
|
+
log(`⚠️ 本地回调没有等到结果(${reasonText}):已自动改用【设备码模式】继续(不需干等,两条路并行)。`);
|
|
1141
|
+
log(
|
|
1142
|
+
'ℹ️ 本机回调监听**继续保留**:如果你之后才在浏览器里点【同意授权】,那一次照样能直接完成登录' +
|
|
1143
|
+
'(不会再出现"连接被拒绝 / ERR_CONNECTION_REFUSED")。',
|
|
1144
|
+
);
|
|
1145
|
+
try {
|
|
1146
|
+
handoff.onSwitch(reason);
|
|
1147
|
+
} catch (e) {
|
|
1148
|
+
// 交接失败不能让"回调这条路"跟着崩:它还在正常等回调,用户还有机会成功
|
|
1149
|
+
log(`[verbose] 交接给设备码那条路时出错(已忽略,回调这条路继续等):${(e && e.message) || e}`);
|
|
1150
|
+
}
|
|
1151
|
+
};
|
|
1152
|
+
|
|
1153
|
+
server = http.createServer(async (req, res) => {
|
|
1154
|
+
// 只管回调路径;其它路径(比如浏览器自动请求 /favicon.ico)一律 404,避免误判
|
|
1155
|
+
let parsed;
|
|
1156
|
+
try {
|
|
1157
|
+
parsed = new URL(req.url, `http://${req.headers.host || '127.0.0.1'}`);
|
|
1158
|
+
} catch {
|
|
1159
|
+
res.writeHead(400).end('bad request');
|
|
1160
|
+
return;
|
|
1161
|
+
}
|
|
1162
|
+
if (parsed.pathname !== config.callbackPath) {
|
|
1163
|
+
res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
|
|
1164
|
+
res.end('not found');
|
|
1165
|
+
return;
|
|
1166
|
+
}
|
|
1167
|
+
if (req.method !== 'GET') {
|
|
1168
|
+
sendHtml(
|
|
1169
|
+
res,
|
|
1170
|
+
405,
|
|
1171
|
+
errorPage({
|
|
1172
|
+
tone: 'warn',
|
|
1173
|
+
heading: '方法不允许',
|
|
1174
|
+
reason: '这个回调地址只接受浏览器直接打开的 GET 请求(收到了 ' + req.method + ')。',
|
|
1175
|
+
hint: '请把终端里打印的那一整行授权网址复制到浏览器地址栏打开。',
|
|
1176
|
+
}),
|
|
1177
|
+
);
|
|
1178
|
+
return;
|
|
1179
|
+
}
|
|
1180
|
+
|
|
1181
|
+
/**
|
|
1182
|
+
* ★★ 设备码那条路**已经拿到令牌**了 ⇒ 这一次回调只是"用户后来才点的同意"。
|
|
1183
|
+
*
|
|
1184
|
+
* 真机证据(老板 2026-10-03 反馈的连带缺陷):旧逻辑在切设备码时**关掉了本地回调监听**,
|
|
1185
|
+
* 于是用户随后点【同意授权】时浏览器跳到 `http://127.0.0.1:<port>/callback?code=…`
|
|
1186
|
+
* 得到 **ERR_CONNECTION_REFUSED** —— 用户会以为授权失败(而他其实已经登录成功了)。
|
|
1187
|
+
* 现在监听还开着,所以这里**必须**给一张友好的"已完成"页,而**不是**任何错误页。
|
|
1188
|
+
*
|
|
1189
|
+
* 🔴 两条硬约束:
|
|
1190
|
+
* 1. **不要**拿这个 code 去换票:凭据已经由设备码那条路写好,再换一次等于同一份授权重复签发
|
|
1191
|
+
* (多一份令牌,还可能把刚写好的凭据覆盖掉);
|
|
1192
|
+
* 2. 这一页**不回显** code,也不出现任何令牌(与其它页同一条安全底线)。
|
|
1193
|
+
*/
|
|
1194
|
+
if (deviceDone) {
|
|
1195
|
+
sendHtml(res, 200, alreadyDonePage(deviceResult && deviceResult.account));
|
|
1196
|
+
// 页面已经交给浏览器了:grace 不必再等,监听立刻收尾
|
|
1197
|
+
if (graceTimer) {
|
|
1198
|
+
clearTimeout(graceTimer);
|
|
1199
|
+
graceTimer = null;
|
|
1200
|
+
}
|
|
1201
|
+
closeServer();
|
|
1202
|
+
return;
|
|
1203
|
+
}
|
|
1204
|
+
|
|
1205
|
+
const gotState = parsed.searchParams.get('state');
|
|
1206
|
+
const code = parsed.searchParams.get('code');
|
|
1207
|
+
const err = parsed.searchParams.get('error');
|
|
1208
|
+
const errDesc = parsed.searchParams.get('error_description');
|
|
1209
|
+
|
|
1210
|
+
// ★ state 校验:**服务端原样回传但不校验**,防 CSRF/串号是客户端自己的责任。
|
|
1211
|
+
// 不匹配就拒绝这一条,但**不结束流程**(可能是别人瞎打的),等真正的回调。
|
|
1212
|
+
if (!gotState || !safeEqual(gotState, state)) {
|
|
1213
|
+
/**
|
|
1214
|
+
* ⚠️ 大标题保留「state 校验失败」这句原文:它是本文件的**契约字样**,
|
|
1215
|
+
* `test/login.test.mjs` 用它分辨"这条分支被走到了",
|
|
1216
|
+
* 外部排障文档也按这句话搜索。改样式可以,改这句话不行。
|
|
1217
|
+
*/
|
|
1218
|
+
sendHtml(
|
|
1219
|
+
res,
|
|
1220
|
+
400,
|
|
1221
|
+
errorPage({
|
|
1222
|
+
tone: 'warn',
|
|
1223
|
+
heading: 'state 校验失败',
|
|
1224
|
+
reason: '这次回调带的 state 与本次登录不一致,已忽略(可能是别人误打进来的请求)。',
|
|
1225
|
+
hint: '如果终端还在等待授权,请回到浏览器重新走一次同意页;已重新点过同意的话,回终端重跑一次即可。',
|
|
1226
|
+
}),
|
|
1227
|
+
);
|
|
1228
|
+
return;
|
|
1229
|
+
}
|
|
1230
|
+
|
|
1231
|
+
if (err) {
|
|
1232
|
+
const hint = err === 'access_denied' ? '你(或页面上的人)点了「拒绝」。' : `服务端返回错误:${err}`;
|
|
1233
|
+
sendHtml(
|
|
1234
|
+
res,
|
|
1235
|
+
200,
|
|
1236
|
+
errorPage({
|
|
1237
|
+
tone: 'warn',
|
|
1238
|
+
heading: '授权未完成',
|
|
1239
|
+
reason: hint,
|
|
1240
|
+
hint: '没有拿到授权码,也没有写入任何凭据。',
|
|
1241
|
+
/**
|
|
1242
|
+
* ⚠️ 这一页**不自动关闭**,哪怕它已经是终态(下面 `finish(...)` 会带着错误结束等待)。
|
|
1243
|
+
* 两个理由:
|
|
1244
|
+
* 1. 用户可能想看清"到底为什么没成"(拒绝了?还是服务端报错?);
|
|
1245
|
+
* 2. 阿里云 `mcp-remote` 那套的教训 —— 它在**刚收到 code** 就替用户宣告成功并
|
|
1246
|
+
* `window.close()`,而此刻令牌还没换(后面才 POST token 端点);一旦换票失败,
|
|
1247
|
+
* 用户已经被打发走了,只剩一个"我刚才是不是失败了"的疑惑。
|
|
1248
|
+
* 所以本项目的口径是:**只有"真的把凭据写进本机"之后的那张成功页**才尝试自动关,
|
|
1249
|
+
* 其余页面(含本页)一律留在屏幕上让人看完。见 `page.mjs` 里 AUTO_CLOSE_SCRIPT 的注释。
|
|
1250
|
+
*/
|
|
1251
|
+
}),
|
|
1252
|
+
);
|
|
1253
|
+
finish(new CliError(err === 'access_denied' ? '用户拒绝了本次授权' : `授权失败:${err}${errDesc ? ' — ' + errDesc : ''}`, {
|
|
1254
|
+
kind: err === 'access_denied' ? 'denied' : 'authz_error',
|
|
1255
|
+
code: err,
|
|
1256
|
+
hint: '没有拿到授权码,未写入任何凭据',
|
|
1257
|
+
exitCode: EXIT.AUTH,
|
|
1258
|
+
}));
|
|
1259
|
+
return;
|
|
1260
|
+
}
|
|
1261
|
+
|
|
1262
|
+
if (!code) {
|
|
1263
|
+
sendHtml(
|
|
1264
|
+
res,
|
|
1265
|
+
400,
|
|
1266
|
+
errorPage({
|
|
1267
|
+
tone: 'warn',
|
|
1268
|
+
heading: '缺少授权码',
|
|
1269
|
+
reason: '回调地址里没有 code 参数,无法继续换票。',
|
|
1270
|
+
hint: '通常说明授权页那边没走完(或被手工改过地址)。',
|
|
1271
|
+
}),
|
|
1272
|
+
);
|
|
1273
|
+
return;
|
|
1274
|
+
}
|
|
1275
|
+
|
|
1276
|
+
// 用 code 换 token(先换再回页面,页面才能如实显示成功/失败)
|
|
1277
|
+
try {
|
|
1278
|
+
const tokenResponse = await api.token({
|
|
1279
|
+
grant_type: 'authorization_code',
|
|
1280
|
+
code,
|
|
1281
|
+
redirect_uri: redirectUri,
|
|
1282
|
+
client_id: config.clientId,
|
|
1283
|
+
code_verifier: verifier,
|
|
1284
|
+
});
|
|
1285
|
+
|
|
1286
|
+
let account = null;
|
|
1287
|
+
try {
|
|
1288
|
+
account = await api.userinfo(tokenResponse.access_token);
|
|
1289
|
+
} catch {
|
|
1290
|
+
// 身份信息拿不到不影响"已经登录"这个事实(权限收敛在服务端,不依赖它)
|
|
1291
|
+
}
|
|
1292
|
+
|
|
1293
|
+
const credentials = credentialsFromToken({
|
|
1294
|
+
clientId: config.clientId,
|
|
1295
|
+
tokenResponse,
|
|
1296
|
+
account,
|
|
1297
|
+
scope: config.scope,
|
|
1298
|
+
now: now(),
|
|
1299
|
+
});
|
|
1300
|
+
const mode = writeCredentials(config.credentialsFile, credentials, { now: now() });
|
|
1301
|
+
|
|
1302
|
+
/**
|
|
1303
|
+
* ⚠️ 成功页只吃 `account`(邮箱/昵称/脱敏手机号),**绝不**把
|
|
1304
|
+
* `tokenResponse` 传进去 —— 那是"页面里不出现令牌"这条红线的实现方式:
|
|
1305
|
+
* 模板没有接收令牌的位置,就不可能漏出去。
|
|
1306
|
+
*
|
|
1307
|
+
* ⚠️ **顺序是有约束的,别调换**:必须先 `await api.token(...)` 换到令牌、
|
|
1308
|
+
* 再 `writeCredentials(...)` 落盘,**最后**才回这张成功页 ——
|
|
1309
|
+
* 因为成功页会尝试自动关掉标签页(见 page.mjs 的 AUTO_CLOSE_SCRIPT)。
|
|
1310
|
+
* 阿里云那套正是在"刚收到 code、还没换票"时就回了成功页并关窗,
|
|
1311
|
+
* 于是换票失败时用户已被打发走、还被告知"成功"(那个坑别踩)。
|
|
1312
|
+
* 我们这里失败一律走下面的 catch → 换票失败页(**不自动关闭**,原因留在屏幕上)。
|
|
1313
|
+
*/
|
|
1314
|
+
sendHtml(res, 200, successPage(account));
|
|
1315
|
+
|
|
1316
|
+
finish(null, { credentials, account, mode, metadata });
|
|
1317
|
+
} catch (e) {
|
|
1318
|
+
const msg = (e && e.message) || String(e);
|
|
1319
|
+
/**
|
|
1320
|
+
* ⚠️ 失败原因来自服务端/网络层,可能夹带用户不可控的内容 ——
|
|
1321
|
+
* `errorPage` 内部会做 HTML 转义(见 page.mjs 的安全底线 4)。
|
|
1322
|
+
* ⚠️ 这里**只放原因**,不放任何凭据:换票失败时服务端的响应体里
|
|
1323
|
+
* 可能带 `error_description`,但绝不会带明文令牌(签发成功才会走上面那条路)。
|
|
1324
|
+
*/
|
|
1325
|
+
sendHtml(res, 500, errorPage({ heading: '换取令牌失败', reason: msg, hint: '没有写入任何凭据。' }));
|
|
1326
|
+
finish(e instanceof CliError ? e : new CliError(`换取令牌失败:${msg}`, { kind: 'token_exchange', hint: '重新运行 `wkgeo login`' }));
|
|
1327
|
+
}
|
|
1328
|
+
});
|
|
1329
|
+
|
|
1330
|
+
const listenOn = (port) =>
|
|
1331
|
+
new Promise((resolve, reject) => {
|
|
1332
|
+
const onError = (e) => {
|
|
1333
|
+
server.removeListener('listening', onListening);
|
|
1334
|
+
reject(e);
|
|
1335
|
+
};
|
|
1336
|
+
const onListening = () => {
|
|
1337
|
+
server.removeListener('error', onError);
|
|
1338
|
+
resolve(server.address());
|
|
1339
|
+
};
|
|
1340
|
+
server.once('error', onError);
|
|
1341
|
+
server.once('listening', onListening);
|
|
1342
|
+
// ⚠️ 只绑 127.0.0.1:绑 0.0.0.0 等于把授权码暴露给同网段任何人
|
|
1343
|
+
server.listen(port, config.callbackHost);
|
|
1344
|
+
});
|
|
1345
|
+
|
|
1346
|
+
/**
|
|
1347
|
+
* ★★ 0.2.4(老板真机反馈):端口优先 53682;被占用就自动换系统分配的空闲端口;
|
|
1348
|
+
* **bind 彻底失败时只报明确错误 + `--device` 建议,绝不静默改走设备码**
|
|
1349
|
+
* (设备码是另一条授权协议,用户没要求时不能替他换;命令层也不再兜底,见 commands/auth.mjs)。
|
|
1350
|
+
*/
|
|
1351
|
+
const preferredPort = deps.listenPort ?? config.callbackPort;
|
|
1352
|
+
const buildListenError = (cause, { afterFallback = false } = {}) => {
|
|
1353
|
+
const what = afterFallback
|
|
1354
|
+
? `首选端口 ${preferredPort} 被占用后,系统分配端口也无法监听`
|
|
1355
|
+
: `无法在 ${config.callbackHost}:${preferredPort} 上监听本地回调服务`;
|
|
1356
|
+
const codeText = cause && cause.code ? `(${cause.code})` : '';
|
|
1357
|
+
return new CliError(`${what}${codeText}:${(cause && cause.message) || cause}`, {
|
|
1358
|
+
kind: 'listen',
|
|
1359
|
+
hint:
|
|
1360
|
+
'本地回调服务没有启动,所以不会打开浏览器。请检查端口占用/防火墙,或用 --callback-port 指定其它端口;' +
|
|
1361
|
+
`若本机确实无法监听回环地址,请显式改用 \`${config.cmdName || 'wkgeo'} login --device\`(设备码模式,不需要本地回调)` +
|
|
1362
|
+
(proxyHint ? `。另外:${proxyHint}` : ''),
|
|
1363
|
+
cause,
|
|
1364
|
+
});
|
|
1365
|
+
};
|
|
1366
|
+
|
|
1367
|
+
let bound;
|
|
1368
|
+
try {
|
|
1369
|
+
bound = await listenOn(preferredPort);
|
|
1370
|
+
} catch (e) {
|
|
1371
|
+
if (e && e.code === 'EADDRINUSE' && Number(preferredPort) !== 0) {
|
|
1372
|
+
log(`⚠️ 回调端口 ${preferredPort} 已被占用,自动改用系统分配的空闲端口(redirect_uri 会使用实际监听端口)`);
|
|
1373
|
+
try {
|
|
1374
|
+
bound = await listenOn(0);
|
|
1375
|
+
} catch (e2) {
|
|
1376
|
+
throw buildListenError(e2, { afterFallback: true });
|
|
1377
|
+
}
|
|
1378
|
+
} else {
|
|
1379
|
+
throw buildListenError(e);
|
|
1380
|
+
}
|
|
1381
|
+
}
|
|
1382
|
+
const actualPort = bound.port;
|
|
1383
|
+
/**
|
|
1384
|
+
* ⚠️ 顺序硬保证(0.2.4):**监听真的成功**之后才允许构造/打印授权地址、才允许打开浏览器。
|
|
1385
|
+
* 理论上 `listenOn` resolve 时 server 一定处于 listening;这里再核一次,是为了让
|
|
1386
|
+
* "服务没起来却把浏览器弹出去"这类故障在代码层**不可能**发生(而不是靠调用顺序的自觉)。
|
|
1387
|
+
*/
|
|
1388
|
+
if (!server.listening) {
|
|
1389
|
+
// 极端防御:真走到这里说明监听状态丢了 —— 先尽量关掉,再明确报错(绝不弹浏览器)
|
|
1390
|
+
try {
|
|
1391
|
+
server.close();
|
|
1392
|
+
} catch {
|
|
1393
|
+
/* 本来就没监听,忽略 */
|
|
1394
|
+
}
|
|
1395
|
+
throw new CliError('本地回调服务没有进入监听状态,已取消打开浏览器', {
|
|
1396
|
+
kind: 'listen',
|
|
1397
|
+
hint:
|
|
1398
|
+
`请重新运行 \`${config.cmdName || 'wkgeo'} login\`;若仍失败,改用 \`${config.cmdName || 'wkgeo'} login --device\`(设备码模式,不需要本地回调)`,
|
|
1399
|
+
});
|
|
1400
|
+
}
|
|
1401
|
+
redirectUri = `http://${config.callbackHost}:${actualPort}${config.callbackPath}`;
|
|
1402
|
+
/**
|
|
1403
|
+
* ★★ 老板要求的可观测证据(0.2.4):先明确告诉用户"本地服务已经在监听",再谈浏览器。
|
|
1404
|
+
* 顺序是:listen 成功 → 这行日志 → 打印授权网址 → 尝试打开浏览器。
|
|
1405
|
+
* 用户/排障者因此能一眼分辨"服务没起来"和"浏览器没打开"这两类完全不同的故障。
|
|
1406
|
+
*/
|
|
1407
|
+
log(`✅ 回调服务已启动 ${redirectUri}`);
|
|
1408
|
+
const authUrl = new URL(authorizeBase);
|
|
1409
|
+
authUrl.searchParams.set('client_id', config.clientId);
|
|
1410
|
+
authUrl.searchParams.set('redirect_uri', redirectUri);
|
|
1411
|
+
authUrl.searchParams.set('response_type', 'code');
|
|
1412
|
+
authUrl.searchParams.set('scope', config.scope);
|
|
1413
|
+
authUrl.searchParams.set('state', state);
|
|
1414
|
+
authUrl.searchParams.set('code_challenge', challenge);
|
|
1415
|
+
authUrl.searchParams.set('code_challenge_method', 'S256');
|
|
1416
|
+
|
|
1417
|
+
/* ---- 4. 交给用户 ---- */
|
|
1418
|
+
// 授权网址必须**同时**以人类可读文本(走 log,JSON 模式下命令层会把它转到 stderr)
|
|
1419
|
+
// 和机器可读 JSON(走 onAuthorizationUrl 回调)输出 —— AI 端要拿到链接交给用户点。
|
|
1420
|
+
log('');
|
|
1421
|
+
log('请在浏览器中完成授权(设备码/回调模式都是同一条授权页;未登录会先让你登录):');
|
|
1422
|
+
log('');
|
|
1423
|
+
log(` ${authUrl.toString()}`);
|
|
1424
|
+
log('');
|
|
1425
|
+
if (shouldOpenBrowser) {
|
|
1426
|
+
log('如果浏览器没有自动打开,请把上面这一整行复制到浏览器地址栏打开。');
|
|
1427
|
+
}
|
|
1428
|
+
/**
|
|
1429
|
+
* ★ 2026-10-02(老板):授权成功后**那个页面会自己关掉** —— 提前交代一句,
|
|
1430
|
+
* 否则用户会一直等一个其实已经结束的页面,或者回去找那个标签页。
|
|
1431
|
+
* ⚠️ "没关就手动关掉即可"**不能省**:`window.close()` 只对**脚本打开的**窗口有效,
|
|
1432
|
+
* 本页是用户自己点开的标签页 ⇒ 大概率关不掉,那句话就是兜底。
|
|
1433
|
+
* ★ 现在对**所有**路径都打(`--no-browser` / 打开成功 / 打开失败都一样)——
|
|
1434
|
+
* B 路线(内置浏览器)暂停后不再有"只给 AI 场景打提示"的分支。
|
|
1435
|
+
*/
|
|
1436
|
+
log('(授权成功后页面会自动尝试关闭;没关就手动关掉即可。)');
|
|
1437
|
+
|
|
1438
|
+
/**
|
|
1439
|
+
* 自动打开浏览器:**多策略依次尝试**(策略表见文件顶部的 BROWSER_STRATEGY_TABLE)。
|
|
1440
|
+
*
|
|
1441
|
+
* ⚠️ 打开失败**绝不允许**让 login 失败:地址已经完整打印在上面(那一整行),
|
|
1442
|
+
* 手动复制照样能走完流程。所以连"注入的 openBrowser 抛错 / 返回 rejected Promise"
|
|
1443
|
+
* 都要在这里吞掉 —— 以前不 await,注入的异步实现 reject 会变成 unhandledRejection
|
|
1444
|
+
* 直接把进程崩掉,比"打不开浏览器"严重得多。
|
|
1445
|
+
*
|
|
1446
|
+
* ⚠️ 顺序是刻意的:先在**人类可读那一段**里打印完整网址,再尝试打开,再打印结果。
|
|
1447
|
+
* 这样哪怕打开很慢(多策略逐条超时,最坏十几秒),用户第一眼也已经看到网址了。
|
|
1448
|
+
* 代价是 `--json` 的 `awaiting_callback` 事件要等打开动作结束才发出去 —— 值得,
|
|
1449
|
+
* 因为 AI 端要靠事件里的 `open_browser` 判断"到底要不要催用户手动打开"。
|
|
1450
|
+
*/
|
|
1451
|
+
let openStatus = {
|
|
1452
|
+
attempted: false,
|
|
1453
|
+
opened: false,
|
|
1454
|
+
tried: [],
|
|
1455
|
+
url: authUrl.toString(),
|
|
1456
|
+
// ★ 只有两种"不尝试":`--no-browser`(no_browser)与非交互/CI(non_interactive)
|
|
1457
|
+
skipped_reason: browserIntent.skipped_reason,
|
|
1458
|
+
};
|
|
1459
|
+
if (shouldOpenBrowser) {
|
|
1460
|
+
try {
|
|
1461
|
+
/**
|
|
1462
|
+
* `await` 是必须的:注入的同步实现返回 boolean(`await` 一个非 Promise 就是它本身),
|
|
1463
|
+
* 生产默认实现(`defaultOpenBrowserAsync`)返回上面那四个字段。
|
|
1464
|
+
*/
|
|
1465
|
+
openStatus = normalizeOpenStatus(await openBrowser(authUrl.toString()), authUrl.toString());
|
|
1466
|
+
} catch (e) {
|
|
1467
|
+
// 打开浏览器**永不允许**把登录搞失败:如实记成"没打开",继续等回调
|
|
1468
|
+
openStatus = { attempted: true, opened: false, tried: [], url: authUrl.toString(), skipped_reason: null };
|
|
1469
|
+
log(`[verbose] 打开浏览器时抛错(已忽略,继续等回调):${(e && e.message) || e}`);
|
|
1470
|
+
}
|
|
1471
|
+
}
|
|
1472
|
+
if (!shouldOpenBrowser) {
|
|
1473
|
+
if (browserIntent.skipped_reason === 'no_browser') {
|
|
1474
|
+
// 用户主动关掉的,不该报"失败"(原有行为,保持兼容)
|
|
1475
|
+
log('(已按 --no-browser 跳过自动打开)');
|
|
1476
|
+
} else if (browserIntent.skipped_reason === 'non_interactive') {
|
|
1477
|
+
/**
|
|
1478
|
+
* ★ 2026-10-21(老板反馈:CI 里弹了浏览器):
|
|
1479
|
+
* 非交互环境**不弹**,但必须把"为什么没弹 + 下一步怎么走"说清楚,
|
|
1480
|
+
* 否则用户/CI 日志里只看到一行 URL,会以为 CLI 卡住了。
|
|
1481
|
+
* ⚠️ 这段走 `log`:`--json` 时命令层会把它转到 stderr,不污染 stdout 的 JSONL。
|
|
1482
|
+
*/
|
|
1483
|
+
const reason = detectNonInteractive({
|
|
1484
|
+
isTTY: deps.isTTY === true,
|
|
1485
|
+
env: deps.env && typeof deps.env === 'object' ? deps.env : {},
|
|
1486
|
+
}).reason;
|
|
1487
|
+
for (const line of nonInteractiveBrowserHintLines({ kind: 'auth', reason, cmdName: config.cmdName || 'wkgeo' })) {
|
|
1488
|
+
log(line);
|
|
1489
|
+
}
|
|
1490
|
+
}
|
|
1491
|
+
} else if (openStatus.opened) {
|
|
1492
|
+
// ★ 成功:明说"已经打开了",并告诉用户去那里做什么(老板最终拍板走传统路线)
|
|
1493
|
+
log(browserOpenedText({ kind: 'auth' }));
|
|
1494
|
+
} else {
|
|
1495
|
+
/**
|
|
1496
|
+
* 全部策略都失败时的提示:`browserFailedHintLines()` 统一了三条硬要求
|
|
1497
|
+
* —— 醒目(`⚠️`)、**自带完整 URL**、说清打开之后干什么;
|
|
1498
|
+
* AI 场景(非 TTY / `--json`)再多一句"客户端支持内置浏览器也可以在那里打开"的可选提示。
|
|
1499
|
+
* 真客户不会自己去找网址,所以这段是"自动打开失败"时唯一能救回流程的东西。
|
|
1500
|
+
*/
|
|
1501
|
+
for (const line of browserFailedHintLines(authUrl.toString(), { kind: 'auth', agent: browserIntent.mode === 'agent' })) {
|
|
1502
|
+
log(line);
|
|
1503
|
+
}
|
|
1504
|
+
}
|
|
1505
|
+
|
|
1506
|
+
log(`等待你在浏览器里完成授权…(最多 ${Math.round(config.loginTimeoutMs / 1000)} 秒,Ctrl+C 可取消)`);
|
|
1507
|
+
if (typeof deps.onAuthorizationUrl === 'function') {
|
|
1508
|
+
deps.onAuthorizationUrl(authUrl.toString(), {
|
|
1509
|
+
redirect_uri: redirectUri,
|
|
1510
|
+
timeout_ms: config.loginTimeoutMs,
|
|
1511
|
+
scope: config.scope,
|
|
1512
|
+
client_id: config.clientId,
|
|
1513
|
+
/**
|
|
1514
|
+
* ★ 机器可读的"自动打开"状态:AI 端据此判断"到底要不要催用户手动打开"。
|
|
1515
|
+
* `authorization_url` 仍然照旧单独给(绝不能因为多了这个字段就把它挤掉)。
|
|
1516
|
+
* ★ 2026-10-21 起 `skipped_reason` 有三种取值:
|
|
1517
|
+
* * `null` = 真的尝试过(成没成看 `opened`);
|
|
1518
|
+
* * `"no_browser"` = 调用方/用户明确要求别打开;
|
|
1519
|
+
* * `"non_interactive"` = CI / 管道 / AI 子进程(**默认不弹**,见 detectNonInteractive)。
|
|
1520
|
+
* (历史取值 `"non_tty_agent_mode"` 已弃用,见 resolveBrowserIntent 的注释。)
|
|
1521
|
+
*/
|
|
1522
|
+
open_browser: openStatus,
|
|
1523
|
+
/** ★ 给 AI 端"照着念"的一句话(AI 不该自己组织语言,否则容易漏掉网址) */
|
|
1524
|
+
paste_text: browserPasteText(authUrl.toString(), {
|
|
1525
|
+
kind: 'auth',
|
|
1526
|
+
nonInteractive: browserIntent.skipped_reason === 'non_interactive',
|
|
1527
|
+
}),
|
|
1528
|
+
});
|
|
1529
|
+
}
|
|
1530
|
+
|
|
1531
|
+
timer = setTimeout(() => {
|
|
1532
|
+
/**
|
|
1533
|
+
* ⚠️ 超时是**老板报的那个故障的现场**:用户在同意页点了「同意」,终端却一直等。
|
|
1534
|
+
* 最常见的原因就是"代理把 127.0.0.1 的回调也接管了"(code 从没打到本地服务)。
|
|
1535
|
+
* 所以检测到代理时,hint 里必须带上"三选一"的可照做指引(第 3 条是设备码模式)。
|
|
1536
|
+
* (⚠️ 注意:有代理时命令层通常**已经**走设备码了,根本走不到这里;
|
|
1537
|
+
* 能走到这里的情况是"用户在代理下强制回调"或"探测没发现代理但回调仍被别的
|
|
1538
|
+
* 东西挡了 —— 防火墙/安全软件/浏览器插件"。)
|
|
1539
|
+
* ★★ 0.2.2 起:整段超时**不再自动改设备码**(老板:默认就是回调,设备码只在
|
|
1540
|
+
* 本地读不了/代理时才用)。这里只报 `kind = 'timeout'`,并在 hint 里明确给出
|
|
1541
|
+
* "显式改用 `--device`"的下一步。
|
|
1542
|
+
* ⚠️ 唯一例外:用户**显式**开了 `--callback-first-wait`,到点已经把设备码那条路
|
|
1543
|
+
* 并发点起来了(`switchReason` 非空)。此时整段超时到点不能再把设备码那条路判死,
|
|
1544
|
+
* 交给它自己跑到设备码过期/成功为止(与 2026-10-03 的"两条路并存"契约一致)。
|
|
1545
|
+
*/
|
|
1546
|
+
if (canHandoff && switchReason && !deviceDone) {
|
|
1547
|
+
return;
|
|
1548
|
+
}
|
|
1549
|
+
finish(new CliError(`等待授权超时(${config.loginTimeoutMs}ms)`, {
|
|
1550
|
+
kind: 'timeout',
|
|
1551
|
+
hint:
|
|
1552
|
+
'授权码本身只有 5 分钟有效期。请重新运行 `wkgeo login`(浏览器里通常还有登录态,点一下同意即可);' +
|
|
1553
|
+
'若本机确实无法接收 127.0.0.1 回调(代理/防火墙/远程环境),请显式使用 `wkgeo login --device`(设备码模式)' +
|
|
1554
|
+
(proxyHint ? `。另外:${proxyHint}` : ''),
|
|
1555
|
+
exitCode: EXIT.AUTH,
|
|
1556
|
+
}));
|
|
1557
|
+
}, config.loginTimeoutMs);
|
|
1558
|
+
if (timer && typeof timer.unref === 'function') timer.unref();
|
|
1559
|
+
|
|
1560
|
+
/**
|
|
1561
|
+
* 可选自愈:**首轮等待**(★ 默认关闭;只有用户显式 `--callback-first-wait` 才会 > 0)
|
|
1562
|
+
* 没等到回调 → 主动结束这一轮等待 / 或交接给设备码(`kind = 'callback_first_wait'`,**不是** `timeout`)。
|
|
1563
|
+
*
|
|
1564
|
+
* ⚠️ 0.2.2 起**默认不挂这个定时器**(旧版有代理时默认 180 秒,会"等太久自动变设备码",
|
|
1565
|
+
* 正是老板这次反馈要改掉的行为)。
|
|
1566
|
+
*
|
|
1567
|
+
* 为什么不是在这里直接改走设备码:设备码流程在 `device.mjs` / `commands/auth.mjs`,
|
|
1568
|
+
* 而 `runLogin` 的契约是"要么拿到凭据、要么抛一个说明原因的错误"。
|
|
1569
|
+
* 由命令层统一裁决"这个错要不要降级"更简单,也保证 `finally` 里把本地 server 关干净
|
|
1570
|
+
* (否则 53682 端口会被自己占着,回落到回调时反而起不来)。
|
|
1571
|
+
* ⚠️ **2026-10-03 起**:命令层传了 `deps.handoff` 时,上面这条"关干净"的口径变了 ——
|
|
1572
|
+
* 到点**只通知、不关监听**,因为关掉监听正是真机上 ERR_CONNECTION_REFUSED 的成因。
|
|
1573
|
+
*
|
|
1574
|
+
* ⚠️ 只在 `0 < firstWait < loginTimeoutMs` 时挂:否则先撞到的必然是整段超时,
|
|
1575
|
+
* 挂上去只会让两个定时器互相打乱,也让错误信息变得难以理解。
|
|
1576
|
+
*/
|
|
1577
|
+
const firstWaitMs = Number(deps.callbackFirstWaitMs ?? 0);
|
|
1578
|
+
if (Number.isFinite(firstWaitMs) && firstWaitMs > 0 && firstWaitMs < config.loginTimeoutMs) {
|
|
1579
|
+
const label = firstWaitMs >= 1000 ? `${Math.round(firstWaitMs / 1000)} 秒` : `${firstWaitMs} 毫秒`;
|
|
1580
|
+
// 提前告知"不用干等",并说清"监听还会开着"(后者正是 2026-10-03 修复:用户之后点同意也来得及)
|
|
1581
|
+
log(`(已按 --callback-first-wait 显式启用首轮等待:如果 ${label}内没收到回调,会自动改用设备码模式继续;本地回调监听也会继续保留)`);
|
|
1582
|
+
firstWaitTimer = setTimeout(() => {
|
|
1583
|
+
if (canHandoff && !deviceDone) {
|
|
1584
|
+
handOff('callback_first_wait');
|
|
1585
|
+
return;
|
|
1586
|
+
}
|
|
1587
|
+
finish(new CliError(`等待授权回调的前 ${label}没有收到结果`, {
|
|
1588
|
+
kind: 'callback_first_wait',
|
|
1589
|
+
hint:
|
|
1590
|
+
'本地回调在这段时间内没有收到结果;命令层会自动改用设备码模式继续(不需要本地回调,授权页照旧点同意即可)' +
|
|
1591
|
+
(proxyHint ? `。另外:${proxyHint}` : ''),
|
|
1592
|
+
exitCode: EXIT.AUTH,
|
|
1593
|
+
}));
|
|
1594
|
+
}, firstWaitMs);
|
|
1595
|
+
// 与整段超时一致:unref 掉,避免"登录早就结束了,进程还被定时器吊着"
|
|
1596
|
+
if (firstWaitTimer && typeof firstWaitTimer.unref === 'function') firstWaitTimer.unref();
|
|
1597
|
+
}
|
|
1598
|
+
|
|
1599
|
+
// Ctrl+C 时把监听端口关掉再退(否则 53682 会短暂占用)
|
|
1600
|
+
const onSigint = () => {
|
|
1601
|
+
// 令牌已经拿到(设备码那条路先成功)时,Ctrl+C 不该把它判成失败:照旧把结果交出去
|
|
1602
|
+
if (deviceDone) {
|
|
1603
|
+
finish(null, deviceResult);
|
|
1604
|
+
return;
|
|
1605
|
+
}
|
|
1606
|
+
finish(new CliError('用户中断了登录', { kind: 'aborted', exitCode: 130 }));
|
|
1607
|
+
};
|
|
1608
|
+
process.once('SIGINT', onSigint);
|
|
1609
|
+
|
|
1610
|
+
try {
|
|
1611
|
+
const result = await flow;
|
|
1612
|
+
return {
|
|
1613
|
+
...result,
|
|
1614
|
+
redirectUri,
|
|
1615
|
+
tokenTtlSeconds: ttlSec,
|
|
1616
|
+
onTokenExpiry: onExpiry,
|
|
1617
|
+
metadata,
|
|
1618
|
+
};
|
|
1619
|
+
} finally {
|
|
1620
|
+
process.removeListener('SIGINT', onSigint);
|
|
1621
|
+
if (deviceDone && postGraceMs > 0) {
|
|
1622
|
+
/**
|
|
1623
|
+
* ★★ 设备码先成功时**不马上关监听**(见 DEFAULT_POST_DEVICE_GRACE_MS):
|
|
1624
|
+
* 用户可能还在那个授权页上,他之后点【同意】时不该看到 ERR_CONNECTION_REFUSED。
|
|
1625
|
+
* ⚠️ 这里刻意**不 await**:调用方要立刻拿到结果去打印"授权成功";
|
|
1626
|
+
* 监听与 grace 定时器在后台再活一小会儿,到点(或被那次迟到的回调提前唤醒)自行关闭。
|
|
1627
|
+
* 定时器 unref 掉不吃事件循环 —— 让进程活下来的是 server 本身,关掉它进程就退出了。
|
|
1628
|
+
*/
|
|
1629
|
+
graceTimer = setTimeout(() => {
|
|
1630
|
+
graceTimer = null;
|
|
1631
|
+
closeServer();
|
|
1632
|
+
}, postGraceMs);
|
|
1633
|
+
if (graceTimer && typeof graceTimer.unref === 'function') graceTimer.unref();
|
|
1634
|
+
} else {
|
|
1635
|
+
await closeServer();
|
|
1636
|
+
}
|
|
1637
|
+
}
|
|
1638
|
+
}
|