diff --git a/packages/app/component-tests/pairing.spec.ts b/packages/app/component-tests/pairing.spec.ts
index 6123a645215..e56cd4fb624 100644
--- a/packages/app/component-tests/pairing.spec.ts
+++ b/packages/app/component-tests/pairing.spec.ts
@@ -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()
diff --git a/packages/app/src/servers/connect/connect.fixture.tsx b/packages/app/src/servers/connect/connect.fixture.tsx
new file mode 100644
index 00000000000..1c38074a4b6
--- /dev/null
+++ b/packages/app/src/servers/connect/connect.fixture.tsx
@@ -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[]
+ scanner?: CameraScene
+ exchange?: "expired" | "unreachable"
+ check?: "unreachable" | "pending"
+}
+
+type DialogPreset = Preset & { target?: Extract; closed?: boolean }
+
+export function serverStory(preset: DialogPreset = {}) {
+ return { render: () => }
+}
+
+function DialogStory(props: { preset: DialogPreset }) {
+ const dialog = useDialog()
+
+ const [saved, setSaved] = createSignal("")
+
+ const open = () => {
+ setSaved("")
+ void dialog.show(() => (
+ setSaved(server.displayName ?? server.http.url)}
+ createForm={(dialog) =>
+ createPreviewForm(
+ { ...dialog, target: props.preset.target ?? { kind: "add" }, removeTabs() {} },
+ props.preset,
+ )
+ }
+ scanner={(scanner) => }
+ />
+ ))
+ }
+
+ onMount(() => {
+ if (!props.preset.closed) open()
+ })
+
+ return (
+
+
+
{(name) => Saved {name()} in this preview.
}
+
+ )
+}
+
+export function screenStory(preset: Preset & { url?: string } = {}) {
+ return { render: () => }
+}
+
+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 (
+ }
+ />
+ )
+ }
+
+ return (
+
+
}>
+ {(url) => (
+
+
Connected to {url()} in this preview.
+
+
+ )}
+
+
+ )
+}
+
+function createPreviewForm(
+ options: ServerConnectControllerOptions,
+ preset: Preset,
+ onSave?: (server: ServerConnection.Http) => void,
+) {
+ const pending = new Promise(() => {})
+
+ 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((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 & { scene: CameraScene }) {
+ let detect: ((data: string) => void) | undefined
+
+ const camera: NonNullable["camera"]> = (_, read, failed) => {
+ detect = read
+ let frame: ReturnType
+
+ return {
+ start: async () => {
+ if (props.scene === "denied") throw new Error("Camera permission denied")
+
+ if (props.scene === "opening") return new Promise(() => {})
+ 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 (
+ <>
+
+
+
+
+ >
+ )
+}
diff --git a/packages/app/src/servers/connect/dialog.fixture.tsx b/packages/app/src/servers/connect/dialog.fixture.tsx
deleted file mode 100644
index 587bb87cb25..00000000000
--- a/packages/app/src/servers/connect/dialog.fixture.tsx
+++ /dev/null
@@ -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
- events?: Extract[]
- scanner?: CameraScene
- exchange?: "expired" | "unreachable"
- check?: "unreachable" | "pending"
- closed?: boolean
-}
-
-export function serverStory(preset: Preset = {}) {
- return { render: () => }
-}
-
-function Story(props: { preset: Preset }) {
- const dialog = useDialog()
-
- const [saved, setSaved] = createSignal("")
-
- const open = () => {
- setSaved("")
- void dialog.show(() => (
- setSaved(server.displayName ?? server.http.url)} />
- ))
- }
-
- onMount(() => {
- if (!props.preset.closed) open()
- })
-
- return (
-
-
-
{(name) => Saved {name()} in this preview.
}
-
- )
-}
-
-function Preview(props: { preset: Preset; onSave: ComponentProps["onSave"] }) {
- const preset = props.preset
-
- const createForm: NonNullable["createForm"]> = (dialog) => {
- const pending = new Promise(() => {})
-
- 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((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 (
- }
- />
- )
-}
-
-function CameraPreview(props: ComponentProps & { scene: CameraScene }) {
- let detect: ((data: string) => void) | undefined
-
- const camera: NonNullable["camera"]> = (_, read, failed) => {
- detect = read
- let frame: ReturnType
-
- return {
- start: async () => {
- if (props.scene === "denied") throw new Error("Camera permission denied")
-
- if (props.scene === "opening") return new Promise(() => {})
- 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 (
- <>
-
-
-
-
- >
- )
-}
diff --git a/packages/app/src/servers/connect/dialog.stories.tsx b/packages/app/src/servers/connect/dialog.stories.tsx
index 813e6faf55b..6901b276cec 100644
--- a/packages/app/src/servers/connect/dialog.stories.tsx
+++ b/packages/app/src/servers/connect/dialog.stories.tsx
@@ -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 })
diff --git a/packages/app/src/servers/connect/screen.stories.tsx b/packages/app/src/servers/connect/screen.stories.tsx
new file mode 100644
index 00000000000..aa624386f63
--- /dev/null
+++ b/packages/app/src/servers/connect/screen.stories.tsx
@@ -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" })
diff --git a/packages/app/src/servers/connect/screen.tsx b/packages/app/src/servers/connect/screen.tsx
index 045209786b6..9a0968a5c61 100644
--- a/packages/app/src/servers/connect/screen.tsx
+++ b/packages/app/src/servers/connect/screen.tsx
@@ -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
+}
+
+export function ConnectServerForm(props: {
+ form: ReturnType
+ scanner: Component>
+}) {
+ 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={
{language.t("server.connect.camera.starting")}
}>
- form.dispatch({ type: "scan.cancelled" })}
onScan={(link) => form.dispatch({ type: "scan.completed", link })}
diff --git a/packages/gui-plugins/src/pairing/dialog.stories.tsx b/packages/gui-plugins/src/pairing/dialog.stories.tsx
index addccef5bf8..67450b1b916 100644
--- a/packages/gui-plugins/src/pairing/dialog.stories.tsx
+++ b/packages/gui-plugins/src/pairing/dialog.stories.tsx
@@ -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[0] & { holdSetup?: boolean }
- const client = {
- ...mock.client,
- setRemote: (...args: Parameters) => {
- if (props.mode === "pending") return new Promise(() => {})
+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(() => {}) }
+ : 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 (
-
mock.server} pairing={() => ({ status: "active", value: client, generation: 1 })} />
+ (!opened() || props.localServer ? mock.server : undefined)}
+ pairing={() => ({ status: "active", value: client, generation: 1 })}
+ />
)
}
+const story = (preset: Preset, args?: { localServer: boolean }) => ({
+ args,
+ render: (props: { localServer: boolean }) => ,
+})
+
export default {
title: "App/Dialogs/Pair Device",
id: "app-dialog-pair-device",
+ args: { localServer: true },
}
-export const Ready = { render: () => }
+export const Ready = story({ enabled: true })
-export const SettingUp = { render: () => }
+export const SettingUp = story({ enabled: false, holdSetup: true })
-export const Failed = { render: () => }
+/** 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: () => }
+/** 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: () => }
+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" })
diff --git a/packages/stories/mocks/gui-plugins/pairing.tsx b/packages/stories/mocks/gui-plugins/pairing.tsx
index a38fde15253..e635f1cd1cc 100644
--- a/packages/stories/mocks/gui-plugins/pairing.tsx
+++ b/packages/stories/mocks/gui-plugins/pairing.tsx
@@ -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((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
},