Phase 3 of the 4-package split (RoadMap #3). Moves the entire `packages/core/src/onebot/` subtree (43 source files + 20 test files spanning network adapters, action handlers, event converters, message parser, message store, media store, instance + manager) into the new `@snowluma/onebot` workspace package. The remaining `@snowluma/core` now hosts only the api-layer (Bridge class + 13 Api classes), the hook tooling, the WebUI server, and the runnable `index.ts`. Why --- - The OneBot adapter is the public-facing OneBot11 protocol surface; it has its own version cadence and its own consumers (third-party bots talking OneBot WS / HTTP). Splitting it lets that cadence move independently of the Api-on-ctx layer. - The two were sharing the `packages/core/` build pipeline only because they happened to live in the same directory. Nothing in the api-layer reaches into OneBot internals. - Mirrors NapCat / Lagrange.OneBot's repo split (their OneBot adapter is a separate assembly from the Core protocol library). Layout ------ Moved via `git mv` (history preserved): packages/core/src/onebot/* → @snowluma/onebot/src/<x> packages/core/tests/onebot/* (6 files) → @snowluma/onebot/tests/ packages/core/tests/{message-parser,message-store,event-pipeline, media-store,media-url-resolver,event-converter, http-server-hot-reload,http-server-content-type, api-handler-logging,message-id,group-msg-emoji-like, config,media-indexer,network-manager}.test.ts (14 files) → @snowluma/onebot/tests/ What stays in @snowluma/core ---------------------------- - `bridge/{bridge,bridge-interface,bridge-context,manager}.ts` - `bridge/apis/*` (the 13 typed Api classes) - `hook/*` (debugger/injector — tooling for the core protocol layer) - `webui/*` (admin UI server — application wiring, not the OneBot adapter itself) - `index.ts` (application entry that wires BridgeManager + OneBotManager + HookManager + WebUI together) Changes ------- - New package `packages/onebot/` (package.json with subpath exports mirroring legacy `core/src/onebot/<x>` 1:1, tsconfig.json, vitest.config.ts with `SNOWLUMA_LOG_LEVEL=debug` env so the action- dispatch logging tests see debug-level subscribers — copied verbatim from core's vitest.config.ts). - @snowluma/core grows new subpath exports for the api-layer files OneBot's type-only imports need: `./bridge`, `./bridge-interface`, `./bridge-context`, `./manager`, `./apis`. - `@snowluma/onebot` depends on `@snowluma/bridge`, `@snowluma/common`, `@snowluma/core`, `@snowluma/proto-defs`, `@snowluma/proton`, `@snowluma/websocket`. - `@snowluma/core` depends on `@snowluma/onebot` (for index.ts + webui/server.ts wiring). - 100+ import sites rewritten via sed: * OneBot → core: `'../bridge/bridge'` → `'@snowluma/core/bridge'`, `'../bridge/manager'` → `'@snowluma/core/manager'`, `'../bridge/bridge-interface'` → `'@snowluma/core/bridge-interface'`, `'@/bridge/bridge'` (vite path alias) → `'@snowluma/core/bridge'`. * Core → OneBot: `'./onebot/manager'` → `'@snowluma/onebot/manager'`, `'../onebot/config'` → `'@snowluma/onebot/config'`, etc. * Test relative paths: `'../../src/onebot/<x>'` → `'../src/<x>'` after the test file move (one level shallower). - New `packages/onebot/src/env.d.ts` declaring `__APP_VERSION__` and `__BUILD_WEBUI__` (the vite-injected globals `info.ts` reads). Workspace cycle --------------- core ↔ onebot is allowed by pnpm workspaces. The runtime direction is one-way: core → onebot (index.ts constructs OneBotManager, webui/server reads OneBot config). OneBot only reaches into core for TYPES (Bridge, BridgeInterface, BridgeManager, ClientKeyInfo, DownloadRKeyInfo); those imports use `import type` so they compile out at runtime and don't introduce a real cycle. Verification ------------ - Full workspace `pnpm -r typecheck`: all 11 projects clean. - `@snowluma/core` test suite: 302/302 pass (33 test files). - `@snowluma/onebot` test suite: 250/250 pass (20 test files; pre-existing `network-manager.test.ts` native-addon failure unchanged — same baseline as before the split). - Combined: 552/552 — identical pass count to the pre-Phase-3 baseline. - Vite build with stubbed native binary: clean, 2.84 MB bundle / 224 KB gzip (identical envelope).
142 lines
5.6 KiB
TypeScript
142 lines
5.6 KiB
TypeScript
// Hot-reload tests for HttpServerAdapter — pins the contract that
|
|
// `reload({ accessToken: <new> })` must take effect on the very next
|
|
// request without the listener being torn down. Earlier the adapter
|
|
// captured `accessToken` into a `startServer()` closure and relied on
|
|
// `bindingSignature` to trigger a `close()` + `open()` round-trip on
|
|
// token change; that race-prone path is gone and `handleRequest` now
|
|
// reads `this.config.accessToken` per request.
|
|
|
|
import { describe, expect, it, vi, afterEach } from 'vitest';
|
|
import http from 'http';
|
|
import type { AddressInfo } from 'net';
|
|
import { HttpServerAdapter } from '../src/network/http-server-adapter';
|
|
import { NetworkReloadType, type NetworkAdapterContext } from '../src/network/adapter';
|
|
import type { HttpServerNetwork } from '../src/types';
|
|
|
|
function fakeCtx(): NetworkAdapterContext {
|
|
return {
|
|
uin: '10001',
|
|
api: {
|
|
handle: vi.fn(async () => ({ status: 'ok', retcode: 0, data: { online: true } })),
|
|
} as any,
|
|
buildLifecycleEvent: vi.fn(() => ({})),
|
|
buildHeartbeatEvent: vi.fn(() => ({})),
|
|
};
|
|
}
|
|
|
|
function get(port: number, path: string, headers: Record<string, string> = {}): Promise<{ status: number }> {
|
|
return new Promise((resolve, reject) => {
|
|
const req = http.request(
|
|
{ hostname: '127.0.0.1', port, path, method: 'GET', headers },
|
|
(res) => {
|
|
res.on('data', () => { /* drain */ });
|
|
res.on('end', () => resolve({ status: res.statusCode! }));
|
|
},
|
|
);
|
|
req.on('error', reject);
|
|
req.end();
|
|
});
|
|
}
|
|
|
|
// Wait until the underlying http.Server has bound its port; tests that
|
|
// hit the socket too early get ECONNREFUSED on slow CI hosts.
|
|
async function waitForListen(adapter: HttpServerAdapter): Promise<number> {
|
|
for (let i = 0; i < 50; i++) {
|
|
const server = (adapter as any).server as http.Server | null;
|
|
const addr = server?.address() as AddressInfo | null | undefined;
|
|
if (addr && typeof addr === 'object') return addr.port;
|
|
await new Promise((r) => setTimeout(r, 20));
|
|
}
|
|
throw new Error('http server never started listening');
|
|
}
|
|
|
|
describe('HttpServerAdapter — accessToken hot reload', () => {
|
|
let adapter: HttpServerAdapter | null = null;
|
|
|
|
afterEach(() => {
|
|
adapter?.close();
|
|
adapter = null;
|
|
});
|
|
|
|
it('a swapped accessToken authorizes the new token on the next request — no listener re-bind', async () => {
|
|
const ctx = fakeCtx();
|
|
// port=0 → OS-assigned; the swap proves no re-bind happens because
|
|
// a re-bind would land on a different port and `waitForListen`
|
|
// would diverge from the original.
|
|
const config: HttpServerNetwork = {
|
|
name: 'hot', port: 0, enabled: true, accessToken: 'tok-1',
|
|
messageFormat: 'array', reportSelfMessage: false,
|
|
};
|
|
adapter = new HttpServerAdapter('hot', config, ctx);
|
|
adapter.open();
|
|
const portBefore = await waitForListen(adapter);
|
|
|
|
// Sanity: old token authorizes, anything else 401s.
|
|
expect((await get(portBefore, '/', { authorization: 'Bearer tok-1' })).status).toBe(200);
|
|
expect((await get(portBefore, '/', { authorization: 'Bearer tok-2' })).status).toBe(401);
|
|
|
|
// Hot-swap the token.
|
|
await adapter.reload({ ...config, accessToken: 'tok-2' });
|
|
|
|
// Same port (no re-bind) — and the new token must take effect on
|
|
// the very next request.
|
|
const portAfter = ((adapter as any).server as http.Server).address() as AddressInfo;
|
|
expect(portAfter.port).toBe(portBefore);
|
|
|
|
expect((await get(portBefore, '/', { authorization: 'Bearer tok-1' })).status).toBe(401);
|
|
expect((await get(portBefore, '/', { authorization: 'Bearer tok-2' })).status).toBe(200);
|
|
});
|
|
|
|
it('clearing accessToken to empty disables auth on the next request', async () => {
|
|
const ctx = fakeCtx();
|
|
const config: HttpServerNetwork = {
|
|
name: 'hot-clear', port: 0, enabled: true, accessToken: 'tok-1',
|
|
messageFormat: 'array', reportSelfMessage: false,
|
|
};
|
|
adapter = new HttpServerAdapter('hot-clear', config, ctx);
|
|
adapter.open();
|
|
const port = await waitForListen(adapter);
|
|
|
|
expect((await get(port, '/')).status).toBe(401); // no token header → 401
|
|
|
|
await adapter.reload({ ...config, accessToken: '' });
|
|
|
|
expect((await get(port, '/')).status).toBe(200); // auth disabled
|
|
});
|
|
|
|
it('setting accessToken from empty enforces auth on the next request', async () => {
|
|
const ctx = fakeCtx();
|
|
const config: HttpServerNetwork = {
|
|
name: 'hot-add', port: 0, enabled: true,
|
|
messageFormat: 'array', reportSelfMessage: false,
|
|
};
|
|
adapter = new HttpServerAdapter('hot-add', config, ctx);
|
|
adapter.open();
|
|
const port = await waitForListen(adapter);
|
|
|
|
expect((await get(port, '/')).status).toBe(200); // no auth configured
|
|
|
|
await adapter.reload({ ...config, accessToken: 'tok-new' });
|
|
|
|
expect((await get(port, '/')).status).toBe(401); // auth now required
|
|
expect((await get(port, '/', { authorization: 'Bearer tok-new' })).status).toBe(200);
|
|
});
|
|
|
|
it('changing only accessToken returns NetworkReloadType.Normal — no Reopened/Closed', async () => {
|
|
const ctx = fakeCtx();
|
|
const config: HttpServerNetwork = {
|
|
name: 'hot-type', port: 0, enabled: true, accessToken: 'a',
|
|
messageFormat: 'array', reportSelfMessage: false,
|
|
};
|
|
adapter = new HttpServerAdapter('hot-type', config, ctx);
|
|
adapter.open();
|
|
await waitForListen(adapter);
|
|
|
|
const reloadType = await adapter.reload({ ...config, accessToken: 'b' });
|
|
// Without re-binding, the adapter reports `Normal` — anything but
|
|
// `Reopened` / `Closed` is acceptable; we mostly care that nothing
|
|
// touched the listener.
|
|
expect(reloadType).toBe(NetworkReloadType.Normal);
|
|
});
|
|
});
|