fix(app): drive Home's server and project selection with an explicit state machine (#61989)

This commit is contained in:
Luke Parker
2026-11-05 00:56:11 -06:00
committed by GitHub
Unverified
parent 4f6a84cf02
commit ca1050c86e
6 changed files with 838 additions and 76 deletions
+97 -2
View File
@@ -1,7 +1,18 @@
import type { OpenCodeEvent } from "@opencode/client/promise"
import { expect, test, type Page } from "@playwright/test"
import { expectPath, holdRoute, NO_PROVIDER, project, REMOTE_SERVER, seed, sessionHref, T0 } from "../utils/app"
import { mockOpenCodeServer } from "../utils/mock-server"
import {
expectPath,
holdRoute,
NO_PROVIDER,
project,
REMOTE_SERVER,
seed,
SERVER,
session,
sessionHref,
T0,
} from "../utils/app"
import { mockOpenCodeServer, mockServers } from "../utils/mock-server"
import { fixture, mockStressTimeline } from "../utils/session-fixture"
import { mockRemoteServer, mockWorkspace, newSessionLocation } from "../utils/workspace"
import { APP_READY_TIMEOUT, expectAppVisible } from "../utils/waits"
@@ -340,6 +351,90 @@ test("Home migrates the directories an older build listed to the server's curren
.toMatchObject({ usedProjectIDs: { local: ["proj_api", "proj_web"] }, projects: {} })
})
test("selecting a Home project lists its worktrees once, however often the project updates", async ({ page }) => {
const listed = [entry("alpha", 2), entry("beta", 1)]
const view = await homeProjects(page, listed)
await seed(page, { usedProjects: { local: ["proj_alpha", "proj_beta"] } })
const lists: string[] = []
page.on("request", (request) => {
const url = new URL(request.url())
if (request.method() === "GET" && url.pathname === "/api/worktree") lists.push(url.searchParams.get("projectID")!)
})
await page.goto("/")
await expect(view.rows).toHaveText(["alpha", "beta"])
const alpha = page.locator('[data-component="home-project-row"]').filter({ hasText: "alpha" })
const refreshed = page.waitForRequest(
(request) => request.method() === "POST" && new URL(request.url()).pathname === "/api/worktree/refresh",
)
await alpha.click()
await expect(alpha).toHaveAttribute("data-selected", "")
await refreshed
// Each update replaces the selected project's object in the store.
const renamed: OpenCodeEvent = {
id: "evt_home_worktrees",
created: T0,
type: "project.updated",
data: { ...listed[0]!, name: "alpha renamed" },
}
await view.server.push([renamed])
await expect(view.rows).toHaveText(["alpha renamed", "beta"])
const beta = page.waitForRequest((request) => new URL(request.url()).searchParams.get("projectID") === "proj_beta")
await page.locator('[data-component="home-project-row"]').filter({ hasText: "beta" }).click()
await beta
expect(lists).toEqual(["proj_alpha", "proj_beta"])
})
test("Home keeps a restored remote selection while the desktop server list loads", async ({ page }) => {
const local = session({ id: "ses_home_local", directory: "/repo", title: "Local session" })
const remote = session({ id: "ses_home_remote", directory: "/remote/project", title: "Remote session" })
const selection = { server: REMOTE_SERVER, directory: "/remote/project" }
await mockServers(page, {
[SERVER]: {
directory: "/repo",
project: project({ id: "proj_local", directory: "/repo" }),
provider: NO_PROVIDER,
sessions: [local],
pageMessages: () => ({ items: [] }),
},
[REMOTE_SERVER]: {
directory: selection.directory,
project: project({ id: "proj_remote", directory: selection.directory, name: "remote-project" }),
provider: NO_PROVIDER,
sessions: [remote],
pageMessages: () => ({ items: [] }),
},
})
await seed(page, {
servers: [{ url: REMOTE_SERVER, name: "Remote" }],
usedProjects: { [REMOTE_SERVER]: ["proj_remote"] },
storage: { "opencode.global.dat:layout": { home: { selection } } },
})
// Desktop storage is asynchronous; the stored servers load after the layout here.
await page.goto(
`/e2e/utils/settings-wsl.html?${new URLSearchParams({ server: SERVER, mode: "stopped", storage: "async", hold: "^server$", path: "/" })}`,
)
// Until then Home shows this computer's sessions, not filtered by the remote server's directory.
await expect(row(page, local.title)).toBeVisible()
await page.getByRole("button", { name: "Load held storage", exact: true }).click()
await expect(row(page, remote.title)).toBeVisible()
await expect(
page.locator('[data-component="home-project-row"]').filter({ hasText: "remote-project" }),
).toHaveAttribute("data-selected", "")
await expect(row(page, local.title)).toHaveCount(0)
expect(
await page.evaluate(() => JSON.parse(localStorage.getItem("opencode.global.dat:layout") ?? "{}").home.selection),
).toEqual(selection)
})
test("Home shows loaded sessions before the location request resolves", async ({ page }) => {
const location = await holdRoute(page, (url) => url.pathname === "/api/location")
await openHome(page)
@@ -19,7 +19,7 @@ type FixtureMethod = (input: FixtureInput) => number | void
// A desktop window. `wsl` is the Ubuntu server's endpoint (default `server`); updating OpenCode restarts it on `restart`
// (default `wsl`). `ssh` adds a saved SSH server `box`, ready on that endpoint with password `ssh-1`; each connect
// brings up a new remote server with the next password (`ssh-2`, ...). `storage=async` stores in localStorage behind
// asynchronous reads like the desktop app's; reads of keys containing `hold` wait for "Load held storage".
// asynchronous reads like the desktop app's; reads of keys matching the pattern `hold` wait for "Load held storage".
export function mount(input: {
server: string
mode: "failed" | "stopped" | "ready"
@@ -46,7 +46,7 @@ export function mount(input: {
return {
getItem: async (key: string) => {
if (input.hold && key.includes(input.hold)) await held.promise
if (input.hold && new RegExp(input.hold).test(key)) await held.promise
return localStorage.getItem(item(key))
},
+286
View File
@@ -0,0 +1,286 @@
import { describe, expect, test } from "bun:test"
import { ServerConnection } from "@/runtime/server/registry"
import {
INITIAL_HOME_SELECTION_STATE,
selectHomeSelection,
transitionHomeSelection,
type HomeEnvSnapshot,
type HomeSelectionEvent,
type HomeSelectionState,
type HomeServerSnapshot,
} from "./machine"
const SIDECAR = ServerConnection.Key.make("sidecar")
const REMOTE = ServerConnection.Key.make("https://apollo.example.test")
const REPO = { id: "proj_repo", worktree: "/srv/repo" }
const API = { id: "proj_api", worktree: "C:/OpenCode/api" }
const APP = { id: "proj_app", worktree: "C:/OpenCode/app" }
const server = (key: ServerConnection.Key, input: Partial<HomeServerSnapshot> = {}): HomeServerSnapshot => ({
key,
failed: false,
connected: true,
projectsReady: true,
usedProjects: [],
...input,
})
const env = (input: Partial<HomeEnvSnapshot> = {}): HomeEnvSnapshot => ({
hydrated: true,
stored: {},
servers: [server(SIDECAR)],
...input,
})
const sync = (state: HomeSelectionState, snapshot: HomeEnvSnapshot) =>
transitionHomeSelection(state, { type: "env.synced", env: snapshot })
const settle = (snapshot: HomeEnvSnapshot) => sync(INITIAL_HOME_SELECTION_STATE, snapshot).state
describe("home selection machine", () => {
test("keeps a restored remote selection while the stored servers load, then verifies its project", () => {
const stored = { server: REMOTE, directory: "/srv/repo" }
const loading = sync(INITIAL_HOME_SELECTION_STATE, env({ hydrated: false, stored }))
expect(loading.state.status).toBe("hydrating")
expect(loading.effects).toEqual([])
// The fallback server shows without the remote server's directory.
expect(selectHomeSelection(loading.state)).toEqual({ server: SIDECAR })
const listed = sync(
loading.state,
env({ stored, servers: [server(SIDECAR), server(REMOTE, { projectsReady: false })] }),
)
expect(listed.state.status).toBe("verifying")
expect(listed.effects).toEqual([])
expect(selectHomeSelection(listed.state)).toEqual(stored)
const ready = sync(
listed.state,
env({ stored, servers: [server(SIDECAR), server(REMOTE, { usedProjects: [REPO] })] }),
)
expect(ready.state).toMatchObject({ status: "ready", server: REMOTE, project: REPO })
expect(ready.effects).toEqual([{ type: "worktrees.list", attempt: 1, server: REMOTE, projectID: REPO.id }])
})
test("writes nothing while the layout loads, so its stored selection is not overwritten", () => {
const early = sync(
INITIAL_HOME_SELECTION_STATE,
env({ hydrated: false, stored: { server: SIDECAR }, servers: [server(REMOTE)] }),
)
expect(early.state.status).toBe("hydrating")
expect(early.effects).toEqual([])
expect(selectHomeSelection(early.state)).toEqual({ server: REMOTE })
const loaded = sync(
early.state,
env({ stored: { server: REMOTE, directory: "/srv/repo" }, servers: [server(REMOTE, { usedProjects: [REPO] })] }),
)
expect(loaded.state).toMatchObject({ status: "ready", server: REMOTE, project: REPO })
expect(loaded.effects.map((effect) => effect.type)).toEqual(["worktrees.list"])
})
test("always shows a listed server, and drops the directory of a server that is gone", () => {
expect(selectHomeSelection(settle(env({ hydrated: false })))).toEqual({ server: SIDECAR })
const gone = sync(INITIAL_HOME_SELECTION_STATE, env({ stored: { server: REMOTE, directory: "/srv/repo" } }))
expect(gone.state).toMatchObject({ status: "ready", server: SIDECAR, project: undefined })
expect(gone.effects).toEqual([{ type: "selection.persist", selection: { server: SIDECAR } }])
})
test("waits for legacy projects to migrate before it keeps or clears the directory", () => {
const stored = { server: SIDECAR, directory: API.worktree }
const migrating = sync(
INITIAL_HOME_SELECTION_STATE,
env({ stored, servers: [server(SIDECAR, { projectsReady: false })] }),
)
expect(migrating.state.status).toBe("verifying")
expect(migrating.effects).toEqual([])
const migrated = sync(migrating.state, env({ stored, servers: [server(SIDECAR, { usedProjects: [API] })] }))
expect(migrated.state).toMatchObject({ status: "ready", project: API })
expect(migrated.effects.map((effect) => effect.type)).toEqual(["worktrees.list"])
})
test("stores a used project's own path for a directory written another way", () => {
const result = sync(
INITIAL_HOME_SELECTION_STATE,
env({
stored: { server: SIDECAR, directory: "C:\\OpenCode\\app\\" },
servers: [server(SIDECAR, { usedProjects: [APP] })],
}),
)
expect(selectHomeSelection(result.state)).toEqual({ server: SIDECAR, directory: APP.worktree })
expect(result.effects).toEqual([
{ type: "selection.persist", selection: { server: SIDECAR, directory: APP.worktree } },
{ type: "worktrees.list", attempt: 1, server: SIDECAR, projectID: APP.id },
])
})
test("lists the selected project's worktrees once per connected span and refreshes only the current one", () => {
const servers = () => [server(SIDECAR, { usedProjects: [{ ...API }, { ...APP }] })]
const stored = { server: SIDECAR, directory: API.worktree }
const listing = settle(env({ stored, servers: servers() }))
expect(listing.status === "ready" && listing.worktrees).toEqual({
status: "listing",
attempt: 1,
server: SIDECAR,
projectID: API.id,
})
// A store update rebuilds every project object; the demand does not start again.
expect(sync(listing, env({ stored, servers: servers() }))).toEqual({ state: listing, effects: [] })
expect(sync(listing, env({ stored, servers: servers() })).state).toBe(listing)
const listed = transitionHomeSelection(listing, { type: "worktrees.listed", attempt: 1 })
expect(listed.effects).toEqual([{ type: "worktrees.refresh", server: SIDECAR, projectID: API.id }])
expect(sync(listed.state, env({ stored, servers: servers() })).state).toBe(listed.state)
// Switching projects while a list runs drops its refresh.
const switched = transitionHomeSelection(listing, {
type: "project.toggled",
server: SIDECAR,
directory: APP.worktree,
})
expect(switched.effects).toEqual([
{ type: "selection.persist", selection: { server: SIDECAR, directory: APP.worktree } },
{ type: "worktrees.list", attempt: 2, server: SIDECAR, projectID: APP.id },
])
const late = transitionHomeSelection(switched.state, { type: "worktrees.listed", attempt: 1 })
expect(late.state).toBe(switched.state)
expect(late.effects).toEqual([])
// A disconnect drops the demand; the next connection lists again.
const offline = sync(
listed.state,
env({ stored, servers: [server(SIDECAR, { connected: false, usedProjects: [API] })] }),
)
expect(offline.state.status === "ready" && offline.state.worktrees).toEqual({ status: "idle" })
expect(transitionHomeSelection(offline.state, { type: "worktrees.listed", attempt: 1 }).state).toBe(offline.state)
const online = sync(offline.state, env({ stored, servers: [server(SIDECAR, { usedProjects: [API] })] }))
expect(online.effects).toEqual([{ type: "worktrees.list", attempt: 2, server: SIDECAR, projectID: API.id }])
})
test("a choice made while loading wins once everything loaded, and is written only then", () => {
const stored = { server: SIDECAR }
const loading = settle(env({ hydrated: false, stored, servers: [server(SIDECAR), server(REMOTE)] }))
const focused = transitionHomeSelection(loading, { type: "server.focused", server: REMOTE })
expect(focused.state.status).toBe("hydrating")
expect(focused.effects).toEqual([])
expect(selectHomeSelection(focused.state)).toEqual({ server: REMOTE })
const loaded = sync(focused.state, env({ stored, servers: [server(SIDECAR), server(REMOTE)] }))
expect(loaded.effects).toEqual([{ type: "selection.persist", selection: { server: REMOTE } }])
})
test("keeps the directory while its server is signed out, and clears it only once the server lists projects", () => {
const stored = { server: SIDECAR, directory: API.worktree }
const ready = settle(env({ stored, servers: [server(SIDECAR, { connected: false, usedProjects: [API] })] }))
const signedOut = sync(
ready,
env({ stored, servers: [server(SIDECAR, { connected: false, projectsReady: false })] }),
)
expect(signedOut.state.status).toBe("verifying")
expect(signedOut.effects).toEqual([])
const closed = sync(signedOut.state, env({ stored, servers: [server(SIDECAR, { connected: false })] }))
expect(closed.state).toMatchObject({ status: "ready", project: undefined })
expect(closed.effects).toEqual([{ type: "selection.persist", selection: { server: SIDECAR } }])
})
test("toggles a used project on a working server and ignores the rest", () => {
const servers = [
server(SIDECAR, { connected: false, usedProjects: [API] }),
server(REMOTE, { failed: true, usedProjects: [REPO] }),
]
const ready = settle(env({ stored: { server: SIDECAR }, servers }))
const toggle = (state: HomeSelectionState, target: ServerConnection.Key, directory: string) =>
transitionHomeSelection(state, { type: "project.toggled", server: target, directory })
expect(toggle(ready, REMOTE, REPO.worktree).state).toBe(ready)
expect(toggle(ready, SIDECAR, "C:/OpenCode/unused").state).toBe(ready)
const on = toggle(ready, SIDECAR, API.worktree)
expect(on.effects).toEqual([{ type: "selection.persist", selection: { server: SIDECAR, directory: API.worktree } }])
const off = toggle(on.state, SIDECAR, "C:\\OpenCode\\api\\")
expect(off.effects).toEqual([{ type: "selection.persist", selection: { server: SIDECAR } }])
})
test("an added project is selected unless the user chose something else first", () => {
const stored = { server: SIDECAR }
const ready = settle(env({ stored, servers: [server(SIDECAR, { connected: false }), server(REMOTE)] }))
const add: HomeSelectionEvent = { type: "project.add", server: SIDECAR, directories: [API.worktree] }
expect(transitionHomeSelection(ready, { ...add, directories: [] }).state).toBe(ready)
const adding = transitionHomeSelection(ready, add)
expect(adding.effects).toEqual([{ type: "project.add", attempt: 1, server: SIDECAR, directories: [API.worktree] }])
// The server reports the project before the result arrives, as the driver syncs it first.
const listed = sync(
adding.state,
env({ stored, servers: [server(SIDECAR, { connected: false, usedProjects: [API] }), server(REMOTE)] }),
)
const added = transitionHomeSelection(listed.state, { type: "project.added", attempt: 1, project: API })
expect(added.state).toMatchObject({ status: "ready", server: SIDECAR, project: API, adding: undefined })
expect(added.effects).toEqual([
{ type: "selection.persist", selection: { server: SIDECAR, directory: API.worktree } },
])
const moved = transitionHomeSelection(listed.state, { type: "server.focused", server: REMOTE })
const stale = transitionHomeSelection(moved.state, { type: "project.added", attempt: 1, project: API })
expect(stale.state).toBe(moved.state)
expect(stale.effects).toEqual([])
const failed = transitionHomeSelection(listed.state, { type: "project.added", attempt: 1, project: undefined })
expect(failed.state).toMatchObject({ status: "ready", project: undefined, adding: undefined })
expect(failed.effects).toEqual([])
})
test("adopts a selection written elsewhere, and does not echo its own writes", () => {
const servers = [server(SIDECAR, { connected: false, usedProjects: [API] }), server(REMOTE)]
const first = sync(INITIAL_HOME_SELECTION_STATE, env({ stored: { server: REMOTE, directory: "/gone" }, servers }))
expect(first.effects).toEqual([{ type: "selection.persist", selection: { server: REMOTE } }])
expect(sync(first.state, env({ stored: { server: REMOTE }, servers })).state).toBe(first.state)
const shown = sync(first.state, env({ stored: { server: SIDECAR, directory: API.worktree }, servers }))
expect(shown.state).toMatchObject({ status: "ready", server: SIDECAR, project: API })
expect(shown.effects).toEqual([])
})
test("ignores everything once disposed", () => {
const listing = settle(
env({
stored: { server: SIDECAR, directory: API.worktree },
servers: [server(SIDECAR, { usedProjects: [API] })],
}),
)
const disposed = transitionHomeSelection(listing, { type: "disposed" }).state
expect(disposed.status).toBe("disposed")
expect(transitionHomeSelection(disposed, { type: "worktrees.listed", attempt: 1 })).toEqual({
state: disposed,
effects: [],
})
expect(transitionHomeSelection(disposed, { type: "project.added", attempt: 1, project: API }).state).toBe(disposed)
expect(sync(disposed, env()).state).toBe(disposed)
})
})
+344
View File
@@ -0,0 +1,344 @@
import type { ServerConnection } from "@/runtime/server/registry"
import { toggleHomeProjectSelection } from "@/shell/layout/helpers"
import type { HomeProjectSelection } from "@/shell/state/layout"
import { pathKey } from "@/workspaces/path-key"
export type HomeProjectItem = {
readonly id: string
readonly worktree: string
}
export type HomeServerSnapshot = {
readonly key: ServerConnection.Key
readonly failed: boolean
readonly connected: boolean
/** The server's project list loaded, and the directories an older build listed for it are migrated. */
readonly projectsReady: boolean
readonly usedProjects: readonly HomeProjectItem[]
}
export type HomeEnvSnapshot = {
/** The stored layout, the stored servers and the servers plugins contribute have all loaded. */
readonly hydrated: boolean
/** What `layout.home.selection` holds now. */
readonly stored: HomeProjectSelection
/** The servers Home lists, in order. */
readonly servers: readonly HomeServerSnapshot[]
}
/** The worktree inventory demand of the selected project, once per connected server and project. */
export type HomeWorktreeSync =
| { readonly status: "idle" }
| {
readonly status: "listing"
readonly attempt: number
readonly server: ServerConnection.Key
readonly projectID: string
}
| { readonly status: "listed"; readonly server: ServerConnection.Key; readonly projectID: string }
type HomeSelectionBase = {
readonly issued: number
/** The selection storage holds, as last read or written. */
readonly stored: HomeProjectSelection
readonly servers: readonly HomeServerSnapshot[]
/** A project add whose result selects the project, unless the user selects something else first. */
readonly adding: { readonly attempt: number; readonly server: ServerConnection.Key } | undefined
readonly worktrees: HomeWorktreeSync
}
/**
* Home's server and project selection:
* - `hydrating`: the layout or a server source has not loaded. Home shows the stored server when it is listed and the
* first server otherwise, and writes nothing. A selection the user makes meanwhile is `override`, which wins.
* - `verifying`: the server is listed, and the directory waits for that server's projects before it is kept or cleared.
* - `ready`: the server and its optional used project are checked against the loaded state.
* - `disposed`: Home unmounted; late results are ignored.
*/
export type HomeSelectionState =
| (HomeSelectionBase & { readonly status: "hydrating"; readonly override: HomeProjectSelection | undefined })
| (HomeSelectionBase & {
readonly status: "verifying"
readonly server: ServerConnection.Key
readonly directory: string
})
| (HomeSelectionBase & {
readonly status: "ready"
readonly server: ServerConnection.Key
readonly project: HomeProjectItem | undefined
})
| { readonly status: "disposed" }
export type HomeSelectionEvent =
| { readonly type: "env.synced"; readonly env: HomeEnvSnapshot }
| { readonly type: "server.focused"; readonly server: ServerConnection.Key }
| { readonly type: "project.toggled"; readonly server: ServerConnection.Key; readonly directory: string }
| { readonly type: "project.add"; readonly server: ServerConnection.Key; readonly directories: readonly string[] }
| { readonly type: "project.added"; readonly attempt: number; readonly project: HomeProjectItem | undefined }
| { readonly type: "worktrees.listed"; readonly attempt: number }
| { readonly type: "disposed" }
export type HomeSelectionEffect =
| { readonly type: "selection.persist"; readonly selection: HomeProjectSelection }
| {
readonly type: "project.add"
readonly attempt: number
readonly server: ServerConnection.Key
readonly directories: readonly string[]
}
| {
readonly type: "worktrees.list"
readonly attempt: number
readonly server: ServerConnection.Key
readonly projectID: string
}
| { readonly type: "worktrees.refresh"; readonly server: ServerConnection.Key; readonly projectID: string }
export type HomeSelectionTransition = {
readonly state: HomeSelectionState
readonly effects: readonly HomeSelectionEffect[]
}
type LiveState = Exclude<HomeSelectionState, { status: "disposed" }>
const IDLE: HomeWorktreeSync = Object.freeze({ status: "idle" })
const DISPOSED: HomeSelectionState = Object.freeze({ status: "disposed" })
const NONE: readonly HomeSelectionEffect[] = Object.freeze([])
export const INITIAL_HOME_SELECTION_STATE: HomeSelectionState = Object.freeze({
status: "hydrating",
issued: 0,
stored: Object.freeze({}),
servers: Object.freeze([]),
adding: undefined,
worktrees: IDLE,
override: undefined,
})
export function transitionHomeSelection(state: HomeSelectionState, event: HomeSelectionEvent): HomeSelectionTransition {
if (state.status === "disposed") return { state, effects: NONE }
if (event.type === "disposed") return { state: DISPOSED, effects: NONE }
if (event.type === "env.synced") return synced(state, event.env)
if (event.type === "server.focused") return choose(state, { server: event.server })
if (event.type === "project.toggled") {
const entry = state.servers.find((server) => server.key === event.server)
const project = entry && !entry.failed ? findProject(entry, event.directory) : undefined
if (!entry || !project) return { state, effects: NONE }
return choose(state, toggleHomeProjectSelection(selectHomeSelection(state), entry.key, project.worktree))
}
if (event.type === "project.add") {
if (event.directories.length === 0) return { state, effects: NONE }
const attempt = state.issued + 1
return {
state: { ...state, issued: attempt, adding: { attempt, server: event.server } },
effects: [{ type: "project.add", attempt, server: event.server, directories: event.directories }],
}
}
if (event.type === "project.added") {
if (state.adding?.attempt !== event.attempt) return { state, effects: NONE }
if (!event.project) return { state: { ...state, adding: undefined }, effects: NONE }
return choose(state, { server: state.adding.server, directory: event.project.worktree })
}
const sync = state.worktrees
if (sync.status !== "listing" || sync.attempt !== event.attempt) return { state, effects: NONE }
return {
state: { ...state, worktrees: { status: "listed", server: sync.server, projectID: sync.projectID } },
effects: [{ type: "worktrees.refresh", server: sync.server, projectID: sync.projectID }],
}
}
/** What Home shows as selected: always a listed server while there is one, and a used project's own path. */
export function selectHomeSelection(state: HomeSelectionState): HomeProjectSelection {
if (state.status === "disposed") return {}
if (state.status === "verifying") return { server: state.server, directory: state.directory }
if (state.status === "ready")
return state.project ? { server: state.server, directory: state.project.worktree } : { server: state.server }
const target = state.override ?? state.stored
const entry = state.servers.find((server) => server.key === target.server)
if (!entry) return state.servers[0] ? { server: state.servers[0].key } : {}
if (!target.directory) return { server: entry.key }
return { server: entry.key, directory: findProject(entry, target.directory)?.worktree ?? target.directory }
}
export function sameHomeSelection(a: HomeProjectSelection | undefined, b: HomeProjectSelection | undefined) {
return a?.server === b?.server && a?.directory === b?.directory
}
function synced(state: LiveState, env: HomeEnvSnapshot): HomeSelectionTransition {
const servers = sameServers(state.servers, env.servers) ? state.servers : env.servers
if (state.status === "hydrating") {
const next = { ...state, servers, stored: selection(env.stored.server, env.stored.directory) }
// Until everything loaded, the stored server may be missing only because its source has not reported yet.
if (!env.hydrated) return finish(state, next, NONE)
return place(state, next, state.override ?? next.stored)
}
// Another part of the app wrote the selection, such as a session's "Show in Home".
const external = !sameHomeSelection(env.stored, state.stored)
const next = {
...state,
servers,
stored: external ? selection(env.stored.server, env.stored.directory) : state.stored,
adding: external ? undefined : state.adding,
}
return place(state, next, external ? next.stored : selectHomeSelection(state))
}
// A selection the user made: it wins over a project add still running.
function choose(state: LiveState, target: HomeProjectSelection): HomeSelectionTransition {
if (state.status === "hydrating")
return finish(state, { ...state, adding: undefined, override: selection(target.server, target.directory) }, NONE)
return place(state, { ...state, adding: undefined }, target)
}
// Checks `target` against the listed servers and writes what storage does not hold yet.
function place(prev: LiveState, base: HomeSelectionBase, target: HomeProjectSelection): HomeSelectionTransition {
const fields = {
issued: base.issued,
stored: base.stored,
servers: base.servers,
adding: base.adding,
worktrees: base.worktrees,
}
const entry = base.servers.find((server) => server.key === target.server)
const first = base.servers[0]
// Home always lists a server; without one the selection stays as it is rather than being cleared.
if (!first) return finish(prev, { ...prev, ...fields }, NONE)
const next: LiveState = (() => {
// The selected server is gone: its directory belonged to it, so only the first server is kept.
if (!entry) return { ...fields, status: "ready", server: first.key, project: undefined }
if (!target.directory) return { ...fields, status: "ready", server: entry.key, project: undefined }
if (!entry.projectsReady) return { ...fields, status: "verifying", server: entry.key, directory: target.directory }
return { ...fields, status: "ready", server: entry.key, project: findProject(entry, target.directory) }
})()
const persisted = selectHomeSelection(next)
if (sameHomeSelection(persisted, base.stored)) return finish(prev, next, NONE)
return finish(prev, { ...next, stored: persisted }, [{ type: "selection.persist", selection: persisted }])
}
// Starts the worktree demand when the selected used project changes or its server connects, and drops it otherwise.
function finish(prev: LiveState, next: LiveState, effects: readonly HomeSelectionEffect[]): HomeSelectionTransition {
const target = worktreeTarget(next)
const sync = next.worktrees
const kept = target
? sync.status !== "idle" && sync.server === target.server && sync.projectID === target.projectID
: sync.status === "idle"
if (kept)
return effects.length === 0 && sameState(prev, next) ? { state: prev, effects: NONE } : { state: next, effects }
if (!target) return { state: { ...next, worktrees: IDLE }, effects }
const attempt = next.issued + 1
return {
state: { ...next, issued: attempt, worktrees: { status: "listing", attempt, ...target } },
effects: [...effects, { type: "worktrees.list", attempt, ...target }],
}
}
function worktreeTarget(state: LiveState) {
const current = selectHomeSelection(state)
const entry = state.servers.find((server) => server.key === current.server)
if (!entry?.connected || !current.directory) return
const project = findProject(entry, current.directory)
if (!project) return
return { server: entry.key, projectID: project.id }
}
function sameState(a: LiveState, b: LiveState) {
if (
a.status !== b.status ||
a.issued !== b.issued ||
a.servers !== b.servers ||
a.adding !== b.adding ||
a.worktrees !== b.worktrees ||
!sameHomeSelection(a.stored, b.stored)
)
return false
if (a.status === "hydrating" && b.status === "hydrating")
return a.override === b.override || (!!a.override && !!b.override && sameHomeSelection(a.override, b.override))
if (a.status === "verifying" && b.status === "verifying") return a.server === b.server && a.directory === b.directory
if (a.status === "ready" && b.status === "ready")
return a.server === b.server && a.project?.id === b.project?.id && a.project?.worktree === b.project?.worktree
return false
}
function sameServers(a: readonly HomeServerSnapshot[], b: readonly HomeServerSnapshot[]) {
return (
a.length === b.length &&
a.every((item, index) => {
const other = b[index]!
return (
item.key === other.key &&
item.failed === other.failed &&
item.connected === other.connected &&
item.projectsReady === other.projectsReady &&
item.usedProjects.length === other.usedProjects.length &&
item.usedProjects.every(
(project, at) =>
project.id === other.usedProjects[at]!.id && project.worktree === other.usedProjects[at]!.worktree,
)
)
})
)
}
function findProject(server: HomeServerSnapshot, directory: string) {
const key = pathKey(directory)
return server.usedProjects.find((project) => pathKey(project.worktree) === key)
}
// A new object every time: `layout.home.setSelection` reconciles it into the layout store.
function selection(server: ServerConnection.Key | undefined, directory: string | undefined): HomeProjectSelection {
if (!server) return {}
return directory ? { server, directory } : { server }
}
+108 -71
View File
@@ -1,76 +1,132 @@
import { useGlobal, useServerCtx } from "@/runtime/server/runtime"
import { type HomeProjectSelection, useLayout } from "@/shell/state/layout"
import { useLayout } from "@/shell/state/layout"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { isServerFailed } from "@/runtime/server/health-machine"
import { usePluginServers } from "@/runtime/plugin/servers"
import { createProjectSessionActions } from "@/shell/tabs/project-sessions"
import { toggleHomeProjectSelection } from "@/shell/layout/helpers"
import { createEffect, createMemo } from "solid-js"
import { batch, createEffect, createMemo, createSignal, onCleanup, untrack } from "solid-js"
import { pathKey } from "@/workspaces/path-key"
import { addProjects } from "./projects/add"
import {
INITIAL_HOME_SELECTION_STATE,
sameHomeSelection,
selectHomeSelection,
transitionHomeSelection,
type HomeEnvSnapshot,
type HomeSelectionEffect,
type HomeSelectionEvent,
} from "./machine"
export function createHomeController() {
const layout = useLayout()
const global = useGlobal()
const servers = useServers()
const pluginServers = usePluginServers()
const sessions = createProjectSessionActions()
const selection = layout.home.selection
const focusedServer = createMemo<ServerConnection.Any | undefined>(
() => servers.visible.find((conn) => ServerConnection.key(conn) === selection().server) ?? servers.visible[0],
const env = createMemo(
(): HomeEnvSnapshot => ({
hydrated: layout.ready() && servers.hydrated() && pluginServers.ready(),
stored: { server: layout.home.selection().server, directory: layout.home.selection().directory },
servers: servers.visible.map((conn) => {
const key = ServerConnection.key(conn)
const ctx = global.serverCtx(key)
return {
key,
failed: isServerFailed(global.servers.health[key]),
connected: ctx?.sdk.connection.status() === "connected",
projectsReady: !!ctx?.sync.project.ready() && servers.projects.forServer(key).legacy() === undefined,
usedProjects: (ctx?.projects.used() ?? []).map((project) => ({ id: project.id, worktree: project.worktree })),
}
}),
}),
)
// Seeded synchronously, so the first render already shows a listed server.
const initial = transitionHomeSelection(INITIAL_HOME_SELECTION_STATE, { type: "env.synced", env: untrack(env) })
const [machine, setMachine] = createSignal(initial.state)
const dispatch = (event: HomeSelectionEvent) => {
const result = transitionHomeSelection(untrack(machine), event)
if (result.state !== untrack(machine)) setMachine(result.state)
result.effects.forEach(run)
}
// A user action can follow a server change in the same update, before the effect below reports it.
const send = (event: HomeSelectionEvent) =>
untrack(() =>
batch(() => {
dispatch({ type: "env.synced", env: env() })
dispatch(event)
}),
)
function run(effect: HomeSelectionEffect) {
if (effect.type === "selection.persist") return layout.home.setSelection(effect.selection)
if (effect.type === "worktrees.refresh")
return void global.serverCtx(effect.server)?.sync.worktrees.refresh(effect.projectID)
const ctx = global.serverCtx(effect.server)
if (effect.type === "worktrees.list") {
// The inventory read never rejects; a failed read still asks the server to discover worktrees.
if (!ctx) return dispatch({ type: "worktrees.listed", attempt: effect.attempt })
return void ctx.sync.worktrees
.list(effect.projectID)
.then(() => dispatch({ type: "worktrees.listed", attempt: effect.attempt }))
}
if (!ctx) return dispatch({ type: "project.added", attempt: effect.attempt, project: undefined })
void addProjects(ctx, [...effect.directories]).then(
(project) =>
send({
type: "project.added",
attempt: effect.attempt,
project: project && { id: project.id, worktree: project.worktree },
}),
() => dispatch({ type: "project.added", attempt: effect.attempt, project: undefined }),
)
}
initial.effects.forEach(run)
createEffect(() => {
const current = env()
untrack(() => dispatch({ type: "env.synced", env: current }))
})
onCleanup(() => dispatch({ type: "disposed" }))
const selection = createMemo(() => selectHomeSelection(machine()), undefined, { equals: sameHomeSelection })
const focusedServer = createMemo(() => {
const key = selection().server
return key ? servers.visible.find((conn) => ServerConnection.key(conn) === key) : undefined
})
const focusedServerCtx = useServerCtx(focusedServer)
const focusedSync = () => focusedServerCtx()?.sync
// Home lists the server's projects this client has used.
const projects = createMemo(() => focusedServerCtx()?.projects.used() ?? [])
const selectedProject = createMemo(() => projects().find((project) => project.worktree === selection().directory))
const selectedProject = createMemo(() => {
const directory = selection().directory
return directory ? projects().find((project) => pathKey(project.worktree) === pathKey(directory)) : undefined
})
const newSessionProject = createMemo(() => selectedProject() ?? focusedServerCtx()?.projects.last() ?? projects()[0])
createEffect(() => {
const list = servers.visible
if (list.some((conn) => ServerConnection.key(conn) === selection().server)) return
const conn = list[0]
if (conn) setSelection({ server: ServerConnection.key(conn) })
})
createEffect(() => {
const ctx = focusedServerCtx()
const id = selectedProject()?.id
if (!ctx || !id || ctx.sdk.connection.status() !== "connected") return
// Selecting a project is the demand for its worktree inventory: the session filter spans its worktrees.
void ctx.sync.worktrees.list(id).then(() => ctx.sync.worktrees.refresh(id))
})
createEffect(() => {
// The project list is empty until the server store hydrates and the server answers; clearing the restored
// selection against it would persist the loss.
if (!servers.hydrated()) return
const current = selection()
const directory = current.directory
if (!directory) return
const conn = servers.visible.find((conn) => ServerConnection.key(conn) === current.server)
if (!conn) return
const ctx = global.serverCtx(ServerConnection.key(conn))
if (!ctx?.sync.project.ready()) return
if (ctx.projects.used().some((project) => pathKey(project.worktree) === pathKey(directory))) return
setSelection({ server: current.server })
})
function setSelection(next: HomeProjectSelection) {
layout.home.setSelection(next)
}
return {
selection: {
value: selection,
set: setSelection,
focusServer: (conn: ServerConnection.Any) => setSelection({ server: ServerConnection.key(conn) }),
focusServer: (conn: ServerConnection.Any) => send({ type: "server.focused", server: ServerConnection.key(conn) }),
},
server: {
list: () => servers.visible,
@@ -86,29 +142,10 @@ export function createHomeController() {
selected: selectedProject,
newSession: newSessionProject,
forServer: (conn: ServerConnection.Any) => global.serverCtx(ServerConnection.key(conn))?.projects.used() ?? [],
select: (conn: ServerConnection.Any, directory: string) => {
const key = ServerConnection.key(conn)
if (isServerFailed(global.servers.health[key])) return
if (
!global
.serverCtx(key)
?.projects.used()
.some((project) => project.worktree === directory)
)
return
setSelection(toggleHomeProjectSelection(selection(), key, directory))
},
add: async (conn: ServerConnection.Any, directories: string[]) => {
const ctx = global.serverCtx(ServerConnection.key(conn))
if (!ctx) return
const project = await addProjects(ctx, directories)
if (!project) return
setSelection({ server: ServerConnection.key(conn), directory: project.worktree })
},
select: (conn: ServerConnection.Any, directory: string) =>
send({ type: "project.toggled", server: ServerConnection.key(conn), directory }),
add: (conn: ServerConnection.Any, directories: string[]) =>
send({ type: "project.add", server: ServerConnection.key(conn), directories }),
openNewSession: () => {
const conn = focusedServer()
const project = newSessionProject()
@@ -43,7 +43,7 @@ export function createHomeProjectsController(home: HomeController) {
server: conn,
title: language.t("command.project.open"),
multiple: true,
onSelect: (result) => void home.project.add(conn, homeProjectDirectories(result)),
onSelect: (result) => home.project.add(conn, homeProjectDirectories(result)),
})
}