diff --git a/packages/app/e2e/regression/home.spec.ts b/packages/app/e2e/regression/home.spec.ts index e28defc954e..0e860e0a5a6 100644 --- a/packages/app/e2e/regression/home.spec.ts +++ b/packages/app/e2e/regression/home.spec.ts @@ -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) diff --git a/packages/app/e2e/utils/settings-wsl.fixture.tsx b/packages/app/e2e/utils/settings-wsl.fixture.tsx index 19c46d57d1b..d40fba4308a 100644 --- a/packages/app/e2e/utils/settings-wsl.fixture.tsx +++ b/packages/app/e2e/utils/settings-wsl.fixture.tsx @@ -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)) }, diff --git a/packages/app/src/home/machine.test.ts b/packages/app/src/home/machine.test.ts new file mode 100644 index 00000000000..9adf7399bf0 --- /dev/null +++ b/packages/app/src/home/machine.test.ts @@ -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 => ({ + key, + failed: false, + connected: true, + projectsReady: true, + usedProjects: [], + ...input, +}) + +const env = (input: Partial = {}): 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) + }) +}) diff --git a/packages/app/src/home/machine.ts b/packages/app/src/home/machine.ts new file mode 100644 index 00000000000..3f6999c4cb6 --- /dev/null +++ b/packages/app/src/home/machine.ts @@ -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 + +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 } +} diff --git a/packages/app/src/home/model.ts b/packages/app/src/home/model.ts index 9f0dd8082c7..1cd712a5257 100644 --- a/packages/app/src/home/model.ts +++ b/packages/app/src/home/model.ts @@ -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( - () => 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() diff --git a/packages/app/src/home/projects/controller.tsx b/packages/app/src/home/projects/controller.tsx index 7fbbe36bf42..f6299d4fe6c 100644 --- a/packages/app/src/home/projects/controller.tsx +++ b/packages/app/src/home/projects/controller.tsx @@ -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)), }) }