@linxin666/dsh-remote-web-ui 0.3.6 → 0.3.9

package/src/mobile/mux.ts

@@ -1,336 +0,0 @@
-/**
- * Mobile-surface live-event client: the plugin's `/m/api/events.mux` SSE
- * channel (Server-Sent Events — the host bridges the mux stream onto it, so
- * no WebSocket handshake or framing is needed on this side). The host
- * pushes mux frames (subscribed baselines, session events, approvals,
- * questions, queue snapshots, tasks, projections) as soon as the stream
- * opens — no subscription handshake is needed. Frames arrive as
- * server-request envelopes whose payload is the mux frame; unknown frame
- * types are dropped so a newer host never breaks this client.
- *
- * EventSource reconnects automatically — but only over a tunnel that
- * actually forwards frames. Public quick tunnels (Cloudflare quick tunnel /
- * Tailscale Serve) do not transparently pass Server-Sent Events: ordinary
- * HTTP works, yet the SSE connection stays open or reconnects with zero
- * bytes, so no live frame ever arrives. That is a transport-layer limit of
- * the tunnel, not something the host can fix. This client therefore
- * degrades gracefully: once the SSE channel has silently stalled (no frame
- * for {@link MuxClientOptions.stallThresholdMs}, or the EventSource reports
- * an error), it starts polling the open session's history over plain HTTP
- * (the `/m/api/session.history` RPC — unaffected by the SSE limitation),
- * and re-emits freshly appended events as `session/event` frames through
- * the same subscriber contract, so listeners (and the message fold) behave
- * exactly as if the frames had arrived over SSE. When the SSE channel
- * delivers again, fallback polling stops and the live stream takes over.
- */
-
-import type { MuxFrame } from '@deepseek-ai/dsh-host-apiproxy/api/events'
-import { muxFrameSchema } from '@deepseek-ai/dsh-host-apiproxy/api/events.schema'
-import { serverRequestSchema } from '@deepseek-ai/dsh-host-apiproxy/api/rpc.schema'
-import { history as fetchHistory, type HistoryPage } from './api.ts'
-
-/** Injectable seams for tests. */
-export interface MuxClientOptions {
-  /** EventSource factory (defaults to the browser EventSource). */
-  sourceFactory?: (url: string) => EventSourceLike
-  /**
-   * Fetch one history page (tail) for a session — the polling fallback's
-   * data source. Defaults to the mobile `session.history` RPC, which rides
-   * the ordinary HTTP channel (unaffected by SSE-impairing tunnels).
-   */
-  pollLatest?: (sessionId: string) => Promise<HistoryPage>
-  /** Initial poll cadence while SSE is stalled (default 3000 ms). Empty polls back off to 60000 ms. */
-  pollIntervalMs?: number
-  /** Initial SSE stall window (default 12000 ms); a previously-live stream gets three windows before fallback. */
-  stallThresholdMs?: number
-  /** Clock seam for tests (defaults to Date.now). */
-  now?: () => number
-}
-
-/** The EventSource subset this client uses (browser EventSource fits). */
-export interface EventSourceLike {
-  onmessage: ((event: { data: string }) => void) | null
-  onerror: ((event: unknown) => void) | null
-  close(): void
-}
-
-/** Browser default source factory. */
-function browserSource(url: string): EventSourceLike {
-  // The DOM EventSource is structurally compatible; the `this`-typed handler
-  // signatures differ, so the narrow face takes it through an adapter cast.
-  return new EventSource(url) as unknown as EventSourceLike
-}
-
-/** The `session/event` arm of the mux frame union. */
-type SessionEventFrame = Extract<MuxFrame, { type: 'session/event' }>
-
-const DEFAULT_POLL_INTERVAL_MS = 3000
-const DEFAULT_STALL_THRESHOLD_MS = 12000
-const LIVE_SSE_STALL_MULTIPLIER = 3
-const MAX_POLL_BACKOFF_MS = 60000
-/**
- * Stall-check granularity: the single scheduler tick runs at least this
- * often so fallback arms within a second of the stall threshold passing,
- * while the poll cadence itself stays {@link MuxClientOptions.pollIntervalMs}.
- */
-const STALL_CHECK_MS = 1000
-/** Poll window: enough recent events to cover a few seconds of agent output. */
-const DEFAULT_POLL_PAGE_SIZE = 50
-
-/**
- * Keep one SSE subscription open, fanning validated frames out to
- * subscribers. EventSource owns reconnection (with its own backoff); this
- * class only manages the subscription lifecycle, plus a polling fallback
- * that keeps the open session live when the SSE channel cannot deliver.
- */
-export class MuxClient {
-  private readonly sourceFactory: (url: string) => EventSourceLike
-  private readonly pollLatest: (sessionId: string) => Promise<HistoryPage>
-  private readonly pollIntervalMs: number
-  private readonly stallThresholdMs: number
-  private readonly now: () => number
-  private readonly listeners = new Set<(frame: MuxFrame) => void>()
-  private source: EventSourceLike | undefined
-  private stopped = false
-  private readonly url: string
-
-  /** The session to keep live via fallback polling (undefined = none). */
-  private observeSessionId: string | undefined
-  /** Last epoch ms the SSE channel produced a frame (or the stream opened). */
-  private lastDataAt = 0
-  /**
-   * Whether the SSE channel has ever delivered a frame in this stream (a
-   * delivered frame proves the tunnel can forward SSE; sustained silence may
-   * still mean a suspended mobile tunnel, so polling re-arms after 3 windows).
-   */
-  private sseAlive = false
-  /** Per-session highest event seq already emitted, for poll dedup. */
-  private readonly pollWatermark = new Map<string, number>()
-  /** Single scheduler tick: both the stall check and the poll cadence ride this one interval. */
-  private tickTimer: ReturnType<typeof setInterval> | undefined
-  private polling = false
-  /** Epoch ms of the next due poll while polling (kept on the same tick timer). */
-  private nextPollAt = 0
-  /** Adaptive delay: productive polls reset it; empty/error polls add one base interval up to one minute. */
-  private pollDelayMs: number
-
-  /**
-   * @param url - the mobile events endpoint (browser-relative).
-   * @param options - seams.
-   */
-  constructor(url = '/m/api/events.mux', options: MuxClientOptions = {}) {
-    this.url = url
-    this.sourceFactory = options.sourceFactory ?? browserSource
-    this.pollLatest = options.pollLatest ?? ((sessionId) => fetchHistory(sessionId, undefined, DEFAULT_POLL_PAGE_SIZE))
-    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS
-    this.pollDelayMs = this.pollIntervalMs
-    this.stallThresholdMs = options.stallThresholdMs ?? DEFAULT_STALL_THRESHOLD_MS
-    this.now = options.now ?? (() => Date.now())
-  }
-
-  /** Open the stream (idempotent; EventSource reconnects until {@link stop}). */
-  start(): void {
-    this.stopped = false
-    this.lastDataAt = this.now()
-    if (this.source === undefined) this.connect()
-    this.startTick()
-  }
-
-  /** Close for good. */
-  stop(): void {
-    this.stopped = true
-    this.stopTick()
-    this.stopPolling()
-    this.closeSource()
-    this.observeSessionId = undefined
-    this.nextPollAt = 0
-  }
-
-  /** Subscribe to validated frames; returns an unsubscribe function. */
-  onFrame(listener: (frame: MuxFrame) => void): () => void {
-    this.listeners.add(listener)
-    return () => { this.listeners.delete(listener) }
-  }
-
-  /**
-   * Point the fallback at one open session (or `undefined` to stop it).
-   * While the SSE channel is stalled this client polls that session's
-   * history and re-emits new events as `session/event` frames.
-   */
-  observe(sessionId: string | undefined): void {
-    this.observeSessionId = sessionId
-    if (sessionId === undefined) {
-      this.stopPolling()
-      return
-    }
-    // If SSE is already stalled for this session, start patching right away.
-    if (!this.polling && !this.stopped && this.isSseStalled()) this.startPolling()
-  }
-
-  private connect(): void {
-    // A fresh stream starts unknown; only a delivered frame proves it works.
-    this.sseAlive = false
-    const source = this.sourceFactory(this.url)
-    this.source = source
-    source.onmessage = (event) => {
-      this.handleMessage(event.data)
-    }
-    source.onerror = () => {
-      // EventSource reconnects by itself; when we are closing, detach first
-      // so the native reconnect cannot outlive stop(). Otherwise an error is
-      // a strong signal the transport is not delivering — degrade to polling.
-      if (this.stopped && this.source === source) {
-        this.closeSource()
-        return
-      }
-      this.sseAlive = false
-      if (this.observeSessionId !== undefined) this.startPolling()
-    }
-  }
-
-  /**
-   * The single scheduler tick is the only interval this client owns. One
-   * timer (at the finer of the stall-check and poll cadences) both arms the
-   * polling fallback once the stall threshold passes and drives each poll at
-   * {@link MuxClientOptions.pollIntervalMs} — one timer instead of two.
-   */
-  private startTick(): void {
-    if (this.tickTimer !== undefined) return
-    const cadence = Math.min(this.pollIntervalMs, STALL_CHECK_MS)
-    this.tickTimer = setInterval(() => { this.tick() }, cadence)
-  }
-
-  private stopTick(): void {
-    if (this.tickTimer !== undefined) {
-      clearInterval(this.tickTimer)
-      this.tickTimer = undefined
-    }
-  }
-
-  private tick(): void {
-    if (this.stopped) return
-    if (this.observeSessionId === undefined) return
-    if (this.polling) {
-      // The stall phase has ended; the same tick now paces the adaptive polls.
-      if (this.now() >= this.nextPollAt) {
-        // pollTick schedules the next run after it settles, so slow requests
-        // cannot overlap with another scheduler tick.
-        this.nextPollAt = Number.POSITIVE_INFINITY
-        void this.pollTick()
-      }
-      return
-    }
-    if (this.isSseStalled()) this.startPolling()
-  }
-
-  private isSseStalled(): boolean {
-    const windowMs = this.sseAlive
-      ? this.stallThresholdMs * LIVE_SSE_STALL_MULTIPLIER
-      : this.stallThresholdMs
-    return (this.now() - this.lastDataAt) > windowMs
-  }
-
-  private startPolling(): void {
-    if (this.polling || this.stopped) return
-    this.polling = true
-    this.pollDelayMs = this.pollIntervalMs
-    this.nextPollAt = Number.POSITIVE_INFINITY
-    void this.pollTick()
-  }
-
-  private stopPolling(): void {
-    this.polling = false
-    this.pollDelayMs = this.pollIntervalMs
-    this.nextPollAt = 0
-  }
-
-  /**
-   * Fetch the latest history page for the observed session and re-emit any
-   * event above the per-session watermark as a `session/event` frame.
-   * Idempotent by seq: listeners (and the fold) never see a duplicate.
-   */
-  private async pollTick(): Promise<void> {
-    const sessionId = this.observeSessionId
-    if (sessionId === undefined) {
-      this.stopPolling()
-      return
-    }
-    let emitted = 0
-    try {
-      const page = await this.pollLatest(sessionId)
-      let maxSeq = this.pollWatermark.get(sessionId) ?? -1
-      const ordered = [...page.events].sort((left, right) => {
-        const leftSeq = typeof left.event?.seq === 'number' ? left.event.seq : -1
-        const rightSeq = typeof right.event?.seq === 'number' ? right.event.seq : -1
-        return leftSeq - rightSeq
-      })
-      for (const entry of ordered) {
-        const event = entry.event
-        const seq = typeof event?.seq === 'number' ? event.seq : -1
-        if (seq <= maxSeq) continue
-        maxSeq = seq
-        emitted += 1
-        this.emit({ type: 'session/event', sessionId: sessionId as SessionEventFrame['sessionId'], event } as SessionEventFrame)
-      }
-      this.pollWatermark.set(sessionId, maxSeq)
-    } catch {
-      // Transient (network, pairing, history paging); retry with backoff.
-    } finally {
-      if (emitted > 0) {
-        this.pollDelayMs = this.pollIntervalMs
-      } else {
-        this.pollDelayMs = Math.min(MAX_POLL_BACKOFF_MS, this.pollDelayMs + this.pollIntervalMs)
-      }
-      if (this.polling && this.observeSessionId === sessionId) {
-        this.nextPollAt = this.now() + this.pollDelayMs
-      }
-    }
-  }
-
-  private handleMessage(data: string): void {
-    if (typeof data !== 'string' || data === '') return
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(data)
-    } catch {
-      return
-    }
-    // The SSE channel carries server-request envelopes whose payload is the
-    // mux frame (same wire shape as the desktop mux channel).
-    const envelope = serverRequestSchema.safeParse(parsed)
-    if (!envelope.success) return
-    const frame = muxFrameSchema.safeParse(envelope.data.payload)
-    if (!frame.success) return
-    // A delivered frame proves the SSE channel is live (the tunnel forwards
-    // it) and delivers again — drop any fallback polling so the live stream
-    // takes over without double delivery.
-    this.sseAlive = true
-    this.lastDataAt = this.now()
-    if (this.polling) this.stopPolling()
-    this.emit(frame.data)
-  }
-
-  private emit(frame: MuxFrame): void {
-    for (const listener of this.listeners) {
-      try {
-        listener(frame)
-      } catch {
-        // A throwing subscriber must not break the emit loop.
-      }
-    }
-  }
-
-  private closeSource(): void {
-    const source = this.source
-    this.source = undefined
-    if (source !== undefined) {
-      source.onmessage = null
-      source.onerror = null
-      try {
-        source.close()
-      } catch {
-        // Already closed.
-      }
-    }
-  }
-}

package/src/mobile/pairing.ts

@@ -1,77 +0,0 @@
-/** Pairing helpers owned by the standalone /m mobile surface. */
-export type PairFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
-
-export interface MobilePairInput {
-  token: string
-  workspaceId?: string
-}
-
-export type MobilePairAccept =
-  | { ok: true }
-  | { ok: false; message: string }
-
-export type MobilePairBootstrap =
-  | { kind: 'none' }
-  | { kind: 'accepted'; path: string }
-  | { kind: 'failed'; path: string; message: string }
-
-const MOBILE_ROOT = '/m/'
-
-/** Parse a pairing token or a copied pairing link without following its origin. */
-export function parseMobilePairInput(value: string): MobilePairInput | undefined {
-  const trimmed = value.trim()
-  if (trimmed === '') return undefined
-
-  try {
-    const url = new URL(trimmed)
-    const token = url.searchParams.get('pair')
-    if (token === null || token === '') return undefined
-    const workspaceId = url.searchParams.get('workspace')
-    return {
-      token,
-      ...(workspaceId !== null && workspaceId !== '' ? { workspaceId } : {}),
-    }
-  } catch {
-    return { token: trimmed }
-  }
-}
-
-/** Build the safe, token-free mobile destination after successful pairing. */
-export function mobilePairPath(workspaceId?: string): string {
-  return workspaceId === undefined ? MOBILE_ROOT : MOBILE_ROOT + '?workspace=' + encodeURIComponent(workspaceId)
-}
-
-/** Accept one pairing token on this exact browser or installed-web-app context. */
-export async function acceptMobilePair(token: string, fetcher: PairFetch = fetch): Promise<MobilePairAccept> {
-  try {
-    const response = await fetcher('/api/pair/accept', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ token }),
-    })
-    if (response.ok) return { ok: true }
-    if (response.status === 404) return { ok: false, message: '配对链接无效或已过期。' }
-    if (response.status === 409) return { ok: false, message: '配对链接已被使用。' }
-    return { ok: false, message: '此设备无法使用该配对链接。' }
-  } catch {
-    return { ok: false, message: '无法连接到配对服务。' }
-  }
-}
-
-/** Consume a QR pairing token before the mobile application starts making RPC calls. */
-export async function consumeMobilePairUrl(href: string, fetcher: PairFetch = fetch): Promise<MobilePairBootstrap> {
-  let url: URL
-  try {
-    url = new URL(href)
-  } catch {
-    return { kind: 'none' }
-  }
-
-  const token = url.searchParams.get('pair')
-  if (token === null || token === '') return { kind: 'none' }
-
-  const workspaceId = url.searchParams.get('workspace')
-  const path = mobilePairPath(workspaceId === null || workspaceId === '' ? undefined : workspaceId)
-  const result = await acceptMobilePair(token, fetcher)
-  return result.ok ? { kind: 'accepted', path } : { kind: 'failed', path, message: result.message }
-}

package/src/mobile/rpc.ts

@@ -1,90 +0,0 @@
-/**
- * Mobile-surface unary RPC over the shared /api transport: the four-quadrant
- * envelope (client-request → server-response), minted rpcIds, and typed
- * error mapping. This is a thin, self-contained slice of the harness
- * apiproxy fetch carrier — the mobile page is an independent bundle and must
- * not depend on the main UI's module loader, so the wire contract is
- * reimplemented here over plain fetch.
- */
-
-/** Transport-level failure (network, HTTP status, malformed envelope). */
-export class RpcTransportError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'RpcTransportError'
-  }
-}
-
-/** A business error the host answered with (200 + err result). */
-export class RpcCallError extends Error {
-  /** The wire error (code + message + details). */
-  readonly error: { code: string; message: string }
-
-  constructor(error: { code: string; message: string }) {
-    super(error.message)
-    this.name = 'RpcCallError'
-    this.error = error
-  }
-}
-
-let rpcCounter = 0
-
-/** Mint one process-unique rpcId (stable under crypto.randomUUID absence). */
-export function mintRpcId(): string {
-  const random = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
-    ? crypto.randomUUID()
-    : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
-  rpcCounter += 1
-  return `${random}-${rpcCounter.toString(36)}`
-}
-
-/**
- * One unary call: POST /m/api/<method> (the plugin's own mobile channel —
- * NOT the connection plugin's /api prefix, so the tunneled Host never needs
- * to enter the transport trust fence) with the client-request envelope,
- * resolve the server-response value, reject with the mapped error classes.
- * @param method - the dotted RPC method, e.g. `session.list`.
- * @param payload - the business payload.
- * @param signal - optional abort.
- * @returns the response value.
- */
-export async function callUnary<T>(
-  method: string,
-  payload: unknown,
-  signal?: AbortSignal,
-): Promise<T> {
-  const rpcId = mintRpcId()
-  let response: Response
-  try {
-    response = await fetch(`/m/api/${method}`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ type: 'client-request', rpcId, method, payload }),
-      ...(signal !== undefined ? { signal } : {}),
-    })
-  } catch (error) {
-    const reason = error instanceof DOMException && error.name === 'AbortError'
-      ? 'aborted'
-      : error instanceof Error ? error.message : String(error)
-    throw new RpcTransportError(`transport failed: ${reason}`)
-  }
-  if (!response.ok) {
-    throw new RpcTransportError(`HTTP ${String(response.status)}`)
-  }
-  let envelope: unknown
-  try {
-    envelope = await response.json()
-  } catch {
-    throw new RpcTransportError('malformed response body')
-  }
-  const parsed = envelope as { type?: unknown; rpcId?: unknown; result?: unknown }
-  if (parsed?.type !== 'server-response' || parsed.rpcId !== rpcId) {
-    throw new RpcTransportError('response envelope mismatch')
-  }
-  const result = parsed.result as { ok?: boolean; value?: unknown; error?: { code: string; message: string } }
-  if (result?.ok === true) return result.value as T
-  if (result?.ok === false && result.error !== undefined) {
-    throw new RpcCallError(result.error)
-  }
-  throw new RpcTransportError('malformed result envelope')
-}

package/src/mobile/theme-toggle.tsx

@@ -1,47 +0,0 @@
-/**
- * Theme toggle button: sits at the right end of every view header and flips
- * the mobile surface between the light (default) and dark palettes. The
- * glyph shows the theme you will switch TO (moon in light mode, sun in dark
- * mode); the choice persists across visits.
- */
-
-import { useSyncExternalStore } from 'react'
-import { getMobileTheme, subscribeMobileTheme, toggleMobileTheme } from './mobile-theme.ts'
-
-/** Sun glyph: circle + eight rays (inline SVG, no emoji). */
-function SunIcon() {
-  return (
-    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" aria-hidden>
-      <circle cx="12" cy="12" r="4.2" />
-      <path d="M12 2.5v2.4M12 19.1v2.4M2.5 12h2.4M19.1 12h2.4M5 5l1.7 1.7M17.3 17.3 19 19M19 5l-1.7 1.7M6.7 17.3 5 19" />
-    </svg>
-  )
-}
-
-/** Moon glyph: crescent path (inline SVG, no emoji). */
-function MoonIcon() {
-  return (
-    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" strokeLinejoin="round" aria-hidden>
-      <path d="M20 14.5A8.5 8.5 0 0 1 9.5 4a8.5 8.5 0 1 0 10.5 10.5Z" />
-    </svg>
-  )
-}
-
-/**
- * Render the header theme toggle.
- * @returns the toggle button.
- */
-export function ThemeToggle() {
-  const theme = useSyncExternalStore(subscribeMobileTheme, getMobileTheme)
-  const dark = theme === 'dark'
-  return (
-    <button
-      type="button"
-      className="mobile-theme-toggle"
-      aria-label={dark ? '切换到浅色' : '切换到深色'}
-      onClick={() => { toggleMobileTheme() }}
-    >
-      {dark ? <SunIcon /> : <MoonIcon />}
-    </button>
-  )
-}

package/src/mobile/views/App.test.tsx

@@ -1,62 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { cleanup, render, screen, waitFor } from '@testing-library/react'
-import { RpcTransportError } from '../rpc.ts'
-
-const api = vi.hoisted(() => ({
-  fetchMobilePreferences: vi.fn(),
-  history: vi.fn(),
-  listSessions: vi.fn(),
-  listWorkspaces: vi.fn(),
-  prompt: vi.fn(),
-}))
-
-vi.mock('../api.ts', () => api)
-vi.mock('../mux.ts', () => ({
-  MuxClient: class {
-    start(): void {}
-    stop(): void {}
-    observe(): void {}
-  },
-}))
-vi.mock('./WorkspaceView.tsx', () => ({ WorkspaceView: () => <div>workspace-ready</div> }))
-vi.mock('./SessionListView.tsx', () => ({ SessionListView: () => <div>sessions-ready</div> }))
-vi.mock('./ChatView.tsx', () => ({ ChatView: () => <div>chat-ready</div> }))
-
-import { App, mobilePairStateForError } from './App.tsx'
-
-afterEach(() => {
-  cleanup()
-  vi.clearAllMocks()
-})
-
-describe('mobile paired-device gate', () => {
-  it('distinguishes a missing paired cookie from a transport outage', () => {
-    expect(mobilePairStateForError(new RpcTransportError('HTTP 403'))).toBe('unpaired')
-    expect(mobilePairStateForError(new RpcTransportError('HTTP 503'))).toBe('unavailable')
-    expect(mobilePairStateForError(new Error('offline'))).toBe('unavailable')
-  })
-
-  it('keeps a valid paired context usable after a failed QR token', async () => {
-    api.fetchMobilePreferences.mockResolvedValue({ mobileEnterToSend: true })
-    render(<App initialPairError="配对链接已被使用。" />)
-
-    await waitFor(() => expect(screen.getByText('workspace-ready')).toBeDefined())
-    expect(screen.queryByRole('alert')).toBeNull()
-  })
-
-  it('shows the pairing screen only when the mobile gateway rejects the device', async () => {
-    api.fetchMobilePreferences.mockRejectedValue(new RpcTransportError('HTTP 403'))
-    render(<App initialPairError="配对链接已被使用。" />)
-
-    await waitFor(() => expect(screen.getByRole('alert').textContent).toContain('配对链接已被使用。'))
-  })
-
-  it('shows a retryable connection failure rather than mounting remote views on outage', async () => {
-    api.fetchMobilePreferences.mockRejectedValue(new RpcTransportError('HTTP 503'))
-    render(<App />)
-
-    await waitFor(() => expect(screen.getByRole('alert').textContent).toContain('无法连接到运行中的 DSH host。'))
-    expect(screen.queryByText('workspace-ready')).toBeNull()
-  })
-})