From 1c42634a68eb259a856327d471aaac950fcffc87 Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:18:43 +0800 Subject: [PATCH] Import apps/android/src/services/server-session-manager.ts --- .../src/services/server-session-manager.ts | 139 ++++++++++++++++++ 1 file changed, 139 insertions(+) create mode 100644 apps/android/src/services/server-session-manager.ts diff --git a/apps/android/src/services/server-session-manager.ts b/apps/android/src/services/server-session-manager.ts new file mode 100644 index 0000000..7193585 --- /dev/null +++ b/apps/android/src/services/server-session-manager.ts @@ -0,0 +1,139 @@ +import type { DeviceCredentials, DeviceIdentity } from '../types' +import { RemoteServerApi } from './api' + +type TokenPair = Pick + +export interface AuthenticatedServer { + api: RemoteServerApi + credentials: DeviceCredentials +} + +export interface CredentialPersistence { + load(serverUrl: string, deviceId: string): Promise + save(credentials: DeviceCredentials): Promise +} + +export type ApiFactory = (baseUrl: string, accessToken?: string) => RemoteServerApi + +export class ServerSessionManager { + private readonly inFlight = new Map>() + + constructor( + private readonly persistence: CredentialPersistence, + private readonly apiFactory: ApiFactory, + ) {} + + /** + * Log in with the account password and register (or restore) this Android + * device under the account. The account token is used only for this HTTPS + * registration and never persisted; the device token pair is stored instead. + */ + async authenticateWithAccount( + baseUrl: string, + identity: DeviceIdentity, + email: string, + password: string, + ): Promise { + const key = `${baseUrl}\0${identity.deviceId}` + const pending = this.inFlight.get(key) + if (pending !== undefined) return pending + + const created = this.authenticateWithAccountOnce(baseUrl, identity, email, password).finally(() => { + if (this.inFlight.get(key) === created) this.inFlight.delete(key) + }) + this.inFlight.set(key, created) + return created + } + + /** + * Register this Android device under a short-lived account token. The account + * token is used only for HTTPS registration and never persisted. + */ + async registerWithAccountToken( + baseUrl: string, + identity: DeviceIdentity, + accountToken: string, + account: string, + ): Promise { + const publicApi = this.apiFactory(baseUrl) + const tokens = await publicApi.registerDevice(identity, accountToken) + const credentials: DeviceCredentials = { + serverUrl: baseUrl, + deviceId: identity.deviceId, + authorizationMethod: 'account', + account, + ...tokens, + } + await this.persistence.save(credentials) + return { + api: this.apiFactory(baseUrl, credentials.accessToken), + credentials, + } + } + + /** + * Register this Android device under an account web session token delivered + * by Zhihu OAuth (dshremote://oauth?token=...). The web token is used only + * for the device registration and never persisted. + */ + async authenticateWithOAuthToken( + baseUrl: string, + identity: DeviceIdentity, + webToken: string, + ): Promise { + const publicApi = this.apiFactory(baseUrl) + const profile = await publicApi.accountMe(webToken) + return this.registerWithAccountToken(baseUrl, identity, webToken, profile.account) + } + + authenticate(baseUrl: string, identity: DeviceIdentity): Promise { + const key = `${baseUrl}\0${identity.deviceId}` + const pending = this.inFlight.get(key) + if (pending !== undefined) return pending + + const created = this.authenticateOnce(baseUrl, identity).finally(() => { + if (this.inFlight.get(key) === created) this.inFlight.delete(key) + }) + this.inFlight.set(key, created) + return created + } + + private async authenticateWithAccountOnce( + baseUrl: string, + identity: DeviceIdentity, + email: string, + password: string, + ): Promise { + const publicApi = this.apiFactory(baseUrl) + const login = await publicApi.loginAccount(email, password) + return this.registerWithAccountToken(baseUrl, identity, login.token, login.account) + } + + private async authenticateOnce(baseUrl: string, identity: DeviceIdentity): Promise { + const now = Date.now() + let credentials = await this.persistence.load(baseUrl, identity.deviceId) + if (credentials === undefined || credentials.accessTokenExpiresAt <= now + 30_000) { + const publicApi = this.apiFactory(baseUrl) + let tokens: TokenPair + if (credentials !== undefined && credentials.refreshTokenExpiresAt > now + 30_000) { + tokens = await publicApi.refreshToken(identity.deviceId, credentials.refreshToken) + } else { + // No valid device credential: the user must log in again. + throw new AccountRequiredError('The phone must be authorized for this server again.') + } + credentials = { + ...credentials, + ...tokens, + } + await this.persistence.save(credentials) + } + return { + api: this.apiFactory(baseUrl, credentials.accessToken), + credentials, + } + } +} + +export class AccountRequiredError extends Error { + constructor(message: string) { super(message) } +}