feat(stories): cover device pairing flows in the Components Lab (#64490)

This commit is contained in:
usrnk1
2026-11-17 19:14:12 +01:00
committed by GitHub
Unverified
parent 18503ee942
commit 0e447fce16
8 changed files with 371 additions and 196 deletions
@@ -1,5 +1,19 @@
import { expect, story } from "../../stories/playwright/story"
story("the connect screen can retry a failed health check after scanning a one-time QR code", async ({ mount }) => {
const component = await mount("app-connect-to-server--retry-after-scan")
await component.getByRole("button", { name: "Read fixture QR code" }).click()
await expect(component.getByRole("alert")).toHaveText(
"Could not connect. Check the server address and password, then try again.",
)
await expect(component.getByLabel("Pairing link", { exact: true })).toHaveValue(
"https://build.example.test/auth/connect/example",
)
await component.getByRole("button", { name: "Connect", exact: true }).click()
await expect(component.getByRole("status")).toHaveText("Connected to https://build.example.test in this preview.")
})
story("a Keep screen active read that fails offers Try again and keeps the switch enabled", async ({ mount, page }) => {
// The page reads three more times, 1, 2 and 4 seconds apart, before it shows the failure.
await page.clock.install()
@@ -0,0 +1,222 @@
import { Button } from "@opencode/ui/button"
import { useDialog } from "@opencode/ui/context/dialog"
import { createEffect, createSignal, onMount, Show, type ComponentProps } from "solid-js"
import type { ServerConnection } from "@/runtime/server/registry"
import { createServerConnectController, type ServerConnectControllerOptions } from "./controller"
import { DialogServer } from "./dialog"
import type { ServerCameraSupport, ServerConnectEvent, ServerConnectField, ServerConnectTarget } from "./machine"
import { PairingScanner } from "./scanner"
import { ConnectServerForm } from "./screen"
export const address = "https://build.example.test"
export const link = `${address}/auth/connect/example`
export const field = (field: ServerConnectField, value: string) => ({ type: "field.changed", field, value }) as const
export const password = { type: "method.changed", method: "password" } satisfies ServerConnectEvent
export const submit = { type: "submitted" } satisfies ServerConnectEvent
type CameraScene = "ready" | "opening" | "denied" | "invalid" | "decode" | "expired" | "redeeming" | "timeout"
type Preset = {
camera?: ServerCameraSupport | "probing"
events?: Extract<ServerConnectEvent, { type: "field.changed" | "method.changed" | "submitted" }>[]
scanner?: CameraScene
exchange?: "expired" | "unreachable"
check?: "unreachable" | "pending"
}
type DialogPreset = Preset & { target?: Extract<ServerConnectTarget, { kind: "edit" }>; closed?: boolean }
export function serverStory(preset: DialogPreset = {}) {
return { render: () => <DialogStory preset={preset} /> }
}
function DialogStory(props: { preset: DialogPreset }) {
const dialog = useDialog()
const [saved, setSaved] = createSignal("")
const open = () => {
setSaved("")
void dialog.show(() => (
<DialogServer
mode={props.preset.target?.kind ?? "add"}
onSave={(server) => setSaved(server.displayName ?? server.http.url)}
createForm={(dialog) =>
createPreviewForm(
{ ...dialog, target: props.preset.target ?? { kind: "add" }, removeTabs() {} },
props.preset,
)
}
scanner={(scanner) => <CameraPreview {...scanner} scene={props.preset.scanner ?? "ready"} />}
/>
))
}
onMount(() => {
if (!props.preset.closed) open()
})
return (
<div class="flex flex-col items-start gap-3">
<Button variant="neutral" onClick={open}>
Open {props.preset.target?.kind ?? "add"} server dialog
</Button>
<Show when={saved()}>{(name) => <p role="status">Saved {name()} in this preview.</p>}</Show>
</div>
)
}
export function screenStory(preset: Preset & { url?: string } = {}) {
return { render: () => <ScreenStory preset={preset} /> }
}
function ScreenStory(props: { preset: Preset & { url?: string } }) {
const [connected, setConnected] = createSignal("")
// On success the app routes away. In the lab show the saved address and let the next run start with a fresh form.
const Screen = () => {
const form = createPreviewForm(
{ surface: "screen", target: { kind: "connect", url: props.preset.url } },
props.preset,
(server) => setConnected(server.http.url),
)
return (
<ConnectServerForm
form={form}
scanner={(scanner) => <CameraPreview {...scanner} scene={props.preset.scanner ?? "ready"} />}
/>
)
}
return (
<div class="flex h-dvh max-h-full min-h-0 w-full flex-col bg-v2-background-bg-base">
<Show when={connected()} fallback={<Screen />}>
{(url) => (
<div class="m-auto flex flex-col items-center gap-3 p-4">
<p role="status">Connected to {url()} in this preview.</p>
<Button variant="neutral" onClick={() => setConnected("")}>
Pair again
</Button>
</div>
)}
</Show>
</div>
)
}
function createPreviewForm(
options: ServerConnectControllerOptions,
preset: Preset,
onSave?: (server: ServerConnection.Http) => void,
) {
const pending = new Promise<never>(() => {})
const spent = new Set(["expired"])
let check = preset.check
let exchange = preset.exchange
const form = createServerConnectController(options, {
camera: preset.camera === "probing" ? "probe" : (preset.camera ?? "probe"),
probeCamera: () => (preset.camera === "probing" ? pending : Promise.resolve(true)),
pageHref: "https://lab.example.test",
servers: {
list: [],
add(server) {
onSave?.(server)
return server
},
remove() {},
},
exchange: async (request) => {
if (request.code === "pending") return pending
if (spent.has(request.code)) return { type: "expired" }
if (exchange) {
const type = exchange
exchange = undefined
if (type === "expired") spent.add(request.code)
return { type }
}
spent.add(request.code)
return { type: "paired", pairing: { url: request.urls[0], password: "fixture" } }
},
check: async () => {
if (check === "pending") return pending
if (check === "unreachable") {
check = undefined
return { type: "unreachable" }
}
await new Promise<void>((resolve) => setTimeout(resolve, 700))
return { type: "healthy" }
},
})
preset.events?.forEach(form.dispatch)
if (preset.scanner) {
let opened = false
createEffect(() => {
if (opened || !form.view().canScan) return
opened = true
form.dispatch({ type: "scan.started" })
})
}
return form
}
function CameraPreview(props: ComponentProps<typeof PairingScanner> & { scene: CameraScene }) {
let detect: ((data: string) => void) | undefined
const camera: NonNullable<ComponentProps<typeof PairingScanner>["camera"]> = (_, read, failed) => {
detect = read
let frame: ReturnType<typeof requestAnimationFrame>
return {
start: async () => {
if (props.scene === "denied") throw new Error("Camera permission denied")
if (props.scene === "opening") return new Promise<void>(() => {})
frame = requestAnimationFrame(() => {
if (props.scene === "invalid") read("not a pairing code")
if (props.scene === "decode") failed()
if (props.scene === "expired") read(JSON.stringify({ code: "expired", urls: [address] }))
if (props.scene === "redeeming" || props.scene === "timeout") read(`${address}/auth/connect/pending`)
})
},
stop() {},
destroy: () => cancelAnimationFrame(frame),
}
}
return (
<>
<PairingScanner {...props} camera={camera} />
<Show when={props.scene !== "opening" && props.scene !== "denied" && props.scene !== "redeeming"}>
<Button variant="neutral" onClick={() => detect?.(JSON.stringify({ code: "example", urls: [address] }))}>
Read fixture QR code
</Button>
</Show>
</>
)
}
@@ -1,159 +0,0 @@
import { Button } from "@opencode/ui/button"
import { useDialog } from "@opencode/ui/context/dialog"
import { createEffect, createSignal, onMount, Show, type ComponentProps } from "solid-js"
import { createServerConnectController } from "./controller"
import { DialogServer } from "./dialog"
import type { ServerCameraSupport, ServerConnectEvent, ServerConnectTarget } from "./machine"
import { PairingScanner } from "./scanner"
export const address = "https://build.example.test"
export const link = `${address}/auth/connect/example`
type CameraScene = "ready" | "opening" | "denied" | "invalid" | "decode" | "redeeming" | "timeout"
type Preset = {
camera?: ServerCameraSupport | "probing"
target?: Extract<ServerConnectTarget, { kind: "edit" }>
events?: Extract<ServerConnectEvent, { type: "field.changed" | "method.changed" | "submitted" }>[]
scanner?: CameraScene
exchange?: "expired" | "unreachable"
check?: "unreachable" | "pending"
closed?: boolean
}
export function serverStory(preset: Preset = {}) {
return { render: () => <Story preset={preset} /> }
}
function Story(props: { preset: Preset }) {
const dialog = useDialog()
const [saved, setSaved] = createSignal("")
const open = () => {
setSaved("")
void dialog.show(() => (
<Preview preset={props.preset} onSave={(server) => setSaved(server.displayName ?? server.http.url)} />
))
}
onMount(() => {
if (!props.preset.closed) open()
})
return (
<div class="flex flex-col items-start gap-3">
<Button variant="neutral" onClick={open}>
Open {props.preset.target?.kind ?? "add"} server dialog
</Button>
<Show when={saved()}>{(name) => <p role="status">Saved {name()} in this preview.</p>}</Show>
</div>
)
}
function Preview(props: { preset: Preset; onSave: ComponentProps<typeof DialogServer>["onSave"] }) {
const preset = props.preset
const createForm: NonNullable<ComponentProps<typeof DialogServer>["createForm"]> = (dialog) => {
const pending = new Promise<never>(() => {})
let check = preset.check
let exchange = preset.exchange
const form = createServerConnectController(
{ ...dialog, target: preset.target ?? { kind: "add" }, removeTabs() {} },
{
camera: preset.camera === "probing" ? "probe" : (preset.camera ?? "probe"),
probeCamera: () => (preset.camera === "probing" ? pending : Promise.resolve(true)),
pageHref: "https://lab.example.test",
servers: { list: [], add: (server) => server, remove() {} },
exchange: async (request) => {
if (request.code === "pending") return pending
if (exchange) {
const type = exchange
exchange = undefined
return { type }
}
return { type: "paired", pairing: { url: request.urls[0], password: "fixture" } }
},
check: async () => {
if (check === "pending") return pending
if (check === "unreachable") {
check = undefined
return { type: "unreachable" }
}
await new Promise<void>((resolve) => setTimeout(resolve, 700))
return { type: "healthy" }
},
},
)
preset.events?.forEach(form.dispatch)
if (preset.scanner) {
let opened = false
createEffect(() => {
if (opened || !form.view().canScan) return
opened = true
form.dispatch({ type: "scan.started" })
})
}
return form
}
return (
<DialogServer
mode={preset.target?.kind ?? "add"}
createForm={createForm}
onSave={props.onSave}
scanner={(props) => <CameraPreview {...props} scene={preset.scanner ?? "ready"} />}
/>
)
}
function CameraPreview(props: ComponentProps<typeof PairingScanner> & { scene: CameraScene }) {
let detect: ((data: string) => void) | undefined
const camera: NonNullable<ComponentProps<typeof PairingScanner>["camera"]> = (_, read, failed) => {
detect = read
let frame: ReturnType<typeof requestAnimationFrame>
return {
start: async () => {
if (props.scene === "denied") throw new Error("Camera permission denied")
if (props.scene === "opening") return new Promise<void>(() => {})
frame = requestAnimationFrame(() => {
if (props.scene === "invalid") read("not a pairing code")
if (props.scene === "decode") failed()
if (props.scene === "redeeming" || props.scene === "timeout") read(`${address}/auth/connect/pending`)
})
},
stop() {},
destroy: () => cancelAnimationFrame(frame),
}
}
return (
<>
<PairingScanner {...props} camera={camera} />
<Show when={props.scene !== "opening" && props.scene !== "denied" && props.scene !== "redeeming"}>
<Button variant="neutral" onClick={() => detect?.(link)}>
Read fixture QR code
</Button>
</Show>
</>
)
}
@@ -1,11 +1,5 @@
import { address, link, serverStory } from "./dialog.fixture"
import type { ServerConnectEvent, ServerConnectField, ServerConnectTarget } from "./machine"
const field = (field: ServerConnectField, value: string) => ({ type: "field.changed", field, value }) as const
const password = { type: "method.changed", method: "password" } satisfies ServerConnectEvent
const submit = { type: "submitted" } satisfies ServerConnectEvent
import { address, field, link, password, serverStory, submit } from "./connect.fixture"
import type { ServerConnectTarget } from "./machine"
const edit = {
kind: "edit",
@@ -62,6 +56,8 @@ export const InvalidQrCode = serverStory({ scanner: "invalid" })
export const DecodeFailed = serverStory({ scanner: "decode" })
export const ExpiredQrCode = serverStory({ scanner: "expired" })
export const ScanTimedOut = serverStory({ scanner: "timeout" })
export const EditPassword = serverStory({ target: edit })
@@ -0,0 +1,63 @@
import { address, field, link, password, screenStory, submit } from "./connect.fixture"
export default {
title: "App/Servers/Connect to Server",
id: "app-connect-to-server",
parameters: { layout: "fullscreen" },
}
export const PairingLink = screenStory()
export const ReadyToPair = screenStory({ events: [field("link", link)] })
// A signed-out server keeps its original address when the new pairing token works there.
export const PairAgain = screenStory({ url: "https://saved.example.test", events: [field("link", link)] })
export const Password = screenStory({ events: [password] })
export const BareServerAddress = screenStory({ events: [field("link", address), submit] })
export const InvalidLink = screenStory({ events: [field("link", "incomplete"), submit] })
export const LegacyLink = screenStory({ events: [field("link", `${address}/connect#example`), submit] })
export const ExpiredLink = screenStory({ events: [field("link", link), submit], exchange: "expired" })
export const UnreachableLink = screenStory({ events: [field("link", link), submit], exchange: "unreachable" })
export const MixedContent = screenStory({
events: [field("link", "http://build.example.test/auth/connect/example"), submit],
exchange: "unreachable",
})
export const Checking = screenStory({ events: [field("link", link), submit], check: "pending" })
export const ConnectionFailed = screenStory({ events: [field("link", link), submit], check: "unreachable" })
export const InvalidAddress = screenStory({ events: [password, field("url", "file:///example"), submit] })
export const CameraProbing = screenStory({ camera: "probing" })
export const CameraUnavailable = screenStory({ camera: "unavailable" })
export const CameraInsecure = screenStory({ camera: "insecure" })
export const NativePairing = screenStory({ camera: "none" })
export const OpeningCamera = screenStory({ scanner: "opening" })
export const Scanning = screenStory({ scanner: "ready" })
export const RetryAfterScan = screenStory({ scanner: "ready", check: "unreachable" })
export const RedeemingScan = screenStory({ scanner: "redeeming" })
export const CameraError = screenStory({ scanner: "denied" })
export const InvalidQrCode = screenStory({ scanner: "invalid" })
export const ExpiredQrCode = screenStory({ scanner: "expired" })
export const DecodeFailed = screenStory({ scanner: "decode" })
export const ScanTimedOut = screenStory({ scanner: "timeout" })
+14 -3
View File
@@ -1,4 +1,4 @@
import { lazy, Show, Suspense } from "solid-js"
import { lazy, Show, Suspense, type Component, type ComponentProps } from "solid-js"
import { Button } from "@opencode/ui/button"
import { TextInput } from "@opencode/ui/text-input"
import { Wordmark } from "@opencode/ui/wordmark"
@@ -10,9 +10,20 @@ import "./screen.css"
const PairingScanner = lazy(() => import("./scanner").then((module) => ({ default: module.PairingScanner })))
export function ConnectServerScreen(props: { url?: string } = {}) {
const language = useLanguage()
// Read once: the screen leaves when the server it signs in to answers, so its address does not change while it shows.
const form = createServerConnectController({ surface: "screen", target: { kind: "connect", url: props.url } })
return <ConnectServerForm form={form} scanner={PairingScanner} />
}
export function ConnectServerForm(props: {
form: ReturnType<typeof createServerConnectController>
scanner: Component<ComponentProps<typeof PairingScanner>>
}) {
const language = useLanguage()
const form = props.form
const view = form.view
return (
@@ -33,7 +44,7 @@ export function ConnectServerScreen(props: { url?: string } = {}) {
when={!view().scanning}
fallback={
<Suspense fallback={<p role="status">{language.t("server.connect.camera.starting")}</p>}>
<PairingScanner
<props.scanner
redeem={form.redeem}
onCancel={() => form.dispatch({ type: "scan.cancelled" })}
onScan={(link) => form.dispatch({ type: "scan.completed", link })}
@@ -1,49 +1,69 @@
import { onMount } from "solid-js"
import { createSignal, onMount } from "solid-js"
import { PairingHost, pairingRemote } from "../../../stories/mocks/gui-plugins/pairing"
import PairingPage from "./page"
function PairingDialogStory(props: {
mode: "ready" | "pending" | "failed"
response?: "Code request fails" | "Copy fails"
}) {
const mock = pairingRemote({
enabled: props.mode === "ready",
response: props.mode === "failed" ? "Remote change fails" : props.response,
})
type Preset = Parameters<typeof pairingRemote>[0] & { holdSetup?: boolean }
const client = {
...mock.client,
setRemote: (...args: Parameters<typeof mock.client.setRemote>) => {
if (props.mode === "pending") return new Promise<never>(() => {})
function PairingDialogStory(props: { preset: Preset; localServer: boolean }) {
const mock = pairingRemote(props.preset)
return mock.client.setRemote(...args)
},
}
const client = props.preset.holdSetup
? { ...mock.client, setRemote: () => new Promise<never>(() => {}) }
: mock.client
const [opened, setOpened] = createSignal(false)
let root!: HTMLDivElement
onMount(() => root.getElementsByTagName("button")[0].click())
onMount(() => {
root.getElementsByTagName("button")[0].click()
// Pair device needs the server to open. Once open, the dialog follows its loss and return.
setOpened(true)
})
return (
<PairingHost copy={mock.copy}>
<div ref={root}>
<PairingPage server={() => mock.server} pairing={() => ({ status: "active", value: client, generation: 1 })} />
<PairingPage
server={() => (!opened() || props.localServer ? mock.server : undefined)}
pairing={() => ({ status: "active", value: client, generation: 1 })}
/>
</div>
</PairingHost>
)
}
const story = (preset: Preset, args?: { localServer: boolean }) => ({
args,
render: (props: { localServer: boolean }) => <PairingDialogStory preset={preset} localServer={props.localServer} />,
})
export default {
title: "App/Dialogs/Pair Device",
id: "app-dialog-pair-device",
args: { localServer: true },
}
export const Ready = { render: () => <PairingDialogStory mode="ready" /> }
export const Ready = story({ enabled: true })
export const SettingUp = { render: () => <PairingDialogStory mode="pending" /> }
export const SettingUp = story({ enabled: false, holdSetup: true })
export const Failed = { render: () => <PairingDialogStory mode="failed" /> }
/** Turns on remote access and waits for the tunnel to connect before the first code arrives. */
export const FirstPairing = story({ enabled: false, response: "Tunnel connects slowly" })
export const CodeRequestFailed = { render: () => <PairingDialogStory mode="ready" response="Code request fails" /> }
/** Try again turns remote access on after the first attempt fails. */
export const Failed = story({ enabled: false, response: "Remote change fails" })
export const CopyFailsOnce = { render: () => <PairingDialogStory mode="ready" response="Copy fails" /> }
export const Unavailable = story({ enabled: true }, { localServer: false })
/** The first request shows the code loader. Refresh code keeps the previous QR visible until its replacement arrives. */
export const GeneratingCode = story({ enabled: true, response: "Code arrives slowly" })
export const CodeRequestFailed = story({ enabled: true, response: "Code request fails" })
/** Refresh code fails once, then the same action fetches a replacement from the error state. */
export const RefreshFailsOnce = story({ enabled: true, response: "Code refresh fails" })
export const ExpiringCode = story({ enabled: true, expiresIn: 5 })
export const CopyFailsOnce = story({ enabled: true, response: "Copy fails" })
+11 -3
View File
@@ -16,12 +16,19 @@ export const pairingResponses = [
"Screen read fails",
"Screen change fails",
"Tunnel connects slowly",
"Code arrives slowly",
"Code request fails",
"Code refresh fails",
"Copy fails",
] as const
type Response = (typeof pairingResponses)[number]
async function slowResponse(signal?: AbortSignal) {
await new Promise<void>((resolve) => setTimeout(resolve, 2000))
signal?.throwIfAborted()
}
/** In-memory settings, tunnel discovery, codes and clipboard, scoped to one story instance. */
export function pairingRemote(input: {
enabled: boolean
@@ -57,7 +64,9 @@ export function pairingRemote(input: {
return { urls }
},
pair: async () => {
pair: async ({ signal }) => {
if (input.response === "Code arrives slowly") await slowResponse(signal)
if (state.issued > 0) fail("Code refresh fails")
fail("Code request fails")
state.issued += 1
// As with server codes, encode 16 bytes. A new fixture replays the same sequence of QR codes.
@@ -76,8 +85,7 @@ export function pairingRemote(input: {
return state.enabled
},
setRemote: async (enabled, options) => {
await new Promise((resolve) => setTimeout(resolve, 2000))
options?.signal?.throwIfAborted()
await slowResponse(options?.signal)
fail("Remote change fails")
state.enabled = enabled
},