@lks347/dsh-oauth 0.0.0-stage → 1.0.2
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.en.md +155 -0
- package/README.md +101 -2
- package/app.js +1045 -0
- package/auth.html +80 -0
- package/client.js +31 -0
- package/cordis.patch.yml +4 -0
- package/docs/CONNECTIONS.md +77 -0
- package/docs/LIVE-VALIDATION-1.0.1.md +100 -0
- package/docs/RELEASE-1.0.1.md +48 -0
- package/docs/RELEASE-1.0.2.md +8 -0
- package/docs/VALIDATION.md +59 -0
- package/docs/evidence/live-1.0.1.json +135 -0
- package/docs/evidence/release-1.0.1.json +38 -0
- package/index.html +43 -0
- package/package.json +64 -4
- package/providers.js +73 -0
- package/scripts/check-upstreams.mjs +27 -0
- package/scripts/link-peers.js +38 -0
- package/scripts/verify-browser.mjs +297 -0
- package/scripts/verify-host.mjs +431 -0
- package/scripts/verify-live.mjs +268 -0
- package/scripts/verify-package.mjs +168 -0
- package/scripts/verify-persistence.mjs +307 -0
- package/scripts/verify-subscriptions-ui.mjs +321 -0
- package/src/account.js +85 -0
- package/src/account.test.js +52 -0
- package/src/authorization.js +199 -0
- package/src/authorization.test.js +332 -0
- package/src/catalog.js +180 -0
- package/src/catalog.test.js +146 -0
- package/src/chat-recovery.js +110 -0
- package/src/chat-recovery.test.js +261 -0
- package/src/connection-runtime.js +129 -0
- package/src/connection-runtime.test.js +244 -0
- package/src/connections.js +70 -0
- package/src/grants.js +104 -0
- package/src/grants.test.js +340 -0
- package/src/index.js +676 -0
- package/src/local-imports.js +263 -0
- package/src/local-imports.test.js +201 -0
- package/src/media.js +152 -0
- package/src/models.js +610 -0
- package/src/models.test.js +503 -0
- package/src/profile-store.js +51 -0
- package/src/pulls.js +100 -0
- package/src/pulls.test.js +156 -0
- package/src/qwen.js +141 -0
- package/src/qwen.test.js +35 -0
- package/src/request-errors.js +50 -0
- package/src/request-errors.test.js +131 -0
- package/src/routes.js +47 -0
- package/src/routes.test.js +136 -0
- package/src/subscription-models.test.js +160 -0
- package/src/usage/aggregators.js +292 -0
- package/src/usage/aggregators.test.js +316 -0
- package/src/usage/core.js +68 -0
- package/src/usage/index.js +93 -0
- package/src/usage/official.js +339 -0
- package/src/usage/official.test.js +273 -0
- package/src/usage/service.test.js +89 -0
- package/src/xai-browser.js +272 -0
- package/src/xai-browser.test.js +256 -0
- package/src/xai-login.js +121 -0
- package/src/xai-login.test.js +259 -0
- package/styles.css +364 -0
- package/theme.js +118 -0
- package/upstreams.json +10 -0
package/src/xai-login.js
ADDED
|
@@ -0,0 +1,121 @@
|
|
|
1
|
+
import { isDeepStrictEqual } from "node:util";
|
|
2
|
+
import { credentialKey } from "@deepseek-ai/dsh-credentials";
|
|
3
|
+
import { loginXaiBrowser } from "./xai-browser.js";
|
|
4
|
+
|
|
5
|
+
const KEY = credentialKey("llm-pi-ai", "xai");
|
|
6
|
+
const cancelled = () => Object.assign(new Error("xAI 登录已取消"), { name: "AbortError" });
|
|
7
|
+
|
|
8
|
+
/** Browser runner over the canonical xAI grant; it does not register or duplicate a DSH credential flow. */
|
|
9
|
+
export function createXaiBrowserAuthorization(ctx, authorization, { login = loginXaiBrowser } = {}) {
|
|
10
|
+
let active;
|
|
11
|
+
let generation = 0;
|
|
12
|
+
let recordEpoch = 0;
|
|
13
|
+
let disposed = false;
|
|
14
|
+
const unwatch = ctx.on("credentials/record-updated", (key) => {
|
|
15
|
+
if (key === KEY) recordEpoch += 1;
|
|
16
|
+
});
|
|
17
|
+
|
|
18
|
+
function assertKey(key) {
|
|
19
|
+
if (key !== KEY) throw new Error("浏览器授权仅支持 xAI 账号");
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
function assertCurrent(attempt) {
|
|
23
|
+
attempt.signal.throwIfAborted();
|
|
24
|
+
if (disposed || active !== attempt || generation !== attempt.generation) throw cancelled();
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
function assertUnchanged(attempt) {
|
|
28
|
+
assertCurrent(attempt);
|
|
29
|
+
if (authorization.describe(KEY)?.inFlight) throw new Error("xAI 正在其他窗口登录,请完成或取消后重试");
|
|
30
|
+
if (recordEpoch !== attempt.recordEpoch) throw new Error("xAI 凭据在登录期间已更改,请重新开始");
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
function describe(key) {
|
|
34
|
+
if (key !== KEY) return undefined;
|
|
35
|
+
return {
|
|
36
|
+
key: KEY,
|
|
37
|
+
label: "xAI (Grok)",
|
|
38
|
+
methods: [{ id: "oauth", label: "浏览器登录" }],
|
|
39
|
+
inFlight: active !== undefined || authorization.describe(KEY)?.inFlight === true,
|
|
40
|
+
};
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
async function begin({ key, method = "oauth", interaction, signal }) {
|
|
44
|
+
assertKey(key);
|
|
45
|
+
if (method !== "oauth") throw new Error("xAI 浏览器授权不支持该登录方式");
|
|
46
|
+
if (disposed) throw new Error("xAI 浏览器授权已卸载");
|
|
47
|
+
if (signal?.aborted) return { status: "cancelled" };
|
|
48
|
+
if (active || authorization.describe(KEY)?.inFlight) throw new Error("xAI 已有登录正在进行,请完成或取消后重试");
|
|
49
|
+
const controller = new AbortController();
|
|
50
|
+
const attempt = {
|
|
51
|
+
generation: ++generation,
|
|
52
|
+
recordEpoch,
|
|
53
|
+
controller,
|
|
54
|
+
signal: signal ? AbortSignal.any([signal, controller.signal]) : controller.signal,
|
|
55
|
+
phase: "starting",
|
|
56
|
+
};
|
|
57
|
+
active = attempt;
|
|
58
|
+
const withdraw = () => {
|
|
59
|
+
if (active === attempt) {
|
|
60
|
+
generation += 1;
|
|
61
|
+
active = undefined;
|
|
62
|
+
}
|
|
63
|
+
controller.abort(signal?.reason ?? cancelled());
|
|
64
|
+
};
|
|
65
|
+
signal?.addEventListener("abort", withdraw, { once: true });
|
|
66
|
+
try {
|
|
67
|
+
const stored = await ctx.credentials.readRecord(KEY);
|
|
68
|
+
assertUnchanged(attempt);
|
|
69
|
+
const snapshot = stored === undefined ? undefined : structuredClone(stored);
|
|
70
|
+
attempt.phase = "browser";
|
|
71
|
+
const grant = await login({
|
|
72
|
+
notify: interaction.notify,
|
|
73
|
+
prompt: interaction.prompt,
|
|
74
|
+
signal: attempt.signal,
|
|
75
|
+
onExchangeStart() {
|
|
76
|
+
assertUnchanged(attempt);
|
|
77
|
+
attempt.phase = "exchanging";
|
|
78
|
+
},
|
|
79
|
+
});
|
|
80
|
+
assertUnchanged(attempt);
|
|
81
|
+
await ctx.credentials.modifyRecord(KEY, async (current) => {
|
|
82
|
+
// Check again after acquiring DSH's record lock; never hold it while waiting for the browser.
|
|
83
|
+
assertUnchanged(attempt);
|
|
84
|
+
if (!isDeepStrictEqual(current, snapshot)) throw new Error("xAI 凭据在登录期间已更改,请重新开始");
|
|
85
|
+
attempt.phase = "committing";
|
|
86
|
+
return { kind: "grant", payload: JSON.parse(JSON.stringify(grant)) };
|
|
87
|
+
});
|
|
88
|
+
// A logout may have queued deletion behind this write. Do not publish a late success or write again.
|
|
89
|
+
assertCurrent(attempt);
|
|
90
|
+
return { status: "authorized" };
|
|
91
|
+
} catch (error) {
|
|
92
|
+
if (attempt.signal.aborted || disposed || generation !== attempt.generation) return { status: "cancelled" };
|
|
93
|
+
throw error;
|
|
94
|
+
} finally {
|
|
95
|
+
signal?.removeEventListener("abort", withdraw);
|
|
96
|
+
if (active === attempt) active = undefined;
|
|
97
|
+
}
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
/** Strong invalidation for logout/clear; ordinary UI cancellation must defer while isCommitting is true. */
|
|
101
|
+
function cancel(key) {
|
|
102
|
+
if (key !== KEY || !active) return;
|
|
103
|
+
const attempt = active;
|
|
104
|
+
active = undefined;
|
|
105
|
+
generation += 1;
|
|
106
|
+
attempt.controller.abort(cancelled());
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
function isCommitting(key) {
|
|
110
|
+
return key === KEY && active !== undefined && ["exchanging", "committing"].includes(active.phase);
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
function dispose() {
|
|
114
|
+
if (disposed) return;
|
|
115
|
+
disposed = true;
|
|
116
|
+
cancel(KEY);
|
|
117
|
+
unwatch();
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
return { describe, begin, cancel, isCommitting, dispose };
|
|
121
|
+
}
|
|
@@ -0,0 +1,259 @@
|
|
|
1
|
+
import assert from "node:assert/strict";
|
|
2
|
+
import test from "node:test";
|
|
3
|
+
import { createXaiBrowserAuthorization } from "./xai-login.js";
|
|
4
|
+
|
|
5
|
+
const KEY = "llm-pi-ai/xai";
|
|
6
|
+
const clone = (value) => value === undefined ? undefined : structuredClone(value);
|
|
7
|
+
const tick = () => new Promise((resolve) => setImmediate(resolve));
|
|
8
|
+
const grant = { type: "oauth", access: "synthetic-access", refresh: "synthetic-refresh", expires: 10000000000000 };
|
|
9
|
+
|
|
10
|
+
function fixture(initial) {
|
|
11
|
+
const listeners = new Set();
|
|
12
|
+
let record = clone(initial);
|
|
13
|
+
let queue = Promise.resolve();
|
|
14
|
+
const state = { hostInFlight: false, writes: 0, modifies: 0, beforePersist: undefined };
|
|
15
|
+
const publish = () => { for (const listener of listeners) listener(KEY); };
|
|
16
|
+
const enqueue = (operation) => {
|
|
17
|
+
const next = queue.then(operation);
|
|
18
|
+
queue = next.catch(() => {});
|
|
19
|
+
return next;
|
|
20
|
+
};
|
|
21
|
+
const credentials = {
|
|
22
|
+
async readRecord(key) { assert.equal(key, KEY); return clone(record); },
|
|
23
|
+
async modifyRecord(key, mutate) {
|
|
24
|
+
assert.equal(key, KEY);
|
|
25
|
+
state.modifies += 1;
|
|
26
|
+
return enqueue(async () => {
|
|
27
|
+
const next = await mutate(clone(record));
|
|
28
|
+
if (next !== undefined) {
|
|
29
|
+
await state.beforePersist?.();
|
|
30
|
+
record = clone(next);
|
|
31
|
+
state.writes += 1;
|
|
32
|
+
publish();
|
|
33
|
+
}
|
|
34
|
+
return clone(record);
|
|
35
|
+
});
|
|
36
|
+
},
|
|
37
|
+
async deleteRecord(key) {
|
|
38
|
+
assert.equal(key, KEY);
|
|
39
|
+
return enqueue(async () => { record = undefined; publish(); });
|
|
40
|
+
},
|
|
41
|
+
};
|
|
42
|
+
return {
|
|
43
|
+
state, credentials, listeners,
|
|
44
|
+
ctx: { credentials, on(event, listener) { assert.equal(event, "credentials/record-updated"); listeners.add(listener); return () => listeners.delete(listener); } },
|
|
45
|
+
authorization: { describe(key) { assert.equal(key, KEY); return { key, inFlight: state.hostInFlight }; } },
|
|
46
|
+
get record() { return clone(record); },
|
|
47
|
+
replace(next) { record = clone(next); publish(); },
|
|
48
|
+
replaceWithoutEvent(next) { record = clone(next); },
|
|
49
|
+
};
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
function controlledLogin() {
|
|
53
|
+
let resolve;
|
|
54
|
+
const result = new Promise((done) => { resolve = done; });
|
|
55
|
+
let entered;
|
|
56
|
+
const started = new Promise((done) => { entered = done; });
|
|
57
|
+
const state = { interaction: undefined, calls: 0 };
|
|
58
|
+
return {
|
|
59
|
+
state, started, finish: (value = grant) => resolve(value),
|
|
60
|
+
login: async (interaction) => { state.calls += 1; state.interaction = interaction; entered(); return result; },
|
|
61
|
+
};
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
const request = (signal) => ({ key: KEY, method: "oauth", interaction: { notify() {}, async prompt() { return "unused"; } }, signal });
|
|
65
|
+
|
|
66
|
+
test("browser authorization commits only the canonical record and reports success after persistence", async () => {
|
|
67
|
+
const f = fixture();
|
|
68
|
+
const login = controlledLogin();
|
|
69
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: login.login });
|
|
70
|
+
const run = adapter.begin(request());
|
|
71
|
+
await login.started;
|
|
72
|
+
assert.equal(f.state.modifies, 0, "the record lock is not held while waiting for browser approval");
|
|
73
|
+
assert.equal(adapter.describe(KEY).inFlight, true);
|
|
74
|
+
assert.equal(adapter.isCommitting(KEY), false);
|
|
75
|
+
login.state.interaction.onExchangeStart();
|
|
76
|
+
assert.equal(adapter.isCommitting(KEY), true);
|
|
77
|
+
login.finish();
|
|
78
|
+
assert.deepEqual(await run, { status: "authorized" });
|
|
79
|
+
assert.deepEqual(f.record, { kind: "grant", payload: grant });
|
|
80
|
+
assert.equal(f.state.writes, 1);
|
|
81
|
+
assert.equal(adapter.describe(KEY).inFlight, false);
|
|
82
|
+
assert.equal(adapter.isCommitting(KEY), false);
|
|
83
|
+
adapter.dispose();
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
test("native device login and a second browser attempt are rejected before another browser login starts", async () => {
|
|
87
|
+
const f = fixture();
|
|
88
|
+
const login = controlledLogin();
|
|
89
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: login.login });
|
|
90
|
+
f.state.hostInFlight = true;
|
|
91
|
+
await assert.rejects(adapter.begin(request()), /登录正在进行/);
|
|
92
|
+
assert.equal(login.state.calls, 0);
|
|
93
|
+
f.state.hostInFlight = false;
|
|
94
|
+
const run = adapter.begin(request());
|
|
95
|
+
await login.started;
|
|
96
|
+
await assert.rejects(adapter.begin(request()), /登录正在进行/);
|
|
97
|
+
assert.equal(login.state.calls, 1);
|
|
98
|
+
adapter.cancel(KEY);
|
|
99
|
+
login.finish();
|
|
100
|
+
assert.deepEqual(await run, { status: "cancelled" });
|
|
101
|
+
assert.equal(f.record, undefined);
|
|
102
|
+
adapter.dispose();
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
test("a native device attempt that starts while the browser waits prevents canonical commit", async () => {
|
|
106
|
+
const f = fixture();
|
|
107
|
+
const login = controlledLogin();
|
|
108
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: login.login });
|
|
109
|
+
const run = adapter.begin(request());
|
|
110
|
+
await login.started;
|
|
111
|
+
f.state.hostInFlight = true;
|
|
112
|
+
login.finish();
|
|
113
|
+
await assert.rejects(run, /其他窗口登录/);
|
|
114
|
+
assert.equal(f.state.writes, 0);
|
|
115
|
+
adapter.dispose();
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
test("the native device guard is repeated after the DSH record lock is acquired", async () => {
|
|
119
|
+
const f = fixture();
|
|
120
|
+
const originalModify = f.credentials.modifyRecord;
|
|
121
|
+
f.credentials.modifyRecord = (key, mutate) => {
|
|
122
|
+
f.state.hostInFlight = true;
|
|
123
|
+
return originalModify(key, mutate);
|
|
124
|
+
};
|
|
125
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: async () => grant });
|
|
126
|
+
await assert.rejects(adapter.begin(request()), /其他窗口登录/);
|
|
127
|
+
assert.equal(f.state.modifies, 1);
|
|
128
|
+
assert.equal(f.state.writes, 0);
|
|
129
|
+
assert.equal(f.record, undefined);
|
|
130
|
+
adapter.dispose();
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
test("a credential change without a local event is still rejected by the compare-and-swap under the DSH lock", async () => {
|
|
134
|
+
const before = { kind: "grant", payload: { ...grant, access: "initial" } };
|
|
135
|
+
const winner = { kind: "grant", payload: { ...grant, access: "other-process" } };
|
|
136
|
+
const f = fixture(before);
|
|
137
|
+
const login = controlledLogin();
|
|
138
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: login.login });
|
|
139
|
+
const run = adapter.begin(request());
|
|
140
|
+
await login.started;
|
|
141
|
+
f.replaceWithoutEvent(winner);
|
|
142
|
+
login.finish();
|
|
143
|
+
await assert.rejects(run, /凭据在登录期间已更改/);
|
|
144
|
+
assert.deepEqual(f.record, winner);
|
|
145
|
+
assert.equal(f.state.writes, 0);
|
|
146
|
+
adapter.dispose();
|
|
147
|
+
});
|
|
148
|
+
|
|
149
|
+
test("local credential ABA changes invalidate a browser attempt even when the final record equals its start snapshot", async () => {
|
|
150
|
+
const before = { kind: "grant", payload: { ...grant, access: "initial" } };
|
|
151
|
+
const f = fixture(before);
|
|
152
|
+
const login = controlledLogin();
|
|
153
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: login.login });
|
|
154
|
+
const run = adapter.begin(request());
|
|
155
|
+
await login.started;
|
|
156
|
+
f.replace(undefined);
|
|
157
|
+
f.replace(before);
|
|
158
|
+
login.finish();
|
|
159
|
+
await assert.rejects(run, /凭据在登录期间已更改/);
|
|
160
|
+
assert.deepEqual(f.record, before);
|
|
161
|
+
assert.equal(f.state.writes, 0);
|
|
162
|
+
adapter.dispose();
|
|
163
|
+
});
|
|
164
|
+
|
|
165
|
+
test("logout during an already-started token exchange invalidates its late result before any credential write", async () => {
|
|
166
|
+
const f = fixture({ kind: "grant", payload: { ...grant, access: "prior" } });
|
|
167
|
+
const login = controlledLogin();
|
|
168
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: login.login });
|
|
169
|
+
const controller = new AbortController();
|
|
170
|
+
const run = adapter.begin(request(controller.signal));
|
|
171
|
+
await login.started;
|
|
172
|
+
login.state.interaction.onExchangeStart();
|
|
173
|
+
assert.equal(adapter.isCommitting(KEY), true);
|
|
174
|
+
controller.abort();
|
|
175
|
+
adapter.cancel(KEY);
|
|
176
|
+
await f.credentials.deleteRecord(KEY);
|
|
177
|
+
login.finish();
|
|
178
|
+
assert.deepEqual(await run, { status: "cancelled" });
|
|
179
|
+
assert.equal(f.record, undefined);
|
|
180
|
+
assert.equal(f.state.writes, 0);
|
|
181
|
+
adapter.dispose();
|
|
182
|
+
});
|
|
183
|
+
|
|
184
|
+
test("logout queued after commit starts wins the DSH write ordering and no late result recreates the grant", async () => {
|
|
185
|
+
const f = fixture();
|
|
186
|
+
let release;
|
|
187
|
+
const held = new Promise((resolve) => { release = resolve; });
|
|
188
|
+
let entered;
|
|
189
|
+
const committing = new Promise((resolve) => { entered = resolve; });
|
|
190
|
+
f.state.beforePersist = async () => { entered(); await held; };
|
|
191
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: async (interaction) => { interaction.onExchangeStart(); return grant; } });
|
|
192
|
+
const controller = new AbortController();
|
|
193
|
+
const run = adapter.begin(request(controller.signal));
|
|
194
|
+
await committing;
|
|
195
|
+
assert.equal(adapter.isCommitting(KEY), true);
|
|
196
|
+
controller.abort();
|
|
197
|
+
adapter.cancel(KEY);
|
|
198
|
+
const deleted = f.credentials.deleteRecord(KEY);
|
|
199
|
+
release();
|
|
200
|
+
assert.deepEqual(await run, { status: "cancelled" });
|
|
201
|
+
await deleted;
|
|
202
|
+
await tick();
|
|
203
|
+
assert.equal(f.record, undefined);
|
|
204
|
+
assert.equal(f.state.writes, 1);
|
|
205
|
+
adapter.dispose();
|
|
206
|
+
});
|
|
207
|
+
|
|
208
|
+
test("a cancelled browser attempt cannot commit after a newer browser attempt succeeds", async () => {
|
|
209
|
+
const f = fixture();
|
|
210
|
+
const first = controlledLogin();
|
|
211
|
+
const second = controlledLogin();
|
|
212
|
+
let calls = 0;
|
|
213
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: (interaction) => (++calls === 1 ? first : second).login(interaction) });
|
|
214
|
+
const stale = adapter.begin(request());
|
|
215
|
+
await first.started;
|
|
216
|
+
adapter.cancel(KEY);
|
|
217
|
+
const current = adapter.begin(request());
|
|
218
|
+
await second.started;
|
|
219
|
+
const winner = { ...grant, access: "new-attempt" };
|
|
220
|
+
second.state.interaction.onExchangeStart();
|
|
221
|
+
second.finish(winner);
|
|
222
|
+
assert.deepEqual(await current, { status: "authorized" });
|
|
223
|
+
first.finish({ ...grant, access: "late-old-attempt" });
|
|
224
|
+
assert.deepEqual(await stale, { status: "cancelled" });
|
|
225
|
+
assert.deepEqual(f.record, { kind: "grant", payload: winner });
|
|
226
|
+
assert.equal(f.state.writes, 1);
|
|
227
|
+
adapter.dispose();
|
|
228
|
+
});
|
|
229
|
+
|
|
230
|
+
test("disposing the adapter removes its credential listener and prevents an ignored-abort login from writing", async () => {
|
|
231
|
+
const f = fixture();
|
|
232
|
+
const login = controlledLogin();
|
|
233
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: login.login });
|
|
234
|
+
const run = adapter.begin(request());
|
|
235
|
+
await login.started;
|
|
236
|
+
assert.equal(f.listeners.size, 1);
|
|
237
|
+
adapter.dispose();
|
|
238
|
+
adapter.dispose();
|
|
239
|
+
assert.equal(f.listeners.size, 0);
|
|
240
|
+
assert.equal(login.state.interaction.signal.aborted, true);
|
|
241
|
+
login.finish();
|
|
242
|
+
assert.deepEqual(await run, { status: "cancelled" });
|
|
243
|
+
assert.equal(f.state.writes, 0);
|
|
244
|
+
await assert.rejects(adapter.begin(request()), /已卸载/);
|
|
245
|
+
});
|
|
246
|
+
|
|
247
|
+
test("wrong keys, unsupported methods, and pre-aborted requests never invoke browser login", async () => {
|
|
248
|
+
const f = fixture();
|
|
249
|
+
let calls = 0;
|
|
250
|
+
const adapter = createXaiBrowserAuthorization(f.ctx, f.authorization, { login: async () => { calls += 1; return grant; } });
|
|
251
|
+
await assert.rejects(adapter.begin({ ...request(), key: "dsh-oauth/xai-browser" }), /仅支持 xAI/);
|
|
252
|
+
await assert.rejects(adapter.begin({ ...request(), method: "device" }), /不支持该登录方式/);
|
|
253
|
+
const controller = new AbortController();
|
|
254
|
+
controller.abort();
|
|
255
|
+
assert.deepEqual(await adapter.begin(request(controller.signal)), { status: "cancelled" });
|
|
256
|
+
assert.equal(adapter.describe("unrelated"), undefined);
|
|
257
|
+
assert.equal(calls, 0);
|
|
258
|
+
adapter.dispose();
|
|
259
|
+
});
|