From 1faa6c58fabebf9bc6e1bc33c1992ab7a8464ea7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=89=8B=E7=93=9C=E4=B8=80=E5=8D=81=E9=9B=AA?= Date: Sun, 18 Oct 2026 13:18:25 +0800 Subject: [PATCH] fix: unify stream cleanup and configuration response handling --- packages/core/src/webui/debug-tools.ts | 74 +++----- packages/core/src/webui/server.ts | 6 +- packages/core/src/webui/sse-response.ts | 122 +++++++------ packages/core/tests/sse-response.test.ts | 80 +++++++-- packages/core/tests/webui-debug-tools.test.ts | 39 +++++ packages/sdk/CHANGELOG.md | 1 + packages/sdk/src/internal/abort.ts | 19 ++- packages/sdk/tests/abort.test.ts | 43 ++++- packages/webui/README.md | 3 + packages/webui/src/lib/api/client.ts | 161 ++++++------------ packages/webui/src/lib/onebot-config.ts | 6 +- .../webui/tests/api-client-config.test.ts | 53 ++++++ .../webui/tests/api-client-sse-auth.test.ts | 103 ++++++++++- 13 files changed, 463 insertions(+), 247 deletions(-) create mode 100644 packages/webui/tests/api-client-config.test.ts diff --git a/packages/core/src/webui/debug-tools.ts b/packages/core/src/webui/debug-tools.ts index 5e2ce9c2..1abe50d0 100644 --- a/packages/core/src/webui/debug-tools.ts +++ b/packages/core/src/webui/debug-tools.ts @@ -20,6 +20,7 @@ import os from 'os'; import path from 'path'; import { randomBytes } from 'crypto'; import { traceWebuiMutationRequestChunk } from './mutation-trace'; +import { sseResponse } from './sse-response'; /** Temp dir for browser→server uploads. Siblings the Stream API's temp root but * kept distinct so the two cleanup stories don't entangle. */ @@ -203,70 +204,43 @@ export function buildStreamInvokeResponse( signal: AbortSignal, delay: (ms: number) => Promise = (ms) => new Promise((r) => setTimeout(r, ms)), ): Response { - const encoder = new TextEncoder(); - const stream = new ReadableStream({ - async start(controller) { - let closed = false; + return sseResponse(signal, (channel) => { + const isAlive = () => !channel.isClosed(); - const onAbort = () => { - closed = true; - }; + const emit = async (json: string): Promise => { + if (!isAlive()) { + throw new Error('stream transport closed'); + } - signal.addEventListener('abort', onAbort); - const isAlive = () => !closed && !signal.aborted; + // Backpressure WITHOUT dropping: wait for the consumer to catch up. + let spins = 0; - const emit = async (json: string): Promise => { - if (!isAlive()) { - throw new Error('stream transport closed'); - } + while (isAlive() && (channel.desiredSize() ?? 1) <= 0 && spins < DRAIN_MAX_SPINS) { + await delay(DRAIN_WAIT_MS); + spins += 1; + } - // Backpressure WITHOUT dropping: wait for the consumer to catch up. - let spins = 0; + if (!isAlive()) { + throw new Error('stream transport closed'); + } - while (isAlive() && (controller.desiredSize ?? 1) <= 0 && spins < DRAIN_MAX_SPINS) { - await delay(DRAIN_WAIT_MS); - spins += 1; - } - - if (!isAlive()) { - throw new Error('stream transport closed'); - } - - controller.enqueue(encoder.encode(`data: ${json}\n\n`)); - }; + channel.raw(channel.encode(`data: ${json}\n\n`)); + }; + const run = async () => { try { await driver(rawRequest, emit, isAlive); } catch (err) { if (isAlive()) { const msg = err instanceof Error ? err.message : 'stream error'; - try { - controller.enqueue( - encoder.encode( - `data: ${JSON.stringify({ status: 'failed', retcode: 1400, message: msg, wording: msg })}\n\n`, - ), - ); - } catch { - /* controller already torn down */ - } + channel.send({ status: 'failed', retcode: 1400, message: msg, wording: msg }); } } finally { - signal.removeEventListener('abort', onAbort); - - try { - controller.close(); - } catch { - /* already closed */ - } + channel.close(); } - }, - }); - return new Response(stream, { - headers: { - 'Content-Type': 'text/event-stream', - 'Cache-Control': 'no-cache', - Connection: 'keep-alive', - }, + }; + + void run(); }); } diff --git a/packages/core/src/webui/server.ts b/packages/core/src/webui/server.ts index af9bb657..87c70caa 100644 --- a/packages/core/src/webui/server.ts +++ b/packages/core/src/webui/server.ts @@ -753,8 +753,8 @@ export async function initWebUI( const app = new Hono(); const shutdownStreams = new AbortController(); - const sseResponse = (...args: Parameters) => - createSseResponse(args[0], args[1], shutdownStreams.signal); + const sseResponse = (c: Context, start: Parameters[1]) => + createSseResponse(c.req.raw.signal, start, shutdownStreams.signal); app.use('*', webuiSecurityHeaders); registerLoginRequestSecurity(app); const storageManagement = new StorageManagementService({ @@ -1726,7 +1726,7 @@ export async function initWebUI( return buildStreamInvokeResponse( (rq, emit, alive) => inst.invokeStream(rq, emit, alive), rawRequest, - c.req.raw.signal, + AbortSignal.any([c.req.raw.signal, shutdownStreams.signal]), ); }); diff --git a/packages/core/src/webui/sse-response.ts b/packages/core/src/webui/sse-response.ts index d4a0c5e6..e0e840cf 100644 --- a/packages/core/src/webui/sse-response.ts +++ b/packages/core/src/webui/sse-response.ts @@ -1,42 +1,25 @@ -import { type Context } from 'hono'; +import { createLogger } from '@snowluma/common/logger'; + +const log = createLogger('WebUI.SSE'); -/** - * The per-connection channel handed to an SSE endpoint's `start` callback. - * Everything the endpoint needs to talk to the client, without owning the - * transport lifecycle (heartbeat / teardown / abort / headers). - */ export interface SseChannel { - /** Enqueue a raw chunk. Tears the stream down if the peer is already gone. */ raw(chunk: Uint8Array): void; - /** Encode a string to bytes (shared TextEncoder). */ encode(s: string): Uint8Array; - /** Convenience: enqueue one `data: \n\n` frame. */ send(payload: unknown): void; - /** Register a cleanup to run once on teardown (unsubscribe / dispose). */ - onClose(fn: () => void): void; - /** True after teardown — guard sends from late subscription callbacks. */ + onClose(cleanup: () => void): void; + close(): void; isClosed(): boolean; - /** Underlying controller backpressure signal, for `createFramePusher`. */ desiredSize(): number | null; } -/** - * The SSE HTTP transport shell shared by the WebUI's live endpoints. Owns the - * TextEncoder, a `closed` guard, a 15s `: heartbeat` keep-alive, teardown - * (clear heartbeat → run registered cleanups → close the controller), safe - * enqueue (a throw means the peer dropped → teardown), the abort listener, and - * the `text/event-stream` headers. `start` wires up the endpoint-specific - * subscription + initial sends via the channel. - * - * Each of `/api/debug/stream`, `/api/state/stream`, `/api/logs/stream` - * previously hand-copied this ~40-line skeleton; a heartbeat-interval / - * teardown-order / header change had to be kept in sync across all three. - */ +/** Owns stream cancellation, subscriptions and the keep-alive timer. */ export function sseResponse( - c: Context, - start: (ch: SseChannel) => void, + request: AbortSignal, + start: (channel: SseChannel) => void, shutdown?: AbortSignal, ): Response { + const signal = shutdown ? AbortSignal.any([request, shutdown]) : request; + let cancel!: () => void; const stream = new ReadableStream({ start(controller) { const encoder = new TextEncoder(); @@ -44,67 +27,78 @@ export function sseResponse( let heartbeat: ReturnType | undefined; const cleanups: Array<() => void> = []; - const teardown = () => { + const cleanup = (fn: () => void) => { + try { + fn(); + } catch (error) { + log.warn('stream cleanup failed: %s', error); + } + }; + + const teardown = (closeStream = true) => { if (closed) { return; } closed = true; + clearInterval(heartbeat); + signal.removeEventListener('abort', onAbort); + cleanups.splice(0).forEach(cleanup); - if (heartbeat) { - clearInterval(heartbeat); - } - - for (const fn of cleanups) { - try { - fn(); - } catch { - /* ignore */ - } - } - - try { + if (closeStream) { controller.close(); - } catch { - /* ignore */ } }; + const onAbort = () => teardown(); + cancel = () => teardown(false); + signal.addEventListener('abort', onAbort, { once: true }); + + if (signal.aborted) { + teardown(); + return; + } + const raw = (chunk: Uint8Array) => { - if (closed) { - return; - } - - try { + if (!closed) { controller.enqueue(chunk); - } catch { - teardown(); } }; - const ch: SseChannel = { + const channel: SseChannel = { raw, - encode: (s) => encoder.encode(s), - send: (payload) => raw(encoder.encode(`data: ${JSON.stringify(payload)}\n\n`)), - onClose: (fn) => { - cleanups.push(fn); + encode: (text) => encoder.encode(text), + send: (payload) => { + if (!closed) { + raw(encoder.encode(`data: ${JSON.stringify(payload)}\n\n`)); + } }, + onClose: (fn) => { + if (closed) { + cleanup(fn); + } else { + cleanups.push(fn); + } + }, + close: () => teardown(), isClosed: () => closed, desiredSize: () => controller.desiredSize, }; - start(ch); - heartbeat = setInterval(() => raw(encoder.encode(': heartbeat\n\n')), 15000); - c.req.raw.signal.addEventListener('abort', teardown); - shutdown?.addEventListener('abort', teardown, { once: true }); - cleanups.push(() => { - c.req.raw.signal.removeEventListener('abort', teardown); - shutdown?.removeEventListener('abort', teardown); - }); - if (shutdown?.aborted) { + try { + start(channel); + + if (!closed) { + heartbeat = setInterval(() => raw(encoder.encode(': heartbeat\n\n')), 15000); + } + } catch (error) { teardown(); + throw error; } }, + cancel() { + cancel(); + }, }); return new Response(stream, { headers: { diff --git a/packages/core/tests/sse-response.test.ts b/packages/core/tests/sse-response.test.ts index c6e97074..0c452fdf 100644 --- a/packages/core/tests/sse-response.test.ts +++ b/packages/core/tests/sse-response.test.ts @@ -1,18 +1,75 @@ -import { describe, it, expect, vi } from 'vitest'; +import { afterEach, describe, it, expect, vi } from 'vitest'; import { sseResponse } from '../src/webui/sse-response'; -// A minimal hono-Context stand-in: sseResponse only reads c.req.raw.signal. -function fakeCtx(signal: AbortSignal): Parameters[0] { - return { req: { raw: { signal } } } as unknown as Parameters[0]; -} - describe('sseResponse', () => { + afterEach(() => { + vi.clearAllTimers(); + vi.useRealTimers(); + }); + + it('releases subscriptions immediately when the response body is canceled', async () => { + vi.useFakeTimers(); + const request = new AbortController(); + const cleanup = vi.fn(); + let channel!: Parameters[1]>[0]; + const response = sseResponse(request.signal, (ch) => { + channel = ch; + ch.onClose(cleanup); + }); + + await response.body!.cancel(); + expect(channel.isClosed()).toBe(true); + expect(cleanup).toHaveBeenCalledOnce(); + expect(vi.getTimerCount()).toBe(0); + request.abort(); + expect(cleanup).toHaveBeenCalledOnce(); + }); + + it('does not subscribe when the request was already aborted', () => { + vi.useFakeTimers(); + const request = new AbortController(); + request.abort(); + const start = vi.fn(); + sseResponse(request.signal, start); + expect(start).not.toHaveBeenCalled(); + expect(vi.getTimerCount()).toBe(0); + }); + + it('releases subscriptions registered before and after an abort during setup', () => { + vi.useFakeTimers(); + const request = new AbortController(); + const before = vi.fn(); + const after = vi.fn(); + sseResponse(request.signal, (channel) => { + channel.onClose(before); + request.abort(); + channel.onClose(after); + }); + expect(before).toHaveBeenCalledOnce(); + expect(after).toHaveBeenCalledOnce(); + expect(vi.getTimerCount()).toBe(0); + }); + + it('releases subscriptions when endpoint setup throws', () => { + vi.useFakeTimers(); + const request = new AbortController(); + const cleanup = vi.fn(); + expect(() => + sseResponse(request.signal, (channel) => { + channel.onClose(cleanup); + throw new Error('setup failed'); + }), + ).toThrow('setup failed'); + expect(cleanup).toHaveBeenCalledOnce(); + expect(vi.getTimerCount()).toBe(0); + }); + it('finishes active streams and releases subscriptions during server shutdown', async () => { const request = new AbortController(); const shutdown = new AbortController(); let cleanups = 0; const response = sseResponse( - fakeCtx(request.signal), + request.signal, (channel) => { channel.onClose(() => { cleanups++; @@ -26,9 +83,10 @@ describe('sseResponse', () => { request.abort(); expect(cleanups).toBe(1); }); + it('returns an event-stream Response with the SSE headers', () => { const ac = new AbortController(); - const res = sseResponse(fakeCtx(ac.signal), () => { + const res = sseResponse(ac.signal, () => { /* no-op */ }); expect(res.headers.get('Content-Type')).toBe('text/event-stream'); @@ -39,7 +97,7 @@ describe('sseResponse', () => { it('ch.send frames JSON as `data: …` and ch.raw enqueues verbatim', async () => { const ac = new AbortController(); - const res = sseResponse(fakeCtx(ac.signal), (ch) => { + const res = sseResponse(ac.signal, (ch) => { ch.send({ type: 'ready' }); ch.raw(ch.encode(': heartbeat\n\n')); }); @@ -56,7 +114,7 @@ describe('sseResponse', () => { const cleanupA = vi.fn(); const cleanupB = vi.fn(); let channel!: Parameters[1]>[0]; - const res = sseResponse(fakeCtx(ac.signal), (ch) => { + const res = sseResponse(ac.signal, (ch) => { channel = ch; ch.onClose(cleanupA); ch.onClose(cleanupB); @@ -75,7 +133,7 @@ describe('sseResponse', () => { it('send after teardown is a silent no-op', () => { const ac = new AbortController(); let channel!: Parameters[1]>[0]; - sseResponse(fakeCtx(ac.signal), (ch) => { + sseResponse(ac.signal, (ch) => { channel = ch; }); ac.abort(); diff --git a/packages/core/tests/webui-debug-tools.test.ts b/packages/core/tests/webui-debug-tools.test.ts index ba3076fe..768c912b 100644 --- a/packages/core/tests/webui-debug-tools.test.ts +++ b/packages/core/tests/webui-debug-tools.test.ts @@ -114,6 +114,45 @@ describe('streamUploadToDisk', () => { describe('buildStreamInvokeResponse', () => { const noDelay = async () => {}; + it('cancels delivery while the action is still pending', async () => { + let finish!: () => void; + const pending = new Promise((resolve) => { + finish = resolve; + }); + let isAlive!: () => boolean; + const response = buildStreamInvokeResponse( + async (_request, _emit, alive) => { + isAlive = alive; + await pending; + }, + '{}', + new AbortController().signal, + ); + const canceled = response.body!.cancel(); + + try { + expect(isAlive()).toBe(false); + } finally { + finish(); + await canceled; + } + }); + + it('does not invoke an action for an already aborted request', async () => { + const controller = new AbortController(); + controller.abort(); + let invoked = false; + const response = buildStreamInvokeResponse( + async () => { + invoked = true; + }, + '{}', + controller.signal, + ); + await readSse(response); + expect(invoked).toBe(false); + }); + it('relays each emitted frame as one SSE event, in order', async () => { const ac = new AbortController(); diff --git a/packages/sdk/CHANGELOG.md b/packages/sdk/CHANGELOG.md index 727cfac7..7cd0d227 100644 --- a/packages/sdk/CHANGELOG.md +++ b/packages/sdk/CHANGELOG.md @@ -2,6 +2,7 @@ ## Unreleased +- Release cancellation listeners as soon as a request stops waiting for a connection. - Isolate WebSocket connection lifetimes and release request timers and abort listeners on every outcome. - Reject duplicate in-flight WebSocket echoes instead of overwriting the original request. - Add `getGroupShareLink()` and typed `get_group_share_link` support for group invitation links. diff --git a/packages/sdk/src/internal/abort.ts b/packages/sdk/src/internal/abort.ts index 146a7e5e..6f6519bb 100644 --- a/packages/sdk/src/internal/abort.ts +++ b/packages/sdk/src/internal/abort.ts @@ -82,16 +82,19 @@ export function raceWithAbort( return promise; } - throwIfAborted(signal, message); - - return new Promise((resolve, reject) => { - const onAbort = (): void => { + let onAbort!: () => void; + const aborted = new Promise((_resolve, reject) => { + onAbort = () => { reject(new SnowLumaAbortError(message, { cause: signal.reason })); }; - signal.addEventListener('abort', onAbort, { once: true }); - promise.then(resolve, reject).finally(() => { - signal.removeEventListener('abort', onAbort); - }); + if (signal.aborted) { + onAbort(); + } else { + signal.addEventListener('abort', onAbort, { once: true }); + } + }); + return Promise.race([aborted, promise]).finally(() => { + signal.removeEventListener('abort', onAbort); }); } diff --git a/packages/sdk/tests/abort.test.ts b/packages/sdk/tests/abort.test.ts index 9c26ba56..6dfcb621 100644 --- a/packages/sdk/tests/abort.test.ts +++ b/packages/sdk/tests/abort.test.ts @@ -1,9 +1,50 @@ import { afterEach, describe, expect, it, vi } from 'vitest'; -import { createRequestAbortState } from '../src/internal/abort'; +import { createRequestAbortState, raceWithAbort } from '../src/internal/abort'; afterEach(() => vi.useRealTimers()); describe('request cancellation', () => { + it('honors an existing cancellation before a completed operation', async () => { + const controller = new AbortController(); + controller.abort('already canceled'); + await expect( + raceWithAbort(Promise.resolve('done'), controller.signal), + ).rejects.toMatchObject({ + cause: 'already canceled', + }); + }); + + it('releases its listener when cancellation wins against a pending operation', async () => { + const operation = Promise.withResolvers(); + const controller = new AbortController(); + const remove = vi.spyOn(controller.signal, 'removeEventListener'); + const result = raceWithAbort(operation.promise, controller.signal); + controller.abort('canceled'); + await expect(result).rejects.toMatchObject({ cause: 'canceled' }); + expect(remove).toHaveBeenCalledWith('abort', expect.any(Function)); + operation.resolve(); + }); + + it.each(['resolve', 'reject'] as const)( + 'releases its listener when the operation will %s', + async (outcome) => { + const operation = Promise.withResolvers(); + const controller = new AbortController(); + const remove = vi.spyOn(controller.signal, 'removeEventListener'); + const result = raceWithAbort(operation.promise, controller.signal); + + if (outcome === 'resolve') { + operation.resolve('done'); + await expect(result).resolves.toBe('done'); + } else { + operation.reject(new Error('failed')); + await expect(result).rejects.toThrow('failed'); + } + + expect(remove).toHaveBeenCalledWith('abort', expect.any(Function)); + }, + ); + it('keeps caller cancellation as the cause when the timeout expires later', () => { vi.useFakeTimers(); const caller = new AbortController(); diff --git a/packages/webui/README.md b/packages/webui/README.md index 877bc006..ad75b649 100644 --- a/packages/webui/README.md +++ b/packages/webui/README.md @@ -22,6 +22,9 @@ status, OneBot configuration, logs, storage, and server settings. result; do not convert failed responses into successful feedback. - JSON endpoints must return an object. Malformed or non-object responses are reported as errors rather than displayed as empty lists or default settings. +- Configuration responses include `config`; saves also report `saved`, `applied`, + `online`, `errors`, and `message`. The UI uses these fields without legacy aliases + or a second request after saving. - Password change flows use floating labels and inline validation consistently. - Password strength details appear only while the new-password field has focus and leave with the same motion language when focus moves away. diff --git a/packages/webui/src/lib/api/client.ts b/packages/webui/src/lib/api/client.ts index da1910a1..090cad3b 100644 --- a/packages/webui/src/lib/api/client.ts +++ b/packages/webui/src/lib/api/client.ts @@ -32,6 +32,7 @@ import { ApiError, type ApiClient, type ChangePasswordResult, + type ConfigSaveResult, type CreateApiClientOptions, type LoginResult, type LogsStreamOptions, @@ -128,61 +129,13 @@ class HttpApiClient implements ApiClient { this.config = { get: async (uin) => { const url = `/api/config/${encodeURIComponent(uin)}`; - const data = await this.getJson<{ config?: unknown } | unknown>(url); - const raw = - typeof data === 'object' && - data != null && - 'config' in (data as Record) - ? (data as { config: unknown }).config - : data; - return normalizeOneBotConfig(raw); + const data = await this.getJson<{ config: unknown }>(url); + return normalizeOneBotConfig(data.config); }, save: async (uin, config) => { const url = `/api/config/${encodeURIComponent(uin)}`; - const result = await this.fetchJson<{ - success?: boolean; - saved?: boolean; - applied?: boolean; - online?: boolean; - reloaded?: boolean; - errors?: Array<{ - name: string; - kind?: 'httpServer' | 'httpClient' | 'wsServer' | 'wsClient'; - phase: string; - message: string; - at: number; - restored?: boolean; - }>; - config?: unknown; - message?: string; - }>(url, { - method: 'POST', - body: JSON.stringify(config), - }); - // Refetch the canonical persisted view after the save. Runtime apply - // is a separate fact and is preserved alongside that config. - let canonical = - result.config === undefined ? null : normalizeOneBotConfig(result.config); - - if (canonical === null) { - try { - canonical = await this.config.get(uin); - } catch (error) { - // Legacy servers omit `config`. Their POST still confirmed the - // save, so a follow-up GET failure must not become "保存失败". - console.warn('config saved but canonical refetch failed', error); - canonical = config; - } - } - - return { - config: canonical, - saved: result.saved ?? result.success === true, - applied: result.applied ?? result.reloaded === true, - online: result.online ?? result.reloaded === true, - errors: Array.isArray(result.errors) ? result.errors : [], - message: result.message ?? '配置保存成功', - }; + const result = await this.postJson(url, config); + return { ...result, config: normalizeOneBotConfig(result.config) }; }, }; @@ -747,14 +700,7 @@ class HttpApiClient implements ApiClient { // ---------- SSE ---------- - /** - * Open a token-authed SSE channel to `path`, dispatching each parsed frame to - * `onMessage` and surfacing transport state ('open' / 'reconnecting' / - * 'closed') via `onStatus`. The fetch stream reconnects after transport loss - * so it retains EventSource's user-visible behaviour while keeping the token - * in the WebUI session header. A malformed frame (or a throw from - * `onMessage`) is skipped. The returned disposer aborts the active request. - */ + /** Fetch-based SSE keeps the session token in a header and reconnects after transport loss. */ private openSseChannel( path: string, onMessage: (data: T) => void, @@ -770,28 +716,47 @@ class HttpApiClient implements ApiClient { let active: AbortController | null = null; let reconnectTimer: ReturnType | null = null; + const clearReconnect = () => { + if (reconnectTimer !== null) { + clearTimeout(reconnectTimer); + reconnectTimer = null; + } + }; + + const disconnect = () => { + clearReconnect(); + active?.abort(); + active = null; + }; + const scheduleReconnect = () => { if (disposed || reconnectTimer !== null) { return; } - onStatus?.('reconnecting'); reconnectTimer = setTimeout(() => { reconnectTimer = null; void connect(); }, 1_000); + onStatus?.('reconnecting'); }; const connect = async () => { + if (disposed || active) { + return; + } + const token = this.currentToken; - if (disposed || !token) { - onStatus?.('closed'); + if (!token) { + dispose(); return; } const controller = new AbortController(); active = controller; + const isCurrent = () => + !disposed && active === controller && !controller.signal.aborted; try { const response = await fetch(path, { @@ -803,12 +768,15 @@ class HttpApiClient implements ApiClient { signal: controller.signal, }); + if (!isCurrent()) { + await response.body?.cancel(); + return; + } + if (response.status === 401) { - disposed = true; - active = null; + dispose(); this.setToken(null); this.onUnauthorized?.(); - onStatus?.('closed'); return; } @@ -822,9 +790,13 @@ class HttpApiClient implements ApiClient { let buffer = ''; try { - while (!disposed) { + while (isCurrent()) { const { done, value } = await reader.read(); + if (!isCurrent()) { + break; + } + if (done) { buffer += decoder.decode(); break; @@ -836,7 +808,7 @@ class HttpApiClient implements ApiClient { throw new Error('SSE frame buffer exceeded 1 MiB'); } - for (;;) { + while (isCurrent()) { const lf = buffer.indexOf('\n\n'); const crlf = buffer.indexOf('\r\n\r\n'); let separator = -1; @@ -880,18 +852,14 @@ class HttpApiClient implements ApiClient { /* already closed */ } - try { - reader.releaseLock(); - } catch { - /* already released */ - } + reader.releaseLock(); } - if (!disposed) { + if (isCurrent()) { scheduleReconnect(); } } catch { - if (!disposed && !controller.signal.aborted) { + if (isCurrent()) { scheduleReconnect(); } } finally { @@ -901,28 +869,18 @@ class HttpApiClient implements ApiClient { } }; - const onPageHide = () => { - active?.abort(); - }; + const onPageHide = disconnect; const onPageShow = (event: PageTransitionEvent) => { if (event.persisted && !disposed) { - if (reconnectTimer !== null) { - clearTimeout(reconnectTimer); - reconnectTimer = null; - } - + clearReconnect(); void connect(); } }; const onVisible = () => { if (document.visibilityState === 'visible' && !disposed && !active) { - if (reconnectTimer !== null) { - clearTimeout(reconnectTimer); - reconnectTimer = null; - } - + clearReconnect(); void connect(); } }; @@ -936,9 +894,7 @@ class HttpApiClient implements ApiClient { document.addEventListener('freeze', onPageHide); } - void connect(); - - return () => { + const dispose = () => { if (disposed) { return; } @@ -952,15 +908,12 @@ class HttpApiClient implements ApiClient { document.removeEventListener('freeze', onPageHide); } - if (reconnectTimer !== null) { - clearTimeout(reconnectTimer); - } - - reconnectTimer = null; - active?.abort(); - active = null; + disconnect(); onStatus?.('closed'); }; + + void connect(); + return dispose; } private openLogStream(options: LogsStreamOptions): () => void { @@ -985,12 +938,7 @@ class HttpApiClient implements ApiClient { }; } - /** Open the single shared /api/logs/stream connection; every frame and status - * change fans out to all subscribers, each isolated so one throwing handler - * can't drop the frame for the others (and a subscriber unsubscribed mid-frame - * is skipped). A no-token attempt does NOT cache a dead disposer — it reports - * 'closed' and returns so a later subscribe / setToken can open for real, - * avoiding poisoning the shared cache. */ + /** Isolate subscribers and leave unauthenticated attempts free to reconnect after login. */ private openSharedLogStream(): void { if (!this.currentToken) { this.lastLogStatus = 'closed'; @@ -1042,10 +990,7 @@ class HttpApiClient implements ApiClient { ); } - /** Token changed (login / re-login / logout): the shared stream baked the old - * token into its URL, so tear it down and reopen with the new one if anyone is - * still listening. Without this a re-login would leave the feed retrying a - * stale-token URL forever. */ + /** A new request must pick up the changed session token. */ private reopenSharedLogStream(): void { if (this.logStreamDispose) { this.logStreamDispose(); diff --git a/packages/webui/src/lib/onebot-config.ts b/packages/webui/src/lib/onebot-config.ts index 5bb8ce2c..af28a5ab 100644 --- a/packages/webui/src/lib/onebot-config.ts +++ b/packages/webui/src/lib/onebot-config.ts @@ -45,7 +45,11 @@ function normalizeNotifications(raw: unknown): { channelIds: string[] } { * into the canonical {@link OneBotConfig} the editor expects. */ export function normalizeOneBotConfig(raw: unknown): OneBotConfig { - const cfg = (raw ?? {}) as Record; + if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) { + throw new Error('服务端返回了无效的配置'); + } + + const cfg = raw as Record; const nets = (cfg.networks as Record | undefined) ?? {}; const legacyFormat: MessageFormat = cfg.messageFormat === 'string' ? 'string' : 'array'; const legacyReport = !!cfg.reportSelfMessage; diff --git a/packages/webui/tests/api-client-config.test.ts b/packages/webui/tests/api-client-config.test.ts new file mode 100644 index 00000000..aab59c57 --- /dev/null +++ b/packages/webui/tests/api-client-config.test.ts @@ -0,0 +1,53 @@ +import { afterEach, describe, expect, it, vi } from 'vitest'; +import { createApiClient } from '../src/lib/api/client'; +import { normalizeOneBotConfig } from '../src/lib/onebot-config'; + +afterEach(() => vi.unstubAllGlobals()); + +describe('API client configuration', () => { + const config = normalizeOneBotConfig({}); + const tokenStore = { load: () => 'token', save: vi.fn() }; + + it('keeps persisted configuration separate from failed runtime application', async () => { + const result = { + config, + saved: true, + applied: false, + online: true, + errors: [{ name: 'http', phase: 'start', message: 'port in use', at: 1 }], + message: '配置已保存,应用失败', + }; + const fetchMock = vi.fn().mockResolvedValue(Response.json(result)); + vi.stubGlobal('fetch', fetchMock); + const client = createApiClient({ tokenStore }); + + await expect(client.config.save('12345', config)).resolves.toEqual(result); + expect(fetchMock).toHaveBeenCalledOnce(); + }); + + it('rejects a save response without configuration instead of refetching or returning the form', async () => { + const fetchMock = vi + .fn() + .mockResolvedValueOnce(Response.json({ success: true, reloaded: true })) + .mockRejectedValue(new Error('refetch failed')); + vi.stubGlobal('fetch', fetchMock); + const client = createApiClient({ tokenStore }); + + await expect(client.config.save('12345', config)).rejects.toThrow('无效的配置'); + expect(fetchMock).toHaveBeenCalledOnce(); + }); + + it('reads the configuration from the server envelope', async () => { + vi.stubGlobal('fetch', vi.fn().mockResolvedValue(Response.json({ config }))); + const client = createApiClient({ tokenStore }); + + await expect(client.config.get('12345')).resolves.toEqual(config); + }); + + it('rejects a response without the configuration envelope', async () => { + vi.stubGlobal('fetch', vi.fn().mockResolvedValue(Response.json(config))); + const client = createApiClient({ tokenStore }); + + await expect(client.config.get('12345')).rejects.toThrow('无效的配置'); + }); +}); diff --git a/packages/webui/tests/api-client-sse-auth.test.ts b/packages/webui/tests/api-client-sse-auth.test.ts index 78435db3..f98f42f7 100644 --- a/packages/webui/tests/api-client-sse-auth.test.ts +++ b/packages/webui/tests/api-client-sse-auth.test.ts @@ -3,8 +3,10 @@ import { createApiClient } from '../src/lib/api/client'; const encoder = new TextEncoder(); -describe('API client SSE authentication', () => { +describe('API client SSE lifecycle', () => { afterEach(() => { + vi.clearAllTimers(); + vi.useRealTimers(); vi.unstubAllGlobals(); }); @@ -47,6 +49,12 @@ describe('API client SSE authentication', () => { }); it('clears the session and stops reconnecting after an unauthorized response', async () => { + const page = new EventTarget(); + const document = new EventTarget(); + const removePageListener = vi.spyOn(page, 'removeEventListener'); + const removeDocumentListener = vi.spyOn(document, 'removeEventListener'); + vi.stubGlobal('window', page); + vi.stubGlobal('document', document); const save = vi.fn(); const onUnauthorized = vi.fn(); const fetchMock = vi.fn().mockResolvedValue(new Response(null, { status: 401 })); @@ -63,6 +71,99 @@ describe('API client SSE authentication', () => { expect(save).toHaveBeenCalledWith(null); expect(statuses.at(-1)).toBe('closed'); expect(fetchMock).toHaveBeenCalledTimes(1); + expect(removePageListener).toHaveBeenCalledWith('pagehide', expect.any(Function)); + expect(removePageListener).toHaveBeenCalledWith('pageshow', expect.any(Function)); + expect(removeDocumentListener).toHaveBeenCalledWith( + 'visibilitychange', + expect.any(Function), + ); + expect(removeDocumentListener).toHaveBeenCalledWith('freeze', expect.any(Function)); + }); + + it('stops delivering the current frame batch after disposal', async () => { + vi.stubGlobal( + 'fetch', + vi + .fn() + .mockResolvedValue( + new Response( + 'data: {"kind":"ready"}\n\ndata: {"kind":"invalidate","resource":"qq-list"}\n\n', + ), + ), + ); + const client = createApiClient({ tokenStore: { load: () => 'token', save: vi.fn() } }); + const onEvent = vi.fn(() => dispose()); + const dispose = client.stateStream({ onEvent }); + await vi.waitFor(() => expect(onEvent).toHaveBeenCalled()); + expect(onEvent).toHaveBeenCalledOnce(); + }); + + it('ignores a delayed unauthorized response from a disposed connection', async () => { + vi.useFakeTimers(); + const response = Promise.withResolvers(); + vi.stubGlobal( + 'fetch', + vi.fn(() => response.promise), + ); + const save = vi.fn(); + const onUnauthorized = vi.fn(); + const client = createApiClient({ + tokenStore: { load: () => 'token', save }, + onUnauthorized, + }); + const dispose = client.stateStream({ onEvent: vi.fn() }); + dispose(); + response.resolve(new Response(null, { status: 401 })); + await vi.advanceTimersByTimeAsync(0); + expect(onUnauthorized).not.toHaveBeenCalled(); + expect(save).not.toHaveBeenCalled(); + }); + + it('clears the reconnect timer when disposed by the status callback', async () => { + vi.useFakeTimers(); + vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(''))); + const client = createApiClient({ tokenStore: { load: () => 'token', save: vi.fn() } }); + const dispose = client.stateStream({ + onEvent: vi.fn(), + onStatus: (status) => { + if (status === 'reconnecting') { + dispose(); + } + }, + }); + await vi.advanceTimersByTimeAsync(0); + expect(vi.getTimerCount()).toBe(0); + }); + + it('suspends reconnects until the page returns and keeps one active request', async () => { + vi.useFakeTimers(); + const page = new EventTarget(); + vi.stubGlobal('window', page); + vi.stubGlobal('document', Object.assign(new EventTarget(), { visibilityState: 'visible' })); + const fetchMock = vi + .fn() + .mockResolvedValueOnce(new Response('')) + .mockImplementation( + (_url: string, init: RequestInit) => + new Promise((_resolve, reject) => { + init.signal!.addEventListener('abort', () => reject(init.signal!.reason), { + once: true, + }); + }), + ); + vi.stubGlobal('fetch', fetchMock); + const client = createApiClient({ tokenStore: { load: () => 'token', save: vi.fn() } }); + const onStatus = vi.fn(); + const dispose = client.stateStream({ onEvent: vi.fn(), onStatus }); + await vi.advanceTimersByTimeAsync(0); + expect(onStatus).toHaveBeenCalledWith('reconnecting'); + page.dispatchEvent(new Event('pagehide')); + await vi.advanceTimersByTimeAsync(1000); + expect(fetchMock).toHaveBeenCalledOnce(); + page.dispatchEvent(Object.assign(new Event('pageshow'), { persisted: true })); + page.dispatchEvent(Object.assign(new Event('pageshow'), { persisted: true })); + expect(fetchMock).toHaveBeenCalledTimes(2); + dispose(); }); it('reconnects after a completed stream without leaking the token', async () => {