fix(app): drive server health and plugin server state with explicit machines (#61763)

This commit is contained in:
Luke Parker
2026-11-04 14:51:22 -06:00
committed by GitHub
Unverified
parent 2047c0d4fd
commit eab8f49022
48 changed files with 1432 additions and 517 deletions
+2 -1
View File
@@ -31,6 +31,7 @@ import { ModelsProvider } from "@/providers/models/models"
import { Contribution } from "@/runtime/plugin/render"
import { ServerProvider, useServer } from "@/runtime/server/current"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { isServerHealthy } from "@/runtime/server/health-machine"
import { useGlobal } from "@/runtime/server/runtime"
import { SessionRouteFrame } from "@/session/session-frame"
import { SessionUIProvider } from "@/shell/routes/session-ui-provider"
@@ -526,7 +527,7 @@ function Workspace(props: { children: JSX.Element }) {
const healthy = createMemo((picked?: ServerConnection.Any) =>
picked && servers.list.some((conn) => ServerConnection.key(conn) === ServerConnection.key(picked))
? picked
: servers.list.find((conn) => global.servers.health[ServerConnection.key(conn)]?.healthy),
: servers.list.find((conn) => isServerHealthy(global.servers.health[ServerConnection.key(conn)])),
)
return (
+2 -1
View File
@@ -1,6 +1,7 @@
import { useGlobal, useServerCtx } from "@/runtime/server/runtime"
import { type HomeProjectSelection, useLayout } from "@/shell/state/layout"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { isServerFailed } from "@/runtime/server/health-machine"
import { createProjectSessionActions } from "@/shell/tabs/project-sessions"
import { toggleHomeProjectSelection } from "@/shell/layout/helpers"
import { createEffect, createMemo } from "solid-js"
@@ -88,7 +89,7 @@ export function createHomeController() {
select: (conn: ServerConnection.Any, directory: string) => {
const key = ServerConnection.key(conn)
if (global.servers.health[key]?.healthy === false) return
if (isServerFailed(global.servers.health[key])) return
if (
!global
+2 -1
View File
@@ -3,6 +3,7 @@ import { useDialog } from "@opencode/ui/context/dialog"
import { useLanguage } from "@/runtime/i18n/language"
import { usePlatform } from "@/runtime/platform/platform"
import { ServerConnection } from "@/runtime/server/registry"
import { isServerUnauthorized } from "@/runtime/server/health-machine"
import { useGlobal } from "@/runtime/server/runtime"
import { useSettingsSurface } from "@/settings/surface"
import { errorMessage } from "@/shell/layout/helpers"
@@ -34,7 +35,7 @@ export function createProjectActions() {
// Resume the requested action with the saved connection after an expired HTTP pairing or plugin sign-in.
function authenticate(conn: ServerConnection.Any, onConnected?: (conn: ServerConnection.Any) => void) {
if (conn.type !== "http" || !global.servers.health[ServerConnection.key(conn)]?.unauthorized)
if (conn.type !== "http" || !isServerUnauthorized(global.servers.health[ServerConnection.key(conn)]))
return ServerConnection.authenticate(conn, () => onConnected?.(conn))
editServer(conn, onConnected)
@@ -4,6 +4,7 @@ import { useSettingsCommand } from "@/settings/command"
import { useLanguage } from "@/runtime/i18n/language"
import { usePlatform } from "@/runtime/platform/platform"
import { ServerConnection } from "@/runtime/server/registry"
import { isServerFailed } from "@/runtime/server/health-machine"
import { homeProjectDirectories } from "@/shell/layout/helpers"
import { Persist, persisted } from "@/runtime/persistence/storage"
import { createResource } from "solid-js"
@@ -90,7 +91,7 @@ export function createHomeProjectsController(home: HomeController) {
choose: (conn: ServerConnection.Any) => {
if (actions.authenticate(conn, (next) => choose(next))) return
if (home.server.health(conn)?.healthy === false) return
if (isServerFailed(home.server.health(conn))) return
choose(conn)
},
hide: actions.hide,
+31 -28
View File
@@ -20,7 +20,14 @@ import { ServerConnection } from "@/runtime/server/registry"
import { useLanguage } from "@/runtime/i18n/language"
import { ServerRowMenuView, serverMenuLabels } from "@/servers/registry/row-menu"
import { ServerHealthIndicator } from "@/servers/registry/row"
import { type ServerHealth } from "@/runtime/server/health"
import {
isServerFailed,
isServerHealthy,
isServerIncompatible,
isServerUnauthorized,
selectServerVersion,
type ServerHealth,
} from "@/runtime/server/health-machine"
import { ProjectMenuItems } from "./menu"
import { CollapsedSidebarToggleSpace } from "@/shell/sidebar-toggle"
import "./view.css"
@@ -32,7 +39,10 @@ const serverContextMenuID = (server: ServerConnection.Any) => `server:${ServerCo
// Plugin servers ask for sign-in themselves; an HTTP server that rejects its saved credentials needs a new
// pairing link or password.
const signInRequired = (server: ServerConnection.Any, health: ServerHealth | undefined) =>
(server.type === "plugin" && server.authenticationRequired) || (server.type === "http" && !!health?.unauthorized)
(server.type === "plugin" && server.status.type === "auth") ||
(server.type === "http" && isServerUnauthorized(health))
const connecting = (server: ServerConnection.Any) => server.type === "plugin" && server.status.type === "starting"
const projectContextMenuID = (server: ServerConnection.Any, directory: string) =>
`project:${ServerConnection.key(server)}:${directory}`
@@ -201,7 +211,7 @@ function HomeProjectsPanel(props: HomeProjectsViewProps) {
size="large"
class="titlebar-icon [&_[data-slot=icon-svg]]:text-v2-icon-icon-muted"
icon={<Icon name="folder-add-left" />}
disabled={props.serverHealth(props.servers[0])?.healthy === false}
disabled={isServerFailed(props.serverHealth(props.servers[0]))}
onClick={() => props.onChooseProject(props.servers[0])}
aria-label={props.language.t("home.project.add")}
/>
@@ -236,11 +246,7 @@ function HomeProjectsPanel(props: HomeProjectsViewProps) {
<Show
when={
props.servers.length > 1 ||
props.servers.some(
(server) =>
signInRequired(server, props.serverHealth(server)) ||
(server.type === "plugin" && server.connecting),
)
props.servers.some((server) => signInRequired(server, props.serverHealth(server)) || connecting(server))
}
fallback={
<Show when={props.servers[0]}>
@@ -253,7 +259,7 @@ function HomeProjectsPanel(props: HomeProjectsViewProps) {
type="button"
data-action="home-add-project-row"
class="mt-1 disabled:opacity-60"
disabled={props.serverHealth(server())?.healthy === false}
disabled={isServerFailed(props.serverHealth(server()))}
onClick={() => props.onChooseProject(server())}
>
<Icon name="folder-add-left" size="small" />
@@ -270,11 +276,10 @@ function HomeProjectsPanel(props: HomeProjectsViewProps) {
<For each={props.servers}>
{(item) => {
const projects = () => props.projectsForServer(item)
const healthy = () => !!props.serverHealth(item)?.healthy
const healthy = () => isServerHealthy(props.serverHealth(item))
const hasProjects = () => projects().length > 0
const collapsed = () => props.collapsed(item)
const authentication = () => signInRequired(item, props.serverHealth(item))
const connecting = () => item.type === "plugin" && item.connecting
return (
<div class="flex min-w-0 flex-col gap-1">
@@ -286,7 +291,7 @@ function HomeProjectsPanel(props: HomeProjectsViewProps) {
collapsed={collapsed()}
health={props.serverHealth(item)}
/>
<Show when={authentication() || connecting()}>
<Show when={authentication() || connecting(item)}>
<div class="mx-3 h-px bg-v2-border-border-base" />
<div class="px-1.5 py-1">
<Button
@@ -294,18 +299,20 @@ function HomeProjectsPanel(props: HomeProjectsViewProps) {
class="w-full"
size="small"
variant="neutral"
disabled={connecting()}
aria-busy={!!connecting()}
disabled={connecting(item)}
aria-busy={connecting(item)}
onClick={() => props.onAuthenticateServer?.(item)}
>
<Show when={connecting()}>
<Show when={connecting(item)}>
<Loader class="size-3.5" />
</Show>
{props.language.t(connecting() ? "server.status.connecting" : "server.action.authenticate")}
{props.language.t(
connecting(item) ? "server.status.connecting" : "server.action.authenticate",
)}
</Button>
</div>
</Show>
<Show when={healthy() && !authentication() && !connecting() && hasProjects() && !collapsed()}>
<Show when={healthy() && !authentication() && !connecting(item) && hasProjects() && !collapsed()}>
<div class="mx-3 h-px bg-v2-border-border-base" />
<HomeProjectList {...props} {...contextMenuProps} server={item} items={projects()} />
</Show>
@@ -376,9 +383,9 @@ function HomeServerRow(props: {
collapsed: boolean
health: ServerHealth | undefined
}) {
const healthy = () => !!props.health?.healthy
const healthy = () => isServerHealthy(props.health)
const authentication = () => signInRequired(props.server, props.health)
const incompatible = () => !!props.health?.incompatible
const incompatible = () => isServerIncompatible(props.health)
const canToggle = () => healthy() && props.projectsForServer(props.server).length > 0
const contextMenuID = () => serverContextMenuID(props.server)
onCleanup(() => {
@@ -397,7 +404,7 @@ function HomeServerRow(props: {
value={
authentication()
? props.language.t("server.status.authentication")
: props.language.t("server.row.incompatible", { version: props.health?.version ?? "1" })
: props.language.t("server.row.incompatible", { version: selectServerVersion(props.health) ?? "1" })
}
>
<div
@@ -444,11 +451,7 @@ function HomeServerRow(props: {
/>
</span>
<div class="flex size-4 shrink-0 items-center justify-center -mr-0.5">
<ServerHealthIndicator
health={props.health}
connecting={props.server.type === "plugin" && props.server.connecting}
authenticationRequired={authentication()}
/>
<ServerHealthIndicator health={props.health} />
</div>
<span
data-slot="home-row-label"
@@ -496,7 +499,7 @@ function HomeServerRow(props: {
size="small"
icon={<Icon name="folder-add-left" />}
aria-label={props.language.t("home.project.add")}
disabled={props.health?.healthy === false && !authentication()}
disabled={isServerFailed(props.health) && !authentication()}
onClick={() => props.onChooseProject(props.server)}
/>
</Tooltip>
@@ -570,7 +573,7 @@ function HomeProjectSlot(props: HomeProjectListProps & { worktree: string }) {
}
function HomeProjectEmpty(props: HomeProjectsViewProps & { server: ServerConnection.Any }) {
const unreachable = () => props.serverHealth(props.server)?.healthy === false
const unreachable = () => isServerFailed(props.serverHealth(props.server))
return (
<HomeProjectNavButton
@@ -595,7 +598,7 @@ function HomeProjectRow(
unread: boolean
},
) {
const serverUnreachable = () => props.serverHealth(props.server)?.healthy === false
const serverUnreachable = () => isServerFailed(props.serverHealth(props.server))
const contextMenuID = () => projectContextMenuID(props.server, props.project.worktree)
onCleanup(() => {
@@ -4,6 +4,7 @@ import { type ServerCtx, useGlobal } from "@/runtime/server/runtime"
import { useServer } from "@/runtime/server/current"
import { useServerSDK } from "@/runtime/server/client"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { isServerFailed } from "@/runtime/server/health-machine"
import { useWorkspaceLocation } from "@/workspaces/location"
import { workspaceSelectionDestination } from "@/workspaces/paths"
import { useTabs } from "@/shell/tabs/tabs"
@@ -45,11 +46,11 @@ export function createComposerProjectControls(props: { draftId: string; worktree
// Servers that are down or still connecting contribute nothing.
const ready = createMemo(() =>
servers.list.filter((connection) => {
if (connection.type === "plugin" && connection.state !== "ready") return false
return global.servers.health[ServerConnection.key(connection)]?.healthy !== false
}),
servers.list.filter(
(connection) =>
!!ServerConnection.http(connection) &&
!isServerFailed(global.servers.health[ServerConnection.key(connection)]),
),
)
const projects = createMemo(() => {
+2 -1
View File
@@ -8,6 +8,7 @@ import { ModelsProvider } from "@/providers/models/models"
import { ComposerPersistenceProvider } from "@/composer/persistence"
import { ServerProvider, useServer } from "@/runtime/server/current"
import { ServerConnection } from "@/runtime/server/registry"
import { isServerIncompatible } from "@/runtime/server/health-machine"
import { useTabs, type DraftTab } from "@/shell/tabs/tabs"
import { SessionUIProvider } from "@/shell/routes/session-ui-provider"
import NewSession from "@/new-session/screen"
@@ -62,7 +63,7 @@ function ResolvedDraftContent(props: { draft: DraftTab }) {
return (
<Show
when={!server.health?.incompatible}
when={!isServerIncompatible(server.health)}
fallback={
<SessionRouteFrame padded>
<SessionPanelFrame raised>
@@ -5,9 +5,8 @@ const contributed = {
type: "plugin",
key: "ssh:production",
plugin: "ssh",
state: "ready",
connecting: false,
authenticationRequired: false,
status: { type: "ready", http: { url: "http://127.0.0.1:4096" } },
authenticate: () => false,
managed: true,
http: { url: "http://127.0.0.1:4096" },
} as const
@@ -40,6 +40,7 @@ import { same } from "@/runtime/persistence/equality"
import { Persist, persisted, removePersisted } from "@/runtime/persistence/storage"
import { useGlobal, type ServerCtx } from "@/runtime/server/runtime"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { isServerIncompatible } from "@/runtime/server/health-machine"
import { useDirectoryPicker } from "@/workspaces/selection/picker"
import { SessionRouteKey, SessionStateKey, type ServerScope } from "@/runtime/server/scope"
import { findSessionTab, tabKey, useTabs } from "@/shell/tabs/tabs"
@@ -540,7 +541,7 @@ export function createPluginAttachment(apis: HostApis) {
return ServerConnection.builtin(listed())
},
get compatible() {
return !global.servers.health[key]?.incompatible
return !isServerIncompatible(global.servers.health[key])
},
get connected() {
return global.serverCtx(key)?.sdk.connection.status() === "connected"
@@ -28,6 +28,7 @@ import type { ComposerStateValue } from "@/composer/state"
import { useLocal } from "@/providers/models/selection"
import { useServer } from "@/runtime/server/current"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { isServerIncompatible } from "@/runtime/server/health-machine"
import { sessionInWorkspace, sessionProject, type SessionModel } from "@/session/model"
import { useFile } from "@/workspaces/files/model"
import { useWorkspaceLocation } from "@/workspaces/location"
@@ -83,7 +84,7 @@ export function createMountedSession(session: SessionModel) {
return ServerConnection.builtin(server.conn)
},
get compatible() {
return !server.health?.incompatible
return !isServerIncompatible(server.health)
},
get connected() {
return server.ctx.sdk.connection.status() === "connected"
@@ -93,12 +93,12 @@ export function PluginServerEndpoints() {
createEffect(() => {
const endpoints = servers.list.flatMap((conn) => {
// Main knows the built-in server first-hand; a contributed server has no endpoint until it is ready.
if (conn.type === "sidecar" || (conn.type === "plugin" && conn.state !== "ready")) return []
const password = conn.http.password
const http = ServerConnection.http(conn)
const endpoint = { id: ServerConnection.key(conn), url: conn.http.url }
if (conn.type === "sidecar" || !http) return []
const endpoint = { id: ServerConnection.key(conn), url: http.url }
return [password ? { ...endpoint, password } : endpoint]
return [http.password ? { ...endpoint, password: http.password } : endpoint]
})
const value = JSON.stringify(endpoints)
+58 -13
View File
@@ -1,9 +1,12 @@
import {
batch,
createContext,
createEffect,
createMemo,
createRenderEffect,
createSignal,
onCleanup,
untrack,
useContext,
type ParentProps,
} from "solid-js"
@@ -12,6 +15,14 @@ import { Schema } from "effect"
import { MenuItem, Server, type ServerEntry } from "@opencode/plugin/gui"
import { Persistence } from "@/runtime/persistence/schema"
import { Persist, persisted } from "@/runtime/persistence/storage"
import {
canAuthenticatePluginServer,
createPluginServerState,
selectPluginStatus,
transitionPluginServer,
type PluginEntrySnapshot,
type PluginServerEvent,
} from "@/runtime/server/plugin-machine"
import type { ServerConnection } from "@/runtime/server/registry"
import { usePluginHost } from "./host"
import { renamedFrom } from "./stores"
@@ -19,7 +30,7 @@ import { renamedFrom } from "./stores"
/** A server a plugin contributes. `key` is `${plugin}:${entry.id}`. */
export type PluginServer = { readonly key: string; readonly plugin: string; readonly entry: ServerEntry }
// Endpoint of a contributed server before its plugin reports one.
// Where a contributed server's event stream starts before its plugin reports an endpoint; it never answers.
const offline = { url: "http://127.0.0.1:0" }
// The last complete inventory of each plugin that contributes servers, without endpoints or credentials.
@@ -120,13 +131,15 @@ function createPluginServers() {
// Routes key on the connection object. Keep one per key across entry updates so reconnecting
// never unmounts an open conversation or composer.
const connections = new Map<string, { update: (server: PluginServer) => void; value: ServerConnection.Plugin }>()
const connections = new Map<string, ReturnType<typeof connection>>()
const list = createMemo(() => {
const listed = entries().filter((item) => item.entry.listed !== false)
const keys = new Set(listed.map((item) => item.key))
connections.forEach((_, key) => {
if (!keys.has(key)) connections.delete(key)
connections.forEach((item, key) => {
if (keys.has(key)) return
item.dispose()
connections.delete(key)
})
return listed.map((item) => {
@@ -145,6 +158,8 @@ function createPluginServers() {
})
})
onCleanup(() => connections.forEach((item) => item.dispose()))
return {
ready: host.serversReady,
/** Contributed servers the app lists, as stable connections. */
@@ -160,7 +175,25 @@ function createPluginServers() {
function connection(initial: PluginServer) {
const [current, setCurrent] = createSignal(initial)
const [machine, setMachine] = createSignal(createPluginServerState(snapshot(initial.entry)))
const entry = () => current().entry
let timer: ReturnType<typeof setTimeout> | undefined
const dispatch = (event: PluginServerEvent) => {
const result = transitionPluginServer(untrack(machine), event)
setMachine(result.state)
result.effects.forEach((effect) => {
if (effect.type === "timeout.cancel") return clearTimeout(timer)
// Out of the update that reported the server ready: the callbacks navigate.
if (effect.type === "notify.connected") return queueMicrotask(() => effect.callbacks.forEach((run) => run()))
timer = setTimeout(() => dispatch({ type: "connect.timed-out", attempt: effect.attempt }), effect.timeoutMs)
const settled = (ready: boolean) => dispatch({ type: "connect.settled", attempt: effect.attempt, ready })
void Promise.try(() => untrack(entry).connect?.() ?? false).then(settled, () => settled(false))
})
}
const value: ServerConnection.Plugin = {
type: "plugin",
@@ -172,14 +205,8 @@ function connection(initial: PluginServer) {
get label() {
return entry().label
},
get state() {
return entry().state
},
get connecting() {
return entry().state === "starting"
},
get authenticationRequired() {
return entry().state === "auth"
get status() {
return selectPluginStatus(machine())
},
get managed() {
return !!entry().reconnect
@@ -193,10 +220,28 @@ function connection(initial: PluginServer) {
return (signal: AbortSignal) => entry().reconnect?.(signal) ?? Promise.resolve(entry().http ?? offline)
},
authenticate: (onConnected) => {
if (!canAuthenticatePluginServer(untrack(machine))) return false
dispatch({ type: "authenticate", onConnected })
return true
},
connect: () => entry().connect?.() ?? Promise.resolve(entry().state === "ready"),
}
return { update: (server: PluginServer) => setCurrent(server), value }
return {
update: (server: PluginServer) =>
batch(() => {
setCurrent(server)
dispatch({ type: "entry.updated", entry: snapshot(server.entry) })
}),
dispose: () => dispatch({ type: "disposed" }),
value,
}
}
function snapshot(entry: ServerEntry): PluginEntrySnapshot {
return { state: entry.state, http: entry.http }
}
/** MenuItem "server.row" contributions that apply to a server. */
@@ -0,0 +1,227 @@
import { expect, test } from "bun:test"
import {
canUseServer,
createServerHealthState,
isServerFailed,
selectServerHealthRank,
selectServerHealthRecord,
selectServerIndicator,
SERVER_HEALTH_POLL_MS,
transitionServerHealth,
type ServerHealth,
type ServerHealthEffect,
type ServerHealthEvent,
type ServerHealthInput,
type ServerHealthState,
type ServerProbeResult,
} from "./health-machine"
import { ServerKey } from "./persistence"
const key = (name: string) => ServerKey.make(`http://${name}`)
const endpoint = (name: string, password?: string, managed = false): ServerHealthInput => ({
type: "endpoint",
key: key(name),
http: { url: `http://${name}`, password },
managed,
})
const staged = (name: string, stage: Extract<ServerHealthInput, { type: "staged" }>["stage"]): ServerHealthInput => ({
type: "staged",
key: key(name),
stage,
})
const synced = (...servers: ServerHealthInput[]): ServerHealthEvent => ({ type: "servers.synced", servers })
const answered = (name: string, attempt: number, result: ServerProbeResult): ServerHealthEvent => ({
type: "probe.settled",
key: key(name),
attempt,
result,
})
const poll: ServerHealthEvent = { type: "poll.due" }
function replay(events: readonly ServerHealthEvent[], state: ServerHealthState = createServerHealthState()) {
return events.reduce<{ state: ServerHealthState; effects: ServerHealthEffect[] }>(
(result, event) => {
const next = transitionServerHealth(result.state, event)
return { state: next.state, effects: [...result.effects, ...next.effects] }
},
{ state, effects: [] },
)
}
const health = (state: ServerHealthState, name: string) => selectServerHealthRecord(state)[key(name)]
const probes = (effects: readonly ServerHealthEffect[]) =>
effects.flatMap((effect) => (effect.type === "probe" ? [`${effect.key} #${effect.attempt}`] : []))
const notified = (effects: readonly ServerHealthEffect[]) => effects.filter((effect) => effect.type === "notify.probe")
test("a slow server's answer never reverts a faster server's newer answer", () => {
const start = replay([synced(endpoint("fast"), endpoint("slow")), answered("fast", 1, { type: "unreachable" })])
// The poll comes due while the slow probe still runs: only the idle server probes again.
const polled = transitionServerHealth(start.state, poll)
expect(probes(polled.effects)).toEqual(["http://fast #2"])
const end = replay(
[answered("fast", 2, { type: "healthy" }), answered("slow", 1, { type: "unreachable" })],
polled.state,
)
expect(health(end.state, "fast")).toEqual({ type: "healthy" })
expect(health(end.state, "slow")).toEqual({ type: "unreachable" })
})
test("a probe that a retry replaced never reaches the listener", () => {
const retried = replay([synced(endpoint("s", "pw1")), { type: "retry.requested", resolve: () => {} }])
const current = transitionServerHealth(retried.state, answered("s", 2, { type: "healthy" }))
expect(notified(current.effects)).toEqual([
{ type: "notify.probe", probe: { key: key("s"), auth: "http://s\npw1", result: { type: "healthy" } } },
])
// The replaced probe answers 401 late: it neither signs the server out nor changes its health.
const late = transitionServerHealth(current.state, answered("s", 1, { type: "unauthorized" }))
expect(late).toEqual({ state: current.state, effects: [] })
expect(health(late.state, "s")).toEqual({ type: "healthy" })
})
test.each([
{ name: "disposed", event: { type: "disposed" } as const },
{ name: "unlisted", event: synced() },
{ name: "moved to a new endpoint", event: synced(endpoint("s", "pw2")) },
{ name: "waiting for its plugin", event: synced(staged("s", "auth")) },
])("a probe of a server that was $name never reaches the listener", (input) => {
const left = replay([synced(endpoint("s", "pw1")), input.event])
const late = transitionServerHealth(left.state, answered("s", 1, { type: "unauthorized" }))
expect(late).toEqual({ state: left.state, effects: [] })
})
test("a check in flight does not read as a failed server", () => {
const moved = replay([synced(endpoint("tunnel", undefined, true), endpoint("plain"))]).state
const tunnel = health(moved, "tunnel")
const plain = health(moved, "plain")
expect(tunnel).toEqual({ type: "checking", managed: true })
expect(plain).toEqual({ type: "checking", managed: false })
;[tunnel, plain].forEach((value) => {
expect(canUseServer(value)).toBe(true)
expect(isServerFailed(value)).toBe(false)
expect(selectServerHealthRank(value)).toBe(1)
})
expect(selectServerIndicator(tunnel)).toBe("connecting")
expect(selectServerIndicator(plain)).toBe("unknown")
})
test("a contributed server that is not ready reports its stage and is never probed", () => {
const stages = ["stopped", "starting", "auth", "failed", "incompatible"] as const
const expected: ServerHealth[] = [
{ type: "stopped" },
{ type: "starting" },
{ type: "auth" },
{ type: "unreachable" },
{ type: "incompatible" },
]
const seen = stages.map((stage, index) => {
const result = replay(stages.slice(0, index + 1).map((item) => synced(staged("ssh", item))))
expect(probes(result.effects)).toEqual([])
return health(result.state, "ssh")
})
expect(seen).toEqual(expected)
// The inbox stops waiting for a server that cannot answer yet.
seen.forEach((value) => expect(canUseServer(value)).toBe(false))
expect(seen.map(selectServerIndicator)).toEqual(["unknown", "connecting", "auth", "unreachable", "incompatible"])
})
test("a background poll keeps the last answer until the next one arrives", () => {
const known = replay([synced(endpoint("s")), answered("s", 1, { type: "healthy", version: "2.0.0" })]).state
const polled = transitionServerHealth(known, poll)
expect(probes(polled.effects)).toEqual(["http://s #2"])
expect(health(polled.state, "s")).toEqual({ type: "healthy", version: "2.0.0" })
// A probe already in flight is not started again.
expect(transitionServerHealth(polled.state, poll)).toEqual({ state: polled.state, effects: [] })
})
test("a server joining the list leaves the probe of an unchanged one running", () => {
const first = replay([synced(endpoint("a"))])
const joined = transitionServerHealth(first.state, synced(endpoint("a"), endpoint("b")))
expect(probes(joined.effects)).toEqual(["http://b #1"])
expect(health(transitionServerHealth(joined.state, answered("a", 1, { type: "healthy" })).state, "a")).toEqual({
type: "healthy",
})
})
test("the poll runs only while a server has an endpoint", () => {
const listed = replay([synced(staged("ssh", "auth"))])
expect(listed.effects).toEqual([])
const ready = transitionServerHealth(listed.state, synced(endpoint("ssh")))
expect(ready.effects).toContainEqual({ type: "timer.start", intervalMs: SERVER_HEALTH_POLL_MS })
expect(transitionServerHealth(ready.state, synced()).effects).toEqual([{ type: "timer.stop" }])
})
test("retry probes every server again and resolves once each answers", () => {
const log: string[] = []
const resolve = () => log.push("resolved")
const start = replay([
synced(endpoint("a"), endpoint("b"), staged("ssh", "auth")),
answered("a", 1, { type: "unreachable" }),
])
const retried = transitionServerHealth(start.state, { type: "retry.requested", resolve })
expect(probes(retried.effects)).toEqual(["http://a #2", "http://b #2"])
expect(retried.effects).toContainEqual({ type: "timer.start", intervalMs: SERVER_HEALTH_POLL_MS })
// The probe the retry replaced answers first: the caller keeps waiting.
const stale = transitionServerHealth(retried.state, answered("b", 1, { type: "healthy" }))
expect(stale.state).toBe(retried.state)
const partial = transitionServerHealth(retried.state, answered("a", 2, { type: "healthy" }))
expect(partial.effects).not.toContainEqual(expect.objectContaining({ type: "waiters.resolve" }))
const done = transitionServerHealth(partial.state, answered("b", 2, { type: "healthy" }))
done.effects.forEach((effect) => effect.type === "waiters.resolve" && effect.resolvers.forEach((run) => run()))
expect(log).toEqual(["resolved"])
expect(done.state.waiters).toEqual([])
})
test.each([
{ name: "is unlisted", event: synced(endpoint("a")) },
{ name: "waits for its plugin", event: synced(endpoint("a"), staged("b", "starting")) },
{ name: "is disposed", event: { type: "disposed" } as const },
])("retry resolves when the server it waits for $name", (input) => {
const retried = replay([synced(endpoint("a"), endpoint("b")), answered("a", 1, { type: "healthy" })])
const waiting = replay(
[{ type: "retry.requested", resolve: () => {} }, answered("a", 2, { type: "healthy" })],
retried.state,
)
expect(waiting.state.waiters).toHaveLength(1)
const result = transitionServerHealth(waiting.state, input.event)
expect(result.effects).toContainEqual(expect.objectContaining({ type: "waiters.resolve" }))
expect(result.state.waiters).toEqual([])
})
test("retry with no server to probe resolves at once", () => {
const resolve = () => {}
expect(
transitionServerHealth(replay([synced(staged("ssh", "auth"))]).state, { type: "retry.requested", resolve }).effects,
).toEqual([{ type: "waiters.resolve", resolvers: [resolve] }])
})
@@ -0,0 +1,357 @@
import { endpointCredentials } from "./machine"
import type { PluginServerStatus } from "./plugin-machine"
import type { ServerConnection } from "./registry"
export const SERVER_HEALTH_POLL_MS = 10_000
/** The answer of one `/api/info` probe. */
export type ServerProbeResult =
| { readonly type: "healthy"; readonly version?: string; readonly hostname?: string }
| { readonly type: "unauthorized" }
| { readonly type: "unreachable" }
/**
* What the app knows about a server's health. `checking` waits for the first answer from the current endpoint; a
* contributed server that is not ready reports its plugin's stage instead.
*/
export type ServerHealth =
| ServerProbeResult
| { readonly type: "checking"; readonly managed: boolean }
| { readonly type: "incompatible" }
| { readonly type: "starting" }
| { readonly type: "auth" }
| { readonly type: "stopped" }
type PluginStage = Exclude<PluginServerStatus["type"], "ready">
/** A listed server, as plain values: the health checks keep the endpoint they started with. */
export type ServerHealthInput =
| { readonly type: "staged"; readonly key: ServerConnection.Key; readonly stage: PluginStage }
| {
readonly type: "endpoint"
readonly key: ServerConnection.Key
readonly http: ServerConnection.HttpBase
/** The plugin re-resolves the endpoint, so a new one shows as connecting until it answers. */
readonly managed: boolean
}
type Endpoint = { readonly http: ServerConnection.HttpBase; readonly auth: string; readonly managed: boolean }
/**
* One server. Every probe carries the slot's `attempt`; an answer for another attempt is stale. `checking` and
* `refreshing` have a probe in flight, `settled` waits for the next poll.
*/
export type ServerHealthSlot =
| { readonly type: "staged"; readonly stage: PluginStage; readonly attempt: number }
| { readonly type: "checking"; readonly endpoint: Endpoint; readonly attempt: number }
| {
readonly type: "settled"
readonly endpoint: Endpoint
readonly result: ServerProbeResult
readonly attempt: number
}
| {
readonly type: "refreshing"
readonly endpoint: Endpoint
readonly result: ServerProbeResult
readonly attempt: number
}
/** A `retry` caller, waiting for each server's probe from at least the given attempt. */
type RetryWaiter = {
readonly resolve: () => void
readonly targets: ReadonlyMap<ServerConnection.Key, number>
}
export type ServerHealthState = {
readonly entries: ReadonlyMap<ServerConnection.Key, ServerHealthSlot>
readonly waiters: readonly RetryWaiter[]
}
/** An accepted probe answer, with the endpoint credentials it used. */
export type ServerProbe = {
readonly key: ServerConnection.Key
readonly auth: string
readonly result: ServerProbeResult
}
export type ServerHealthEvent =
| { readonly type: "servers.synced"; readonly servers: readonly ServerHealthInput[] }
| { readonly type: "poll.due" }
| { readonly type: "retry.requested"; readonly resolve: () => void }
| {
readonly type: "probe.settled"
readonly key: ServerConnection.Key
readonly attempt: number
readonly result: ServerProbeResult
}
| { readonly type: "disposed" }
export type ServerHealthEffect =
| {
readonly type: "probe"
readonly key: ServerConnection.Key
readonly attempt: number
readonly http: ServerConnection.HttpBase
}
| { readonly type: "notify.probe"; readonly probe: ServerProbe }
| { readonly type: "timer.start"; readonly intervalMs: number }
| { readonly type: "timer.stop" }
| { readonly type: "waiters.resolve"; readonly resolvers: readonly (() => void)[] }
export type ServerHealthTransition = {
readonly state: ServerHealthState
readonly effects: readonly ServerHealthEffect[]
}
export function createServerHealthState(): ServerHealthState {
return { entries: new Map(), waiters: [] }
}
export function transitionServerHealth(state: ServerHealthState, event: ServerHealthEvent): ServerHealthTransition {
if (event.type === "servers.synced") return synced(state, event.servers)
if (event.type === "poll.due") return polled(state)
if (event.type === "retry.requested") return retried(state, event.resolve)
if (event.type === "probe.settled") return answered(state, event)
// Disposed: stop polling and release every `retry` caller.
if (!state.entries.size && !state.waiters.length) return { state, effects: [] }
return {
state: createServerHealthState(),
effects: [
...(polling(state) ? [{ type: "timer.stop" as const }] : []),
...resolved(state.waiters.map((waiter) => waiter.resolve)),
],
}
}
/** Every listed server's health, keyed by server. */
export function selectServerHealthRecord(state: ServerHealthState) {
return Object.fromEntries([...state.entries].map(([key, slot]) => [key, selectServerHealth(slot)]))
}
// Builds a new object on every call: the driver hands it to a store, which adopts and later changes it.
export function selectServerHealth(slot: ServerHealthSlot): ServerHealth {
if (slot.type === "staged") return slot.stage === "failed" ? { type: "unreachable" } : { type: slot.stage }
if (slot.type === "checking") return { type: "checking", managed: slot.endpoint.managed }
return { ...slot.result }
}
export function isServerHealthy(health: ServerHealth | undefined) {
return health?.type === "healthy"
}
/** The server can be used: it answered, or nothing says it cannot (not checked yet, or a check is in flight). */
export function canUseServer(health: ServerHealth | undefined) {
return health === undefined || health.type === "healthy" || health.type === "checking"
}
/** The server's last answer, or its plugin, says it cannot be used. A check in flight is not a failure. */
export function isServerFailed(health: ServerHealth | undefined) {
return health?.type === "unreachable" || health?.type === "unauthorized" || health?.type === "incompatible"
}
export function isServerUnauthorized(health: ServerHealth | undefined) {
return health?.type === "unauthorized"
}
export function isServerIncompatible(health: ServerHealth | undefined) {
return health?.type === "incompatible"
}
export function selectServerVersion(health: ServerHealth | undefined) {
return health?.type === "healthy" ? health.version : undefined
}
export function selectServerHostname(health: ServerHealth | undefined) {
return health?.type === "healthy" ? health.hostname : undefined
}
/** Sort rank: healthy first, then servers still settling, then failed ones. */
export function selectServerHealthRank(health: ServerHealth | undefined) {
if (health?.type === "healthy") return 0
if (isServerFailed(health)) return 2
return 1
}
/** The status mark a server row shows. */
export function selectServerIndicator(health: ServerHealth | undefined) {
if (health === undefined || health.type === "stopped") return "unknown"
if (health.type === "auth" || health.type === "unauthorized") return "auth"
if (health.type === "starting") return "connecting"
if (health.type === "checking") return health.managed ? "connecting" : "unknown"
return health.type
}
export type ServerIndicator = ReturnType<typeof selectServerIndicator>
function synced(state: ServerHealthState, servers: readonly ServerHealthInput[]): ServerHealthTransition {
const steps = servers.map((input) => {
const slot = state.entries.get(input.key)
return { key: input.key, slot, next: listed(slot, input) }
})
const entries =
steps.length === state.entries.size && steps.every((step) => step.next === step.slot)
? state.entries
: new Map(steps.map((step) => [step.key, step.next]))
return settle(
state,
entries,
steps.flatMap((step) =>
step.next.type === "checking" && step.next.attempt !== step.slot?.attempt ? [probe(step.key, step.next)] : [],
),
)
}
function listed(slot: ServerHealthSlot | undefined, input: ServerHealthInput): ServerHealthSlot {
if (input.type === "staged") {
if (slot?.type === "staged" && slot.stage === input.stage) return slot
// The probe in flight, if any, keeps its attempt and so can never land.
return { type: "staged", stage: input.stage, attempt: slot?.attempt ?? 0 }
}
const auth = endpointCredentials(input.http)
// Another endpoint is another target: its previous answer says nothing about the new one.
if (!slot || slot.type === "staged" || slot.endpoint.auth !== auth)
return {
type: "checking",
endpoint: { http: input.http, auth, managed: input.managed },
attempt: (slot?.attempt ?? 0) + 1,
}
if (slot.endpoint.managed === input.managed) return slot
return { ...slot, endpoint: { ...slot.endpoint, managed: input.managed } }
}
// A probe still in flight keeps running: a server slower than the poll interval still gets its answer.
function polled(state: ServerHealthState): ServerHealthTransition {
const due = [...state.entries].flatMap(([key, slot]) =>
slot.type === "settled" ? [{ key, next: { ...slot, type: "refreshing" as const, attempt: slot.attempt + 1 } }] : [],
)
if (!due.length) return { state, effects: [] }
const entries = new Map(state.entries)
due.forEach((item) => entries.set(item.key, item.next))
return { state: { entries, waiters: state.waiters }, effects: due.map((item) => probe(item.key, item.next)) }
}
// A retry replaces any probe in flight, so one that hangs cannot hold the caller.
function retried(state: ServerHealthState, resolve: () => void): ServerHealthTransition {
const restarted = [...state.entries].flatMap(([key, slot]) => {
if (slot.type === "staged") return []
const next: ServerHealthSlot =
slot.type === "checking"
? { ...slot, attempt: slot.attempt + 1 }
: { ...slot, type: "refreshing", attempt: slot.attempt + 1 }
return [{ key, next }]
})
if (!restarted.length) return { state, effects: resolved([resolve]) }
const entries = new Map(state.entries)
restarted.forEach((item) => entries.set(item.key, item.next))
return {
state: {
entries,
waiters: [
...state.waiters,
{ resolve, targets: new Map(restarted.map((item) => [item.key, item.next.attempt])) },
],
},
effects: [
...restarted.map((item) => probe(item.key, item.next)),
{ type: "timer.start", intervalMs: SERVER_HEALTH_POLL_MS },
],
}
}
function answered(
state: ServerHealthState,
event: Extract<ServerHealthEvent, { type: "probe.settled" }>,
): ServerHealthTransition {
const slot = state.entries.get(event.key)
// A superseded, unlisted or disposed probe changes nothing and reaches no listener.
if (!slot || (slot.type !== "checking" && slot.type !== "refreshing") || slot.attempt !== event.attempt)
return { state, effects: [] }
return settle(
state,
new Map(state.entries).set(event.key, {
type: "settled",
endpoint: slot.endpoint,
result: event.result,
attempt: slot.attempt,
}),
[{ type: "notify.probe", probe: { key: event.key, auth: slot.endpoint.auth, result: event.result } }],
)
}
/** Applies new entries: starts or stops the poll and resolves the `retry` callers whose probes all answered. */
function settle(
state: ServerHealthState,
entries: ServerHealthState["entries"],
effects: readonly ServerHealthEffect[],
): ServerHealthTransition {
if (entries === state.entries) return { state, effects }
const remaining = state.waiters.map((waiter) => {
const targets = [...waiter.targets].filter(([key, attempt]) => !answeredSince(entries.get(key), attempt))
return targets.length === waiter.targets.size ? waiter : { resolve: waiter.resolve, targets: new Map(targets) }
})
const next = { entries, waiters: remaining.filter((waiter) => waiter.targets.size > 0) }
return {
state: next,
effects: [
...effects,
...(!polling(state) && polling(next)
? [{ type: "timer.start" as const, intervalMs: SERVER_HEALTH_POLL_MS }]
: []),
...(polling(state) && !polling(next) ? [{ type: "timer.stop" as const }] : []),
...resolved(remaining.flatMap((waiter) => (waiter.targets.size ? [] : [waiter.resolve]))),
],
}
}
// A server that left the list or has no endpoint has nothing left to answer.
function answeredSince(slot: ServerHealthSlot | undefined, attempt: number) {
return !slot || slot.type === "staged" || (slot.type === "settled" && slot.attempt >= attempt)
}
function polling(state: ServerHealthState) {
return [...state.entries.values()].some((slot) => slot.type !== "staged")
}
function probe(key: ServerConnection.Key, slot: { readonly endpoint: Endpoint; readonly attempt: number }) {
return { type: "probe" as const, key, attempt: slot.attempt, http: slot.endpoint.http }
}
function resolved(resolvers: readonly (() => void)[]): ServerHealthEffect[] {
return resolvers.length ? [{ type: "waiters.resolve", resolvers }] : []
}
+49 -40
View File
@@ -9,6 +9,18 @@ const server: ServerConnection.HttpBase = {
const info = (version = "1.2.3") =>
Response.json({ version, pid: 1, urls: [server.url], paths: { tmp: "/tmp/opencode" } })
// SAFETY: `checkServerHealth` only calls `fetch(input, init)`, which these fakes implement; none reads `preconnect`.
const fakeFetch = (handler: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) =>
handler as typeof globalThis.fetch
// Puts back the `AbortSignal.timeout` a test replaced, or removes the stand-in when the runtime had none.
function restoreTimeout(descriptor: PropertyDescriptor | undefined) {
if (descriptor) return void Object.defineProperty(AbortSignal, "timeout", descriptor)
const signal: Partial<typeof AbortSignal> = AbortSignal
delete signal.timeout
}
function abortFromInput(input: RequestInfo | URL, init?: RequestInit) {
if (init?.signal) return init.signal
@@ -21,14 +33,14 @@ describe("checkServerHealth", () => {
test.each([undefined, "secret"])("reads /api/info authenticating with only the password (%s)", async (password) => {
const requests: { path: string; authorization: string | null }[] = []
const fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
const fetch = fakeFetch(async (input, init) => {
const url = input instanceof URL ? input : new URL(input instanceof Request ? input.url : input)
requests.push({ path: url.pathname, authorization: new Headers(init?.headers).get("authorization") })
return info("2.0.0")
}) as typeof globalThis.fetch
})
expect(await checkServerHealth({ ...server, password }, fetch)).toEqual({ healthy: true, version: "2.0.0" })
expect(await checkServerHealth({ ...server, password }, fetch)).toEqual({ type: "healthy", version: "2.0.0" })
expect(requests).toEqual([
{ path: "/api/info", authorization: password ? `Basic ${btoa(`opencode:${password}`)}` : null },
])
@@ -37,13 +49,16 @@ describe("checkServerHealth", () => {
test("reports rejected credentials without retrying", async () => {
let calls = 0
const fetch = (async () => {
const fetch = fakeFetch(async () => {
calls++
return Response.json({ _tag: "UnauthorizedError", message: "Authentication required" }, { status: 401 })
}) as unknown as typeof globalThis.fetch
return new Response(`{"_tag":"UnauthorizedError","message":"Authentication required"}`, {
status: 401,
headers: { "content-type": "application/json" },
})
})
expect(await checkServerHealth(server, fetch)).toEqual({ healthy: false, unauthorized: true })
expect(await checkServerHealth(server, fetch)).toEqual({ type: "unauthorized" })
expect(calls).toBe(1)
})
@@ -59,13 +74,9 @@ describe("checkServerHealth", () => {
},
})
const fetch = (async () => info()) as unknown as typeof globalThis.fetch
const fetch = fakeFetch(async () => info())
await checkServerHealth(server, fetch).finally(() => {
if (timeout) Object.defineProperty(AbortSignal, "timeout", timeout)
if (!timeout) delete (AbortSignal as Partial<typeof AbortSignal>).timeout
})
await checkServerHealth(server, fetch).finally(() => restoreTimeout(timeout))
expect(timeoutMs).toBe(30_000)
})
@@ -79,39 +90,37 @@ describe("checkServerHealth", () => {
let aborted = false
const fetch = ((input: RequestInfo | URL, init?: RequestInit) =>
new Promise<Response>((_resolve, reject) => {
const signal = abortFromInput(input, init)
signal?.addEventListener(
"abort",
() => {
aborted = true
reject(new DOMException("Aborted", "AbortError"))
},
{ once: true },
)
})) as unknown as typeof globalThis.fetch
const fetch = fakeFetch(
(input, init) =>
new Promise<Response>((_resolve, reject) => {
const signal = abortFromInput(input, init)
signal?.addEventListener(
"abort",
() => {
aborted = true
reject(new DOMException("Aborted", "AbortError"))
},
{ once: true },
)
}),
)
const result = await checkServerHealth(server, fetch, {
timeoutMs: 10,
}).finally(() => {
if (timeout) Object.defineProperty(AbortSignal, "timeout", timeout)
if (!timeout) delete (AbortSignal as Partial<typeof AbortSignal>).timeout
})
}).finally(() => restoreTimeout(timeout))
expect(aborted).toBe(true)
expect(result).toEqual({ healthy: false })
expect(result).toEqual({ type: "unreachable" })
})
test("uses provided abort signal", async () => {
let signal: AbortSignal | undefined
const fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
const fetch = fakeFetch(async (input, init) => {
signal = abortFromInput(input, init)
return info()
}) as unknown as typeof globalThis.fetch
})
const abort = new AbortController()
await checkServerHealth(server, fetch, {
@@ -124,13 +133,13 @@ describe("checkServerHealth", () => {
test("retries transient failures and eventually succeeds", async () => {
let count = 0
const fetch = (async () => {
const fetch = fakeFetch(async () => {
count += 1
if (count < 3) throw new TypeError("network")
return info()
}) as unknown as typeof globalThis.fetch
})
const result = await checkServerHealth(server, fetch, {
retryCount: 2,
@@ -138,16 +147,16 @@ describe("checkServerHealth", () => {
})
expect(count).toBe(3)
expect(result).toEqual({ healthy: true, version: "1.2.3" })
expect(result).toEqual({ type: "healthy", version: "1.2.3" })
})
test("returns unhealthy when retries are exhausted", async () => {
test("returns unreachable when retries are exhausted", async () => {
let count = 0
const fetch = (async () => {
const fetch = fakeFetch(async () => {
count += 1
throw new TypeError("network")
}) as unknown as typeof globalThis.fetch
})
const result = await checkServerHealth(server, fetch, {
retryCount: 2,
@@ -155,6 +164,6 @@ describe("checkServerHealth", () => {
})
expect(count).toBe(3)
expect(result).toEqual({ healthy: false })
expect(result).toEqual({ type: "unreachable" })
})
})
+75 -125
View File
@@ -1,22 +1,21 @@
import { usePlatform } from "@/runtime/platform/platform"
import { ServerConnection } from "@/runtime/server/registry"
import { authTokenFromCredentials } from "./api"
import {
createServerHealthState,
selectServerHealthRecord,
transitionServerHealth,
type ServerHealth,
type ServerHealthEvent,
type ServerHealthInput,
type ServerProbe,
type ServerProbeResult,
} from "./health-machine"
import { endpointCredentials } from "./machine"
import { ClientError, isUnauthorizedError, OpenCode } from "@opencode/client"
import { Match } from "effect"
import { Accessor, createEffect, createSignal, onCleanup } from "solid-js"
import { Accessor, batch, createComputed, createSignal, onCleanup, untrack } from "solid-js"
import { createStore, reconcile } from "solid-js/store"
export type ServerHealth = {
healthy: boolean
version?: string
/** The server machine's name, when the server reports one. */
hostname?: string
incompatible?: boolean
checking?: boolean
unauthorized?: boolean
}
interface CheckServerHealthOptions {
timeoutMs?: number
signal?: AbortSignal
@@ -32,9 +31,10 @@ const defaultRetryDelayMs = 100
const cacheMs = 750
// `at` is when the probe started, then when it answered: a probe that hangs is shared only briefly.
const healthCache = new Map<
string,
{ at: number; done: boolean; fetch: typeof globalThis.fetch; promise: Promise<ServerHealth> }
{ at: number; fetch: typeof globalThis.fetch; promise: Promise<ServerProbeResult> }
>()
/** A signal that aborts after a timeout, and how to stop its timer early when one runs. */
@@ -92,11 +92,13 @@ function retryable(error: unknown, signal?: AbortSignal) {
return /network|fetch|econnreset|econnrefused|enotfound|timedout/i.test(error.message)
}
const unreachable = { type: "unreachable" } as const
export async function checkServerHealth(
server: ServerConnection.HttpBase,
fetch: typeof globalThis.fetch,
opts?: CheckServerHealthOptions,
): Promise<ServerHealth> {
): Promise<ServerProbeResult> {
const timeout = opts?.signal ? undefined : timeoutSignal(opts?.timeoutMs ?? defaultTimeoutMs)
const signal = opts?.signal ?? timeout?.signal
const retryCount = opts?.retryCount ?? defaultRetryCount
@@ -108,15 +110,15 @@ export async function checkServerHealth(
}
: undefined
const next = (count: number, retry: boolean) => {
if (count >= retryCount || !retry) return Promise.resolve({ healthy: false } as const)
const next = (count: number, retry: boolean): Promise<ServerProbeResult> => {
if (count >= retryCount || !retry) return Promise.resolve(unreachable)
return wait(retryDelayMs * (count + 1), signal)
.then(() => attempt(count + 1))
.catch(() => ({ healthy: false }))
.catch(() => unreachable)
}
const attempt = async (count: number): Promise<ServerHealth> => {
const attempt = async (count: number): Promise<ServerProbeResult> => {
const current = await OpenCode.make({
baseUrl: server.url,
fetch,
@@ -124,15 +126,15 @@ export async function checkServerHealth(
})
.server.info({ signal })
.then((status) => ({
data: { healthy: true as const, version: status.version, hostname: status.hostname },
data: { type: "healthy" as const, version: status.version, hostname: status.hostname },
}))
.catch((error) => ({ error }))
if ("data" in current) return current.data
if (signal?.aborted) return { healthy: false }
if (signal?.aborted) return unreachable
if (isUnauthorizedError(current.error)) return { healthy: false, unauthorized: true }
if (isUnauthorizedError(current.error)) return { type: "unauthorized" }
return next(count, retryable(current.error, signal))
}
@@ -140,16 +142,6 @@ export async function checkServerHealth(
return attempt(0).finally(() => timeout?.clear?.())
}
const pollMs = 10_000
// What a contributed server that is not ready reports: failed and incompatible are known; any other stage is unknown.
const stageHealth = (stage: ServerConnection.Plugin["state"]) =>
Match.value(stage).pipe(
Match.when("failed", (): ServerHealth | undefined => ({ healthy: false })),
Match.when("incompatible", (): ServerHealth | undefined => ({ healthy: false, incompatible: true })),
Match.orElse((): ServerHealth | undefined => undefined),
)
export function useCheckServerHealth() {
const platform = usePlatform()
const fetcher = platform.fetch ?? globalThis.fetch
@@ -159,128 +151,86 @@ export function useCheckServerHealth() {
const hit = healthCache.get(key)
const now = Date.now()
if (hit && hit.fetch === fetcher && (!hit.done || now - hit.at < cacheMs)) return hit.promise
if (hit && hit.fetch === fetcher && now - hit.at < cacheMs) return hit.promise
const promise = checkServerHealth(http, fetcher).finally(() => {
const next = healthCache.get(key)
if (!next || next.promise !== promise) return
next.done = true
next.at = Date.now()
if (healthCache.get(key)?.promise === promise) healthCache.set(key, { at: Date.now(), fetch: fetcher, promise })
})
healthCache.set(key, { at: now, done: false, fetch: fetcher, promise })
healthCache.set(key, { at: now, fetch: fetcher, promise })
return promise
}
}
/** One finished probe, with the endpoint credentials it used. */
export type ServerProbe = { key: ServerConnection.Key; auth: string; health: ServerHealth }
export const useServerHealth = (
servers: Accessor<ServerConnection.Any[]>,
enabled: Accessor<boolean>,
onProbe?: (probe: ServerProbe) => void,
) => {
return createServerHealth(servers, enabled, useCheckServerHealth(), onProbe)
export const useServerHealth = (servers: Accessor<ServerConnection.Any[]>, onProbe?: (probe: ServerProbe) => void) => {
return createServerHealth(servers, useCheckServerHealth(), onProbe)
}
export function createServerHealth(
servers: Accessor<ServerConnection.Any[]>,
enabled: Accessor<boolean>,
check: (http: ServerConnection.HttpBase) => Promise<ServerHealth>,
check: (http: ServerConnection.HttpBase) => Promise<ServerProbeResult>,
onProbe?: (probe: ServerProbe) => void,
) {
const [machine, setMachine] = createSignal(createServerHealthState())
const [status, setStatus] = createStore<Record<ServerConnection.Key, ServerHealth | undefined>>({})
const [attempt, setAttempt] = createSignal(0)
const endpoints = new Map<ServerConnection.Key, string>()
// Callers of `retry` wait for the probe round it starts.
const waiting: (() => void)[] = []
let timer: ReturnType<typeof setInterval> | undefined
createEffect(() => {
attempt()
const dispatch = (event: ServerHealthEvent) =>
batch(() => {
const prev = untrack(machine)
const result = transitionServerHealth(prev, event)
if (!enabled()) {
endpoints.clear()
setStatus(reconcile({}))
waiting.splice(0).forEach((resolve) => resolve())
// The selector builds new objects, which the store adopts and later updates in place.
if (result.state.entries !== prev.entries) setStatus(reconcile(selectServerHealthRecord(result.state)))
setMachine(result.state)
return
}
result.effects.forEach((effect) => {
if (effect.type === "probe") {
const settled = (answer: ServerProbeResult) =>
dispatch({ type: "probe.settled", key: effect.key, attempt: effect.attempt, result: answer })
// Snapshot transport fields synchronously so a newly established SSH tunnel
// invalidates both the old result and any probe still using the old endpoint.
const list = servers().map((conn) => ({
key: ServerConnection.key(conn),
managed: conn.type === "plugin" && conn.managed,
http: conn.http,
stage: conn.type === "plugin" ? conn.state : undefined,
}))
void Promise.try(() => check(effect.http)).then(settled, () => settled(unreachable))
for (const conn of list) {
if (conn.stage && conn.stage !== "ready") {
endpoints.delete(conn.key)
setStatus(conn.key, reconcile(stageHealth(conn.stage)))
continue
}
return
}
const endpoint = endpointCredentials(conn.http)
if (effect.type === "notify.probe") return onProbe?.(effect.probe)
if (conn.managed && endpoints.get(conn.key) !== endpoint) {
setStatus(conn.key, reconcile({ healthy: false, checking: true }))
}
if (effect.type === "waiters.resolve") return effect.resolvers.forEach((resolve) => resolve())
endpoints.set(conn.key, endpoint)
}
for (const key of endpoints.keys()) {
if (!list.some((conn) => conn.key === key)) endpoints.delete(key)
}
let dead = false
const refresh = async () => {
const results: Record<string, ServerHealth | undefined> = {}
await Promise.all(
list.map(async (conn) => {
if (conn.stage && conn.stage !== "ready") {
results[conn.key] = stageHealth(conn.stage)
return
}
// The endpoint can change while the probe runs; the listener matches the result to the credentials it used.
const auth = endpointCredentials(conn.http)
const result = await check(conn.http)
results[conn.key] = result
onProbe?.({ key: conn.key, auth, health: result })
if (!dead) setStatus(conn.key, reconcile(result))
}),
)
if (dead) return
setStatus(reconcile(results))
}
void refresh().finally(() => {
if (!dead) waiting.splice(0).forEach((resolve) => resolve())
})
const id = setInterval(() => void refresh(), pollMs)
onCleanup(() => {
dead = true
clearInterval(id)
clearInterval(timer)
timer =
effect.type === "timer.start"
? setInterval(() => dispatch({ type: "poll.due" }), effect.intervalMs)
: undefined
})
})
// Runs during updates, so a server's health is known on the render that lists it. Reading the endpoint here tracks a
// saved password and a plugin server's stage and endpoint.
createComputed(() => {
const list = servers().map(healthInput)
untrack(() => dispatch({ type: "servers.synced", servers: list }))
})
onCleanup(() => dispatch({ type: "disposed" }))
return {
status,
/** Probes every server now instead of at the next poll; resolves when that round finishes. */
retry: () =>
new Promise<void>((resolve) => {
waiting.push(resolve)
setAttempt((value) => value + 1)
}),
/** Probes every server now instead of at the next poll; resolves when each has answered or left the list. */
retry: () => new Promise<void>((resolve) => dispatch({ type: "retry.requested", resolve })),
}
}
function healthInput(conn: ServerConnection.Any): ServerHealthInput {
const key = ServerConnection.key(conn)
if (conn.type !== "plugin")
return { type: "endpoint", key, http: { url: conn.http.url, password: conn.http.password }, managed: false }
if (conn.status.type === "ready") return { type: "endpoint", key, http: conn.status.http, managed: conn.managed }
return { type: "staged", key, stage: conn.status.type }
}
@@ -36,8 +36,7 @@ const rejected = (password: string): ServerControllersEvent<Ctx> => ({
type: "health.reported",
key,
auth: `${url}\n${password}`,
healthy: false,
unauthorized: true,
result: { type: "unauthorized" },
})
// Controllers dispose long after the run that created them, so every run appends to one log.
@@ -114,6 +113,24 @@ test("a rejection of credentials the server has since replaced changes nothing",
expect(selectServerCtx(late.state, key)?.name).toBe("ctx2")
})
test("a contributed server has credentials to check only while it is ready, never its placeholder endpoint", () => {
const plugin = (status: ServerConnection.Plugin["status"]): ServerConnection.Plugin => ({
type: "plugin",
key: "ssh:box",
plugin: "ssh",
status,
managed: true,
http: { url: "http://127.0.0.1:0" },
authenticate: () => false,
})
expect(serverCredentials(plugin({ type: "auth" }))).toEqual({ controller: "", auth: undefined })
expect(serverCredentials(plugin({ type: "ready", http: { url, password: "pw" } }))).toEqual({
controller: "",
auth: `${url}\npw`,
})
})
test("new HTTP credentials dispose the old controller before the new one starts", () => {
expect(run(live("pw1"), synced(http("pw2"))).log).toEqual(["dispose ctx1", "create ctx2"])
})
+9 -8
View File
@@ -1,3 +1,4 @@
import type { ServerProbeResult } from "./health-machine"
import type { ServerConnection } from "./registry"
/** What a server's controller is bound to, as plain values read from its listed connection. */
@@ -59,8 +60,7 @@ export type ServerControllersEvent<T> =
readonly type: "health.reported"
readonly key: ServerConnection.Key
readonly auth: string
readonly healthy: boolean
readonly unauthorized: boolean
readonly result: ServerProbeResult
}
| { readonly type: "disposed" }
@@ -94,12 +94,12 @@ export function endpointCredentials(http: ServerConnection.HttpBase) {
}
export function serverCredentials(conn: ServerConnection.Any): ServerCredentials {
if (conn.type === "plugin")
return { controller: "", auth: conn.status.type === "ready" ? endpointCredentials(conn.status.http) : undefined }
const endpoint = endpointCredentials(conn.http)
return {
controller: conn.type === "http" ? endpoint : "",
auth: conn.type === "plugin" && conn.state !== "ready" ? undefined : endpoint,
}
return { controller: conn.type === "http" ? endpoint : "", auth: endpoint }
}
export function createServerControllersState<T>(): ServerControllersState<T> {
@@ -220,13 +220,14 @@ function reported<T>(
// A server that accepts the rejected credentials again, such as after its password was restored, gets a controller.
if (state.type === "unauthorized") {
if (event.healthy && event.auth === state.credentials.auth) return start(state, state.conn, state.credentials, [])
if (event.result.type === "healthy" && event.auth === state.credentials.auth)
return start(state, state.conn, state.credentials, [])
return { state, effects: [] }
}
// A probe of credentials the server has since replaced says nothing about the current ones.
if (!event.unauthorized || event.auth !== state.credentials.auth) return { state, effects: [] }
if (event.result.type !== "unauthorized" || event.auth !== state.credentials.auth) return { state, effects: [] }
return {
state: {
@@ -0,0 +1,128 @@
import { expect, test } from "bun:test"
import {
canAuthenticatePluginServer,
createPluginServerState,
PLUGIN_CONNECT_TIMEOUT_MS,
selectPluginStatus,
transitionPluginServer,
type PluginEntrySnapshot,
type PluginServerEffect,
type PluginServerEvent,
type PluginServerState,
type PluginServerStatus,
} from "./plugin-machine"
const http = { url: "http://127.0.0.1:4100", password: "secret" }
const entry = (state: PluginEntrySnapshot["state"], endpoint?: PluginEntrySnapshot["http"]): PluginServerEvent => ({
type: "entry.updated",
entry: { state, http: endpoint },
})
const settled = (attempt: number, ready: boolean): PluginServerEvent => ({ type: "connect.settled", attempt, ready })
function replay(events: readonly PluginServerEvent[], state = createPluginServerState({ state: "auth" })) {
return events.reduce<{ state: PluginServerState; effects: PluginServerEffect[] }>(
(result, event) => {
const next = transitionPluginServer(result.state, event)
return { state: next.state, effects: [...result.effects, ...next.effects] }
},
{ state, effects: [] },
)
}
// What the callbacks the driver ran did.
const log: string[] = []
const logs = (step: string) => () => void log.push(step)
/** Plays the driver's `notify.connected`: runs every callback and returns what they logged. */
function run(effects: readonly PluginServerEffect[]) {
const from = log.length
effects.forEach((effect) => effect.type === "notify.connected" && effect.callbacks.forEach((callback) => callback()))
return log.slice(from)
}
test("a second sign-in request joins the first instead of connecting again", () => {
const clicked = replay([
{ type: "authenticate", onConnected: logs("focus") },
{ type: "authenticate", onConnected: logs("open project") },
])
expect(clicked.effects).toEqual([{ type: "connect", attempt: 1, timeoutMs: PLUGIN_CONNECT_TIMEOUT_MS }])
expect(selectPluginStatus(clicked.state)).toEqual({ type: "starting" })
expect(canAuthenticatePluginServer(clicked.state)).toBe(true)
const ready = transitionPluginServer(clicked.state, entry("ready", http))
expect(selectPluginStatus(ready.state)).toEqual({ type: "ready", http })
expect(run(ready.effects)).toEqual(["focus", "open project"])
})
test("a password prompt during sign-in keeps the server connecting until the attempt ends", () => {
const prompted = replay([{ type: "authenticate", onConnected: logs("focus") }, entry("starting"), entry("auth")])
expect(selectPluginStatus(prompted.state)).toEqual({ type: "starting" })
// The user cancels the prompt: the server asks for sign-in again and nothing continues.
const cancelled = transitionPluginServer(prompted.state, settled(1, false))
expect(selectPluginStatus(cancelled.state)).toEqual({ type: "auth" })
expect(cancelled.effects).toEqual([{ type: "timeout.cancel" }])
expect(canAuthenticatePluginServer(cancelled.state)).toBe(true)
})
test.each([
{ name: "the plugin reports ready first", events: [entry("ready", http), settled(1, true)] },
{ name: "connect resolves first", events: [settled(1, true), entry("ready", http)] },
])("sign-in continues exactly once when $name", (input) => {
const result = replay([{ type: "authenticate", onConnected: logs("focus") }, ...input.events])
expect(run(result.effects)).toEqual(["focus"])
expect(selectPluginStatus(result.state)).toEqual({ type: "ready", http })
})
test("a sign-in that runs out of time shows the plugin's stage again and never continues", () => {
const timedOut = replay([
{ type: "authenticate", onConnected: logs("focus") },
entry("starting"),
{ type: "connect.timed-out", attempt: 1 },
])
expect(selectPluginStatus(timedOut.state)).toEqual({ type: "starting" })
const late = replay([settled(1, true), entry("ready", http)], timedOut.state)
expect(run(late.effects)).toEqual([])
expect(selectPluginStatus(late.state)).toEqual({ type: "ready", http })
})
test.each<{ name: string; event: PluginServerEvent; status: PluginServerStatus["type"] }>([
{ name: "fails", event: entry("failed"), status: "failed" },
{ name: "stops", event: entry("stopped"), status: "stopped" },
{ name: "is unlisted", event: { type: "disposed" }, status: "stopped" },
])("a sign-in ends and drops its callbacks when the server $name", (input) => {
const ended = replay([{ type: "authenticate", onConnected: logs("focus") }, input.event])
expect(ended.effects).toContainEqual({ type: "timeout.cancel" })
expect(selectPluginStatus(ended.state).type).toBe(input.status)
expect(run(replay([settled(1, true), entry("ready", http)], ended.state).effects)).toEqual([])
})
test.each(["stopped", "starting", "ready", "failed", "incompatible"] as const)(
"a server in %s does not start sign-in",
(stage) => {
const state = createPluginServerState({ state: stage, http })
expect(canAuthenticatePluginServer(state)).toBe(false)
expect(transitionPluginServer(state, { type: "authenticate" })).toEqual({ state, effects: [] })
},
)
test("a ready report without an endpoint is a failure, never a ready server", () => {
const state = createPluginServerState({ state: "ready" })
expect(selectPluginStatus(state)).toEqual({ type: "failed" })
expect(transitionPluginServer(state, entry("ready")).state).toBe(state)
const ready = transitionPluginServer(state, entry("ready", { ...http })).state
expect(transitionPluginServer(ready, entry("ready", { ...http })).state).toBe(ready)
})
@@ -0,0 +1,170 @@
import type { ServerState } from "@opencode/plugin/gui"
import type { ServerConnection } from "./registry"
/** How long a sign-in may run before the server shows what its plugin reports again. */
export const PLUGIN_CONNECT_TIMEOUT_MS = 120_000
/** Where a contributed server stands. Only a ready server has an endpoint. */
export type PluginServerStatus =
| { readonly type: "stopped" | "starting" | "auth" | "failed" | "incompatible" }
| { readonly type: "ready"; readonly http: ServerConnection.HttpBase }
/** What the app reads from a plugin's `ServerEntry`, as plain values. */
export type PluginEntrySnapshot = { readonly state: ServerState; readonly http?: ServerConnection.HttpBase }
type Stage = Exclude<ServerState, "ready">
/**
* One contributed server. `authenticating` starts when the user asks to sign in and lasts until the plugin reports the
* server ready, the plugin's `connect` gives up, or the timeout runs out; meanwhile the server shows as starting.
*/
export type PluginServerState =
| { readonly status: Stage; readonly attempt: number }
| { readonly status: "ready"; readonly attempt: number; readonly http: ServerConnection.HttpBase }
| {
readonly status: "authenticating"
readonly attempt: number
/** What the plugin reports meanwhile; the server returns to it when sign-in ends without it ready. */
readonly reported: "auth" | "starting"
/** Run once the server is ready. */
readonly callbacks: readonly (() => void)[]
}
export type PluginServerEvent =
| { readonly type: "entry.updated"; readonly entry: PluginEntrySnapshot }
| { readonly type: "authenticate"; readonly onConnected?: () => void }
| { readonly type: "connect.settled"; readonly attempt: number; readonly ready: boolean }
| { readonly type: "connect.timed-out"; readonly attempt: number }
| { readonly type: "disposed" }
export type PluginServerEffect =
| { readonly type: "connect"; readonly attempt: number; readonly timeoutMs: number }
| { readonly type: "timeout.cancel" }
| { readonly type: "notify.connected"; readonly callbacks: readonly (() => void)[] }
export type PluginServerTransition = {
readonly state: PluginServerState
readonly effects: readonly PluginServerEffect[]
}
export function createPluginServerState(entry: PluginEntrySnapshot): PluginServerState {
return { ...target(entry), attempt: 0 }
}
export function transitionPluginServer(state: PluginServerState, event: PluginServerEvent): PluginServerTransition {
if (event.type === "entry.updated") return updated(state, event.entry)
if (event.type === "authenticate") {
if (state.status === "auth") {
const attempt = state.attempt + 1
return {
state: {
status: "authenticating",
attempt,
reported: "auth",
callbacks: event.onConnected ? [event.onConnected] : [],
},
effects: [{ type: "connect", attempt, timeoutMs: PLUGIN_CONNECT_TIMEOUT_MS }],
}
}
// A second click joins the sign-in in progress instead of starting another.
if (state.status === "authenticating" && event.onConnected)
return { state: { ...state, callbacks: [...state.callbacks, event.onConnected] }, effects: [] }
return unchanged(state)
}
// An unlisted server drops the callbacks of its sign-in; a late answer finds nothing to resume.
if (event.type === "disposed") {
if (state.status === "stopped") return unchanged(state)
return {
state: { status: "stopped", attempt: state.attempt },
effects: state.status === "authenticating" ? [{ type: "timeout.cancel" }] : [],
}
}
if (state.status !== "authenticating" || event.attempt !== state.attempt) return unchanged(state)
if (event.type === "connect.timed-out")
return { state: { status: state.reported, attempt: state.attempt }, effects: [] }
// The plugin reports the server ready on its own channel; until it does, the timeout bounds the wait.
if (event.ready) return unchanged(state)
return { state: { status: state.reported, attempt: state.attempt }, effects: [{ type: "timeout.cancel" }] }
}
/** What the app shows and connects to; a sign-in in progress shows as starting. */
export function selectPluginStatus(state: PluginServerState): PluginServerStatus {
if (state.status === "ready") return { type: "ready", http: state.http }
if (state.status === "authenticating") return stages.starting
return stages[state.status]
}
/** The server waits for sign-in, or one is in progress that a new request joins. */
export function canAuthenticatePluginServer(state: PluginServerState) {
return state.status === "auth" || state.status === "authenticating"
}
const stages = {
stopped: { type: "stopped" },
starting: { type: "starting" },
auth: { type: "auth" },
failed: { type: "failed" },
incompatible: { type: "incompatible" },
} as const satisfies Record<Stage, PluginServerStatus>
function updated(state: PluginServerState, entry: PluginEntrySnapshot): PluginServerTransition {
const next = target(entry)
if (state.status === "authenticating") {
if (next.status === "ready")
return {
state: { ...next, attempt: state.attempt },
effects: [
{ type: "timeout.cancel" },
...(state.callbacks.length ? [{ type: "notify.connected" as const, callbacks: state.callbacks }] : []),
],
}
// A sign-in can report a prompt (`auth`) or progress (`starting`) before it settles.
if (next.status === "auth" || next.status === "starting")
return next.status === state.reported
? unchanged(state)
: { state: { ...state, reported: next.status }, effects: [] }
return { state: { ...next, attempt: state.attempt }, effects: [{ type: "timeout.cancel" }] }
}
if (
next.status === state.status &&
(next.status !== "ready" || (state.status === "ready" && same(next.http, state.http)))
)
return unchanged(state)
return { state: { ...next, attempt: state.attempt }, effects: [] }
}
// A plugin that reports ready without an endpoint cannot be reached; it never reads as ready.
function target(
entry: PluginEntrySnapshot,
): { readonly status: Stage } | { readonly status: "ready"; readonly http: ServerConnection.HttpBase } {
if (entry.state !== "ready") return { status: entry.state }
if (!entry.http) return { status: "failed" }
return { status: "ready", http: { url: entry.http.url, password: entry.http.password } }
}
function same(a: ServerConnection.HttpBase, b: ServerConnection.HttpBase) {
return a.url === b.url && a.password === b.password
}
function unchanged(state: PluginServerState): PluginServerTransition {
return { state, effects: [] }
}
@@ -68,9 +68,8 @@ test("treats WSL and mismatched-port loopback servers as remote connections", ()
type: "plugin",
key: "wsl:Debian",
plugin: "wsl",
state: "ready",
connecting: false,
authenticationRequired: false,
status: { type: "ready", http: { url: "http://127.0.0.1:4097" } },
authenticate: () => false,
managed: false,
http: { url: "http://127.0.0.1:4097" },
},
+21 -13
View File
@@ -4,7 +4,7 @@ import { batch, createMemo } from "solid-js"
import { reconcile, type SetStoreFunction, type Store } from "solid-js/store"
import { Persist, persisted } from "@/runtime/persistence/storage"
import { ServerScope } from "@/runtime/server/scope"
import type { ServerEntry } from "@opencode/plugin/gui"
import type { PluginServerStatus } from "./plugin-machine"
import { ServerHttp, ServerHttpBase, ServerKey, ServerState } from "./persistence"
type StoredState = typeof ServerState.Type
@@ -23,7 +23,7 @@ export function serverName(conn?: ServerConnection.Any, ignoreDisplayName = fals
if (conn.displayName && !ignoreDisplayName) return conn.displayName
return conn.http.url.replace(/^https?:\/\//, "").replace(/\/+$/, "")
return (ServerConnection.http(conn)?.url ?? "").replace(/^https?:\/\//, "").replace(/\/+$/, "")
}
/**
@@ -169,14 +169,21 @@ export namespace ServerConnection {
type: "plugin"
key: string
plugin: string
state: ServerEntry["state"]
connecting: boolean
authenticationRequired: boolean
status: PluginServerStatus
/** The plugin re-resolves the endpoint (e.g. a tunnel), so the connection can drop and come back. */
managed: boolean
/**
* Where the event stream starts and follows: the plugin's last endpoint, or an unroutable placeholder before it
* reports one. Everything else reads `ServerConnection.http`, which has an endpoint only while the server is ready.
*/
http: HttpBase
reconnect?: (signal: AbortSignal) => Promise<HttpBase>
/** Called before opening a server that is not ready. Resolves true once it is. */
/**
* Starts sign-in while the server waits for it, or joins the one in progress; false when the server does not
* wait for sign-in. `onConnected` runs once the server is ready.
*/
authenticate: (onConnected?: () => void) => boolean
/** Asks the plugin to connect, e.g. after the server rejected our credentials. Resolves true once it is ready. */
connect?: () => Promise<boolean>
} & Base
@@ -200,14 +207,15 @@ export namespace ServerConnection {
export type Key = typeof Key.Type
export const builtin = (conn: Any) => conn.type === "sidecar" && conn.variant === "base"
/** Starts sign-in for a server that asks for it; false when it does not. */
export const authenticate = (conn: Any, onConnected?: () => void) => {
if (conn.type !== "plugin" || !conn.authenticationRequired || !conn.connect) return false
void conn.connect().then((ready) => {
if (ready) onConnected?.()
})
/** Starts sign-in for a server that asks for it, or joins the one in progress; false when it does not. */
export const authenticate = (conn: Any, onConnected?: () => void) =>
conn.type === "plugin" && conn.authenticate(onConnected)
return true
/** The endpoint to probe, show or call; undefined while a contributed server is not ready. */
export const http = (conn: Any) => {
if (conn.type !== "plugin") return conn.http
return conn.status.type === "ready" ? conn.status.http : undefined
}
// The desktop sidecar, or a loopback http connection on the same port as the app's own server. Other loopback
+3 -10
View File
@@ -23,6 +23,7 @@ import {
} from "./machine"
import { pathKey } from "@/workspaces/path-key"
import { useServerHealth } from "@/runtime/server/health"
import { selectServerHostname } from "@/runtime/server/health-machine"
import { createServerSdkContext } from "./client"
import { createServerSyncContext } from "./sync"
import { createData, createSessionRetention } from "@opencode/client/solid"
@@ -89,15 +90,7 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
const serverHealth = useServerHealth(
() => server.list,
() => true,
(probe) =>
dispatch({
type: "health.reported",
key: probe.key,
auth: probe.auth,
healthy: probe.health.healthy,
unauthorized: !!probe.health.unauthorized,
}),
(probe) => dispatch({ type: "health.reported", key: probe.key, auth: probe.auth, result: probe.result }),
)
// Runs during updates, so listed servers have a controller before anything reads them, including on first render.
@@ -117,7 +110,7 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
createEffect(() => {
for (const conn of server.list) {
const key = ServerConnection.key(conn)
const hostname = serverHealth.status[key]?.hostname
const hostname = selectServerHostname(serverHealth.status[key])
if (hostname) server.setHostname(key, hostname)
}
+8 -6
View File
@@ -27,6 +27,7 @@ import { useLanguage } from "@/runtime/i18n/language"
import { normalizeServerUrl, ServerConnection, useServers } from "@/runtime/server/registry"
import { useTabs } from "@/shell/tabs/tabs"
import { useCheckServerHealth } from "@/runtime/server/health"
import { isServerFailed, isServerHealthy, isServerUnauthorized } from "@/runtime/server/health-machine"
import { usePlatform } from "@/runtime/platform/platform"
import { isMixedContent } from "./browser"
import { cameraHint, createCameraAvailability } from "./camera"
@@ -327,7 +328,7 @@ function createFormController(options: { onSelect?: (server: ServerConnection.Ht
if (!original || original.http.url === pairing.url) return pairing
const http = { url: original.http.url, password: pairing.password }
return (await checkServerHealth(http)).healthy ? http : pairing
return (await checkServerHealth(http)).type === "healthy" ? http : pairing
}
// Where the form points: a scanned or pasted pairing link wins, else the address and password fields.
@@ -380,7 +381,7 @@ function createFormController(options: { onSelect?: (server: ServerConnection.Ht
// asked for sign-in can continue.
if (
original?.type === "http" &&
!global.servers.health[ServerConnection.key(original)]?.unauthorized &&
!isServerUnauthorized(global.servers.health[ServerConnection.key(original)]) &&
normalized === original.http.url &&
name === original.displayName &&
password === original.http.password
@@ -401,7 +402,7 @@ function createFormController(options: { onSelect?: (server: ServerConnection.Ht
const result = await checkServerHealth(connection.http)
if (!result.healthy) {
if (result.type !== "healthy") {
setStore(
"error",
language.t(
@@ -456,11 +457,12 @@ function createFormController(options: { onSelect?: (server: ServerConnection.Ht
}
const startEdit = (connection: ServerConnection.Http) => {
const health = global.servers.health[ServerConnection.key(connection)]
reset()
setStore({
mode: "edit",
// A signed-out server needs a new pairing link; otherwise editing starts from its address.
method: global.servers.health[ServerConnection.key(connection)]?.unauthorized ? "link" : "password",
method: isServerUnauthorized(health) ? "link" : "password",
originalUrl: connection.http.url,
values: {
url: connection.http.url,
@@ -468,7 +470,7 @@ function createFormController(options: { onSelect?: (server: ServerConnection.Ht
password: connection.http.password ?? "",
},
error: "",
status: global.servers.health[ServerConnection.key(connection)]?.healthy,
status: isServerFailed(health) ? false : isServerHealthy(health) || undefined,
})
}
@@ -508,7 +510,7 @@ function createFormController(options: { onSelect?: (server: ServerConnection.Ht
signedOut: () => {
const original = editing()
return !!original && !!global.servers.health[ServerConnection.key(original)]?.unauthorized
return !!original && isServerUnauthorized(global.servers.health[ServerConnection.key(original)])
},
},
change: {
+1 -1
View File
@@ -128,5 +128,5 @@ async function preferFirst(
const http = { url: first, password: pairing.password }
const health = await checkServerHealth(http, globalThis.fetch, { signal: AbortSignal.timeout(5_000), retryCount: 0 })
return health.healthy ? http : pairing
return health.type === "healthy" ? http : pairing
}
+2 -2
View File
@@ -47,13 +47,13 @@ export function ConnectServerScreen(props: { url?: string } = {}) {
if (!props.url || props.url === pairing.url) return pairing
const http = { url: props.url, password: pairing.password }
return (await check(http)).healthy ? http : pairing
return (await check(http)).type === "healthy" ? http : pairing
}
const connect = async (http: ServerConnection.HttpBase) => {
const result = await check(http)
if (!result.healthy) {
if (result.type !== "healthy") {
setState("error", connectionError(http.url))
return
@@ -9,15 +9,18 @@ describe("sortServerConnections", () => {
const first = server("http://first")
const offline = server("http://offline")
const unknown = server("http://unknown")
// A tunnel that just moved is still being checked, not failed.
const checking = server("http://checking")
const result = sortServerConnections({
servers: [first, offline, unknown],
servers: [first, offline, unknown, checking],
health: {
[ServerConnection.key(first)]: { healthy: true },
[ServerConnection.key(offline)]: { healthy: false },
[ServerConnection.key(first)]: { type: "healthy" },
[ServerConnection.key(offline)]: { type: "unreachable" },
[ServerConnection.key(checking)]: { type: "checking", managed: true },
},
})
expect(result).toEqual([first, unknown, offline])
expect(result).toEqual([first, unknown, checking, offline])
})
})
@@ -3,7 +3,7 @@ import { useGlobal } from "@/runtime/server/runtime"
import { useLanguage } from "@/runtime/i18n/language"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { useTabs } from "@/shell/tabs/tabs"
import { type ServerHealth } from "@/runtime/server/health"
import { selectServerHealthRank, type ServerHealth } from "@/runtime/server/health-machine"
import { showToast } from "@/shell/notifications/toast"
import { usePluginServers } from "@/runtime/plugin/servers"
@@ -12,17 +12,10 @@ export function sortServerConnections(input: {
health: Record<string, ServerHealth | undefined>
}) {
const order = new Map(input.servers.map((item, index) => [item, index] as const))
const rank = (value?: ServerHealth) => {
if (value?.healthy === true) return 0
if (value?.healthy === false) return 2
return 1
}
const rank = (conn: ServerConnection.Any) => selectServerHealthRank(input.health[ServerConnection.key(conn)])
return input.servers.slice().sort((a, b) => {
const health = rank(input.health[ServerConnection.key(a)]) - rank(input.health[ServerConnection.key(b)])
const health = rank(a) - rank(b)
if (health !== 0) return health
@@ -1,4 +1,5 @@
import { describe, expect, test } from "bun:test"
import type { ServerProbeResult } from "@/runtime/server/health-machine"
import { ServerConnection } from "@/runtime/server/registry"
import { createServerHealthPreview, replaceServerConnection, type ServerFormValues } from "./management"
@@ -21,51 +22,55 @@ describe("createServerHealthPreview", () => {
const preview = createServerHealthPreview(async (http) => {
requests.push(http)
return { healthy: true }
return { type: "healthy" }
})
await preview.preview({ ...values("server.example.com"), password }, () => {})
expect(requests).toEqual([{ url: "http://server.example.com", ...(password ? { password } : {}) }])
const expected: ServerConnection.HttpBase = { url: "http://server.example.com" }
if (password) expected.password = password
expect(requests).toEqual([expected])
})
test("ignores an older response that resolves after the latest response", async () => {
const first = deferred<{ healthy: boolean }>()
const second = deferred<{ healthy: boolean }>()
const first = deferred<ServerProbeResult>()
const second = deferred<ServerProbeResult>()
const requests = [first, second]
const status: Array<boolean | undefined> = []
const preview = createServerHealthPreview(() => requests.shift()!.promise)
const older = preview.preview(values("old.example.com"), (value) => status.push(value))
const latest = preview.preview(values("new.example.com"), (value) => status.push(value))
second.resolve({ healthy: true })
second.resolve({ type: "healthy" })
await latest
first.resolve({ healthy: false })
first.resolve({ type: "unreachable" })
await older
expect(status).toEqual([undefined, undefined, true])
})
test("an incomplete value invalidates an in-flight response", async () => {
const request = deferred<{ healthy: boolean }>()
const request = deferred<ServerProbeResult>()
const status: Array<boolean | undefined> = []
const preview = createServerHealthPreview(() => request.promise)
const pending = preview.preview(values("server.example.com"), (value) => status.push(value))
await preview.preview(values("server"), (value) => status.push(value))
request.resolve({ healthy: true })
request.resolve({ type: "healthy" })
await pending
expect(status).toEqual([undefined, undefined])
})
test("cancellation prevents an in-flight response from updating status", async () => {
const request = deferred<{ healthy: boolean }>()
const request = deferred<ServerProbeResult>()
const status: Array<boolean | undefined> = []
const preview = createServerHealthPreview(() => request.promise)
const pending = preview.preview(values("server.example.com"), (value) => status.push(value))
preview.cancel()
request.resolve({ healthy: true })
request.resolve({ type: "healthy" })
await pending
expect(status).toEqual([undefined])
@@ -1,5 +1,5 @@
import { normalizeServerUrl, ServerConnection } from "@/runtime/server/registry"
import type { ServerHealth } from "@/runtime/server/health"
import type { ServerProbeResult } from "@/runtime/server/health-machine"
export type ServerFormValues = {
url: string
@@ -7,9 +7,7 @@ export type ServerFormValues = {
password: string
}
export function createServerHealthPreview(
check: (server: ServerConnection.HttpBase) => Promise<Pick<ServerHealth, "healthy">>,
) {
export function createServerHealthPreview(check: (server: ServerConnection.HttpBase) => Promise<ServerProbeResult>) {
let generation = 0
const cancel = () => {
@@ -35,7 +33,7 @@ export function createServerHealthPreview(
const result = await check(http)
if (current !== generation) return
setStatus(result.healthy)
setStatus(result.type === "healthy")
}
return { cancel, preview }
@@ -2,11 +2,16 @@ import { untrack } from "solid-js"
import type { ServerRow } from "@opencode/plugin/gui"
import { Contribution } from "@/runtime/plugin/render"
import { usePluginServers } from "@/runtime/plugin/servers"
import type { ServerHealth } from "@/runtime/server/health-machine"
import type { ServerConnection } from "@/runtime/server/registry"
import type { ServerCollectionController } from "./controller"
import { ServerHealthIndicator } from "./row"
import { ServerRowItems } from "./row-items"
type PluginHealth = ReturnType<ServerRow["health"]>
type PluginIndicator = Parameters<ServerRow["Indicator"]>[0]
/** A contributed server's connection row; the plugin renders it with the host's shared parts. */
export function PluginServerRow(props: { server: ServerConnection.Key; controller: ServerCollectionController }) {
const servers = usePluginServers()
@@ -15,14 +20,8 @@ export function PluginServerRow(props: { server: ServerConnection.Key; controlle
const row: ServerRow = {
key: props.server,
health: () => props.controller.collection.health()[props.server],
Indicator: (indicator) => (
<ServerHealthIndicator
health={indicator.health}
connecting={indicator.connecting}
authenticationRequired={indicator.auth}
/>
),
health: () => toPluginHealth(props.controller.collection.health()[props.server]),
Indicator: (indicator) => <ServerHealthIndicator health={fromPluginIndicator(indicator)} />,
remove: () => props.controller.connection.remove(props.server),
Items: () => <ServerRowItems server={props.server} />,
}
@@ -31,3 +30,28 @@ export function PluginServerRow(props: { server: ServerConnection.Key; controlle
return <Contribution plugin={source.plugin}>{() => untrack(() => source.entry.row?.(row))}</Contribution>
}
// The SDK's health has no stages: a server that is not ready, or not checked yet, reports none.
function toPluginHealth(health: ServerHealth | undefined): PluginHealth {
if (health?.type === "healthy") return { healthy: true, version: health.version }
if (health?.type === "checking") return health.managed ? { healthy: false, checking: true } : undefined
if (health?.type === "unreachable" || health?.type === "unauthorized") return { healthy: false }
if (health?.type === "incompatible") return { healthy: false, incompatible: true }
return undefined
}
function fromPluginIndicator(indicator: PluginIndicator): ServerHealth | undefined {
if (indicator.auth) return { type: "auth" }
if (indicator.connecting || indicator.health?.checking) return { type: "starting" }
if (indicator.health?.incompatible) return { type: "incompatible" }
if (indicator.health === undefined) return undefined
return indicator.health.healthy ? { type: "healthy", version: indicator.health.version } : { type: "unreachable" }
}
@@ -1,23 +1,17 @@
import { For } from "solid-js"
import { ServerHealthIndicator } from "./row"
import type { ServerHealth } from "@/runtime/server/health"
import type { ServerHealth } from "@/runtime/server/health-machine"
const states: { label: string; connecting?: boolean; authenticationRequired?: boolean; health?: ServerHealth }[] = [
{
label: "Authentication required (overrides failed health)",
authenticationRequired: true,
health: { healthy: false },
},
{
label: "Authentication required (overrides pending health)",
authenticationRequired: true,
health: { healthy: false, checking: true },
},
{ label: "Connecting (previous health check failed)", connecting: true, health: { healthy: false } },
{ label: "Tunnel ready, checking its new endpoint", health: { healthy: false, checking: true } },
{ label: "Connected", health: { healthy: true } },
{ label: "Failed", health: { healthy: false } },
{ label: "Incompatible", health: { healthy: false, incompatible: true } },
const states: { label: string; health?: ServerHealth }[] = [
{ label: "Waiting for sign-in", health: { type: "auth" } },
{ label: "Rejected our credentials", health: { type: "unauthorized" } },
{ label: "Connecting", health: { type: "starting" } },
{ label: "Tunnel ready, checking its new endpoint", health: { type: "checking", managed: true } },
{ label: "Checking", health: { type: "checking", managed: false } },
{ label: "Connected", health: { type: "healthy" } },
{ label: "Failed", health: { type: "unreachable" } },
{ label: "Incompatible", health: { type: "incompatible" } },
{ label: "Stopped", health: { type: "stopped" } },
{ label: "Not checked" },
]
@@ -30,11 +24,7 @@ export const States = {
{(state) => (
<div class="flex items-center gap-2">
<div class="flex size-4 shrink-0 items-center justify-center">
<ServerHealthIndicator
health={state.health}
connecting={state.connecting}
authenticationRequired={state.authenticationRequired}
/>
<ServerHealthIndicator health={state.health} />
</div>
<span>{state.label}</span>
</div>
+35 -45
View File
@@ -1,57 +1,47 @@
import { Icon } from "@opencode/ui/icon"
import { Loader } from "@opencode/ui/loader"
import { useLanguage } from "@/runtime/i18n/language"
import { Show } from "solid-js"
import type { ServerHealth } from "@/runtime/server/health"
import { Match, Switch } from "solid-js"
import { selectServerIndicator, type ServerHealth } from "@/runtime/server/health-machine"
export function ServerHealthIndicator(props: {
health?: ServerHealth
connecting?: boolean
authenticationRequired?: boolean
}) {
export function ServerHealthIndicator(props: { health?: ServerHealth }) {
const language = useLanguage()
const indicator = () => selectServerIndicator(props.health)
return (
<Show
when={props.authenticationRequired}
<Switch
fallback={
<Show
when={props.connecting || props.health?.checking}
fallback={
<Show
when={props.health?.incompatible}
fallback={
<div
classList={{
"size-1.5 rounded-full shrink-0 my-[3.5px]": true,
"bg-icon-success-base": props.health?.healthy === true,
"bg-icon-critical-base": props.health?.healthy === false,
"bg-v2-icon-icon-faint": props.health === undefined,
}}
/>
}
>
<Icon name="warning" size="small" class="shrink-0 text-icon-warning-base" />
</Show>
}
>
<span
role="status"
aria-label={language.t("server.status.connecting")}
class="inline-flex h-3.5 w-1.5 shrink-0 items-center justify-center text-v2-icon-icon-muted"
>
<Loader class="size-3 shrink-0" />
</span>
</Show>
<div
classList={{
"size-1.5 rounded-full shrink-0 my-[3.5px]": true,
"bg-icon-success-base": indicator() === "healthy",
"bg-icon-critical-base": indicator() === "unreachable",
"bg-v2-icon-icon-faint": indicator() === "unknown",
}}
/>
}
>
<span
role="status"
aria-label={language.t("server.status.authentication")}
class="inline-flex h-3.5 w-1.5 shrink-0 items-center justify-center text-v2-icon-icon-muted"
>
<Icon name="lock" size="small" class="shrink-0" />
</span>
</Show>
<Match when={indicator() === "auth"}>
<span
role="status"
aria-label={language.t("server.status.authentication")}
class="inline-flex h-3.5 w-1.5 shrink-0 items-center justify-center text-v2-icon-icon-muted"
>
<Icon name="lock" size="small" class="shrink-0" />
</span>
</Match>
<Match when={indicator() === "connecting"}>
<span
role="status"
aria-label={language.t("server.status.connecting")}
class="inline-flex h-3.5 w-1.5 shrink-0 items-center justify-center text-v2-icon-icon-muted"
>
<Loader class="size-3 shrink-0" />
</span>
</Match>
<Match when={indicator() === "incompatible"}>
<Icon name="warning" size="small" class="shrink-0 text-icon-warning-base" />
</Match>
</Switch>
)
}
@@ -1,5 +1,5 @@
import { expect, test } from "bun:test"
import type { ServerHealth } from "@/runtime/server/health"
import type { ServerHealth } from "@/runtime/server/health-machine"
import {
createSessionResolutionState,
sessionRouteView,
@@ -154,31 +154,31 @@ const missing: State = { status: "not-found", target: target("ses_a"), attempt:
test.each<{ name: string; health: ServerHealth; state: State; view: SessionRouteView<Session>["type"] }>([
{
name: "incompatible wins over a resolved session",
health: { healthy: true, incompatible: true },
health: { type: "incompatible" },
state: resolved,
view: "incompatible",
},
{
name: "an unreachable server explains a pending session",
health: { healthy: false },
health: { type: "unreachable" },
state: resolving,
view: "unreachable",
},
{
name: "a running health check keeps waiting",
health: { healthy: false, checking: true },
health: { type: "checking", managed: true },
state: resolving,
view: "resolving",
},
{
name: "a rejected credential keeps waiting",
health: { healthy: false, unauthorized: true },
health: { type: "unauthorized" },
state: resolving,
view: "resolving",
},
{
name: "an unreachable server keeps a known outcome",
health: { healthy: false },
health: { type: "unreachable" },
state: missing,
view: "not-found",
},
@@ -1,5 +1,5 @@
import { isSessionNotFoundError } from "@/runtime/server/errors"
import type { ServerHealth } from "@/runtime/server/health"
import type { ServerHealth } from "@/runtime/server/health-machine"
// One routed session: its ID within the session store that resolves it. A replaced store is a new target.
export type SessionTarget<Scope> = {
@@ -109,7 +109,7 @@ export function sessionRouteView<T, Scope>(
if (state.status === "idle") return { type: "idle" }
const sessionID = state.target.sessionID
if (health?.incompatible) return { type: "incompatible", sessionID }
if (health?.type === "incompatible") return { type: "incompatible", sessionID }
if (state.status === "ready") return { type: "ready", sessionID, session: state.session }
@@ -119,7 +119,7 @@ export function sessionRouteView<T, Scope>(
// Nothing is cached and an unreachable server never resolves the session, so explain instead of waiting blank.
// Only a failed health check counts: a version mismatch has its own panel, and a rejected credential is not an outage.
if (health && !health.healthy && !health.checking && !health.unauthorized) return { type: "unreachable", sessionID }
if (health?.type === "unreachable") return { type: "unreachable", sessionID }
return { type: "resolving", sessionID }
}
+2 -1
View File
@@ -4,6 +4,7 @@ import { ErrorPage } from "@/shell/errors/error"
import { useLanguage } from "@/runtime/i18n/language"
import { useServer } from "@/runtime/server/current"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { isServerIncompatible } from "@/runtime/server/health-machine"
import { useTabs } from "@/shell/tabs/tabs"
import { isSessionNotFoundError } from "@/runtime/server/errors"
import { ServerUnavailablePanel } from "./server-unavailable-panel"
@@ -19,7 +20,7 @@ export function SessionErrorFallback(props: { error: unknown; sessionID?: string
return (
<Show
when={!activeServer.health?.incompatible}
when={!isServerIncompatible(activeServer.health)}
fallback={<ServerUnavailablePanel reason="incompatible" onClose={props.sessionID ? closeSession : undefined} />}
>
<Show
@@ -4,6 +4,7 @@ import { Icon } from "@opencode/ui/icon"
import { Show } from "solid-js"
import { useLanguage } from "@/runtime/i18n/language"
import { useServer } from "@/runtime/server/current"
import { selectServerVersion } from "@/runtime/server/health-machine"
import { type ServerConnection, useServers } from "@/runtime/server/registry"
export function ServerUnavailablePanel(props: { reason: "incompatible" | "unreachable"; onClose?: () => void }) {
@@ -25,7 +26,7 @@ export function ServerUnavailablePanel(props: { reason: "incompatible" | "unreac
{props.reason === "incompatible"
? language.t("session.error.incompatible.description", {
server: servers.label(server.conn),
version: server.health?.version ?? "1",
version: selectServerVersion(server.health) ?? "1",
})
: language.t("session.error.unreachable.description", { server: servers.label(server.conn) })}
</div>
@@ -13,9 +13,8 @@ const connection: ServerConnection.Plugin = {
type: "plugin",
key: "ssh:build",
plugin: "ssh",
state: "stopped",
connecting: false,
authenticationRequired: false,
status: { type: "stopped" },
authenticate: () => false,
managed: true,
displayName: "Build server",
http: { url: "http://127.0.0.1:4000", password: "secret" },
@@ -1,7 +1,7 @@
import { createMemo } from "solid-js"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { usePluginServers, type PluginServer } from "@/runtime/plugin/servers"
import type { ServerHealth } from "@/runtime/server/health"
import { isServerFailed, type ServerHealth } from "@/runtime/server/health-machine"
export type SettingsServer = {
key: ServerConnection.Key
@@ -56,5 +56,5 @@ export function useSettingsServers() {
/** Whether a server's pages can load: it runs and its last health check did not fail. */
export function settingsServerReachable(server: SettingsServer, health: ServerHealth | undefined) {
return !!server.connection && health?.healthy !== false
return !!server.connection && !isServerFailed(health)
}
@@ -7,6 +7,7 @@ import { PluginServerRow } from "@/servers/registry/plugin-row"
import { AddServerMenu } from "@/servers/registry/add-menu"
import { useLanguage } from "@/runtime/i18n/language"
import { ServerConnection } from "@/runtime/server/registry"
import { isServerFailed, isServerUnauthorized } from "@/runtime/server/health-machine"
import { useServerCollectionController } from "@/servers/registry/controller"
import { DialogServer } from "@/servers/connect/dialog"
import { SettingsList } from "@/settings/list"
@@ -33,7 +34,7 @@ export const SettingsServerGeneral: Component<{ entry: SettingsServer; onAddServ
</SettingsList>
</section>
<Show when={props.entry.connection && health()?.healthy !== false ? props.entry.connection : undefined} keyed>
<Show when={props.entry.connection && !isServerFailed(health()) ? props.entry.connection : undefined} keyed>
{(server) => (
<section class="settings-section">
<h3 class="settings-section-title">{language.t("settings.tab.preferences")}</h3>
@@ -75,7 +76,7 @@ export const SettingsServerList: Component<{
<ServerConnectionRow entry={entry} onServerChange={props.onServerChange} />
<Show
when={
entry.connection && controller.collection.health()[entry.key]?.healthy !== false
entry.connection && !isServerFailed(controller.collection.health()[entry.key])
? entry.connection
: undefined
}
@@ -126,7 +127,7 @@ function ServerConnectionRow(props: { entry: SettingsServer; onServerChange?: (s
// An HTTP server that rejects its saved credentials signs in again through the edit dialog.
const signedOut = (server: ServerConnection.Any) =>
server.type === "http" && health()?.unauthorized ? server : undefined
server.type === "http" && isServerUnauthorized(health()) ? server : undefined
return (
<Show
@@ -137,13 +138,13 @@ function ServerConnectionRow(props: { entry: SettingsServer; onServerChange?: (s
{(server) => (
<div class="settings-servers-row">
<div class="settings-servers-lead">
<ServerHealthIndicator health={health()} authenticationRequired={!!health()?.unauthorized} />
<ServerHealthIndicator health={health()} />
<div class="settings-servers-copy">
<bdi class="settings-servers-name" dir="auto">
{props.entry.name}
</bdi>
<bdi class="settings-servers-meta" dir="ltr">
{server().http.url}
{ServerConnection.http(server())?.url}
</bdi>
</div>
</div>
@@ -4,7 +4,7 @@ import { Menu } from "@opencode/ui/menu"
import { For, Show } from "solid-js"
import { useLanguage } from "@/runtime/i18n/language"
import { useGlobal } from "@/runtime/server/runtime"
import type { ServerHealth } from "@/runtime/server/health"
import type { ServerHealth } from "@/runtime/server/health-machine"
import { ServerHealthIndicator } from "@/servers/registry/row"
import { ServerLabel } from "@/servers/registry/label"
import { useSettingsSurface } from "@/settings/surface"
@@ -72,11 +72,11 @@ export function SettingsServerSwitcher() {
}
function ServerDot(props: { health: ServerHealth | undefined; unreachable: boolean }) {
const health = () => props.health ?? (props.unreachable ? { healthy: false } : undefined)
const health = (): ServerHealth | undefined => props.health ?? (props.unreachable ? { type: "unreachable" } : undefined)
return (
<span class="settings-server-switcher-icon">
<ServerHealthIndicator health={health()} authenticationRequired={!!health()?.unauthorized} />
<ServerHealthIndicator health={health()} />
</span>
)
}
@@ -3,6 +3,7 @@ import { startTransition } from "solid-js"
import { useGlobal } from "@/runtime/server/runtime"
import { useLanguage } from "@/runtime/i18n/language"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { isServerFailed } from "@/runtime/server/health-machine"
import { useTabs } from "@/shell/tabs/tabs"
import { createKnownServerSessions, createServerSessionEntries, type CommandPaletteEntry } from "./palette"
import { CommandPaletteView } from "./dialog"
@@ -18,9 +19,7 @@ export function DialogSessionSearch(props: { archived?: boolean }) {
const tabs = useTabs()
const registry = useServers()
const servers = registry.visible.filter(
(conn) => global.servers.health[ServerConnection.key(conn)]?.healthy !== false,
)
const servers = registry.visible.filter((conn) => !isServerFailed(global.servers.health[ServerConnection.key(conn)]))
const loaders = servers.flatMap((conn) => {
const ctx = global.serverCtx(ServerConnection.key(conn))
+2 -1
View File
@@ -4,6 +4,7 @@ import { Home } from "@/home/route"
import { ServerProvider } from "@/runtime/server/current"
import { useGlobal } from "@/runtime/server/runtime"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { isServerUnauthorized } from "@/runtime/server/health-machine"
import { SessionPanelFrame, SessionRouteFrame } from "@/session/session-frame"
import { ServerSignedOutPanel } from "@/session/server-unavailable-panel"
import { LayoutProvider } from "@/shell/state/layout"
@@ -115,7 +116,7 @@ function AppLayout(props: ParentProps) {
if (only?.type !== "http") return
return global.servers.health[ServerConnection.key(only)]?.unauthorized ? only : undefined
return isServerUnauthorized(global.servers.health[ServerConnection.key(only)]) ? only : undefined
}
return (
@@ -4,6 +4,7 @@ import { createStore } from "solid-js/store"
import { createEffect, createMemo, onCleanup, startTransition } from "solid-js"
import { useGlobal, type ServerCtx } from "@/runtime/server/runtime"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { canUseServer } from "@/runtime/server/health-machine"
import { useLanguage } from "@/runtime/i18n/language"
import { projectSettingsKey, useSettings } from "@/settings/model"
import { useLayout } from "@/shell/state/layout"
@@ -239,9 +240,7 @@ export function createSessionInbox(options: { archived?: boolean } = {}) {
previous ||
(servers.hydrated() &&
connections().every((item, index) => {
const health = global.servers.health[ServerConnection.key(item.conn)]
if (health && !health.checking && !health.healthy) return true
if (!canUseServer(global.servers.health[ServerConnection.key(item.conn)])) return true
return !!queries[index]?.isSuccess || !!queries[index]?.isError
}) &&
@@ -11,9 +11,8 @@ const remote = {
type: "plugin",
key: "ssh:example",
plugin: "ssh",
state: "ready",
connecting: false,
authenticationRequired: false,
status: { type: "ready", http: { url: "http://localhost:4096" } },
authenticate: () => false,
managed: true,
http: { url: "http://localhost:4096" },
} as const
@@ -47,9 +47,10 @@ test("a plugin server's event stream follows the endpoint the plugin reports", a
type: "plugin",
key: "remote:box",
plugin: "remote",
state: "ready",
connecting: false,
authenticationRequired: false,
get status() {
return { type: "ready" as const, http: http() }
},
authenticate: () => false,
managed: false,
get http() {
return http()
+100 -105
View File
@@ -1,148 +1,143 @@
import { expect, test } from "bun:test"
import { createRoot } from "solid-js"
import { createStore } from "solid-js/store"
import { createServerHealth, type ServerHealth } from "../src/runtime/server/health"
import { createRoot, createSignal } from "solid-js"
import { createServerHealth } from "../src/runtime/server/health"
import type { ServerProbeResult } from "../src/runtime/server/health-machine"
import type { PluginServerStatus } from "../src/runtime/server/plugin-machine"
import { ServerConnection } from "../src/runtime/server/registry"
test("SSH health is checked only with an active tunnel, and cancellation clears stale failures", async () => {
const requests: ReturnType<typeof Promise.withResolvers<ServerHealth>>[] = []
const flush = () => new Promise((resolve) => setTimeout(resolve, 0))
function plugin(status: () => PluginServerStatus): ServerConnection.Plugin {
return {
type: "plugin",
key: "ssh:fixture",
plugin: "ssh",
managed: true,
http: { url: "http://127.0.0.1:0" },
authenticate: () => false,
get status() {
return status()
},
}
}
function probes() {
const requests: ReturnType<typeof Promise.withResolvers<ServerProbeResult>>[] = []
return {
requests,
check: () => {
const request = Promise.withResolvers<ServerProbeResult>()
requests.push(request)
return request.promise
},
}
}
test("SSH health follows the plugin's stage and checks only an active tunnel", async () => {
const fake = probes()
const tunnel = { type: "ready", http: { url: "http://127.0.0.1:12345" } } as const
const app = createRoot((dispose) => {
const [state, setState] = createStore<{ state: ServerConnection.Plugin["state"] }>({ state: "stopped" })
const [status, setStatus] = createSignal<PluginServerStatus>({ type: "stopped" })
const connection = plugin(status)
const health = createServerHealth(() => [connection], fake.check)
const connection: ServerConnection.Plugin = {
type: "plugin",
key: "ssh:fixture",
plugin: "ssh",
connecting: false,
authenticationRequired: false,
managed: true,
http: { url: "http://127.0.0.1:12345" },
get state() {
return state.state
},
}
const health = createServerHealth(
() => [connection],
() => true,
() => {
const request = Promise.withResolvers<ServerHealth>()
requests.push(request)
return request.promise
},
)
return { dispose, setState, health: () => health.status[ServerConnection.key(connection)] }
return { dispose, setStatus, health: () => health.status[ServerConnection.key(connection)] }
})
try {
expect(app.health()).toBeUndefined()
app.setState("state", "starting")
app.setState("state", "auth")
app.setState("state", "stopped")
expect(requests).toHaveLength(0)
expect(app.health()).toBeUndefined()
app.setState("state", "ready")
expect(requests).toHaveLength(1)
expect(app.health()?.checking).toBe(true)
app.setState("state", "auth")
requests[0]?.resolve({ healthy: false })
await Promise.resolve()
expect(app.health()).toBeUndefined()
app.setState("state", "failed")
expect(app.health()?.healthy).toBe(false)
app.setState("state", "auth")
expect(app.health()).toBeUndefined()
app.setState("state", "ready")
requests[1]?.resolve({ healthy: false })
await Promise.resolve()
expect(app.health()).toEqual({ healthy: false })
expect(app.health()).toEqual({ type: "stopped" })
app.setStatus({ type: "starting" })
expect(app.health()).toEqual({ type: "starting" })
app.setStatus({ type: "auth" })
expect(app.health()).toEqual({ type: "auth" })
expect(fake.requests).toHaveLength(0)
app.setStatus(tunnel)
expect(fake.requests).toHaveLength(1)
expect(app.health()).toEqual({ type: "checking", managed: true })
// The tunnel asks for sign-in again before its probe answers: the late answer is stale.
app.setStatus({ type: "auth" })
fake.requests[0]?.resolve({ type: "unreachable" })
await flush()
expect(app.health()).toEqual({ type: "auth" })
app.setStatus({ type: "failed" })
expect(app.health()).toEqual({ type: "unreachable" })
app.setStatus(tunnel)
fake.requests[1]?.resolve({ type: "healthy", version: "2.0.0" })
await flush()
expect(app.health()).toEqual({ type: "healthy", version: "2.0.0" })
} finally {
app.dispose()
}
})
test("a late failure from the old endpoint cannot overwrite the new endpoint check", async () => {
const requests: ReturnType<typeof Promise.withResolvers<ServerHealth>>[] = []
const fake = probes()
const app = createRoot((dispose) => {
const [state, setState] = createStore({ url: "http://127.0.0.1:0" })
const [url, setUrl] = createSignal("http://127.0.0.1:12344")
const connection = plugin(() => ({ type: "ready", http: { url: url() } }))
const health = createServerHealth(() => [connection], fake.check)
const connection: ServerConnection.Plugin = {
type: "plugin",
key: "ssh:fixture",
plugin: "ssh",
state: "ready",
connecting: false,
authenticationRequired: false,
managed: true,
get http() {
return { url: state.url }
},
}
const health = createServerHealth(
() => [connection],
() => true,
() => {
const request = Promise.withResolvers<ServerHealth>()
requests.push(request)
return request.promise
},
)
return { dispose, setState, health: () => health.status[ServerConnection.key(connection)] }
return { dispose, setUrl, health: () => health.status[ServerConnection.key(connection)] }
})
try {
app.setState({ url: "http://127.0.0.1:12345" })
requests[0]?.resolve({ healthy: false })
await Promise.resolve()
expect(app.health()).toEqual({ healthy: false, checking: true })
requests[1]?.resolve({ healthy: true })
await Promise.resolve()
expect(app.health()).toEqual({ healthy: true })
app.setUrl("http://127.0.0.1:12345")
fake.requests[0]?.resolve({ type: "unreachable" })
await flush()
expect(app.health()).toEqual({ type: "checking", managed: true })
fake.requests[1]?.resolve({ type: "healthy" })
await flush()
expect(app.health()).toEqual({ type: "healthy" })
} finally {
app.dispose()
}
})
test("retry probes again before the next poll and resolves once that round answers", async () => {
const requests: ReturnType<typeof Promise.withResolvers<ServerHealth>>[] = []
test("retry probes again before the next poll and resolves once that probe answers", async () => {
const fake = probes()
const connection: ServerConnection.Http = { type: "http", http: { url: "http://127.0.0.1:12346" } }
const app = createRoot((dispose) => {
const health = createServerHealth(
() => [connection],
() => true,
() => {
const request = Promise.withResolvers<ServerHealth>()
requests.push(request)
return request.promise
},
)
const health = createServerHealth(() => [connection], fake.check)
return { dispose, retry: health.retry, health: () => health.status[ServerConnection.key(connection)] }
})
try {
requests[0]?.resolve({ healthy: false })
await Promise.resolve()
expect(app.health()?.healthy).toBe(false)
fake.requests[0]?.resolve({ type: "unreachable" })
await flush()
expect(app.health()).toEqual({ type: "unreachable" })
const state = { done: false }
const retried = app.retry().then(() => (state.done = true))
expect(requests).toHaveLength(2)
await Promise.resolve()
expect(fake.requests).toHaveLength(2)
await flush()
expect(state.done).toBe(false)
requests[1]?.resolve({ healthy: true })
fake.requests[1]?.resolve({ type: "healthy" })
await retried
expect(app.health()?.healthy).toBe(true)
expect(app.health()).toEqual({ type: "healthy" })
} finally {
app.dispose()
}
})
test("disposal releases a retry whose probe never answers", async () => {
const fake = probes()
const connection: ServerConnection.Http = { type: "http", http: { url: "http://127.0.0.1:12347" } }
const app = createRoot((dispose) => ({ dispose, health: createServerHealth(() => [connection], fake.check) }))
const retried = app.health.retry()
app.dispose()
await retried
expect(fake.requests).toHaveLength(2)
})
@@ -245,7 +245,7 @@ function AuthenticationHome() {
recentlyClosed={[]}
selection={{ server: ServerConnection.key(server) }}
homedir="/home/user"
serverHealth={() => ({ healthy: ssh.servers[0]?.stage === "ready" })}
serverHealth={() => (ssh.servers[0]?.stage === "ready" ? { type: "healthy" } : { type: "unreachable" })}
serverLabel={(server) => server.displayName ?? server.http.url}
projectsForServer={() => projects}
collapsed={() => false}