@linxin666/dsh-client-ui-task-board 0.1.20 → 0.2.1

package/src/host-routes.ts

@@ -0,0 +1,196 @@
+import { timingSafeEqual } from 'node:crypto'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { WebRoute } from '@deepseek-ai/dsh-host-webserver'
+import type { TaskBoardHostService } from './host-service.ts'
+import { isLoopbackAddress, isLoopbackRequest } from './loopback.ts'
+import { parseActionEnvelope, TASK_BOARD_API_PREFIX } from './protocol.ts'
+
+const ACTION_LIMIT = 64 * 1024
+const IMPORT_LIMIT = 2 * 1024 * 1024
+const HEARTBEAT_MS = 15_000
+
+/** Header replaced by an authenticated same-host reverse proxy. */
+export const TASK_BOARD_PROXY_TOKEN_HEADER = 'x-dsh-task-board-proxy-token'
+
+/** Optional authenticated reverse-proxy access layered over the loopback default. */
+export interface TaskBoardRouteAccess {
+  trustedProxyHosts?: readonly string[]
+  proxyToken?: string
+}
+
+interface ResolvedRouteAccess {
+  trustedProxyHosts: ReadonlySet<string>
+  proxyToken?: string
+}
+
+function json(res: ServerResponse, status: number, body: unknown): void {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
+  res.end(JSON.stringify(body))
+}
+
+function parseAuthority(authority: string): { canonical: string; url: URL } | undefined {
+  if (authority.trim() !== authority) return undefined
+  const match = authority.startsWith('[')
+    ? /^\[[^\]]+\](?::([0-9]+))?$/.exec(authority)
+    : /^[^:@/?#\s]+(?::([0-9]+))?$/.exec(authority)
+  if (match === null) return undefined
+  try {
+    const url = new URL(`http://${authority}`)
+    if (url.username !== '' || url.password !== '' || url.pathname !== '/' || url.search !== '' || url.hash !== '') return undefined
+    const rawPort = match[1]
+    if (rawPort !== undefined && (String(Number(rawPort)) !== rawPort || Number(rawPort) > 65_535)) return undefined
+    return { canonical: url.hostname.toLowerCase() + (rawPort === undefined ? '' : `:${rawPort}`), url }
+  } catch {
+    return undefined
+  }
+}
+
+function resolveAccess(access: TaskBoardRouteAccess): ResolvedRouteAccess {
+  const trustedProxyHosts = new Set<string>()
+  for (const authority of access.trustedProxyHosts ?? []) {
+    const parsed = parseAuthority(authority)
+    if (parsed === undefined || parsed.canonical !== authority.toLowerCase()) {
+      throw new Error(`task-board: trustedProxyHosts entry ${JSON.stringify(authority)} is not a canonical host[:port] authority`)
+    }
+    trustedProxyHosts.add(parsed.canonical)
+  }
+  if (trustedProxyHosts.size > 0 && (access.proxyToken === undefined || access.proxyToken === '')) {
+    throw new Error('task-board: authenticated proxy hosts require a non-empty proxy token')
+  }
+  return { trustedProxyHosts, ...(access.proxyToken === undefined ? {} : { proxyToken: access.proxyToken }) }
+}
+
+/**
+ * Browser-signal tripwire, NOT an authority check: a bare curl sends neither
+ * header and is refused, but a curl with a forged Origin passes this too.
+ * The real boundary is the loopback socket + Host + origin-equality checks
+ * in isTrustedTaskBoardRequest below; do not rely on this marker alone.
+ */
+function browserSameOriginMarker(req: IncomingMessage): boolean {
+  const site = req.headers['sec-fetch-site']
+  return site === 'same-origin' || typeof req.headers.origin === 'string'
+}
+
+function sameAuthority(req: IncomingMessage, host: URL): boolean {
+  if (req.headers['sec-fetch-site'] === 'cross-site') return false
+  const origin = req.headers.origin
+  if (origin === undefined) return req.headers['sec-fetch-site'] === 'same-origin'
+  try {
+    return new URL(origin).host === host.host
+  } catch {
+    return false
+  }
+}
+
+function matchesToken(candidate: string | string[] | undefined, expected: string | undefined): boolean {
+  if (typeof candidate !== 'string' || expected === undefined || candidate === '' || expected === '') return false
+  const actual = Buffer.from(candidate)
+  const wanted = Buffer.from(expected)
+  return actual.length === wanted.length && timingSafeEqual(actual, wanted)
+}
+
+/**
+ * Task-board route fence. Direct desktop access uses the repository-wide
+ * loopback socket + Host guard and additionally requires a browser same-origin
+ * marker: a bare local curl without any browser signal cannot exercise the
+ * agent control plane (a forged Origin does pass the marker — it is a
+ * tripwire, the socket/Host/origin-equality checks carry the authority).
+ * Authenticated proxies must be explicitly allowlisted and replace the
+ * internal token header after their own authentication step.
+ */
+export function isTrustedTaskBoardRequest(req: IncomingMessage, access: ResolvedRouteAccess): boolean {
+  if (!browserSameOriginMarker(req)) return false
+  if (isLoopbackRequest(req)) return true
+  if (!isLoopbackAddress(req.socket.remoteAddress)) return false
+  const host = req.headers.host
+  if (typeof host !== 'string') return false
+  const parsed = parseAuthority(host)
+  if (parsed === undefined || parsed.canonical !== host.toLowerCase()) return false
+  if (!access.trustedProxyHosts.has(parsed.canonical) || !sameAuthority(req, parsed.url)) return false
+  return matchesToken(req.headers[TASK_BOARD_PROXY_TOKEN_HEADER], access.proxyToken)
+}
+
+async function readBody(req: IncomingMessage): Promise<{ raw: string; value: unknown }> {
+  const chunks: Buffer[] = []
+  let size = 0
+  for await (const chunk of req) {
+    const buffer = chunk as Buffer
+    size += buffer.length
+    if (size > IMPORT_LIMIT) throw new Error('body-too-large')
+    chunks.push(buffer)
+  }
+  const raw = Buffer.concat(chunks).toString('utf8')
+  return { raw, value: JSON.parse(raw) }
+}
+
+export function makeTaskBoardRoutes(service: TaskBoardHostService, access: TaskBoardRouteAccess = {}): WebRoute[] {
+  const resolvedAccess = resolveAccess(access)
+  const guard = (req: IncomingMessage, res: ServerResponse): boolean => {
+    if (isTrustedTaskBoardRequest(req, resolvedAccess)) return true
+    json(res, 403, { ok: false, error: 'forbidden' })
+    return false
+  }
+  const state: WebRoute = {
+    kind: 'exact',
+    path: `${TASK_BOARD_API_PREFIX}/state`,
+    handler: (req, res): void => {
+      if (req.method !== 'GET') return json(res, 405, { ok: false, error: 'method-not-allowed' })
+      if (!guard(req, res)) return
+      json(res, 200, service.snapshot())
+    },
+  }
+  const action: WebRoute = {
+    kind: 'exact',
+    path: `${TASK_BOARD_API_PREFIX}/action`,
+    handler: async (req, res): Promise<void> => {
+      if (req.method !== 'POST') return json(res, 405, { ok: false, error: 'method-not-allowed' })
+      if (!guard(req, res)) return
+      if (!(req.headers['content-type'] ?? '').toLowerCase().startsWith('application/json')) {
+        return json(res, 415, { ok: false, error: 'json-required' })
+      }
+      try {
+        const body = await readBody(req)
+        const parsed = parseActionEnvelope(body.value)
+        if (parsed === undefined) return json(res, 400, { ok: false, error: 'invalid-action' })
+        if (parsed.action.kind !== 'import' && Buffer.byteLength(body.raw) > ACTION_LIMIT) {
+          return json(res, 413, { ok: false, error: 'body-too-large' })
+        }
+        json(res, 200, service.apply(parsed.requestId, parsed.action))
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        json(res, message === 'body-too-large' ? 413 : 400, { ok: false, error: message })
+      }
+    },
+  }
+  const events: WebRoute = {
+    kind: 'exact',
+    path: `${TASK_BOARD_API_PREFIX}/events`,
+    handler: (req, res): void => {
+      if (req.method !== 'GET') {
+        res.writeHead(405)
+        res.end()
+        return
+      }
+      if (!guard(req, res)) return
+      res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache',
+        connection: 'keep-alive',
+      })
+      const push = (): void => {
+        const payload = service.eventPayload()
+        res.write(`data: ${JSON.stringify(payload)}\n\n`)
+      }
+      const unsubscribe = service.subscribe(push)
+      const heartbeat = setInterval(() => { res.write(': ping\n\n') }, HEARTBEAT_MS)
+      const close = (): void => {
+        clearInterval(heartbeat)
+        unsubscribe()
+      }
+      req.once('close', close)
+      res.once('close', close)
+      push()
+    },
+  }
+  return [state, action, events]
+}

package/src/host-runner.ts

@@ -0,0 +1,152 @@
+import type { ApiProxy, RpcId } from '@deepseek-ai/dsh-host-apiproxy'
+import type { TaskRecord } from './core/tasks.ts'
+
+function request<T>(payload: T) {
+  return { rpcId: `task-board-${crypto.randomUUID()}` as RpcId, payload }
+}
+
+function failure(error: { code: string; message: string }): Error {
+  return new Error(`${error.code}: ${error.message}`)
+}
+
+/** One session-list row, extracted from the sessions.list RPC result. */
+export type SessionSummary = Extract<
+  Awaited<ReturnType<ApiProxy['sessions']['list']>>['result'],
+  { ok: true }
+>['value']['items'][number]
+
+export type ExecutionInspection =
+  | { outcome: 'pending' }
+  | { outcome: 'succeeded' }
+  | { outcome: 'failed'; error: string }
+  | { outcome: 'cancelled'; error: string }
+
+/** A post-create launch failure that still identifies the session to the ledger. */
+export class SessionLaunchError extends Error {
+  constructor(readonly sessionId: string, cause: unknown) {
+    super(`execution session ${sessionId} failed during launch: ${cause instanceof Error ? cause.message : String(cause)}`, { cause })
+    this.name = 'SessionLaunchError'
+  }
+}
+
+function isErrorTurnEnd(data: unknown): boolean {
+  if (typeof data !== 'object' || data === null) return false
+  const reason = (data as { reason?: unknown }).reason
+  return typeof reason === 'object' && reason !== null && (reason as { kind?: unknown }).kind === 'error'
+}
+
+export class HostExecutionRunner {
+  constructor(private readonly api: ApiProxy) {}
+
+  async launch(task: TaskRecord): Promise<string> {
+    if (task.workspaceId !== undefined) {
+      const workspaces = await this.api.workspace.list(request({}))
+      if (!workspaces.result.ok) throw failure(workspaces.result.error)
+      if (!workspaces.result.value.items.some(item => item.workspaceId === task.workspaceId)) {
+        throw new Error(`workspace not found: ${task.workspaceId}`)
+      }
+    }
+    if (task.mode !== undefined) {
+      const presets = await this.api.agentPresets.list(request({}))
+      if (!presets.result.ok) throw failure(presets.result.error)
+      const preset = presets.result.value.presets.find(item => item.id === task.mode)
+      if (preset === undefined) throw new Error(`agent preset not found: ${task.mode}`)
+      if (preset.broken !== undefined) throw new Error(`agent preset is unavailable: ${preset.broken}`)
+    }
+    const created = await this.api.sessions.create(request({
+      ...(task.workspaceId === undefined ? {} : { workspaceId: task.workspaceId as never }),
+      ...(task.mode === undefined ? {} : { agentPreset: task.mode }),
+    }))
+    if (!created.result.ok) throw failure(created.result.error)
+    const sessionId = created.result.value.sessionId
+    try {
+      const renamed = await this.api.sessions.rename(request({ sessionId, title: task.title }))
+      if (!renamed.result.ok) throw failure(renamed.result.error)
+      if (task.permission !== undefined) {
+        const command = await this.api.sessions.prompt(request({
+          sessionId,
+          mode: 'queue' as const,
+          content: [{ type: 'text' as const, text: `/permission ${task.permission}` }],
+        }))
+        if (!command.result.ok) throw failure(command.result.error)
+        if (command.result.value.command?.kind !== 'success') throw new Error('permission command was not acknowledged')
+      }
+      const prompt = await this.api.sessions.prompt(request({
+        sessionId,
+        mode: 'queue' as const,
+        content: [{ type: 'text' as const, text: task.prompt !== '' ? task.prompt : task.title }],
+      }))
+      if (!prompt.result.ok) throw failure(prompt.result.error)
+    } catch (error) {
+      throw new SessionLaunchError(sessionId, error)
+    }
+    return sessionId
+  }
+
+  async listRunning(): Promise<{ known: true; count: number; items: SessionSummary[] } | { known: false }> {
+    try {
+      const response = await this.api.sessions.list(request({}))
+      return response.result.ok
+        ? { known: true, count: response.result.value.items.filter(item => item.running).length, items: response.result.value.items }
+        : { known: false }
+    } catch {
+      return { known: false }
+    }
+  }
+
+  /**
+   * Resolve one execution's outcome. The caller may pass the session list it
+   * already fetched this poll tick; otherwise inspect lists sessions itself.
+   * Sharing the list keeps a poll with E open executions at one list RPC
+   * instead of 1 + E.
+   */
+  async inspect(sessionId: string, startedAt = 0, sessions?: readonly SessionSummary[]): Promise<ExecutionInspection> {
+    let items: readonly SessionSummary[]
+    if (sessions !== undefined) {
+      items = sessions
+    } else {
+      const response = await this.api.sessions.list(request({}))
+      if (!response.result.ok) return { outcome: 'pending' }
+      items = response.result.value.items
+    }
+    const summary = items.find(item => item.sessionId === sessionId)
+    if (summary === undefined) return { outcome: 'cancelled', error: 'execution session no longer exists' }
+    if (summary.running) return { outcome: 'pending' }
+    const events: Array<{ event: { type: string; seq?: number; time?: number; data: unknown } }> = []
+    let beforeSeq: number | undefined
+    let reachedExecutionBoundary = false
+    for (let page = 0; page < 100; page += 1) {
+      const history = await this.api.sessions.history(request({
+        sessionId: summary.sessionId,
+        maxMessages: 100,
+        ...(beforeSeq === undefined ? {} : { beforeSeq }),
+      }))
+      if (!history.result.ok) return { outcome: 'pending' }
+      events.push(...history.result.value.events)
+      const oldestTime = history.result.value.events.reduce<number | undefined>((oldest, entry) => {
+        const time = entry.event.time
+        return typeof time !== 'number' ? oldest : oldest === undefined ? time : Math.min(oldest, time)
+      }, undefined)
+      if (!history.result.value.hasMore || (oldestTime !== undefined && oldestTime <= startedAt)) {
+        reachedExecutionBoundary = true
+        break
+      }
+      const oldestSeq = history.result.value.events.reduce<number | undefined>((oldest, entry) => {
+        const seq = entry.event.seq
+        return typeof seq !== 'number' ? oldest : oldest === undefined ? seq : Math.min(oldest, seq)
+      }, undefined)
+      if (oldestSeq === undefined || oldestSeq === beforeSeq) return { outcome: 'pending' }
+      beforeSeq = oldestSeq
+    }
+    if (!reachedExecutionBoundary) return { outcome: 'pending' }
+    const turnEnd = events
+      .filter(entry => entry.event.type === 'turn/end' && (
+        startedAt <= 0 || (typeof entry.event.time === 'number' && entry.event.time >= startedAt)
+      ))
+      .sort((a, b) => (a.event.seq ?? Number.MAX_SAFE_INTEGER) - (b.event.seq ?? Number.MAX_SAFE_INTEGER))[0]
+    if (turnEnd === undefined) return { outcome: 'pending' }
+    return isErrorTurnEnd(turnEnd.event.data)
+      ? { outcome: 'failed', error: 'agent turn ended with an error' }
+      : { outcome: 'succeeded' }
+  }
+}

package/src/host-service.ts

@@ -0,0 +1,226 @@
+import type { ApiProxy } from '@deepseek-ai/dsh-host-apiproxy'
+import { nextRunAtMs } from './core/schedule.ts'
+import type { TaskRecord } from './core/tasks.ts'
+import { HostTaskLedger, type OpenedRun } from './host-ledger.ts'
+import { HostExecutionRunner, SessionLaunchError, type SessionSummary } from './host-runner.ts'
+import { PowerInhibitor } from './power-inhibitor.ts'
+import type { TaskBoardAction, TaskBoardEventPayload, TaskBoardSnapshot } from './protocol.ts'
+
+const SESSION_POLL_MS = 5_000
+const SCHEDULE_TICK_MS = 30_000
+const RESUME_GAP_MS = SCHEDULE_TICK_MS + 15_000
+
+export class TaskBoardHostService {
+  readonly ledger: HostTaskLedger
+  readonly runner: HostExecutionRunner
+  readonly power: PowerInhibitor
+  private readonly listeners = new Set<() => void>()
+  private timers: Array<ReturnType<typeof setInterval>> = []
+  private lastScheduleTick: number | undefined
+  private disposed = false
+  private pollInFlight = false
+  private tickInFlight = false
+  private active = true
+  private preventIdleSleep = false
+  private lastPowerJson = ''
+  private readonly now: () => number
+
+  constructor(api: ApiProxy, options: { ledger?: HostTaskLedger; power?: PowerInhibitor; now?: () => number } = {}) {
+    this.ledger = options.ledger ?? new HostTaskLedger()
+    this.runner = new HostExecutionRunner(api)
+    this.power = options.power ?? new PowerInhibitor()
+    this.now = options.now ?? Date.now
+    this.ledger.subscribe(() => {
+      this.syncPowerReasons()
+      this.emit()
+    })
+    this.power.subscribe(() => {
+      // updateReasons emits on every poll tick even when nothing changed;
+      // gate on the actual snapshot so the 5 s heartbeat does not push an
+      // empty SSE frame per tab forever.
+      const json = JSON.stringify(this.power.snapshot())
+      if (json === this.lastPowerJson) return
+      this.lastPowerJson = json
+      this.emit()
+    })
+  }
+
+  start(): void {
+    if (this.disposed || this.timers.length > 0) return
+    this.syncPowerReasons()
+    this.timers.push(setInterval(() => { this.schedulePoll() }, SESSION_POLL_MS))
+    this.timers.push(setInterval(() => { this.scheduleTick(false) }, SCHEDULE_TICK_MS))
+    this.schedulePoll()
+    this.scheduleTick(true)
+  }
+
+  setConfiguration(active: boolean, preventIdleSleep: boolean): void {
+    const resumed = !this.active && active
+    this.active = active
+    this.preventIdleSleep = preventIdleSleep
+    if (resumed) {
+      const current = this.power.snapshot()
+      this.power.updateReasons({
+        runningSessions: current.runningSessions,
+        armedSchedules: this.armedSchedules(),
+        sessionStateKnown: false,
+      })
+    }
+    this.power.setEnabled(active && preventIdleSleep)
+    if (resumed) {
+      this.schedulePoll()
+      this.scheduleTick(true)
+    }
+    this.emit()
+  }
+
+  snapshot(): TaskBoardSnapshot {
+    const state = this.ledger.state()
+    return {
+      schemaVersion: 2,
+      revision: state.revision,
+      tasks: state.tasks,
+      scheduler: state.scheduler,
+      power: this.power.snapshot(),
+    }
+  }
+
+  /** SSE frame payload; deliberately skips the tasks deep-clone of {@link snapshot}. */
+  eventPayload(): TaskBoardEventPayload {
+    const { revision, scheduler } = this.ledger.summary()
+    return { revision, scheduler, power: this.power.snapshot() }
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener)
+    return () => { this.listeners.delete(listener) }
+  }
+
+  apply(requestId: string, action: TaskBoardAction): TaskBoardSnapshot {
+    if (!this.active) throw new Error('task board is disabled')
+    const result = this.ledger.applyRequest(requestId, action)
+    if (result.run !== undefined) this.scheduleLaunch(result.run)
+    return {
+      schemaVersion: 2,
+      revision: result.state.revision,
+      tasks: result.state.tasks,
+      scheduler: result.state.scheduler,
+      power: this.power.snapshot(),
+    }
+  }
+
+  dispose(): void {
+    this.disposed = true
+    for (const timer of this.timers.splice(0)) clearInterval(timer)
+    this.power.dispose()
+    this.ledger.dispose()
+    this.listeners.clear()
+  }
+
+  private async launch(opened: OpenedRun): Promise<void> {
+    try {
+      const sessionId = await this.runner.launch(opened.task)
+      this.ledger.attachSession(opened.task.id, opened.execution.id, sessionId)
+    } catch (error) {
+      if (error instanceof SessionLaunchError) {
+        this.ledger.attachSession(opened.task.id, opened.execution.id, error.sessionId)
+      }
+      this.ledger.settle(opened.task.id, opened.execution.id, 'failed', error instanceof Error ? error.message : String(error))
+    }
+  }
+
+  private async pollSessions(): Promise<void> {
+    if (this.disposed) return
+    if (!this.active && !this.hasOpenExecutions()) return
+    const running = await this.runner.listRunning()
+    const previous = this.power.snapshot()
+    this.power.updateReasons({
+      runningSessions: running.known ? running.count : previous.runningSessions,
+      armedSchedules: this.armedSchedules(),
+      sessionStateKnown: running.known,
+    })
+    // No unconditional emit here: real changes already emit through the
+    // ledger subscription (settles) and the gated power listener above.
+    if (running.known) await this.reconcileExecutions(running.items)
+  }
+
+  /** Reuse the session list this poll already fetched: one list RPC per tick, not 1 + E. */
+  private async reconcileExecutions(sessions: readonly SessionSummary[]): Promise<void> {
+    for (const task of this.ledger.state().tasks) {
+      for (const execution of task.executions) {
+        if (execution.sessionId === undefined || execution.endedAt !== undefined) continue
+        try {
+          const result = await this.runner.inspect(execution.sessionId, execution.startedAt, sessions)
+          if (result.outcome === 'pending') continue
+          this.ledger.settle(task.id, execution.id, result.outcome, 'error' in result ? result.error : undefined)
+        } catch {
+          // A transient inspection failure never settles a running execution.
+        }
+      }
+    }
+  }
+
+  private async tickSchedule(first: boolean): Promise<void> {
+    if (this.disposed || !this.active) return
+    const now = this.now()
+    const recovered = first || (this.lastScheduleTick !== undefined && now - this.lastScheduleTick > RESUME_GAP_MS)
+    this.lastScheduleTick = now
+    this.ledger.setScheduler({ lastTickAt: now })
+    if (recovered) {
+      this.ledger.skipMissed(now)
+      return
+    }
+    for (const task of this.ledger.state().tasks) {
+      if (task.archivedAt !== undefined) continue
+      const schedule = task.schedule
+      if (schedule === undefined || !schedule.enabled || schedule.nextRunAt === undefined || schedule.nextRunAt > now) continue
+      const next = nextRunAtMs(schedule.cron, schedule.nextRunAt)
+      const opened = this.ledger.openScheduled(task.id, next, now)
+      if (opened !== undefined) this.scheduleLaunch(opened)
+    }
+  }
+
+  private armedSchedules(): number {
+    return this.ledger.state().tasks.filter((task: TaskRecord) => task.archivedAt === undefined && task.schedule?.enabled === true).length
+  }
+
+  private hasOpenExecutions(): boolean {
+    return this.ledger.state().tasks.some(task => task.executions.some(execution => execution.endedAt === undefined))
+  }
+
+  private scheduleLaunch(opened: OpenedRun): void {
+    void this.launch(opened).catch(error => {
+      console.error('[dsh-task-board] execution launch settlement failed', error)
+    })
+  }
+
+  private schedulePoll(): void {
+    if (this.pollInFlight || this.disposed) return
+    this.pollInFlight = true
+    void this.pollSessions().catch(error => {
+      console.error('[dsh-task-board] session polling failed', error)
+    }).finally(() => { this.pollInFlight = false })
+  }
+
+  private scheduleTick(first: boolean): void {
+    if (this.tickInFlight || this.disposed) return
+    this.tickInFlight = true
+    void this.tickSchedule(first).catch(error => {
+      console.error('[dsh-task-board] scheduler tick failed', error)
+    }).finally(() => { this.tickInFlight = false })
+  }
+
+  private syncPowerReasons(): void {
+    const current = this.power.snapshot()
+    this.power.updateReasons({
+      runningSessions: current.runningSessions,
+      armedSchedules: this.armedSchedules(),
+      sessionStateKnown: current.sessionStateKnown,
+    })
+    this.power.setEnabled(this.active && this.preventIdleSleep)
+  }
+
+  private emit(): void {
+    for (const listener of [...this.listeners]) listener()
+  }
+}