From cb4206481eba2688ec182c8cec4792c951acfbd5 Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:27:27 +0800 Subject: [PATCH] Import apps/browser/src/background.ts --- apps/browser/src/background.ts | 293 +++++++++++++++++++++++++++++++++ 1 file changed, 293 insertions(+) create mode 100644 apps/browser/src/background.ts diff --git a/apps/browser/src/background.ts b/apps/browser/src/background.ts new file mode 100644 index 0000000..22ad02f --- /dev/null +++ b/apps/browser/src/background.ts @@ -0,0 +1,293 @@ +/** + * DS Harness Remote browser launcher service worker. + * + * The extension reads the current Web authorization only for the exchange call, + * replaces it with an isolated Browser device credential, and + * then owns Host discovery only. Remote workspaces, sessions and transport live + * in Remote Web. Opening a Host reuses the Web session already held by the browser. + */ +import { generateKeyPair } from '@dsh-remote/crypto' +import { emptyState, isRecord, type AppState } from './common.js' +import { ServerApi } from './server-api.js' +import type { Credentials, DeviceIdentity } from './types.js' + +const IDENTITY_KEY = 'dshRemote.identity.v1' +const CREDENTIALS_KEY = 'dshRemote.credentials.v1' +const DEFAULT_SERVER_URL = 'https://dsh.r2049.cn' + +async function storageGet(key: string): Promise { + const result = await chrome.storage.local.get(key) + return result[key] as T | undefined +} + +async function storageSet(key: string, value: unknown): Promise { + await chrome.storage.local.set({ [key]: value }) +} + +class Background { + private state: AppState = { ...emptyState } + private identity?: DeviceIdentity + private credentials?: Credentials + private authorizationTask?: Promise + private refreshTask?: Promise + private authEpoch = 0 + + async start(): Promise { + this.identity = await this.loadIdentity() + this.credentials = await this.loadCredentials() + this.state = { + ...emptyState, + settings: { serverUrl: DEFAULT_SERVER_URL }, + authorized: this.credentials !== undefined, + ...(this.credentials === undefined ? {} : { account: this.credentials.account }), + } + if (this.credentials !== undefined) await this.refresh().catch(() => undefined) + this.broadcast() + } + + snapshot(): AppState { return this.state } + + private broadcast(): void { + this.state = { ...this.state } + void chrome.runtime.sendMessage({ type: 'state', state: this.state }).catch(() => undefined) + } + + async command(action: string, payload: Record): Promise { + switch (action) { + case 'authorizeFromWeb': + await this.authorizeFromWeb() + return + case 'signOut': + await this.signOut() + return + case 'refresh': + await this.refresh() + return + case 'openHost': + await this.openHost(String(payload.deviceId ?? '')) + return + default: + throw new Error('This launcher action is not supported.') + } + } + + private async authorizeFromWeb(): Promise { + if (this.authorizationTask !== undefined) return this.authorizationTask + const task = this.runWebAuthorization() + this.authorizationTask = task + this.state.authorizationBusy = true + this.state.authorizationError = undefined + this.broadcast() + try { + await task + } catch (error) { + this.state.authorizationError = errorMessage(error) + throw error + } finally { + if (this.authorizationTask === task) this.authorizationTask = undefined + this.state.authorizationBusy = false + this.broadcast() + } + } + + private async runWebAuthorization(): Promise { + const authEpoch = ++this.authEpoch + const api = new ServerApi(DEFAULT_SERVER_URL) + const identity = this.identity ?? await this.loadIdentity() + this.identity = identity + const webToken = await readWebAccountToken(api.baseUrl) + const credentials = await new ServerApi(api.baseUrl, webToken).exchangeBrowserAuthorization(identity) + if (authEpoch !== this.authEpoch) { + await new ServerApi(credentials.serverUrl, credentials.accessToken).removeSelf().catch(() => undefined) + return + } + this.credentials = credentials + this.state = { + ...this.state, + settings: { serverUrl: DEFAULT_SERVER_URL }, + authorized: true, + account: credentials.account, + authorizationError: undefined, + notice: undefined, + } + await storageSet(CREDENTIALS_KEY, JSON.stringify(credentials)) + if (authEpoch !== this.authEpoch) return + await this.refresh().catch(() => undefined) + } + + private async signOut(): Promise { + const credentials = this.credentials + const authorizationTask = this.authorizationTask + const refreshTask = this.refreshTask + this.authEpoch += 1 + this.credentials = undefined + await authorizationTask?.catch(() => undefined) + const refreshed = await refreshTask?.catch(() => undefined) + if (refreshed !== undefined) { + await new ServerApi(refreshed.serverUrl, refreshed.accessToken).removeSelf().catch(() => undefined) + } else if (credentials !== undefined) { + await this.revokeDevice(credentials).catch(() => undefined) + } + this.identity = undefined + this.state = { ...emptyState, settings: { serverUrl: DEFAULT_SERVER_URL } } + await chrome.storage.local.remove([CREDENTIALS_KEY, IDENTITY_KEY]) + this.broadcast() + } + + private async refresh(): Promise { + if (this.refreshTask !== undefined) { + await this.refreshTask + return + } + this.state.refreshing = true + this.state.notice = undefined + this.broadcast() + const task = this.runRefresh() + this.refreshTask = task + try { + await task + } catch (error) { + this.state.notice = `${errorMessage(error)} Try again.` + throw error + } finally { + if (this.refreshTask === task) this.refreshTask = undefined + this.state.refreshing = false + this.broadcast() + } + } + + private async runRefresh(): Promise { + const authEpoch = this.authEpoch + let credentials = this.credentials + if (credentials === undefined) return undefined + let refreshed: Credentials | undefined + if (credentials.accessTokenExpiresAt <= Date.now() + 30_000) { + credentials = await new ServerApi(credentials.serverUrl).refresh(credentials.deviceId, credentials.refreshToken, credentials.account) + refreshed = credentials + if (authEpoch !== this.authEpoch) return refreshed + this.credentials = credentials + await storageSet(CREDENTIALS_KEY, JSON.stringify(credentials)) + if (authEpoch !== this.authEpoch) return refreshed + } + const hosts = await new ServerApi(credentials.serverUrl, credentials.accessToken).hosts() + if (authEpoch !== this.authEpoch) return refreshed + this.state.hosts = hosts + return refreshed + } + + private async openHost(deviceId: string): Promise { + if (deviceId.length === 0 || this.credentials === undefined) throw new Error('Authorize this launcher first.') + this.state.openingHostId = deviceId + this.state.notice = undefined + this.broadcast() + try { + await this.refresh() + const host = this.state.hosts.find(item => item.deviceId === deviceId) + if (host === undefined) throw new Error('This Host is no longer available.') + if (!host.online) throw new Error(`${host.name} is offline.`) + const credentials = this.credentials + if (credentials === undefined) throw new Error('Authorize this launcher first.') + const launchUrl = new URL(`/app/remote/${encodeURIComponent(host.deviceId)}`, credentials.serverUrl).toString() + await chrome.tabs.create({ url: launchUrl }) + } catch (error) { + this.state.notice = `${errorMessage(error)} Try again.` + throw error + } finally { + this.state.openingHostId = undefined + this.broadcast() + } + } + + private async loadIdentity(): Promise { + const stored = await storageGet(IDENTITY_KEY) + if (stored !== undefined) { + try { + const parsed = JSON.parse(stored) as DeviceIdentity + if (parsed.platform === 'browser' && typeof parsed.deviceId === 'string' && typeof parsed.publicKey === 'string') return parsed + } catch { + // Replace malformed local state with a fresh launcher identity. + } + } + const { publicKey } = generateKeyPair() + const identity: DeviceIdentity = { + deviceId: crypto.randomUUID(), + name: `Browser on ${navigator.platform || 'unknown'}`, + platform: 'browser', + publicKey, + } + await storageSet(IDENTITY_KEY, JSON.stringify(identity)) + return identity + } + + private async loadCredentials(): Promise { + const stored = await storageGet(CREDENTIALS_KEY) + if (stored === undefined) return undefined + try { + const parsed = JSON.parse(stored) as Credentials + return parsed.serverUrl === DEFAULT_SERVER_URL + && typeof parsed.deviceId === 'string' + && typeof parsed.account === 'string' + && typeof parsed.accessToken === 'string' + && typeof parsed.refreshToken === 'string' + ? parsed + : undefined + } catch { + return undefined + } + } + + private async revokeDevice(credentials: Credentials): Promise { + let accessToken = credentials.accessToken + if (credentials.accessTokenExpiresAt <= Date.now() + 30_000) { + const refreshed = await new ServerApi(credentials.serverUrl).refresh(credentials.deviceId, credentials.refreshToken, credentials.account) + accessToken = refreshed.accessToken + } + await new ServerApi(credentials.serverUrl, accessToken).removeSelf() + } +} + +function errorMessage(error: unknown): string { + return error instanceof Error && error.message.trim() ? error.message : 'Something went wrong.' +} + +async function readWebAccountToken(serverUrl: string): Promise { + const origin = new URL(serverUrl).origin + const tabs = await chrome.tabs.query({}) + const tab = tabs.find(candidate => { + if (candidate.id === undefined || candidate.url === undefined) return false + try { return new URL(candidate.url).origin === origin } catch { return false } + }) + if (tab?.id === undefined) { + await chrome.tabs.create({ url: new URL('/app/remote', origin).toString() }) + throw new Error('Sign in to Remote Web, then authorize again.') + } + const results = await chrome.scripting.executeScript({ + target: { tabId: tab.id }, + world: 'MAIN', + func: (key: string) => window.localStorage.getItem(key), + args: ['dsh.remote.accountToken'], + }) + const token = results[0]?.result + if (typeof token !== 'string' || token.length === 0) { + await chrome.tabs.update(tab.id, { active: true }) + throw new Error('Sign in to Remote Web, then authorize again.') + } + return token +} + +const background = new Background() +void background.start() + +chrome.runtime.onMessage.addListener((message: unknown, _sender, sendResponse) => { + if (!isRecord(message) || message.type !== 'command' || typeof message.action !== 'string') return false + void background.command(message.action, isRecord(message.payload) ? message.payload : {}) + .then(() => sendResponse({ ok: true })) + .catch(error => sendResponse({ ok: false, error: errorMessage(error) })) + return true +}) + +chrome.runtime.onMessage.addListener((message: unknown, _sender, sendResponse) => { + if (!isRecord(message) || message.type !== 'getState') return false + sendResponse({ state: background.snapshot() }) + return false +})