From e06f774db567a244791087f77458a5d436bb4366 Mon Sep 17 00:00:00 2001 From: Hona <10430890+Hona@users.noreply.github.com> Date: Sat, 5 Sep 2026 02:23:57 +0000 Subject: [PATCH] fix(app): defer background workspace discovery --- packages/app/src/new-session/view.tsx | 3 + .../src/new-session/workspace/controller.ts | 35 ++- .../src/new-session/workspace/selector.tsx | 9 + .../src/runtime/server/catalog-events.test.ts | 206 +++++++++++++++++ .../app/src/runtime/server/catalog-events.ts | 73 ++++++ packages/app/src/runtime/server/data.ts | 2 +- .../server/global-sync/bootstrap.test.ts | 52 +++-- .../runtime/server/global-sync/bootstrap.ts | 49 ++-- packages/app/src/runtime/server/runtime.tsx | 4 +- packages/app/src/runtime/server/sync.tsx | 33 ++- .../workspaces/project-extensions.tsx | 21 +- .../src/settings/workspaces/workspaces.tsx | 63 +++--- packages/app/src/workspaces/inventory.test.ts | 214 ++++++++++++++++++ packages/app/src/workspaces/inventory.ts | 86 +++++++ packages/app/src/workspaces/location.tsx | 8 + 15 files changed, 764 insertions(+), 94 deletions(-) create mode 100644 packages/app/src/runtime/server/catalog-events.test.ts create mode 100644 packages/app/src/runtime/server/catalog-events.ts create mode 100644 packages/app/src/workspaces/inventory.test.ts create mode 100644 packages/app/src/workspaces/inventory.ts diff --git a/packages/app/src/new-session/view.tsx b/packages/app/src/new-session/view.tsx index 19a0c4ce8e..c1a8d81290 100644 --- a/packages/app/src/new-session/view.tsx +++ b/packages/app/src/new-session/view.tsx @@ -84,6 +84,9 @@ export function NewSessionView(props: { value={props.workspace.selection.value()} projectRoot={props.workspace.project.root()} workspaces={props.workspace.project.workspaces()} + loading={props.workspace.project.loading()} + error={props.workspace.project.error()} + onOpenChange={props.workspace.project.setOpen} branches={props.workspace.project.branches()} branch={props.workspace.bar.branch()} onboarding={onboardingReady() && !onboarding.used} diff --git a/packages/app/src/new-session/workspace/controller.ts b/packages/app/src/new-session/workspace/controller.ts index b0e42ddb91..07d68b9f23 100644 --- a/packages/app/src/new-session/workspace/controller.ts +++ b/packages/app/src/new-session/workspace/controller.ts @@ -1,13 +1,15 @@ import { debounce } from "@solid-primitives/scheduled" import { createEffect, createMemo, createResource } from "solid-js" import { createStore } from "solid-js/store" +import { useQuery } from "@tanstack/solid-query" import { useWorkspaceLocation } from "@/workspaces/location" import { useServerSDK } from "@/runtime/server/client" -import { useData } from "@/runtime/server/current" +import { useData, useServer } from "@/runtime/server/current" import { useSettings } from "@/settings/model" import { useTabs } from "@/shell/tabs/tabs" import { ServerConnection } from "@/runtime/server/registry" import { normalizeProjectInfo } from "@/runtime/server/global-sync/utils" +import { withWorktreeInventory } from "@/workspaces/inventory" import { isWorkspaceDirectory, isWorkspaceSelection, @@ -46,16 +48,26 @@ export function createNewSessionWorkspaceController(input: { }) { const sdk = useWorkspaceLocation() const serverSDK = useServerSDK() + const server = useServer() const data = useData() const settings = useSettings() const tabs = useTabs() - const [state, setState] = createStore({ search: "" }) + const [state, setState] = createStore({ search: "", open: false }) const searchBranches = debounce((search: string) => setState("search", search.trim()), 100) - const currentProject = createMemo(() => { + const projectMetadata = createMemo(() => { const projectID = data.location.info({ directory: sdk().directory })?.project.id const current = projectID ? data.project.get(projectID) : undefined return current ? normalizeProjectInfo(current) : undefined }) + const projectRoot = createMemo(() => projectMetadata()?.worktree ?? sdk().directory) + const inventory = useQuery(() => ({ + ...server.ctx.sync.worktrees.query(projectRoot()), + enabled: state.open && serverSDK.connection.status() === "connected", + })) + const currentProject = createMemo(() => { + const project = projectMetadata() + return project ? withWorktreeInventory(project, inventory.data) : undefined + }) const visible = createMemo(() => resolveNewSessionGit({ projectVcs: currentProject()?.vcs, @@ -66,7 +78,8 @@ export function createNewSessionWorkspaceController(input: { const project = currentProject() const worktree = input.selectedWorktree() if (!project || !worktree) return - return isWorkspaceSelection(project, worktree) ? worktree : undefined + // A restored explicit choice is not disproved by metadata alone. + return !inventory.data || isWorkspaceSelection(project, worktree) ? worktree : undefined }) const fallback = createMemo(() => { const project = currentProject() @@ -83,9 +96,8 @@ export function createNewSessionWorkspaceController(input: { fallback: fallback(), }), ) - const projectRoot = createMemo(() => currentProject()?.worktree ?? sdk().directory) const [branches] = createResource( - () => (visible() ? { directory: projectRoot(), search: state.search } : undefined), + () => (visible() && state.open ? { directory: projectRoot(), search: state.search } : undefined), ({ directory, search }) => serverSDK.api.vcs .branches({ location: { directory }, search, limit: 50 }) @@ -96,9 +108,11 @@ export function createNewSessionWorkspaceController(input: { void Promise.all([data.location.syncInfo({ directory: sdk().directory }), data.project.sync()]).catch( () => undefined, ) - const project = currentProject() - const directories = project ? [project.worktree, ...workspaceDirectories(project)] : [sdk().directory] - directories.forEach((directory) => void data.location.vcs.sync({ directory }).catch(() => undefined)) + }) + createEffect(() => { + const selection = value() + const directory = selection === "main" || selection === "create" ? sdk().directory : selection + void data.location.vcs.sync({ directory }).catch(() => undefined) }) const branch = createMemo(() => resolveNewSessionBranch({ @@ -142,6 +156,9 @@ export function createNewSessionWorkspaceController(input: { }, project: { root: projectRoot, + loading: () => state.open && inventory.isPending, + error: () => inventory.isError, + setOpen: (open: boolean) => setState("open", open), workspaces: () => { const project = currentProject() return project ? workspaceDirectories(project) : [] diff --git a/packages/app/src/new-session/workspace/selector.tsx b/packages/app/src/new-session/workspace/selector.tsx index e39175abef..c7c1a7f22e 100644 --- a/packages/app/src/new-session/workspace/selector.tsx +++ b/packages/app/src/new-session/workspace/selector.tsx @@ -11,6 +11,9 @@ export function PromptWorkspaceSelector(props: { value: string projectRoot: string workspaces: string[] + loading?: boolean + error?: boolean + onOpenChange?: (open: boolean) => void branches: string[] branch?: string onboarding?: boolean @@ -41,6 +44,7 @@ export function PromptWorkspaceSelector(props: { pending = { type: "select", value } } const onOpenChange = (open: boolean) => { + props.onOpenChange?.(open) if (open) { setSearch({ workspaces: "", branches: "" }) props.onSearch("") @@ -133,6 +137,11 @@ export function PromptWorkspaceSelector(props: { + +
+ {language.t(props.error ? "session.location.worktreesFailed" : "common.loading")} +
+
0} fallback={ diff --git a/packages/app/src/runtime/server/catalog-events.test.ts b/packages/app/src/runtime/server/catalog-events.test.ts new file mode 100644 index 0000000000..aff56555b7 --- /dev/null +++ b/packages/app/src/runtime/server/catalog-events.test.ts @@ -0,0 +1,206 @@ +import { afterEach, describe, expect, test } from "bun:test" +import { OpenCode, type LocationRef, type OpenCodeEvent } from "@opencode-ai/client/promise" +import { createRoot } from "solid-js" +import { createOpenCodeEventSource } from "./client" +import { createAppData } from "./catalog-events" + +const cleanups: Array<() => void> = [] +afterEach(() => cleanups.splice(0).forEach((dispose) => dispose())) + +function setup() { + return createRoot((dispose) => { + cleanups.push(dispose) + const events = createOpenCodeEventSource() + const calls: Array<{ path: string; location: LocationRef }> = [] + const api = OpenCode.make({ + baseUrl: "http://localhost:3000", + fetch: Object.assign( + async (input: RequestInfo | URL, init?: RequestInit) => { + const url = new URL(new Request(input, init).url) + const location = { + directory: url.searchParams.get("location[directory]") ?? "/default", + workspaceID: url.searchParams.get("location[workspace]") ?? undefined, + } + calls.push({ path: url.pathname, location }) + if (url.pathname === "/api/health") return Response.json({ healthy: true, version: "2.0.0-test", pid: 1 }) + if (url.pathname === "/api/mcp") return Response.json({ location, data: [] }) + if (url.pathname === "/api/mcp/resource") + return Response.json({ location, data: { resources: [], templates: [] } }) + throw new Error(`Unexpected request: ${url.pathname}`) + }, + { preconnect() {} }, + ), + }) + const data = createAppData({ + api: () => api, + directory: "/default", + event: { + on: events.event.on, + listen: (handler) => events.event.listen((event) => handler({ name: event.type, details: event })), + }, + onError: (error) => { + throw error + }, + }) + const emit = (location: LocationRef) => { + events.publish({ + id: "evt_status", + created: 1, + type: "mcp.status.changed", + location, + data: { server: "test" }, + }) + events.publish({ + id: "evt_resources", + created: 2, + type: "mcp.resources.changed", + location, + data: { server: "test" }, + }) + } + return { data, calls, emit, events, api, dispose } + }) +} + +const settle = () => new Promise((resolve) => setTimeout(resolve, 0)) + +describe("desktop catalog events", () => { + test("does not fetch MCP catalogs for hundreds of unopened locations", async () => { + const input = setup() + Array.from({ length: 400 }, (_, index) => input.emit({ directory: `/history/${index}` })) + await settle() + await input.api.health.get() + expect(input.calls).toHaveLength(1) + expect(input.calls[0].path).toBe("/api/health") + }) + + test("coalesces active MCP events and leaves unrelated locations deferred", async () => { + const input = setup() + const location = { directory: "/active" } + const release = input.data.location.retain(location) + Array.from({ length: 30 }, () => { + input.emit(location) + input.emit({ directory: "/history" }) + }) + await settle() + await Promise.all([input.data.location.mcp.server.sync(location), input.data.location.mcp.resource.sync(location)]) + expect(input.calls).toHaveLength(2) + expect(input.calls.every((call) => call.location.directory === location.directory)).toBe(true) + release() + input.emit(location) + await settle() + expect(input.calls).toHaveLength(2) + const reopen = input.data.location.retain(location) + await Promise.all([input.data.location.mcp.server.sync(location), input.data.location.mcp.resource.sync(location)]) + expect(input.calls).toHaveLength(4) + reopen() + }) + + test("keeps shared owners active and distinguishes workspace identities", async () => { + const input = setup() + const location = { directory: "C:\\repo", workspaceID: "workspace_a" } + const first = input.data.location.retain(location) + const second = input.data.location.retain(location) + first() + input.emit({ directory: "C:/repo/", workspaceID: "workspace_a" }) + input.emit({ directory: "C:/repo/", workspaceID: "workspace_b" }) + await settle() + expect(input.calls).toHaveLength(2) + expect(input.calls.every((call) => call.location.workspaceID === "workspace_a")).toBe(true) + second() + input.emit(location) + await settle() + expect(input.calls).toHaveLength(2) + }) + + test("never suppresses session permission events for an unopened location", () => { + const input = setup() + const event = { + id: "evt_permission", + created: 1, + type: "permission.asked", + location: { directory: "/history" }, + data: { + id: "perm_1", + sessionID: "ses_1", + action: "read", + resources: ["src/**"], + source: { type: "tool", messageID: "msg_1", id: "call_1" }, + }, + } satisfies Extract + input.events.publish(event) + expect(input.data.session.permission.list("ses_1")).toEqual([event.data]) + expect(input.calls).toHaveLength(0) + }) + + test("refreshes a requested Windows path after changes arrive using a normalized alias", async () => { + const input = setup() + const location = { directory: "C:\\repo" } + const release = input.data.location.retain(location) + await input.data.location.mcp.server.sync(location) + release() + input.emit({ directory: "C:/repo/" }) + await settle() + expect(input.calls).toHaveLength(1) + const reopen = input.data.location.retain(location) + await input.data.location.mcp.server.sync(location) + expect(input.calls).toHaveLength(2) + reopen() + }) + + test("keeps background questions visible without loading that location's MCP catalogs", () => { + const input = setup() + const event = { + id: "evt_form", + created: 1, + type: "form.created", + location: { directory: "/history" }, + data: { + form: { + id: "frm_question", + sessionID: "ses_1", + title: "Choose an option", + fields: [{ key: "answer", type: "string" }], + }, + }, + } satisfies Extract + input.events.publish(event) + expect(input.data.session.form.list("ses_1")).toEqual([event.data.form]) + expect(input.calls).toHaveLength(0) + }) + + test("refreshes a mounted shared catalog independently of the project catalog", async () => { + const input = setup() + const project = input.data.location.retain({ directory: "/project" }) + await input.data.location.mcp.server.sync() + const shared = input.data.location.retain(input.data.location.default()) + input.emit(input.data.location.default()) + await settle() + await input.data.location.mcp.server.sync() + expect(input.calls).toHaveLength(3) + expect(input.calls.every((call) => call.location.directory === "/default")).toBe(true) + shared() + input.emit(input.data.location.default()) + await settle() + expect(input.calls).toHaveLength(3) + project() + }) + + test("does not dispatch a queued catalog refresh after its last owner closes", async () => { + const input = setup() + const release = input.data.location.retain({ directory: "/active" }) + input.emit({ directory: "/active" }) + release() + await settle() + expect(input.calls).toHaveLength(0) + }) + + test("disposes a queued refresh without starting requests", async () => { + const input = setup() + input.data.location.retain({ directory: "/active" }) + input.emit({ directory: "/active" }) + input.dispose() + await settle() + expect(input.calls).toHaveLength(0) + }) +}) diff --git a/packages/app/src/runtime/server/catalog-events.ts b/packages/app/src/runtime/server/catalog-events.ts new file mode 100644 index 0000000000..c3dde4a6c6 --- /dev/null +++ b/packages/app/src/runtime/server/catalog-events.ts @@ -0,0 +1,73 @@ +import { createData, type CreateDataInput, type Data } from "@opencode-ai/client/solid" +import type { LocationRef, OpenCodeEvent } from "@opencode-ai/client/promise" +import { onCleanup } from "solid-js" +import { pathKey } from "@/workspaces/path-key" + +type DataEvent = { name: OpenCodeEvent["type"]; details: OpenCodeEvent } + +const key = (location: LocationRef) => JSON.stringify([pathKey(location.directory), location.workspaceID]) + +export function createAppData(input: CreateDataInput) { + const owners = new Map() + const pending = new Map() + const data: Data = createData({ + ...input, + event: { + ...input.event, + listen: (handler) => + input.event.listen((event) => { + const info = event.details + if (!info.location || (info.type !== "mcp.status.changed" && info.type !== "mcp.resources.changed")) { + handler(event) + return + } + + const resource = info.type === "mcp.status.changed" ? data.location.mcp.server : data.location.mcp.resource + // Keep unopened catalogs stale without booting their Location just to refresh the UI. + resource.invalidate(info.location) + if (!owners.has(key(info.location))) return + + if (pending.size === 0) { + queueMicrotask(() => { + const events = [...pending.values()] + pending.clear() + for (const event of events) { + const location = event.details.location + if (location && owners.has(key(location))) handler(event) + } + }) + } + // A server may publish several MCP changes in one event-stream batch; one catalog read suffices. + pending.set(`${key(info.location)}:${info.type}`, event) + }), + }, + }) + onCleanup(() => { + pending.clear() + owners.clear() + }) + + return { + ...data, + location: { + ...data.location, + retain(location: LocationRef) { + const id = key(location) + if (!owners.has(id)) { + // Reopening a view also refreshes requested-path aliases of the server's event Location. + data.location.mcp.server.invalidate(location) + data.location.mcp.resource.invalidate(location) + } + owners.set(id, (owners.get(id) ?? 0) + 1) + return () => { + const count = owners.get(id) ?? 0 + if (count > 1) { + owners.set(id, count - 1) + return + } + owners.delete(id) + } + }, + }, + } +} diff --git a/packages/app/src/runtime/server/data.ts b/packages/app/src/runtime/server/data.ts index 5be4b7ba19..fa4505104d 100644 --- a/packages/app/src/runtime/server/data.ts +++ b/packages/app/src/runtime/server/data.ts @@ -5,7 +5,7 @@ import { createStore } from "solid-js/store" type SessionMutation = { readonly id: string; readonly type: "remove"; readonly sessionID: string } -export function createDesktopData(input: { data: Data; remove: (sessionID: string) => Promise }) { +export function createDesktopData(input: { data: T; remove: (sessionID: string) => Promise }) { const mutation = createSessionMutations(input.remove) onCleanup(input.data.on("session.deleted", (event) => mutation.deleted(event.data.sessionID))) diff --git a/packages/app/src/runtime/server/global-sync/bootstrap.test.ts b/packages/app/src/runtime/server/global-sync/bootstrap.test.ts index 511cff488c..c014028f16 100644 --- a/packages/app/src/runtime/server/global-sync/bootstrap.test.ts +++ b/packages/app/src/runtime/server/global-sync/bootstrap.test.ts @@ -6,6 +6,7 @@ import { bootstrapGlobal, loadPathQuery, loadProjectsQuery } from "./bootstrap" import { ServerScope } from "@/runtime/server/scope" import type { ServerApi } from "@/runtime/server/api" import type { ServerSync } from "@/runtime/server/sync" +import { worktreeInventoryKey } from "@/workspaces/inventory" test("bootstraps projects through the native store setter and preserves subsequent updates", async () => { const api = OpenCode.make({ @@ -47,6 +48,17 @@ test("bootstraps projects through the native store setter and preserves subseque await bootstrapGlobal({ serverAPI: api, scope: ServerScope.local, setGlobalStore: setStore, queryClient }) expect(store.project.map((project) => [project.id, project.worktree])).toEqual([["project", "/repo"]]) expect(store.config).toEqual({}) + + queryClient.setQueryData(worktreeInventoryKey(ServerScope.local, "/repo"), [ + { directory: "/repo" }, + { directory: "/repo/feature", strategy: "git" }, + ]) + await bootstrapGlobal({ serverAPI: api, scope: ServerScope.local, setGlobalStore: setStore, queryClient }) + expect(store.project[0]?.sandboxes).toEqual(["/repo/feature"]) + expect(store.project[0]?.worktrees).toEqual([ + { directory: "/repo" }, + { directory: "/repo/feature", strategy: "git" }, + ]) } finally { queryClient.clear() } @@ -76,7 +88,7 @@ describe("query keys", () => { expect(result).toMatchObject({ directory: "/repo/subpath", worktree: "/repo" }) }) - test("loads each project's inventory through its own location using the real client", async () => { + test("loads 400 historical project records without discovering their worktrees", async () => { const calls: string[] = [] const api = OpenCode.make({ baseUrl: "http://localhost:3000", @@ -85,8 +97,16 @@ describe("query keys", () => { const url = new URL(new Request(input, init).url) if (url.pathname === "/api/project") return Response.json([ - { id: "b", canonical: "/b", time: { created: 1, updated: 1 }, sandboxes: [] }, - { id: "a", canonical: "/a", time: { created: 1, updated: 1 }, sandboxes: [] }, + ...Array.from({ length: 400 }, (_, index) => ({ + id: `project-${index.toString().padStart(3, "0")}`, + canonical: `/old/${index}`, + name: `Project ${index}`, + time: { created: 1, updated: 1 }, + sandboxes: [`/old/${index}/known`], + })), + { id: "test", canonical: "/tmp/opencode-test-123", time: { created: 1, updated: 1 }, sandboxes: [] }, + { id: "empty", canonical: "", time: { created: 1, updated: 1 }, sandboxes: [] }, + { id: "duplicate", canonical: "/old/0", time: { created: 1, updated: 1 }, sandboxes: [] }, ]) const directory = url.searchParams.get("location[directory]") if (url.pathname !== "/api/worktree" || !directory) throw new Error(`Unexpected request: ${url}`) @@ -101,21 +121,19 @@ describe("query keys", () => { ), }) - const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, api.project, api.worktree)) + const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, api.project)) - expect(result.map((project) => project.id)).toEqual(["a", "b"]) - expect(result.map((project) => project.sandboxes)).toEqual([ - ["/a/clone", "/a/copy"], - ["/b/clone", "/b/copy"], - ]) - expect(result.map((project) => project.worktrees)).toEqual([ - [{ directory: "/a" }, { directory: "/a/clone" }, { directory: "/a/copy", strategy: "git" }], - [{ directory: "/b" }, { directory: "/b/clone" }, { directory: "/b/copy", strategy: "git" }], - ]) - expect(calls.toSorted()).toEqual(["/a", "/b"]) + expect(calls).toEqual([]) + expect(result).toHaveLength(401) + expect(result.find((project) => project.id === "project-000")).toMatchObject({ + name: "Project 0", + worktree: "/old/0", + sandboxes: ["/old/0/known"], + }) + expect(result.some((project) => project.id === "test" || project.id === "empty")).toBe(false) }) - test("keeps projects whose directory inventory cannot load", async () => { + test("keeps metadata without consulting unavailable directories", async () => { const api = OpenCode.make({ baseUrl: "http://localhost:3000", fetch: Object.assign( @@ -135,10 +153,10 @@ describe("query keys", () => { ), }) - const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, api.project, api.worktree)) + const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, api.project)) expect(result.map((project) => ({ id: project.id, sandboxes: project.sandboxes }))).toEqual([ - { id: "a", sandboxes: ["/a/copy"] }, + { id: "a", sandboxes: [] }, { id: "b", sandboxes: [] }, ]) }) diff --git a/packages/app/src/runtime/server/global-sync/bootstrap.ts b/packages/app/src/runtime/server/global-sync/bootstrap.ts index b1010c1790..ded6c4e9e4 100644 --- a/packages/app/src/runtime/server/global-sync/bootstrap.ts +++ b/packages/app/src/runtime/server/global-sync/bootstrap.ts @@ -15,8 +15,7 @@ import { cmp, normalizeProjectInfo } from "./utils" import { formatServerError } from "@/runtime/server/errors" import { QueryClient, queryOptions } from "@tanstack/solid-query" import type { ServerScope } from "@/runtime/server/scope" -import type { ServerApi } from "@/runtime/server/api" -import { sameDirectory } from "@/workspaces/paths" +import { withWorktreeInventory, worktreeInventoryKey } from "@/workspaces/inventory" type GlobalStore = { path: Path @@ -64,38 +63,17 @@ type ProjectApi = { readonly list: () => Promise readonly current: (input?: ProjectCurrentInput) => Promise } -type WorktreeApi = Pick type LocationApi = { readonly get: (input?: LocationGetInput) => Promise } -export const loadProjectsQuery = (scope: ServerScope, projects: ProjectApi, worktrees: WorktreeApi) => +export const loadProjectsQuery = (scope: ServerScope, projects: ProjectApi) => queryOptions({ queryKey: [scope, "project"], queryFn: () => retry(() => - projects.list().then(async (items) => { - return ( - await Promise.all( - items - .filter((project) => !!project?.id) - .map(async (project) => { - const directories = await worktrees - .list({ location: { directory: project.canonical } }) - .catch(() => [ - { directory: project.canonical }, - ...(project.sandboxes ?? []) - .filter((directory) => !sameDirectory(project.canonical, directory)) - .map((directory) => ({ directory })), - ]) - return normalizeProjectInfo({ - ...project, - sandboxes: directories - .map((item) => item.directory) - .filter((directory) => !sameDirectory(project.canonical, directory)), - worktrees: directories, - }) - }), - ) - ) + projects.list().then((items) => { + return items + .filter((project) => !!project?.id) + .map(normalizeProjectInfo) .filter((p) => !!p.worktree && !p.worktree.includes("opencode-test")) .slice() .sort((a, b) => cmp(a.id, b.id)) @@ -107,7 +85,6 @@ export async function bootstrapGlobal(input: { serverAPI: { readonly location: LocationApi readonly project: ProjectApi - readonly worktree: WorktreeApi } scope: ServerScope setGlobalStore: SetStoreFunction @@ -117,9 +94,17 @@ export async function bootstrapGlobal(input: { () => input.queryClient.fetchQuery(loadGlobalConfigQuery(input.scope)), () => input.queryClient.fetchQuery(loadPathQuery(input.scope, null, input.serverAPI.location)), () => - input.queryClient - .fetchQuery(loadProjectsQuery(input.scope, input.serverAPI.project, input.serverAPI.worktree)) - .then((data) => input.setGlobalStore("project", data)), + input.queryClient.fetchQuery(loadProjectsQuery(input.scope, input.serverAPI.project)).then((data) => + input.setGlobalStore( + "project", + data.map((project) => + withWorktreeInventory( + project, + input.queryClient.getQueryData(worktreeInventoryKey(input.scope, project.worktree)), + ), + ), + ), + ), ] await runAll(slow) } diff --git a/packages/app/src/runtime/server/runtime.tsx b/packages/app/src/runtime/server/runtime.tsx index 6739e8aff9..5be3fd8320 100644 --- a/packages/app/src/runtime/server/runtime.tsx +++ b/packages/app/src/runtime/server/runtime.tsx @@ -6,7 +6,7 @@ import { pathKey } from "@/workspaces/path-key" import { useServerHealth } from "@/runtime/server/health" import { createServerSdkContext } from "./client" import { createServerSyncContext } from "./sync" -import { createData } from "@opencode-ai/client/solid" +import { createAppData } from "./catalog-events" import type { ServerScope } from "@/runtime/server/scope" import { createPermissionAutoApprover } from "@/session/requests/auto-approve" import { createServerNotificationState } from "@/shell/notifications/notification" @@ -133,7 +133,7 @@ function createServerController( const language = useLanguage() const connKey = ServerConnection.key(conn) const sdk = createServerSdkContext(conn, scope) - const source = createData({ + const source = createAppData({ api: () => sdk.api, event: { on: sdk.event.on, diff --git a/packages/app/src/runtime/server/sync.tsx b/packages/app/src/runtime/server/sync.tsx index 375aab7dde..a752ae473a 100644 --- a/packages/app/src/runtime/server/sync.tsx +++ b/packages/app/src/runtime/server/sync.tsx @@ -20,6 +20,8 @@ import { toggleMcp } from "./global-sync/mcp" import { createConnectionSync } from "./server-sync/connection" import { usePlatform } from "@/runtime/platform/platform" import type { Data } from "@opencode-ai/client/solid" +import { createWorktreeInventory, withWorktreeInventory, worktreeInventoryKey } from "@/workspaces/inventory" +import { sameDirectory } from "@/workspaces/paths" type GlobalStore = { path: Path @@ -79,6 +81,17 @@ export function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) { }) const queryClient = useQueryClient() + const worktrees = createWorktreeInventory({ + scope: serverSDK.scope, + queryClient, + api: () => serverSDK.api.worktree, + updated: (directory, items) => + setGlobalStore("project", (projects) => + projects.map((project) => + sameDirectory(project.worktree, directory) ? withWorktreeInventory(project, items) : project, + ), + ), + }) const bootstrap = useQuery(() => ({ queryKey: [serverSDK.scope, "bootstrap"], queryFn: async () => { @@ -197,17 +210,29 @@ export function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) { function applyProjectUpdate(update: Parameters[1]) { setGlobalStore("project", (projects) => - projects.map((project) => (project.id === update.id ? updateProjectInfo(project, update) : project)), + projects.map((project) => + project.id === update.id + ? withWorktreeInventory( + updateProjectInfo(project, update), + queryClient.getQueryData(worktreeInventoryKey(serverSDK.scope, update.canonical)), + ) + : project, + ), ) } const unsub = serverSDK.event.listen((event) => { connection.handleEvent({ type: event.type }) if (event.type === "project.updated") applyProjectUpdate(event.data) + if (event.type === "worktree.updated") { + const project = globalStore.project.find((project) => project.id === event.data.projectID) + const directory = project?.worktree ?? data.project.get(event.data.projectID)?.canonical + if (directory) void worktrees.invalidate(directory) + return + } if (!event.location) { - if (event.type === "config.updated" || event.type === "agent.updated" || event.type === "worktree.updated") - bootstrap.refetch() + if (event.type === "config.updated" || event.type === "agent.updated") bootstrap.refetch() return } @@ -216,7 +241,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) { if (!children.children[key]) return children.mark(key) if (event.type === "config.updated" || event.type === "agent.updated") queue.push(key) - if (event.type === "worktree.updated") void bootstrap.refetch() }) onCleanup(unsub) @@ -261,6 +285,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) { // bootstrap, updateConfig: updateConfigMutation.mutateAsync, project: projectApi, + worktrees, mcp: { toggle: async (directory: string, name: string) => { const key = directoryKey(directory) diff --git a/packages/app/src/settings/workspaces/project-extensions.tsx b/packages/app/src/settings/workspaces/project-extensions.tsx index 90018bdab4..cae11bb900 100644 --- a/packages/app/src/settings/workspaces/project-extensions.tsx +++ b/packages/app/src/settings/workspaces/project-extensions.tsx @@ -1,7 +1,17 @@ import { Icon } from "@opencode-ai/ui/icon" import { Switch } from "@opencode-ai/ui/switch" import { Tabs } from "@opencode-ai/ui/tabs" -import { type Component, For, Show, createEffect, createMemo, createResource, createSignal, type JSX } from "solid-js" +import { + type Component, + For, + Show, + createEffect, + createMemo, + createResource, + createSignal, + onCleanup, + type JSX, +} from "solid-js" import { useLanguage } from "@/runtime/i18n/language" import { useMcpToggle } from "@/providers/connect/mcp" import { useWorkspaceLocation } from "@/workspaces/location" @@ -69,12 +79,17 @@ export const ProjectSettingsExtensions: Component = () => { const data = useData() const toggleMcp = useMcpToggle(() => directorySDK().directory) + createEffect(() => { + if (serverSDK.connection.status() !== "connected") return + // This view displays shared MCP servers as well as the project Location's catalog. + onCleanup(data.location.retain(data.location.default())) + }) + createEffect(() => { if (serverSDK.connection.status() !== "connected") return const ref = { directory: directorySDK().directory } void Promise.all([ - data.location.mcp.server.sync(), - data.location.skill.sync(), + data.location.syncInfo().then(() => Promise.all([data.location.mcp.server.sync(), data.location.skill.sync()])), data.location.mcp.server.sync(ref), data.location.skill.sync(ref), ]).catch(() => undefined) diff --git a/packages/app/src/settings/workspaces/workspaces.tsx b/packages/app/src/settings/workspaces/workspaces.tsx index db372816d3..5869758d18 100644 --- a/packages/app/src/settings/workspaces/workspaces.tsx +++ b/packages/app/src/settings/workspaces/workspaces.tsx @@ -2,7 +2,7 @@ import type { Component } from "solid-js" import { For, Show, createMemo } from "solid-js" import { createStore } from "solid-js/store" import type { SessionInfo } from "@opencode-ai/client/promise" -import { useQuery } from "@tanstack/solid-query" +import { useQueries, useQuery } from "@tanstack/solid-query" import { Button } from "@opencode-ai/ui/button" import { Dialog, DialogFooter, DialogHeader, DialogTitleGroup } from "@opencode-ai/ui/dialog" import { Icon } from "@opencode-ai/ui/icon" @@ -13,7 +13,7 @@ import { useDialog } from "@opencode-ai/ui/context/dialog" import { getFilename } from "@opencode-ai/util/path" import { useLanguage } from "@/runtime/i18n/language" import { useServerSDK } from "@/runtime/server/client" -import { useData } from "@/runtime/server/current" +import { useData, useServer } from "@/runtime/server/current" import { showToast } from "@/shell/notifications/toast" import { getRelativeTime } from "@/shell/time" import { sessionLabel } from "@/session/title" @@ -29,7 +29,6 @@ import { containsDirectory, filterWorkspaceInventory, inspectWorkspaceDeletion, - managedWorkspaceDirectories, mergeWorkspaceSessionInventory, removeWorkspacesSequentially, sessionsForWorkspace, @@ -38,7 +37,8 @@ import { } from "@/workspaces/paths" import { listAllSessions } from "@/session/list" import type { ServerScope } from "@/runtime/server/scope" -import { normalizeProjectInfo } from "@/runtime/server/global-sync/utils" +import { loadProjectsQuery } from "@/runtime/server/global-sync/bootstrap" +import { withWorktreeInventory, worktreeInventoryKey } from "@/workspaces/inventory" import "@/settings/settings.css" type Workspace = { @@ -50,6 +50,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop const dialog = useDialog() const language = useLanguage() const serverSDK = useServerSDK() + const server = useServer() const data = useData() const tabs = useTabs() const platform = usePlatform() @@ -59,22 +60,15 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop }) const projectQuery = useQuery(() => ({ - queryKey: [serverSDK.scope, "settings-workspace-projects"] as const, + ...loadProjectsQuery(serverSDK.scope, serverSDK.api.project), enabled: serverSDK.connection.status() === "connected", - queryFn: async () => - Promise.all( - (await serverSDK.api.project.list()).map(async (project) => { - const worktrees = await serverSDK.api.worktree - .list({ location: { directory: project.canonical } }) - .catch(() => [{ directory: project.canonical }, ...project.sandboxes.map((directory) => ({ directory }))]) - return normalizeProjectInfo({ ...project, worktrees }) - }), - ), refetchOnMount: "always", })) - const inventory = createMemo(() => (projectQuery.isPending ? [] : (projectQuery.data ?? []))) - const workspaces = createMemo(() => workspaceInventory(inventory())) - const projects = createMemo(() => inventory().filter((project) => managedWorkspaceDirectories(project).length > 0)) + const projects = createMemo(() => [ + ...new Map( + (projectQuery.data ?? []).map((project) => [worktreeInventoryKey(serverSDK.scope, project.worktree)[2], project]), + ).values(), + ]) const projectName = (project: Project) => project.name || getFilename(project.worktree) const projectOptions = createMemo(() => [ { id: "all", label: language.t("settings.workspaces.filter.all") }, @@ -83,12 +77,28 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop const selectedProject = createMemo(() => store.project === "all" || projects().some((project) => project.id === store.project) ? store.project : "all", ) + const requested = createMemo(() => + projects().filter((project) => selectedProject() === "all" || project.id === selectedProject()), + ) + const inventoryQueries = useQueries(() => ({ + queries: requested().map((project) => ({ + ...server.ctx.sync.worktrees.query(project.worktree), + enabled: serverSDK.connection.status() === "connected", + })), + })) + const inventory = createMemo(() => + requested().map((project, index) => withWorktreeInventory(project, inventoryQueries[index]?.data)), + ) + const loading = () => projectQuery.isPending || inventoryQueries.some((query) => query.isPending) + const failed = () => projectQuery.isError || inventoryQueries.some((query) => query.isError) + const workspaces = createMemo(() => workspaceInventory(inventory())) const filtered = createMemo(() => filterWorkspaceInventory(workspaces(), selectedProject())) const captureDeleteContext = () => { const sdk = serverSDK return { sdk, data, + worktrees: server.ctx.sync.worktrees, server: ServerConnection.key(sdk.server), activeDirectory: props.activeDirectory, } @@ -110,7 +120,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop workspaceDirectories().map((directory) => String(pathKey(directory))), ] as const, queryFn: () => loadSessions(workspaceDirectories()), - enabled: serverSDK.connection.status() === "connected" && workspaceDirectories().length > 0, + enabled: serverSDK.connection.status() === "connected" && !loading() && workspaceDirectories().length > 0, refetchOnMount: "always", })) const sessionsByWorkspace = createMemo(() => { @@ -205,7 +215,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop }) }) clearWorkspaceTerminals(workspace.directory, platform, context.sdk.scope) - await projectQuery.refetch() + await context.worktrees.invalidate(workspace.project.worktree) } let inspectionID = 0 @@ -279,7 +289,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
- + {language.plural("settings.workspaces.count", filtered().length)} @@ -316,7 +326,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop variant="ghost-muted" size="small" aria-label={language.t("common.moreOptions")} - disabled={!!store.transaction} + disabled={!!store.transaction || loading() || failed()} icon={} /> @@ -332,16 +342,17 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
+ 0 && (loading() || failed())}> +
+ {language.t(failed() ? "common.requestFailed" : "common.loading")} +
+
0} fallback={
{language.t( - projectQuery.isPending - ? "common.loading" - : projectQuery.isError - ? "common.requestFailed" - : "settings.workspaces.empty", + loading() ? "common.loading" : failed() ? "common.requestFailed" : "settings.workspaces.empty", )}
} diff --git a/packages/app/src/workspaces/inventory.test.ts b/packages/app/src/workspaces/inventory.test.ts new file mode 100644 index 0000000000..1b6142efa6 --- /dev/null +++ b/packages/app/src/workspaces/inventory.test.ts @@ -0,0 +1,214 @@ +import { expect, test } from "bun:test" +import { QueryClient, QueryObserver } from "@tanstack/solid-query" +import { createWorktreeInventory, withWorktreeInventory } from "./inventory" +import { ServerScope } from "@/runtime/server/scope" +import { normalizeProjectInfo, updateProjectInfo } from "@/runtime/server/global-sync/utils" + +function pending() { + let resolve!: () => void + const promise = new Promise((done) => (resolve = done)) + return { promise, resolve } +} + +test("picker demand loads once, shares in-flight work, and reuses cache", async () => { + const client = new QueryClient() + const calls: string[] = [] + const gate = pending() + const inventory = createWorktreeInventory({ + scope: ServerScope.local, + queryClient: client, + api: () => ({ + list: async (input) => { + const directory = input!.location!.directory! + calls.push(directory) + await gate.promise + return [{ directory }, { directory: `${directory}/existing`, strategy: "git" }] + }, + }), + }) + const closed = new QueryObserver(client, { ...inventory.query("/repo"), enabled: false }) + const unsubscribe = closed.subscribe(() => {}) + expect(calls).toEqual([]) + closed.setOptions({ ...inventory.query("/repo"), enabled: true }) + expect(closed.getCurrentResult().isFetching).toBe(true) + const duplicate = client.fetchQuery(inventory.query("/repo/")) + expect(calls).toEqual(["/repo"]) + gate.resolve() + expect(await duplicate).toHaveLength(2) + await client.fetchQuery(inventory.query("/repo")) + expect(calls).toEqual(["/repo"]) + unsubscribe() + client.clear() +}) + +test("invalidation is targeted and does not fetch inactive inventories", async () => { + const client = new QueryClient() + const calls: string[] = [] + const inventory = createWorktreeInventory({ + scope: ServerScope.local, + queryClient: client, + api: () => ({ + list: async (input) => { + const directory = input!.location!.directory! + calls.push(directory) + return [{ directory }] + }, + }), + }) + await client.fetchQuery(inventory.query("/a")) + await client.fetchQuery(inventory.query("/b")) + await inventory.invalidate("/a") + expect(calls).toEqual(["/a", "/b"]) + await client.fetchQuery(inventory.query("/b")) + await client.fetchQuery(inventory.query("/a")) + expect(calls).toEqual(["/a", "/b", "/a"]) + client.clear() +}) + +test("explicit multi-project inventory has at most four active lists and cancels queued offscreen demand", async () => { + const client = new QueryClient() + const calls: string[] = [] + const gate = pending() + const inventory = createWorktreeInventory({ + scope: ServerScope.local, + queryClient: client, + api: () => ({ + list: async (input) => { + const directory = input!.location!.directory! + calls.push(directory) + await gate.promise + return [{ directory }] + }, + }), + }) + const queries = Array.from({ length: 20 }, (_, index) => + client.fetchQuery(inventory.query(`/repo/${index}`)).catch(() => undefined), + ) + await Promise.resolve() + expect(calls).toHaveLength(4) + await client.cancelQueries() + gate.resolve() + await Promise.all(queries) + await Promise.resolve() + expect(calls).toHaveLength(4) + client.clear() +}) + +test("switching the selected project exposes its own pending/error state, not previous choices", async () => { + const client = new QueryClient() + const gate = pending() + const inventory = createWorktreeInventory({ + scope: ServerScope.local, + queryClient: client, + api: () => ({ + list: async (input) => { + const directory = input!.location!.directory! + if (directory === "/b") { + await gate.promise + throw new Error("Unavailable") + } + return [{ directory }, { directory: "/a/existing" }] + }, + }), + }) + await client.fetchQuery(inventory.query("/a")) + const observer = new QueryObserver(client, inventory.query("/a")) + const unsubscribe = observer.subscribe(() => {}) + expect(observer.getCurrentResult().data).toHaveLength(2) + observer.setOptions(inventory.query("/b")) + expect(observer.getCurrentResult().isPending).toBe(true) + expect(observer.getCurrentResult().data).toBeUndefined() + gate.resolve() + await client.fetchQuery(inventory.query("/b")).catch(() => undefined) + expect(observer.getCurrentResult().isError).toBe(true) + expect(observer.getCurrentResult().data).toBeUndefined() + unsubscribe() + client.clear() +}) + +test("visible multi-project demand drains the bounded queue and deduplicates canonical directories", async () => { + const client = new QueryClient() + const calls: string[] = [] + let active = 0 + let peak = 0 + const inventory = createWorktreeInventory({ + scope: ServerScope.local, + queryClient: client, + api: () => ({ + list: async (input) => { + const directory = input!.location!.directory! + calls.push(directory) + active++ + peak = Math.max(peak, active) + await Promise.resolve() + active-- + return [{ directory }] + }, + }), + }) + await Promise.all( + Array.from({ length: 30 }, (_, index) => + client.fetchQuery(inventory.query(`/repo/${index % 20}${index >= 20 ? "/" : ""}`)), + ), + ) + expect(calls).toHaveLength(20) + expect(new Set(calls).size).toBe(20) + expect(peak).toBe(4) + client.clear() +}) + +test("an update during an active list does not cancel it and start another backend refresh", async () => { + const client = new QueryClient() + const gate = pending() + let calls = 0 + const inventory = createWorktreeInventory({ + scope: ServerScope.local, + queryClient: client, + api: () => ({ + list: async () => { + calls++ + await gate.promise + return [{ directory: "/repo" }] + }, + }), + }) + const observer = new QueryObserver(client, inventory.query("/repo")) + const unsubscribe = observer.subscribe(() => {}) + const invalidated = inventory.invalidate("/repo") + expect(calls).toBe(1) + gate.resolve() + await invalidated + expect(calls).toBe(1) + expect(observer.getCurrentResult().data).toEqual([{ directory: "/repo" }]) + unsubscribe() + client.clear() +}) + +test("cached inventory survives metadata updates and is partitioned by server", async () => { + const client = new QueryClient() + const api = () => ({ list: async () => [{ directory: "/repo/feature", strategy: "git" }] }) + const local = createWorktreeInventory({ scope: ServerScope.local, queryClient: client, api }) + const remote = createWorktreeInventory({ + scope: "https://remote.example" as typeof ServerScope.local, + queryClient: client, + api, + }) + const cached = await client.fetchQuery(local.query("/repo")) + expect(client.getQueryData(remote.query("/repo").queryKey)).toBeUndefined() + const metadata = { + id: "project", + canonical: "/repo", + name: "Before", + time: { created: 1, updated: 1 }, + sandboxes: [], + } + const updated = updateProjectInfo(normalizeProjectInfo(metadata), { ...metadata, name: "After" }) + expect(withWorktreeInventory(updated, cached)).toMatchObject({ + name: "After", + sandboxes: ["/repo/feature"], + worktrees: cached, + }) + expect(local.query("C:\\Repo\\").queryKey).toEqual(local.query("C:/Repo").queryKey) + expect(local.query("C:/Repo").queryKey).not.toEqual(local.query("C:/repo").queryKey) + client.clear() +}) diff --git a/packages/app/src/workspaces/inventory.ts b/packages/app/src/workspaces/inventory.ts new file mode 100644 index 0000000000..568c503286 --- /dev/null +++ b/packages/app/src/workspaces/inventory.ts @@ -0,0 +1,86 @@ +import { QueryClient, queryOptions } from "@tanstack/solid-query" +import type { WorktreeDirectory } from "@opencode-ai/client/promise" +import type { ServerApi } from "@/runtime/server/api" +import type { ServerScope } from "@/runtime/server/scope" +import type { Project } from "@/runtime/server/types" +import { pathKey } from "./path-key" +import { sameDirectory } from "./paths" + +export function worktreeInventoryKey(scope: ServerScope, directory: string) { + return [scope, "worktree", pathKey(directory)] as const +} + +export function withWorktreeInventory(project: Project, worktrees: readonly WorktreeDirectory[] | undefined): Project { + if (!worktrees) return project + return { + ...project, + worktrees: [...worktrees], + sandboxes: worktrees + .map((item) => item.directory) + .filter((directory) => !sameDirectory(project.worktree, directory)), + } +} + +// Owned by one server context. Only picker/settings observers demand these queries; +// metadata bootstrap never enumerates directories. QueryClient owns cache and deduplication. +export function createWorktreeInventory(input: { + scope: ServerScope + queryClient: QueryClient + api: () => Pick + updated?: (directory: string, worktrees: readonly WorktreeDirectory[]) => void +}) { + let active = 0 + const waiting: Array<() => void> = [] + const query = (directory: string) => + queryOptions({ + queryKey: worktreeInventoryKey(input.scope, directory), + staleTime: 30_000, + retry: false, + refetchOnWindowFocus: false, + queryFn: ({ signal }) => + new Promise((resolve, reject) => { + const cancel = () => { + const index = waiting.indexOf(run) + if (index >= 0) waiting.splice(index, 1) + reject(signal.reason) + } + const run = () => { + signal.removeEventListener("abort", cancel) + if (signal.aborted) { + reject(signal.reason) + return + } + active++ + // list already refreshes the server inventory; do not call refresh first. + void input + .api() + .list({ location: { directory } }, { signal }) + .then((items) => { + signal.throwIfAborted() + input.updated?.(directory, items) + resolve(items) + }) + .catch(reject) + .finally(() => { + active-- + waiting.shift()?.() + }) + } + if (active < 4) return run() + waiting.push(run) + signal.addEventListener("abort", cancel, { once: true }) + }), + }) + return { + query, + invalidate: (directory: string) => + input.queryClient.invalidateQueries( + { + queryKey: worktreeInventoryKey(input.scope, directory), + exact: true, + refetchType: "active", + }, + { cancelRefetch: false }, + ), + } +} diff --git a/packages/app/src/workspaces/location.tsx b/packages/app/src/workspaces/location.tsx index 2bd83bc3e2..72f9abe310 100644 --- a/packages/app/src/workspaces/location.tsx +++ b/packages/app/src/workspaces/location.tsx @@ -28,6 +28,14 @@ const context = createSimpleContext({ ) const current = createMemo(() => data.location.info(ref())) + createEffect(() => { + onCleanup(data.location.retain(ref())) + }) + createEffect(() => { + const resolved = current() + if (resolved) onCleanup(data.location.retain(resolved)) + }) + createEffect(() => { const location = ref() let stale = false