mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-21 04:12:08 +03:00
fix(app): drive Home's server and project selection with an explicit state machine (#61989)
This commit is contained in:
committed by
GitHub
Unverified
parent
4f6a84cf02
commit
ca1050c86e
@@ -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))
|
||||
},
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
@@ -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
@@ -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)),
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user