@jingyi0605/codingns4dsh 0.1.2 → 0.1.7-rc.2

package/data/build/dist/host/modules/peer-host/peer-host-handshake.js

@@ -0,0 +1,133 @@
+import { PEER_HOST_ERROR_CODES } from '../../../shared/contracts/peer-host.js';
+import { PeerHostStore, } from './peer-host-store.js';
+export const PEER_HOST_HANDSHAKE_PATH = '/api/public/host-handshake';
+/** 目标 Host 握手协调器；只把脱敏结果写回 PeerHostRecord。 */
+export class PeerHostHandshakeService {
+    store;
+    credentials;
+    options;
+    fetchImpl;
+    timeoutMs;
+    now;
+    constructor(store, credentials, options) {
+        this.store = store;
+        this.credentials = credentials;
+        this.options = options;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.timeoutMs = options.timeoutMs ?? 5_000;
+        this.now = options.now ?? Date.now;
+    }
+    async check(peerHostId) {
+        const current = await this.requireRecord(peerHostId);
+        await this.store.updateHandshake(peerHostId, this.emptyUpdate('checking'));
+        try {
+            const payload = await this.fetchHandshake(current.route);
+            const update = this.resolve(current, payload);
+            if (update.status === 'identity_changed')
+                await this.credentials.clear(peerHostId);
+            return await this.store.updateHandshake(peerHostId, update);
+        }
+        catch (error) {
+            const code = errorCode(error, PEER_HOST_ERROR_CODES.UNREACHABLE);
+            return this.store.updateHandshake(peerHostId, {
+                ...this.emptyUpdate('unreachable'),
+                lastErrorCode: code,
+            });
+        }
+    }
+    async fetchHandshake(route) {
+        if (route.kind !== 'lan')
+            throw new HandshakeError(PEER_HOST_ERROR_CODES.RELAY_UNAVAILABLE, '中转 PeerHost 暂不可用');
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await this.fetchImpl(new URL(PEER_HOST_HANDSHAKE_PATH, route.normalizedOrigin), { method: 'GET', signal: controller.signal, headers: { accept: 'application/json' } });
+            if (!response.ok)
+                throw new HandshakeError(PEER_HOST_ERROR_CODES.UNREACHABLE, `握手请求失败: ${response.status}`);
+            let value;
+            try {
+                value = await response.json();
+            }
+            catch {
+                throw new HandshakeError(PEER_HOST_ERROR_CODES.RESPONSE_INVALID, '握手响应不是 JSON');
+            }
+            if (!isHandshakePayload(value))
+                throw new HandshakeError(PEER_HOST_ERROR_CODES.RESPONSE_INVALID, '握手响应字段无效');
+            return value;
+        }
+        catch (error) {
+            if (error instanceof HandshakeError)
+                throw error;
+            throw new HandshakeError(PEER_HOST_ERROR_CODES.UNREACHABLE, '目标 Host 不可达');
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    resolve(current, payload) {
+        const common = {
+            pluginId: payload.pluginId,
+            pluginVersion: payload.pluginVersion,
+            dshVersion: payload.dshVersion,
+            apiCompatibility: payload.apiCompatibility,
+            fingerprint: payload.fingerprint,
+            lastCheckedAt: this.now(),
+            lastErrorCode: null,
+        };
+        if (payload.productId !== this.options.productId || payload.pluginId !== this.options.pluginId) {
+            return { ...common, status: 'plugin_missing', lastErrorCode: PEER_HOST_ERROR_CODES.PLUGIN_MISSING };
+        }
+        if (payload.pluginVersion !== this.options.pluginVersion || !this.options.isDshVersionSupported(payload.dshVersion) || payload.apiCompatibility !== this.options.apiCompatibility) {
+            return { ...common, status: 'version_mismatch', lastErrorCode: PEER_HOST_ERROR_CODES.VERSION_MISMATCH };
+        }
+        if (current.fingerprint !== null && payload.fingerprint !== current.fingerprint) {
+            return { ...common, status: 'identity_changed', lastErrorCode: PEER_HOST_ERROR_CODES.IDENTITY_CHANGED };
+        }
+        return { ...common, status: 'ready' };
+    }
+    emptyUpdate(status) {
+        return {
+            status,
+            pluginId: null,
+            pluginVersion: null,
+            dshVersion: null,
+            apiCompatibility: null,
+            fingerprint: null,
+            lastCheckedAt: this.now(),
+            lastErrorCode: null,
+        };
+    }
+    async requireRecord(peerHostId) {
+        const record = await this.store.get(peerHostId);
+        if (record === null)
+            throw new HandshakeError(PEER_HOST_ERROR_CODES.NOT_FOUND, 'PeerHost 不存在');
+        return record;
+    }
+}
+export class HandshakeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'HandshakeError';
+    }
+}
+function isHandshakePayload(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const input = value;
+    return typeof input.productId === 'string'
+        && (typeof input.pluginId === 'string' || input.pluginId === null)
+        && (typeof input.pluginVersion === 'string' || input.pluginVersion === null)
+        && typeof input.dshVersion === 'string'
+        && typeof input.apiCompatibility === 'string'
+        && (typeof input.fingerprint === 'string' || input.fingerprint === null)
+        && Array.isArray(input.capabilities)
+        && input.capabilities.every((item) => typeof item === 'string');
+}
+function errorCode(error, fallback) {
+    if (error instanceof HandshakeError)
+        return error.code;
+    return fallback;
+}
+//# sourceMappingURL=peer-host-handshake.js.map

package/data/build/dist/host/modules/peer-host/peer-host-relay.d.ts

@@ -0,0 +1,65 @@
+import type { HostScope, PeerHostRecord } from '../../../shared/contracts/peer-host.js';
+import type { PeerHostRemoteConnector, PeerHostSocket } from './host-ws-proxy-service.js';
+/** 已验证的 Host 侧 Relay 适配器；适配器内部必须复用现有 Transport。 */
+export interface PeerHostRelayTransportFactory {
+    readonly transportVersion: string;
+    readonly open: (input: {
+        readonly record: PeerHostRecord;
+        readonly scope: HostScope;
+        /** 只在当前调用栈传递，禁止写入持久状态。 */
+        readonly accessToken: string;
+    }) => Promise<PeerHostSocket>;
+}
+export interface PeerHostRelayConnectorOptions {
+    readonly transport?: PeerHostRelayTransportFactory;
+}
+/**
+ * 构造中转 connector。没有经过 Host 侧 Transport 验证的实现一律保持不可用。
+ * relayEntryId/deviceId 只作为稳定路由标识传给适配器，不会被解释为 URL 或 ticket。
+ */
+export declare function createPeerHostRelayConnector(options?: PeerHostRelayConnectorOptions): PeerHostRemoteConnector;
+export type PeerHostReconnectState = 'idle' | 'connecting' | 'ready' | 'reconnecting' | 'unreachable' | 'stopped' | 'relay_unavailable';
+export interface PeerHostReconnectSnapshot {
+    readonly peerHostId: string;
+    readonly state: PeerHostReconnectState;
+    readonly attempts: number;
+    readonly generation: number;
+    /** 重连成功后供上层重建订阅的完整作用域快照。 */
+    readonly scope: HostScope;
+    readonly lastErrorCode: string | null;
+}
+export interface PeerHostReconnectManagerOptions {
+    readonly connect: PeerHostRemoteConnector;
+    readonly onState?: (snapshot: PeerHostReconnectSnapshot) => void | Promise<void>;
+    readonly initialDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly maxAttempts?: number;
+    readonly setTimer?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    readonly clearTimer?: (timer: ReturnType<typeof setTimeout>) => void;
+}
+/**
+ * 单个 PeerHost 的有界断线恢复状态机。ticket/token 只存在 Entry 内存，close 后立即释放。
+ * 重连成功会递增 generation；调用方必须用新快照重新建立 HostScope 订阅。
+ */
+export declare class PeerHostReconnectManager {
+    private readonly options;
+    private readonly entries;
+    private readonly setTimer;
+    private readonly clearTimer;
+    private readonly initialDelayMs;
+    private readonly maxDelayMs;
+    private readonly maxAttempts;
+    private closed;
+    constructor(options: PeerHostReconnectManagerOptions);
+    connect(record: PeerHostRecord, accessToken: string, scope: HostScope): Promise<PeerHostSocket>;
+    snapshot(peerHostId: string): PeerHostReconnectSnapshot | null;
+    close(peerHostId?: string): Promise<void>;
+    private attach;
+    private onClosed;
+    private markFailure;
+    private schedule;
+    private reconnect;
+    private stopEntry;
+    private publish;
+}
+//# sourceMappingURL=peer-host-relay.d.ts.map

package/data/build/dist/host/modules/peer-host/peer-host-relay.js

@@ -0,0 +1,196 @@
+import { PEER_HOST_ERROR_CODES } from '../../../shared/contracts/peer-host.js';
+import { PeerHostConnectorError } from './host-ws-connector.js';
+/**
+ * 构造中转 connector。没有经过 Host 侧 Transport 验证的实现一律保持不可用。
+ * relayEntryId/deviceId 只作为稳定路由标识传给适配器，不会被解释为 URL 或 ticket。
+ */
+export function createPeerHostRelayConnector(options = {}) {
+    return async (record, accessToken, scope) => {
+        if (record.route.kind !== 'relay') {
+            throw new PeerHostConnectorError('PEER_HOST_PROXY_UNREACHABLE', 'PeerHost relay connector 收到非中转路由');
+        }
+        assertScope(scope, record.id);
+        const transport = options.transport;
+        if (transport === undefined || transport.transportVersion.trim() === '' || transport.transportVersion !== record.route.transportVersion) {
+            throw new PeerHostConnectorError('PEER_HOST_RELAY_UNAVAILABLE', '中转 PeerHost 尚未具备已验证的 Host Transport');
+        }
+        if (accessToken.trim() === '')
+            throw new PeerHostConnectorError('PEER_HOST_SESSION_REQUIRED', '目标 Host 登录态为空');
+        try {
+            return await transport.open({ record, scope, accessToken });
+        }
+        catch (error) {
+            if (error instanceof PeerHostConnectorError)
+                throw error;
+            throw new PeerHostConnectorError('PEER_HOST_PROXY_UNREACHABLE', '中转 PeerHost 连接失败');
+        }
+    };
+}
+/**
+ * 单个 PeerHost 的有界断线恢复状态机。ticket/token 只存在 Entry 内存，close 后立即释放。
+ * 重连成功会递增 generation；调用方必须用新快照重新建立 HostScope 订阅。
+ */
+export class PeerHostReconnectManager {
+    options;
+    entries = new Map();
+    setTimer;
+    clearTimer;
+    initialDelayMs;
+    maxDelayMs;
+    maxAttempts;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+        this.setTimer = options.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+        this.clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
+        this.initialDelayMs = bounded(options.initialDelayMs ?? 250, 10, 60_000);
+        this.maxDelayMs = bounded(options.maxDelayMs ?? 10_000, this.initialDelayMs, 120_000);
+        this.maxAttempts = bounded(options.maxAttempts ?? 5, 0, 100);
+    }
+    async connect(record, accessToken, scope) {
+        if (this.closed)
+            throw new PeerHostConnectorError('PEER_HOST_PROXY_UNREACHABLE', 'PeerHost reconnect manager 已关闭');
+        assertScope(scope, record.id);
+        const previous = this.entries.get(record.id);
+        if (previous)
+            this.stopEntry(previous);
+        const entry = {
+            record,
+            accessToken,
+            scope,
+            socket: null,
+            timer: null,
+            state: 'connecting',
+            attempts: 0,
+            generation: scope.scopeGeneration,
+            lastErrorCode: null,
+            stopped: false,
+        };
+        this.entries.set(record.id, entry);
+        await this.publish(entry);
+        try {
+            const socket = await this.options.connect(record, accessToken, scope);
+            this.attach(entry, socket);
+            entry.state = 'ready';
+            entry.attempts = 0;
+            entry.lastErrorCode = null;
+            await this.publish(entry);
+            return socket;
+        }
+        catch (error) {
+            this.markFailure(entry, error);
+            this.schedule(entry);
+            throw error;
+        }
+    }
+    snapshot(peerHostId) {
+        const entry = this.entries.get(peerHostId);
+        return entry ? toSnapshot(entry) : null;
+    }
+    async close(peerHostId) {
+        if (peerHostId === undefined) {
+            this.closed = true;
+            for (const entry of this.entries.values())
+                this.stopEntry(entry);
+            this.entries.clear();
+            return;
+        }
+        const entry = this.entries.get(peerHostId);
+        if (!entry)
+            return;
+        this.stopEntry(entry);
+        this.entries.delete(peerHostId);
+    }
+    attach(entry, socket) {
+        entry.socket = socket;
+        socket.on('close', () => this.onClosed(entry));
+        socket.on('error', () => this.onClosed(entry));
+    }
+    onClosed(entry) {
+        if (entry.stopped || this.closed || entry.socket === null)
+            return;
+        entry.socket = null;
+        entry.state = 'reconnecting';
+        this.schedule(entry);
+        void this.publish(entry);
+    }
+    markFailure(entry, error) {
+        entry.attempts += 1;
+        entry.lastErrorCode = error instanceof PeerHostConnectorError ? error.code : PEER_HOST_ERROR_CODES.PROXY_UNREACHABLE;
+        entry.state = entry.lastErrorCode === PEER_HOST_ERROR_CODES.RELAY_UNAVAILABLE ? 'relay_unavailable' : 'unreachable';
+    }
+    schedule(entry) {
+        if (entry.stopped || this.closed || entry.timer !== null)
+            return;
+        if (entry.lastErrorCode === PEER_HOST_ERROR_CODES.RELAY_UNAVAILABLE) {
+            entry.state = 'relay_unavailable';
+            void this.publish(entry);
+            return;
+        }
+        if (this.maxAttempts === 0 || entry.attempts >= this.maxAttempts) {
+            entry.state = entry.lastErrorCode === PEER_HOST_ERROR_CODES.RELAY_UNAVAILABLE ? 'relay_unavailable' : 'unreachable';
+            void this.publish(entry);
+            return;
+        }
+        const delay = Math.min(this.maxDelayMs, this.initialDelayMs * 2 ** Math.max(0, entry.attempts - 1));
+        entry.timer = this.setTimer(() => {
+            entry.timer = null;
+            if (entry.stopped || this.closed)
+                return;
+            void this.reconnect(entry);
+        }, delay);
+        void this.publish(entry);
+    }
+    async reconnect(entry) {
+        if (entry.stopped || this.closed)
+            return;
+        entry.state = 'reconnecting';
+        await this.publish(entry);
+        try {
+            const socket = await this.options.connect(entry.record, entry.accessToken, { ...entry.scope, scopeGeneration: ++entry.generation });
+            if (entry.stopped || this.closed) {
+                socket.close(1000, 'PeerHost reconnect manager 已关闭');
+                return;
+            }
+            entry.scope = { ...entry.scope, scopeGeneration: entry.generation };
+            this.attach(entry, socket);
+            entry.state = 'ready';
+            entry.attempts = 0;
+            entry.lastErrorCode = null;
+            await this.publish(entry);
+        }
+        catch (error) {
+            this.markFailure(entry, error);
+            this.schedule(entry);
+        }
+    }
+    stopEntry(entry) {
+        entry.stopped = true;
+        entry.state = 'stopped';
+        if (entry.timer !== null)
+            this.clearTimer(entry.timer);
+        entry.timer = null;
+        const socket = entry.socket;
+        entry.socket = null;
+        if (socket?.readyState === 1)
+            socket.close(1000, 'PeerHost reconnect manager 已清理');
+        void this.publish(entry);
+    }
+    async publish(entry) {
+        await this.options.onState?.(toSnapshot(entry));
+    }
+}
+function assertScope(scope, peerHostId) {
+    if (scope.targetHostId !== peerHostId || scope.hostId.trim() === '' || scope.workspaceId.trim() === '' || !Number.isSafeInteger(scope.scopeGeneration) || scope.scopeGeneration < 0 || (scope.sessionId !== null && scope.sessionId.trim() === '')) {
+        throw new PeerHostConnectorError('PEER_HOST_PROXY_UNREACHABLE', 'PeerHost relay 作用域无效');
+    }
+}
+function toSnapshot(entry) {
+    return { peerHostId: entry.record.id, state: entry.state, attempts: entry.attempts, generation: entry.generation, scope: entry.scope, lastErrorCode: entry.lastErrorCode };
+}
+function bounded(value, min, max) {
+    if (!Number.isSafeInteger(value) || value < min || value > max)
+        throw new TypeError('PeerHost reconnect 参数无效');
+    return value;
+}
+//# sourceMappingURL=peer-host-relay.js.map

package/data/build/dist/host/modules/peer-host/peer-host-session.d.ts

@@ -0,0 +1,42 @@
+import type { PeerHostErrorCode } from '../../../shared/contracts/peer-host.js';
+import { PeerHostStore, type PeerHostCredentialStore } from './peer-host-store.js';
+export interface PeerHostLoginInput {
+    readonly username: string;
+    readonly password: string;
+}
+export interface PeerHostSessionView {
+    readonly peerHostId: string;
+    readonly status: 'logged_in' | 'logged_out';
+    readonly expiresAt: number | null;
+}
+export interface PeerHostSessionOptions {
+    readonly fetchImpl?: typeof fetch;
+    readonly now?: () => number;
+    readonly refreshSkewMs?: number;
+}
+/** PeerHost 目标登录态协调器；token 只在 Host 进程和敏感存储中流转。 */
+export declare class PeerHostSessionService {
+    private readonly store;
+    private readonly credentials;
+    private readonly options;
+    private readonly fetchImpl;
+    private readonly now;
+    private readonly refreshSkewMs;
+    constructor(store: PeerHostStore, credentials: PeerHostCredentialStore, options?: {
+        readonly apiPath?: string;
+    } & PeerHostSessionOptions);
+    login(peerHostId: string, input: PeerHostLoginInput): Promise<PeerHostSessionView>;
+    refresh(peerHostId: string): Promise<PeerHostSessionView>;
+    getAccessToken(peerHostId: string): Promise<string>;
+    /** 目标 Host 明确拒绝当前 token 时，只清理该 PeerHost 的登录态。 */
+    invalidate(peerHostId: string): Promise<void>;
+    logout(peerHostId: string): Promise<PeerHostSessionView>;
+    private ensureReady;
+    private request;
+    private sessionRequired;
+}
+export declare class PeerHostSessionError extends Error {
+    readonly code: PeerHostErrorCode;
+    constructor(code: PeerHostErrorCode, message: string);
+}
+//# sourceMappingURL=peer-host-session.d.ts.map

package/data/build/dist/host/modules/peer-host/peer-host-session.js

@@ -0,0 +1,152 @@
+import { PEER_HOST_ERROR_CODES } from '../../../shared/contracts/peer-host.js';
+import { PeerHostStore } from './peer-host-store.js';
+/** PeerHost 目标登录态协调器；token 只在 Host 进程和敏感存储中流转。 */
+export class PeerHostSessionService {
+    store;
+    credentials;
+    options;
+    fetchImpl;
+    now;
+    refreshSkewMs;
+    constructor(store, credentials, options = {}) {
+        this.store = store;
+        this.credentials = credentials;
+        this.options = options;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.now = options.now ?? Date.now;
+        this.refreshSkewMs = options.refreshSkewMs ?? 30_000;
+    }
+    async login(peerHostId, input) {
+        const record = await this.ensureReady(peerHostId);
+        const username = requiredText(input.username, 'username');
+        const password = requiredText(input.password, 'password');
+        const response = await this.request(record, '/api/auth/login', { username, password });
+        const payload = parseTokenResponse(response);
+        const credential = toCredential(payload, this.now());
+        await this.credentials.write(peerHostId, credential);
+        return toView(peerHostId, credential);
+    }
+    async refresh(peerHostId) {
+        const record = await this.ensureReady(peerHostId);
+        const previous = await this.credentials.read(peerHostId);
+        if (previous === null)
+            return this.sessionRequired(peerHostId);
+        try {
+            const response = await this.request(record, '/api/auth/refresh', { refreshToken: previous.refreshToken });
+            const payload = parseTokenResponse(response, previous.refreshToken);
+            const credential = toCredential(payload, this.now());
+            await this.credentials.write(peerHostId, credential);
+            return toView(peerHostId, credential);
+        }
+        catch (error) {
+            await this.credentials.clear(peerHostId);
+            await this.store.updateStatus(peerHostId, 'session_required', errorCode(error, PEER_HOST_ERROR_CODES.SESSION_REQUIRED));
+            return this.sessionRequired(peerHostId);
+        }
+    }
+    async getAccessToken(peerHostId) {
+        const record = await this.ensureReady(peerHostId);
+        const credential = await this.credentials.read(peerHostId);
+        if (credential === null)
+            return this.sessionRequired(peerHostId).then(() => '');
+        if (credential.expiresAt - this.now() <= this.refreshSkewMs) {
+            const refreshed = await this.refresh(peerHostId);
+            const latest = await this.credentials.read(peerHostId);
+            if (refreshed.status !== 'logged_in' || latest === null)
+                throw new PeerHostSessionError(PEER_HOST_ERROR_CODES.SESSION_REQUIRED, '目标 Host 登录态已失效');
+            return latest.accessToken;
+        }
+        return credential.accessToken;
+    }
+    /** 目标 Host 明确拒绝当前 token 时，只清理该 PeerHost 的登录态。 */
+    async invalidate(peerHostId) {
+        await this.credentials.clear(peerHostId);
+        const record = await this.store.get(peerHostId);
+        if (record !== null && record.status === 'ready')
+            await this.store.updateStatus(peerHostId, 'session_required', PEER_HOST_ERROR_CODES.SESSION_REQUIRED);
+    }
+    async logout(peerHostId) {
+        const record = await this.store.get(peerHostId);
+        if (record === null)
+            throw new PeerHostSessionError(PEER_HOST_ERROR_CODES.NOT_FOUND, 'PeerHost 不存在');
+        const credential = await this.credentials.read(peerHostId);
+        if (credential !== null) {
+            try {
+                await this.request(record, '/api/auth/logout', undefined, credential.accessToken);
+            }
+            catch {
+                // 远端退出失败不能阻止本地凭据清理，避免旧 token 继续被代理使用。
+            }
+        }
+        await this.credentials.clear(peerHostId);
+        if (record.status === 'ready')
+            await this.store.updateStatus(peerHostId, 'ready', null);
+        return { peerHostId, status: 'logged_out', expiresAt: null };
+    }
+    async ensureReady(peerHostId) {
+        const record = await this.store.get(peerHostId);
+        if (record === null)
+            throw new PeerHostSessionError(PEER_HOST_ERROR_CODES.NOT_FOUND, 'PeerHost 不存在');
+        if (record.status !== 'ready')
+            throw new PeerHostSessionError(record.status === 'session_required' ? PEER_HOST_ERROR_CODES.SESSION_REQUIRED : PEER_HOST_ERROR_CODES.NOT_READY, 'PeerHost 尚未通过握手检查');
+        return record;
+    }
+    async request(record, path, body, accessToken) {
+        if (record.route.kind !== 'lan')
+            throw new PeerHostSessionError(PEER_HOST_ERROR_CODES.RELAY_UNAVAILABLE, '中转 PeerHost 暂不可用');
+        const headers = new Headers({ accept: 'application/json' });
+        if (body !== undefined)
+            headers.set('content-type', 'application/json');
+        if (accessToken !== undefined)
+            headers.set('authorization', `Bearer ${accessToken}`);
+        const response = await this.fetchImpl(new URL(path, record.route.normalizedOrigin), {
+            method: 'POST', headers, ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        });
+        let payload = null;
+        try {
+            payload = await response.json();
+        }
+        catch { /* logout 允许空响应 */ }
+        if (!response.ok)
+            throw new PeerHostSessionError(response.status === 401 ? PEER_HOST_ERROR_CODES.SESSION_REQUIRED : PEER_HOST_ERROR_CODES.PROXY_UNREACHABLE, '目标 Host 登录请求失败');
+        return payload;
+    }
+    async sessionRequired(peerHostId) {
+        await this.store.updateStatus(peerHostId, 'session_required', PEER_HOST_ERROR_CODES.SESSION_REQUIRED);
+        throw new PeerHostSessionError(PEER_HOST_ERROR_CODES.SESSION_REQUIRED, '目标 Host 需要登录');
+    }
+}
+export class PeerHostSessionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'PeerHostSessionError';
+    }
+}
+function parseTokenResponse(value, fallbackRefreshToken) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new PeerHostSessionError(PEER_HOST_ERROR_CODES.RESPONSE_INVALID, '目标 Host 登录响应无效');
+    const input = value;
+    const accessToken = typeof input.accessToken === 'string' ? input.accessToken : '';
+    const refreshToken = typeof input.refreshToken === 'string' ? input.refreshToken : fallbackRefreshToken ?? '';
+    const expiresIn = typeof input.expiresIn === 'number' && Number.isFinite(input.expiresIn) && input.expiresIn > 0 ? input.expiresIn : 0;
+    if (!accessToken || !refreshToken || expiresIn <= 0)
+        throw new PeerHostSessionError(PEER_HOST_ERROR_CODES.RESPONSE_INVALID, '目标 Host token 响应无效');
+    return { accessToken, refreshToken, expiresIn };
+}
+function toCredential(payload, now) {
+    return { accessToken: payload.accessToken, refreshToken: payload.refreshToken, expiresAt: now + payload.expiresIn * 1000 };
+}
+function toView(peerHostId, credential) {
+    return { peerHostId, status: 'logged_in', expiresAt: credential.expiresAt };
+}
+function requiredText(value, field) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new TypeError(`${field} 不能为空`);
+    return value.trim();
+}
+function errorCode(error, fallback) {
+    return error instanceof PeerHostSessionError ? error.code : fallback;
+}
+//# sourceMappingURL=peer-host-session.js.map

package/data/build/dist/host/modules/peer-host/peer-host-store.d.ts

@@ -0,0 +1,92 @@
+import type { PeerHostErrorCode, PeerHostRecord, PeerHostRoute } from '../../../shared/contracts/peer-host.js';
+export interface PeerHostTokenRecord {
+    readonly accessToken: string;
+    readonly refreshToken: string;
+    readonly expiresAt: number;
+}
+export interface PeerHostRecordStore {
+    read(): Promise<readonly PeerHostRecord[]>;
+    write(records: readonly PeerHostRecord[]): Promise<void>;
+}
+export interface PeerHostCredentialStore {
+    read(peerHostId: string): Promise<PeerHostTokenRecord | null>;
+    write(peerHostId: string, credential: PeerHostTokenRecord): Promise<void>;
+    clear(peerHostId: string): Promise<void>;
+}
+export interface PeerHostCreateInput {
+    readonly displayName: string;
+    readonly route: PeerHostRoute;
+}
+export interface PeerHostUpdateInput {
+    readonly displayName?: string;
+    readonly route?: PeerHostRoute;
+}
+export interface PeerHostHandshakeUpdate {
+    readonly status: PeerHostRecord['status'];
+    readonly pluginId: string | null;
+    readonly pluginVersion: string | null;
+    readonly dshVersion: string | null;
+    readonly apiCompatibility: string | null;
+    readonly fingerprint: string | null;
+    readonly lastCheckedAt: number;
+    readonly lastErrorCode: PeerHostErrorCode | null;
+}
+export declare class PeerHostStoreError extends Error {
+    readonly code: PeerHostErrorCode;
+    constructor(code: PeerHostErrorCode, message: string);
+}
+/** 当前 Host 的 PeerHost 配置服务；所有 mutation 都在 Host 内完成校验。 */
+export declare class PeerHostStore {
+    private readonly ownerUserId;
+    private readonly recordStore;
+    private readonly credentials;
+    private readonly now;
+    private readonly createId;
+    private records;
+    private operation;
+    constructor(ownerUserId: string, recordStore: PeerHostRecordStore, credentials: PeerHostCredentialStore, now?: () => number, createId?: () => string);
+    list(): Promise<readonly PeerHostRecord[]>;
+    get(peerHostId: string): Promise<PeerHostRecord | null>;
+    create(input: PeerHostCreateInput): Promise<PeerHostRecord>;
+    update(peerHostId: string, input: PeerHostUpdateInput): Promise<PeerHostRecord>;
+    remove(peerHostId: string): Promise<void>;
+    updateHandshake(peerHostId: string, input: PeerHostHandshakeUpdate): Promise<PeerHostRecord>;
+    updateStatus(peerHostId: string, status: PeerHostRecord['status'], lastErrorCode: PeerHostErrorCode | null): Promise<PeerHostRecord>;
+    private load;
+    private persist;
+    private findIndex;
+    private assertUnique;
+    private enqueue;
+}
+export declare class InMemoryPeerHostRecordStore implements PeerHostRecordStore {
+    private records;
+    constructor(records?: readonly PeerHostRecord[]);
+    read(): Promise<readonly PeerHostRecord[]>;
+    write(records: readonly PeerHostRecord[]): Promise<void>;
+}
+export declare class InMemoryPeerHostCredentialStore implements PeerHostCredentialStore {
+    private readonly records;
+    read(peerHostId: string): Promise<PeerHostTokenRecord | null>;
+    write(peerHostId: string, credential: PeerHostTokenRecord): Promise<void>;
+    clear(peerHostId: string): Promise<void>;
+}
+/** 非敏感记录的原子文件存储；token 不允许进入此文件。 */
+export declare class FilePeerHostRecordStore implements PeerHostRecordStore {
+    private readonly filePath;
+    constructor(filePath: string);
+    read(): Promise<readonly PeerHostRecord[]>;
+    write(records: readonly PeerHostRecord[]): Promise<void>;
+}
+/** AES-256-GCM 文件存储，密钥必须由 Host 启动边界注入。 */
+export declare class EncryptedFilePeerHostCredentialStore implements PeerHostCredentialStore {
+    private readonly filePath;
+    constructor(filePath: string, key: Uint8Array);
+    private readonly key;
+    read(peerHostId: string): Promise<PeerHostTokenRecord | null>;
+    write(peerHostId: string, credential: PeerHostTokenRecord): Promise<void>;
+    clear(peerHostId: string): Promise<void>;
+    private readAll;
+    private writeAll;
+}
+export declare function normalizePeerHostRoute(route: PeerHostRoute): PeerHostRoute;
+//# sourceMappingURL=peer-host-store.d.ts.map