mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-16 21:15:57 +03:00
refactor(app): replace dead directory bootstrap with a directory cache machine (#61753)
This commit is contained in:
committed by
GitHub
Unverified
parent
0cb3d68f6e
commit
8a8a9d4af3
@@ -1,6 +1,6 @@
|
||||
import { describe, expect, test } from "bun:test"
|
||||
import { QueryClient } from "@tanstack/solid-query"
|
||||
import { OpenCode } from "@opencode/client/promise"
|
||||
import { OpenCode, type LocationGetInput } from "@opencode/client/promise"
|
||||
import { createStore } from "solid-js/store"
|
||||
import { bootstrapGlobal, inferHomeDirectory, loadPathQuery, loadProjectsQuery } from "./bootstrap"
|
||||
import { ServerScope } from "@/runtime/server/scope"
|
||||
@@ -35,7 +35,6 @@ test("bootstraps projects through the native store setter and preserves subseque
|
||||
project: [],
|
||||
provider_auth: {},
|
||||
config: {},
|
||||
reload: undefined,
|
||||
})
|
||||
|
||||
const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
|
||||
@@ -114,14 +113,16 @@ describe("query keys", () => {
|
||||
test("partitions identical directories by server scope and loads current location metadata", async () => {
|
||||
const calls: unknown[] = []
|
||||
|
||||
// SAFETY: the path query reads only `directory` and `project.directory` from the location it gets.
|
||||
const location = {
|
||||
get: async (input: unknown) => {
|
||||
get: async (input?: LocationGetInput) => {
|
||||
calls.push(input)
|
||||
|
||||
return { directory: "/repo/subpath", project: { id: "project", directory: "/repo" } }
|
||||
},
|
||||
} as ServerApi["location"]
|
||||
|
||||
// SAFETY: a remote server's scope is its origin string, which is how the app scopes it.
|
||||
const remote = "https://debian.example" as typeof ServerScope.local
|
||||
|
||||
expect([...loadPathQuery(ServerScope.local, "/repo", location).queryKey]).toEqual(["local", "/repo", "path"])
|
||||
|
||||
@@ -1,54 +1,13 @@
|
||||
import type { Config, Path, Project, ProviderAuthResponse } from "@/runtime/server/types"
|
||||
import type { Config, Path } from "@/runtime/server/types"
|
||||
import type { LocationGetInput, LocationGetOutput, ProjectListOutput } from "@opencode/client/promise"
|
||||
import { showToast } from "@/shell/notifications/toast"
|
||||
import { getFilename } from "@opencode/util/path"
|
||||
import { retry } from "@opencode/util/retry"
|
||||
import { reconcile, type SetStoreFunction, type Store } from "solid-js/store"
|
||||
import type { State } from "./types"
|
||||
import type { SetStoreFunction } from "solid-js/store"
|
||||
import type { GlobalStore } from "./types"
|
||||
import { normalizeProjectInfo } from "./utils"
|
||||
import { formatServerError } from "@/runtime/server/errors"
|
||||
import { QueryClient, queryOptions } from "@tanstack/solid-query"
|
||||
import type { ServerScope } from "@/runtime/server/scope"
|
||||
import { withWorktreeInventory, worktreeInventoryKey } from "@/workspaces/inventory"
|
||||
|
||||
type GlobalStore = {
|
||||
path: Path
|
||||
project: Project[]
|
||||
provider_auth: ProviderAuthResponse
|
||||
config: Config
|
||||
reload: undefined | "pending" | "complete"
|
||||
}
|
||||
|
||||
function waitForPaint() {
|
||||
return new Promise<void>((resolve) => {
|
||||
let done = false
|
||||
|
||||
const finish = () => {
|
||||
if (done) return
|
||||
done = true
|
||||
resolve()
|
||||
}
|
||||
|
||||
const timer = setTimeout(finish, 50)
|
||||
|
||||
if (typeof requestAnimationFrame !== "function") return
|
||||
requestAnimationFrame(() => {
|
||||
setTimeout(() => {
|
||||
clearTimeout(timer)
|
||||
finish()
|
||||
}, 0)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
function errors(list: PromiseSettledResult<unknown>[]) {
|
||||
return list.filter((item): item is PromiseRejectedResult => item.status === "rejected").map((item) => item.reason)
|
||||
}
|
||||
|
||||
function runAll(list: Array<() => Promise<unknown>>) {
|
||||
return Promise.allSettled(list.map((item) => item()))
|
||||
}
|
||||
|
||||
export const loadGlobalConfigQuery = (scope: ServerScope) =>
|
||||
queryOptions({
|
||||
queryKey: [scope, "config"],
|
||||
@@ -100,26 +59,18 @@ export async function bootstrapGlobal(input: {
|
||||
setGlobalStore: SetStoreFunction<GlobalStore>
|
||||
queryClient: QueryClient
|
||||
}) {
|
||||
const slow = [
|
||||
() => input.queryClient.fetchQuery(loadGlobalConfigQuery(input.scope)),
|
||||
() =>
|
||||
input.queryClient
|
||||
.fetchQuery(loadPathQuery(input.scope, null, input.serverAPI.location))
|
||||
.then((data) => input.setGlobalStore("path", data)),
|
||||
() =>
|
||||
loadProjects({
|
||||
scope: input.scope,
|
||||
project: input.serverAPI.project,
|
||||
setGlobalStore: input.setGlobalStore,
|
||||
queryClient: input.queryClient,
|
||||
}),
|
||||
]
|
||||
|
||||
await runAll(slow)
|
||||
}
|
||||
|
||||
function projectID(directory: string, projects: Project[]) {
|
||||
return projects.find((project) => project.worktree === directory || project.sandboxes?.includes(directory))?.id
|
||||
await Promise.allSettled([
|
||||
input.queryClient.fetchQuery(loadGlobalConfigQuery(input.scope)),
|
||||
input.queryClient
|
||||
.fetchQuery(loadPathQuery(input.scope, null, input.serverAPI.location))
|
||||
.then((data) => input.setGlobalStore("path", data)),
|
||||
loadProjects({
|
||||
scope: input.scope,
|
||||
project: input.serverAPI.project,
|
||||
setGlobalStore: input.setGlobalStore,
|
||||
queryClient: input.queryClient,
|
||||
}),
|
||||
])
|
||||
}
|
||||
|
||||
export function inferHomeDirectory(path: string) {
|
||||
@@ -143,57 +94,3 @@ export const loadPathQuery = (scope: ServerScope, directory: string | null, api:
|
||||
home: inferHomeDirectory(location.directory) || inferHomeDirectory(location.project.directory),
|
||||
})),
|
||||
})
|
||||
|
||||
export async function bootstrapDirectory(input: {
|
||||
directory: string
|
||||
scope: ServerScope
|
||||
mcp: boolean
|
||||
api: {
|
||||
readonly project: ProjectApi
|
||||
readonly location: LocationApi
|
||||
}
|
||||
store: Store<State>
|
||||
setStore: SetStoreFunction<State>
|
||||
translate: (key: string, vars?: Record<string, string | number>) => string
|
||||
global: {
|
||||
config: Config
|
||||
path: Path
|
||||
project: Project[]
|
||||
}
|
||||
queryClient: QueryClient
|
||||
}) {
|
||||
const loading = input.store.status !== "complete"
|
||||
const seededProject = projectID(input.directory, input.global.project)
|
||||
|
||||
if (seededProject) input.setStore("project", seededProject)
|
||||
|
||||
if (Object.keys(input.store.config).length === 0 && Object.keys(input.global.config).length > 0) {
|
||||
input.setStore("config", reconcile(input.global.config, { merge: false }))
|
||||
}
|
||||
|
||||
if (loading) input.setStore("status", "partial")
|
||||
|
||||
const slow = [
|
||||
seededProject
|
||||
? undefined
|
||||
: () =>
|
||||
retry(() => input.api.location.get({ location: { directory: input.directory } })).then((location) =>
|
||||
input.setStore("project", location.project.id),
|
||||
),
|
||||
].filter((task): task is () => Promise<void> => !!task)
|
||||
|
||||
await waitForPaint()
|
||||
const slowErrs = errors(await runAll(slow))
|
||||
|
||||
if (slowErrs.length > 0) {
|
||||
console.error("Failed to finish bootstrap instance", slowErrs[0])
|
||||
const project = getFilename(input.directory)
|
||||
showToast({
|
||||
variant: "error",
|
||||
title: input.translate("toast.project.reloadFailed.title", { project }),
|
||||
description: formatServerError(slowErrs[0], input.translate),
|
||||
})
|
||||
}
|
||||
|
||||
if (loading && slowErrs.length === 0) input.setStore("status", "complete")
|
||||
}
|
||||
|
||||
@@ -1,16 +1,11 @@
|
||||
import { beforeAll, describe, expect, mock, test } from "bun:test"
|
||||
import { describe, expect, test } from "bun:test"
|
||||
import { createRoot, getOwner } from "solid-js"
|
||||
import { createStore } from "solid-js/store"
|
||||
import type { State } from "./types"
|
||||
import type { QueryOptionsApi } from "../sync"
|
||||
import { createChildStoreManager } from "./child-store"
|
||||
import { ServerScope } from "@/runtime/server/scope"
|
||||
import type { Data } from "@opencode/client/solid"
|
||||
import type { persisted } from "@/runtime/persistence/storage"
|
||||
|
||||
let createChildStoreManager: typeof import("./child-store").createChildStoreManager
|
||||
|
||||
const querySingles: Array<() => { queryKey?: unknown[]; enabled?: boolean }> = []
|
||||
|
||||
const persist: typeof persisted = (_target, _schema, initial) => [
|
||||
...createStore(initial),
|
||||
null,
|
||||
@@ -19,203 +14,34 @@ const persist: typeof persisted = (_target, _schema, initial) => [
|
||||
|
||||
const path = { state: "", config: "", worktree: "", directory: "", home: "" }
|
||||
|
||||
const data = {
|
||||
location: {
|
||||
info: () => undefined,
|
||||
agent: { list: () => undefined },
|
||||
command: { list: () => undefined },
|
||||
reference: { list: () => undefined },
|
||||
provider: { list: () => undefined },
|
||||
model: { list: () => undefined, default: () => undefined },
|
||||
mcp: {
|
||||
server: { list: () => undefined },
|
||||
resource: { list: () => undefined },
|
||||
},
|
||||
vcs: { info: () => undefined },
|
||||
},
|
||||
} as unknown as Data
|
||||
|
||||
const queryOptionsApi = {
|
||||
globalConfig: () => ({ queryKey: ["globalConfig"], queryFn: async () => ({}) }),
|
||||
projects: () => ({ queryKey: ["projects"], queryFn: async () => [] }),
|
||||
path: (directory: string | null) => ({
|
||||
queryKey: [directory, "path"],
|
||||
queryFn: async () => ({
|
||||
state: "",
|
||||
config: "",
|
||||
worktree: "",
|
||||
directory: directory ?? "",
|
||||
home: "",
|
||||
}),
|
||||
}),
|
||||
agents: (directory: string) => ({ queryKey: [directory, "agents"], queryFn: async () => [] }),
|
||||
mcp: (directory: string) => ({ queryKey: [directory, "mcp"], queryFn: async () => ({}) }),
|
||||
mcpResources: (directory: string) => ({ queryKey: [directory, "mcpResources"], queryFn: async () => ({}) }),
|
||||
lsp: (directory: string) => ({ queryKey: [directory, "lsp"], queryFn: async () => [] }),
|
||||
references: (directory: string) => ({ queryKey: [directory, "references"], queryFn: async () => [] }),
|
||||
sessions: (directory: string) => ({ queryKey: [directory, "loadSessions"] as const }),
|
||||
} as unknown as QueryOptionsApi
|
||||
|
||||
function setup(input: { connected?: () => boolean } = {}) {
|
||||
const bootstraps: string[] = []
|
||||
const mcpLoads: string[] = []
|
||||
const offset = querySingles.length
|
||||
|
||||
return createRoot((dispose) => {
|
||||
const owner = getOwner()
|
||||
|
||||
if (!owner) throw new Error("owner required")
|
||||
|
||||
const manager = createChildStoreManager({
|
||||
owner,
|
||||
connected: input.connected ?? (() => true),
|
||||
scope: ServerScope.local,
|
||||
persist,
|
||||
isBooting: () => false,
|
||||
isLoadingSessions: () => false,
|
||||
onBootstrap: (directory) => bootstraps.push(directory),
|
||||
onMcp: (directory) => mcpLoads.push(directory),
|
||||
onDispose() {},
|
||||
translate: (key) => key,
|
||||
queryOptions: queryOptionsApi,
|
||||
data,
|
||||
global: { path },
|
||||
})
|
||||
|
||||
return { manager, bootstraps, mcpLoads, queries: () => querySingles.slice(offset), dispose }
|
||||
})
|
||||
}
|
||||
|
||||
beforeAll(async () => {
|
||||
mock.module("@tanstack/solid-query", () => ({
|
||||
useQuery: (options: () => { queryKey?: unknown[]; enabled?: boolean }) => {
|
||||
querySingles.push(options)
|
||||
|
||||
return {
|
||||
get isLoading() {
|
||||
return options().queryKey?.[1] === "path"
|
||||
},
|
||||
get isSuccess() {
|
||||
return false
|
||||
},
|
||||
get isRefetchError() {
|
||||
return false
|
||||
},
|
||||
get data() {
|
||||
if (options().queryKey?.[1] === "path") throw new Error("pending path data read")
|
||||
|
||||
if (options().queryKey?.[1] === "mcp") return options().enabled ? { demo: { status: "disabled" } } : undefined
|
||||
|
||||
if (options().queryKey?.[1] === "lsp") return []
|
||||
|
||||
return undefined
|
||||
},
|
||||
}
|
||||
},
|
||||
}))
|
||||
|
||||
createChildStoreManager = (await import("./child-store")).createChildStoreManager
|
||||
})
|
||||
// SAFETY: the child store reads only this location info, and only from its getters.
|
||||
// oxlint-disable-next-line anti-slop/no-chained-type-assertions -- see SAFETY above
|
||||
const data = { location: { info: () => undefined } } as unknown as Data
|
||||
|
||||
describe("createChildStoreManager", () => {
|
||||
test("does not evict the active directory during mark", () => {
|
||||
const { manager, dispose } = setup()
|
||||
test("provides the requested directory while its location is loading", () => {
|
||||
createRoot((dispose) => {
|
||||
const owner = getOwner()
|
||||
|
||||
try {
|
||||
Array.from({ length: 30 }, (_, index) => `/pinned-${index}`).forEach((directory) => {
|
||||
manager.children[directory] = createStore({} as State)
|
||||
manager.pin(directory)
|
||||
if (!owner) throw new Error("owner required")
|
||||
|
||||
const manager = createChildStoreManager({
|
||||
owner,
|
||||
scope: ServerScope.local,
|
||||
persist,
|
||||
translate: (key) => key,
|
||||
data,
|
||||
global: { path },
|
||||
})
|
||||
|
||||
manager.children["/active"] = createStore({} as State)
|
||||
manager.mark("/active")
|
||||
try {
|
||||
const [store] = manager.child("/project")
|
||||
|
||||
expect(manager.children["/active"]).toBeDefined()
|
||||
} finally {
|
||||
dispose()
|
||||
}
|
||||
})
|
||||
|
||||
test("starts new child stores as loading and bootstraps them on first access", () => {
|
||||
const { manager, bootstraps, dispose } = setup()
|
||||
|
||||
try {
|
||||
const [store] = manager.child("/project")
|
||||
|
||||
expect(store.status).toBe("loading")
|
||||
expect(bootstraps).toEqual(["/project"])
|
||||
} finally {
|
||||
dispose()
|
||||
}
|
||||
})
|
||||
|
||||
test("provides the requested directory while the path query is pending", () => {
|
||||
const { manager, dispose } = setup()
|
||||
|
||||
try {
|
||||
const [store] = manager.child("/project", { bootstrap: false })
|
||||
|
||||
expect(store.path.directory).toBe("/project")
|
||||
expect(store.path.worktree).toBe("")
|
||||
} finally {
|
||||
dispose()
|
||||
}
|
||||
})
|
||||
|
||||
test("syncs MCP only when requested for the directory", () => {
|
||||
const { manager, mcpLoads, queries, dispose } = setup()
|
||||
|
||||
try {
|
||||
const [, setStore] = manager.child("/project", { bootstrap: false })
|
||||
expect(queries()).toHaveLength(1)
|
||||
|
||||
setStore("status", "complete")
|
||||
manager.child("/project", { bootstrap: false, mcp: true })
|
||||
expect(mcpLoads).toEqual(["/project"])
|
||||
|
||||
manager.disableMcp("/project")
|
||||
expect(manager.mcp("/project")).toBe(false)
|
||||
} finally {
|
||||
dispose()
|
||||
}
|
||||
})
|
||||
|
||||
test("keeps non-bootstrapping children passive until a real directory access", () => {
|
||||
const { manager, bootstraps, queries, dispose } = setup()
|
||||
|
||||
try {
|
||||
const [store] = manager.child("/project", { bootstrap: false })
|
||||
|
||||
expect(queries()).toHaveLength(1)
|
||||
expect(queries()[0]?.().enabled).toBe(false)
|
||||
expect(store.path.directory).toBe("/project")
|
||||
expect(store.provider_ready).toBe(false)
|
||||
expect(store.lsp_ready).toBe(false)
|
||||
expect(bootstraps).toEqual([])
|
||||
|
||||
manager.child("/project")
|
||||
expect(queries()[0]?.().enabled).toBe(true)
|
||||
expect(bootstraps).toEqual(["/project"])
|
||||
|
||||
manager.child("/project", { bootstrap: false })
|
||||
expect(queries()[0]?.().enabled).toBe(true)
|
||||
} finally {
|
||||
dispose()
|
||||
}
|
||||
})
|
||||
|
||||
test("does not enable location queries before the event handshake", () => {
|
||||
const connection = { connected: false }
|
||||
const { manager, queries, dispose } = setup({ connected: () => connection.connected })
|
||||
|
||||
try {
|
||||
manager.child("/handshake")
|
||||
expect(queries()[0]?.().enabled).toBe(false)
|
||||
|
||||
connection.connected = true
|
||||
expect(queries()[0]?.().enabled).toBe(true)
|
||||
} finally {
|
||||
dispose()
|
||||
}
|
||||
expect(store.path.directory).toBe("/project")
|
||||
expect(store.path.worktree).toBe("")
|
||||
} finally {
|
||||
dispose()
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
@@ -1,357 +1,190 @@
|
||||
import { createRoot, createSignal, getOwner, onCleanup, runWithOwner, type Accessor, type Owner } from "solid-js"
|
||||
import { getOwner, onCleanup, runWithOwner, type Owner } from "solid-js"
|
||||
import { createStore, type SetStoreFunction, type Store } from "solid-js/store"
|
||||
import { Persist, persisted } from "@/runtime/persistence/storage"
|
||||
import type { Path } from "@/runtime/server/types"
|
||||
import {
|
||||
DIR_IDLE_TTL_MS,
|
||||
MAX_DIR_STORES,
|
||||
type ChildOptions,
|
||||
type DirState,
|
||||
type MetaCache,
|
||||
type ProjectMeta,
|
||||
type State,
|
||||
} from "./types"
|
||||
import { canDisposeDirectory, pickDirectoriesToEvict } from "./eviction"
|
||||
import { useQuery } from "@tanstack/solid-query"
|
||||
import { QueryOptionsApi } from "../sync"
|
||||
import type { ProjectMeta, State } from "./types"
|
||||
import { createDirectoryCacheState, transitionDirectoryCache, type DirectoryCacheEvent } from "./machine"
|
||||
import { directoryKey, type DirectoryKey } from "./utils"
|
||||
import type { ServerScope } from "@/runtime/server/scope"
|
||||
import type { Data } from "@opencode/client/solid"
|
||||
import { normalizeAgentList, normalizeProviderList } from "./utils"
|
||||
import { ProjectState, VcsState } from "../persistence"
|
||||
|
||||
type ChildHandle = {
|
||||
store: [Store<State>, SetStoreFunction<State>]
|
||||
setMeta: SetStoreFunction<typeof ProjectState.Type>
|
||||
}
|
||||
|
||||
export function createChildStoreManager(input: {
|
||||
owner: Owner
|
||||
connected: Accessor<boolean>
|
||||
scope: ServerScope
|
||||
persist: typeof persisted
|
||||
isBooting: (directory: string) => boolean
|
||||
isLoadingSessions: (directory: string) => boolean
|
||||
onBootstrap: (directory: string) => void
|
||||
onMcp: (directory: string, setStore: SetStoreFunction<State>) => void
|
||||
onDispose: (directory: string) => void
|
||||
translate: (key: string, vars?: Record<string, string | number>) => string
|
||||
queryOptions: QueryOptionsApi
|
||||
data: Data
|
||||
global: {
|
||||
path: Path
|
||||
}
|
||||
}) {
|
||||
const children: Record<string, [Store<State>, SetStoreFunction<State>]> = {}
|
||||
const metaCache = new Map<string, MetaCache>()
|
||||
const lifecycle = new Map<string, DirState>()
|
||||
const pins = new Map<string, number>()
|
||||
const ownerPins = new WeakMap<object, Set<string>>()
|
||||
const disposers = new Map<string, () => void>()
|
||||
const mcpDirectories = new Set<string>()
|
||||
const activeDirectories = new Set<string>()
|
||||
const activationToggles = new Map<string, (enabled: boolean) => void>()
|
||||
// Read only by `dispatch`; no reader tracks the cache, so a reactive memo that accesses a directory never re-runs.
|
||||
let cache = createDirectoryCacheState()
|
||||
const handles = new Map<DirectoryKey, ChildHandle>()
|
||||
const ownerPins = new WeakMap<Owner, Set<string>>()
|
||||
|
||||
const markKey = (key: DirectoryKey) => {
|
||||
if (!key) return
|
||||
lifecycle.set(key, { lastAccessAt: Date.now() })
|
||||
runEviction(key)
|
||||
function dispatch(event: DirectoryCacheEvent) {
|
||||
const result = transitionDirectoryCache(cache, event)
|
||||
|
||||
result.effects.forEach((effect) => {
|
||||
if (effect.type === "evict") return handles.delete(effect.key)
|
||||
handles.set(effect.key, createHandle(effect.key, effect.directory))
|
||||
})
|
||||
// Committed after the effects, so a store that failed to build is built again on the next access.
|
||||
cache = result.state
|
||||
}
|
||||
|
||||
const mark = (directory: string) => {
|
||||
const key = directoryKey(directory)
|
||||
markKey(key)
|
||||
}
|
||||
|
||||
const pin = (directory: string) => {
|
||||
function access(directory: string, pin: boolean) {
|
||||
const key = directoryKey(directory)
|
||||
|
||||
if (!key) return
|
||||
pins.set(key, (pins.get(key) ?? 0) + 1)
|
||||
markKey(key)
|
||||
if (!key) console.error("No directory provided")
|
||||
dispatch({ type: "accessed", key, directory, pin, at: Date.now() })
|
||||
const handle = handles.get(key)
|
||||
|
||||
if (!handle) throw new Error(input.translate("error.childStore.storeCreateFailed"))
|
||||
|
||||
return handle
|
||||
}
|
||||
|
||||
const unpin = (directory: string) => {
|
||||
const key = directoryKey(directory)
|
||||
// Pins the directory once per reactive computation, until that computation re-runs or is disposed.
|
||||
function claimForOwner(key: DirectoryKey) {
|
||||
const owner = getOwner()
|
||||
|
||||
if (!key) return
|
||||
const next = (pins.get(key) ?? 0) - 1
|
||||
if (!owner || owner === input.owner) return false
|
||||
const set = ownerPins.get(owner)
|
||||
|
||||
if (next > 0) {
|
||||
pins.set(key, next)
|
||||
if (set?.has(key)) return false
|
||||
|
||||
return
|
||||
}
|
||||
if (set) set.add(key)
|
||||
|
||||
pins.delete(key)
|
||||
runEviction()
|
||||
}
|
||||
|
||||
const pinned = (directory: string) => (pins.get(directoryKey(directory)) ?? 0) > 0
|
||||
|
||||
const pinForOwner = (directory: string) => {
|
||||
const current = getOwner()
|
||||
|
||||
if (!current) return
|
||||
|
||||
if (current === input.owner) return
|
||||
const key = current as object
|
||||
const set = ownerPins.get(key)
|
||||
|
||||
if (set?.has(directory)) return
|
||||
|
||||
if (set) set.add(directory)
|
||||
|
||||
if (!set) ownerPins.set(key, new Set([directory]))
|
||||
pin(directory)
|
||||
if (!set) ownerPins.set(owner, new Set([key]))
|
||||
onCleanup(() => {
|
||||
const set = ownerPins.get(key)
|
||||
const set = ownerPins.get(owner)
|
||||
|
||||
if (set) {
|
||||
set.delete(directory)
|
||||
set.delete(key)
|
||||
|
||||
if (set.size === 0) ownerPins.delete(key)
|
||||
if (set.size === 0) ownerPins.delete(owner)
|
||||
}
|
||||
|
||||
// A re-running memo cleans up before it pins its directories again. Unpinning at once lets
|
||||
// eviction dispose them mid-run, so the memo recreates them, and their hydration re-runs it.
|
||||
queueMicrotask(() => unpin(directory))
|
||||
// A re-running memo cleans up before it pins its directories again. Releasing at once lets
|
||||
// eviction drop them mid-run, so the memo recreates them, and their hydration re-runs it.
|
||||
queueMicrotask(() => dispatch({ type: "released", key, at: Date.now() }))
|
||||
})
|
||||
}
|
||||
|
||||
function disposeDirectory(directory: DirectoryKey) {
|
||||
const key = directory
|
||||
|
||||
if (
|
||||
!canDisposeDirectory({
|
||||
directory: key,
|
||||
hasStore: !!children[key],
|
||||
pinned: pinned(key),
|
||||
booting: input.isBooting(key),
|
||||
loadingSessions: input.isLoadingSessions(key),
|
||||
})
|
||||
) {
|
||||
return false
|
||||
}
|
||||
|
||||
metaCache.delete(key)
|
||||
lifecycle.delete(key)
|
||||
mcpDirectories.delete(key)
|
||||
activeDirectories.delete(key)
|
||||
activationToggles.delete(key)
|
||||
const dispose = disposers.get(key)
|
||||
|
||||
if (dispose) {
|
||||
dispose()
|
||||
disposers.delete(key)
|
||||
}
|
||||
|
||||
delete children[key]
|
||||
input.onDispose(key)
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
function runEviction(skip?: string) {
|
||||
const stores = Object.keys(children)
|
||||
function createHandle(key: DirectoryKey, directory: string): ChildHandle {
|
||||
const vcs = runWithOwner(input.owner, () =>
|
||||
input.persist(Persist.serverWorkspace(input.scope, directory, "vcs"), VcsState, { value: undefined }),
|
||||
)
|
||||
|
||||
if (stores.length === 0) return
|
||||
if (!vcs) throw new Error(input.translate("error.childStore.persistedCacheCreateFailed"))
|
||||
const vcsStore = vcs[0]
|
||||
|
||||
const list = pickDirectoriesToEvict({
|
||||
stores,
|
||||
state: lifecycle,
|
||||
pins: new Set(stores.filter(pinned)),
|
||||
max: MAX_DIR_STORES,
|
||||
ttl: DIR_IDLE_TTL_MS,
|
||||
now: Date.now(),
|
||||
}).filter((directory) => directory !== skip)
|
||||
const meta = runWithOwner(input.owner, () =>
|
||||
input.persist(Persist.serverWorkspace(input.scope, directory, "project"), ProjectState, { value: undefined }),
|
||||
)
|
||||
|
||||
if (list.length === 0) return
|
||||
if (!meta) throw new Error(input.translate("error.childStore.persistedProjectMetadataCreateFailed"))
|
||||
const initialMeta = meta[0].value
|
||||
|
||||
for (const directory of list) {
|
||||
if (!disposeDirectory(directoryKey(directory))) continue
|
||||
}
|
||||
}
|
||||
const child = createStore<State>({
|
||||
project: "",
|
||||
projectMeta: initialMeta,
|
||||
get provider_ready() {
|
||||
return (
|
||||
input.data.location.provider.list({ directory }) !== undefined &&
|
||||
input.data.location.model.list({ directory }) !== undefined
|
||||
)
|
||||
},
|
||||
get provider() {
|
||||
const provider = input.data.location.provider.list({ directory })
|
||||
const model = input.data.location.model.list({ directory })
|
||||
|
||||
function ensureChild(directory: string) {
|
||||
const key = directoryKey(directory)
|
||||
if (!provider || !model) return { all: new Map(), connected: [], default: {} }
|
||||
|
||||
if (!key) console.error("No directory provided")
|
||||
return normalizeProviderList(provider, model)
|
||||
},
|
||||
config: {},
|
||||
get path() {
|
||||
const location = input.data.location.info({ directory })
|
||||
|
||||
if (!children[key]) {
|
||||
const vcs = runWithOwner(input.owner, () =>
|
||||
input.persist(Persist.serverWorkspace(input.scope, directory, "vcs"), VcsState, { value: undefined }),
|
||||
)
|
||||
return {
|
||||
state: "",
|
||||
config: "",
|
||||
worktree: location?.project.directory ?? "",
|
||||
directory: location?.directory ?? directory,
|
||||
home: input.global.path.home,
|
||||
}
|
||||
},
|
||||
get agent() {
|
||||
return normalizeAgentList(input.data.location.agent.list({ directory }) ?? [])
|
||||
},
|
||||
get command() {
|
||||
return input.data.location.command.list({ directory }) ?? []
|
||||
},
|
||||
get reference() {
|
||||
return input.data.location.reference.list({ directory }) ?? []
|
||||
},
|
||||
get mcp_ready() {
|
||||
return input.data.location.mcp.server.list({ directory }) !== undefined
|
||||
},
|
||||
get mcp_resource() {
|
||||
return Object.fromEntries(
|
||||
(input.data.location.mcp.resource.list({ directory }) ?? []).map((resource) => [
|
||||
`${resource.server}:${resource.uri}`,
|
||||
resource,
|
||||
]),
|
||||
)
|
||||
},
|
||||
get vcs() {
|
||||
const vcs = input.data.location.vcs.info({ directory })
|
||||
|
||||
if (!vcs) throw new Error(input.translate("error.childStore.persistedCacheCreateFailed"))
|
||||
const vcsStore = vcs[0]
|
||||
if (!vcs) return vcsStore.value
|
||||
|
||||
const meta = runWithOwner(input.owner, () =>
|
||||
input.persist(Persist.serverWorkspace(input.scope, directory, "project"), ProjectState, { value: undefined }),
|
||||
)
|
||||
return { branch: vcs.branch.current, default_branch: vcs.branch.default }
|
||||
},
|
||||
})
|
||||
|
||||
if (!meta) throw new Error(input.translate("error.childStore.persistedProjectMetadataCreateFailed"))
|
||||
metaCache.set(key, { store: meta[0], setStore: meta[1], ready: meta[3] })
|
||||
|
||||
const init = () =>
|
||||
createRoot((dispose) => {
|
||||
const initialMeta = meta[0].value
|
||||
const [instanceQueriesEnabled, setInstanceQueriesEnabled] = createSignal(false)
|
||||
|
||||
const lspQuery = useQuery(() => ({
|
||||
...input.queryOptions.lsp(key),
|
||||
enabled: input.connected() && instanceQueriesEnabled(),
|
||||
}))
|
||||
|
||||
const child = createStore<State>({
|
||||
project: "",
|
||||
projectMeta: initialMeta,
|
||||
get provider_ready() {
|
||||
return (
|
||||
input.data.location.provider.list({ directory }) !== undefined &&
|
||||
input.data.location.model.list({ directory }) !== undefined
|
||||
)
|
||||
},
|
||||
get provider() {
|
||||
const provider = input.data.location.provider.list({ directory })
|
||||
const model = input.data.location.model.list({ directory })
|
||||
|
||||
if (!provider || !model) return { all: new Map(), connected: [], default: {} }
|
||||
|
||||
return normalizeProviderList(provider, model)
|
||||
},
|
||||
config: {},
|
||||
get path() {
|
||||
const location = input.data.location.info({ directory })
|
||||
|
||||
return {
|
||||
state: "",
|
||||
config: "",
|
||||
worktree: location?.project.directory ?? "",
|
||||
directory: location?.directory ?? directory,
|
||||
home: input.global.path.home,
|
||||
}
|
||||
},
|
||||
status: "loading" as const,
|
||||
get agent() {
|
||||
return normalizeAgentList(input.data.location.agent.list({ directory }) ?? [])
|
||||
},
|
||||
get command() {
|
||||
return input.data.location.command.list({ directory }) ?? []
|
||||
},
|
||||
get reference() {
|
||||
return input.data.location.reference.list({ directory }) ?? []
|
||||
},
|
||||
get mcp_ready() {
|
||||
return input.data.location.mcp.server.list({ directory }) !== undefined
|
||||
},
|
||||
get mcp() {
|
||||
return Object.fromEntries(
|
||||
(input.data.location.mcp.server.list({ directory }) ?? []).map((server) => [
|
||||
server.name,
|
||||
server.status,
|
||||
]),
|
||||
)
|
||||
},
|
||||
get mcp_resource() {
|
||||
return Object.fromEntries(
|
||||
(input.data.location.mcp.resource.list({ directory }) ?? []).map((resource) => [
|
||||
`${resource.server}:${resource.uri}`,
|
||||
resource,
|
||||
]),
|
||||
)
|
||||
},
|
||||
get lsp_ready() {
|
||||
return instanceQueriesEnabled() && !lspQuery.isLoading
|
||||
},
|
||||
get lsp() {
|
||||
return lspQuery.isLoading ? [] : (lspQuery.data ?? [])
|
||||
},
|
||||
get vcs() {
|
||||
const vcs = input.data.location.vcs.info({ directory })
|
||||
|
||||
if (!vcs) return vcsStore.value
|
||||
|
||||
return { branch: vcs.branch.current, default_branch: vcs.branch.default }
|
||||
},
|
||||
})
|
||||
|
||||
children[key] = child
|
||||
disposers.set(key, dispose)
|
||||
activationToggles.set(key, setInstanceQueriesEnabled)
|
||||
|
||||
const onPersistedInit = (init: Promise<string | null> | string | null, run: () => void) => {
|
||||
if (!(init instanceof Promise)) return
|
||||
void init.then(() => {
|
||||
if (children[key] !== child) return
|
||||
run()
|
||||
})
|
||||
}
|
||||
|
||||
onPersistedInit(vcs[2], () => {
|
||||
const cached = vcsStore.value
|
||||
|
||||
if (!cached?.branch) return
|
||||
child[1]("vcs", (value) => value ?? cached)
|
||||
})
|
||||
|
||||
onPersistedInit(meta[2], () => {
|
||||
if (child[0].projectMeta !== initialMeta) return
|
||||
child[1]("projectMeta", meta[0].value)
|
||||
})
|
||||
})
|
||||
|
||||
runWithOwner(input.owner, init)
|
||||
const onPersistedInit = (init: Promise<string | null> | string | null, run: () => void) => {
|
||||
if (!(init instanceof Promise)) return
|
||||
void init.then(() => {
|
||||
if (handles.get(key)?.store !== child) return
|
||||
run()
|
||||
})
|
||||
}
|
||||
|
||||
markKey(key)
|
||||
const childStore = children[key]
|
||||
onPersistedInit(vcs[2], () => {
|
||||
const cached = vcsStore.value
|
||||
|
||||
if (!childStore) throw new Error(input.translate("error.childStore.storeCreateFailed"))
|
||||
if (!cached?.branch) return
|
||||
child[1]("vcs", (value) => value ?? cached)
|
||||
})
|
||||
|
||||
return childStore
|
||||
onPersistedInit(meta[2], () => {
|
||||
if (child[0].projectMeta !== initialMeta) return
|
||||
child[1]("projectMeta", meta[0].value)
|
||||
})
|
||||
|
||||
return { store: child, setMeta: meta[1] }
|
||||
}
|
||||
|
||||
function child(directory: string, options: ChildOptions = {}) {
|
||||
const key = directoryKey(directory)
|
||||
const childStore = ensureChild(directory)
|
||||
pinForOwner(key)
|
||||
|
||||
if (options.mcp) enableMcp(directory, key, childStore)
|
||||
const shouldBootstrap = options.bootstrap ?? true
|
||||
|
||||
if (shouldBootstrap) activate(key)
|
||||
|
||||
if (shouldBootstrap && childStore[0].status === "loading") {
|
||||
input.onBootstrap(directory)
|
||||
}
|
||||
|
||||
return childStore
|
||||
}
|
||||
|
||||
function enableMcp(directory: string, key: DirectoryKey, childStore: [Store<State>, SetStoreFunction<State>]) {
|
||||
if (mcpDirectories.has(key)) return
|
||||
mcpDirectories.add(key)
|
||||
|
||||
if (childStore[0].status !== "loading") input.onMcp(directory, childStore[1])
|
||||
}
|
||||
|
||||
// Passive project metadata reads must not initialize the directory.
|
||||
// A real directory access enables these queries once for the store lifetime.
|
||||
function activate(key: DirectoryKey) {
|
||||
if (activeDirectories.has(key)) return
|
||||
activeDirectories.add(key)
|
||||
activationToggles.get(key)?.(true)
|
||||
}
|
||||
|
||||
function disableMcp(directory: string) {
|
||||
const key = directoryKey(directory)
|
||||
|
||||
if (!mcpDirectories.delete(key)) return
|
||||
function child(directory: string) {
|
||||
return access(directory, claimForOwner(directoryKey(directory))).store
|
||||
}
|
||||
|
||||
function projectMeta(directory: string, patch: ProjectMeta) {
|
||||
const key = directoryKey(directory)
|
||||
const [store, setStore] = ensureChild(directory)
|
||||
const cached = metaCache.get(key)
|
||||
|
||||
if (!cached) return
|
||||
const previous = store.projectMeta ?? {}
|
||||
const handle = access(directory, false)
|
||||
const previous = handle.store[0].projectMeta ?? {}
|
||||
const icon = patch.icon ? { ...previous.icon, ...patch.icon } : previous.icon
|
||||
const commands = patch.commands ? { ...previous.commands, ...patch.commands } : previous.commands
|
||||
|
||||
@@ -362,22 +195,12 @@ export function createChildStoreManager(input: {
|
||||
commands,
|
||||
}
|
||||
|
||||
cached.setStore("value", next)
|
||||
setStore("projectMeta", next)
|
||||
handle.setMeta("value", next)
|
||||
handle.store[1]("projectMeta", next)
|
||||
}
|
||||
|
||||
return {
|
||||
children,
|
||||
ensureChild,
|
||||
child,
|
||||
projectMeta,
|
||||
mark,
|
||||
pin,
|
||||
unpin,
|
||||
pinned,
|
||||
mcp: (directory: string) => mcpDirectories.has(directoryKey(directory)),
|
||||
active: (directory: string) => activeDirectories.has(directoryKey(directory)),
|
||||
disableMcp,
|
||||
disposeDirectory,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
import { expect, test } from "bun:test"
|
||||
import { canDisposeDirectory, pickDirectoriesToEvict } from "./eviction"
|
||||
|
||||
test("pickDirectoriesToEvict keeps pinned stores and evicts idle stores", () => {
|
||||
const picks = pickDirectoriesToEvict({
|
||||
stores: ["a", "b", "c", "d"],
|
||||
state: new Map([
|
||||
["a", { lastAccessAt: 1_000 }],
|
||||
["b", { lastAccessAt: 4_900 }],
|
||||
["c", { lastAccessAt: 4_800 }],
|
||||
["d", { lastAccessAt: 3_000 }],
|
||||
]),
|
||||
pins: new Set(["a"]),
|
||||
max: 2,
|
||||
ttl: 1_500,
|
||||
now: 5_000,
|
||||
})
|
||||
|
||||
expect(picks).toEqual(["d", "c"])
|
||||
})
|
||||
|
||||
test.each([
|
||||
[{ pinned: true, booting: false, loadingSessions: false }, false],
|
||||
[{ pinned: false, booting: true, loadingSessions: false }, false],
|
||||
[{ pinned: false, booting: false, loadingSessions: true }, false],
|
||||
[{ pinned: false, booting: false, loadingSessions: false }, true],
|
||||
])("canDisposeDirectory(%o) is %p", (state, expected) => {
|
||||
expect(canDisposeDirectory({ directory: "dir", hasStore: true, ...state })).toBe(expected)
|
||||
})
|
||||
@@ -1,39 +0,0 @@
|
||||
import type { DisposeCheck, EvictPlan } from "./types"
|
||||
|
||||
export function pickDirectoriesToEvict(input: EvictPlan) {
|
||||
const overflow = Math.max(0, input.stores.length - input.max)
|
||||
let pendingOverflow = overflow
|
||||
|
||||
const sorted = input.stores
|
||||
.filter((dir) => !input.pins.has(dir))
|
||||
.slice()
|
||||
.sort((a, b) => (input.state.get(a)?.lastAccessAt ?? 0) - (input.state.get(b)?.lastAccessAt ?? 0))
|
||||
|
||||
const output: string[] = []
|
||||
|
||||
for (const dir of sorted) {
|
||||
const last = input.state.get(dir)?.lastAccessAt ?? 0
|
||||
const idle = input.now - last >= input.ttl
|
||||
|
||||
if (!idle && pendingOverflow <= 0) continue
|
||||
output.push(dir)
|
||||
|
||||
if (pendingOverflow > 0) pendingOverflow -= 1
|
||||
}
|
||||
|
||||
return output
|
||||
}
|
||||
|
||||
export function canDisposeDirectory(input: DisposeCheck) {
|
||||
if (!input.directory) return false
|
||||
|
||||
if (!input.hasStore) return false
|
||||
|
||||
if (input.pinned) return false
|
||||
|
||||
if (input.booting) return false
|
||||
|
||||
if (input.loadingSessions) return false
|
||||
|
||||
return true
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
import { describe, expect, test } from "bun:test"
|
||||
import {
|
||||
createDirectoryCacheState,
|
||||
transitionDirectoryCache,
|
||||
type DirectoryCacheEvent,
|
||||
type DirectoryCacheState,
|
||||
} from "./machine"
|
||||
import { DIR_IDLE_TTL_MS, MAX_DIR_STORES } from "./types"
|
||||
import { directoryKey } from "./utils"
|
||||
|
||||
function accessed(directory: string, at: number, pin = false): DirectoryCacheEvent {
|
||||
return { type: "accessed", key: directoryKey(directory), directory, pin, at }
|
||||
}
|
||||
|
||||
function replay(events: DirectoryCacheEvent[], state = createDirectoryCacheState()) {
|
||||
return events.reduce<{ state: DirectoryCacheState; effects: unknown[] }>(
|
||||
(result, event) => {
|
||||
const next = transitionDirectoryCache(result.state, event)
|
||||
|
||||
return { state: next.state, effects: [...result.effects, ...next.effects] }
|
||||
},
|
||||
{ state, effects: [] },
|
||||
)
|
||||
}
|
||||
|
||||
describe("transitionDirectoryCache", () => {
|
||||
test("creates a directory's store on its first access only", () => {
|
||||
const result = replay([accessed("C:\\repo", 1), accessed("C:/repo", 2, true)])
|
||||
|
||||
expect(result.effects).toEqual([{ type: "create", key: directoryKey("C:\\repo"), directory: "C:\\repo" }])
|
||||
expect(result.state.get(directoryKey("C:/repo"))).toEqual({ directory: "C:\\repo", pins: 1, lastAccessAt: 2 })
|
||||
})
|
||||
|
||||
test("evicts the least recently used store over the limit, then idle stores, keeping pinned ones", () => {
|
||||
const start = replay([
|
||||
accessed("/pinned", 0, true),
|
||||
accessed("/older", 1_000),
|
||||
accessed("/newer", 2_000),
|
||||
...Array.from({ length: MAX_DIR_STORES - 3 }, (_, index) => accessed(`/held-${index}`, 3_000, true)),
|
||||
])
|
||||
|
||||
expect(start.state.size).toBe(MAX_DIR_STORES)
|
||||
|
||||
const over = transitionDirectoryCache(start.state, accessed("/next", 4_000))
|
||||
|
||||
expect(over.effects).toEqual([
|
||||
{ type: "create", key: directoryKey("/next"), directory: "/next" },
|
||||
{ type: "evict", key: directoryKey("/older") },
|
||||
])
|
||||
expect(over.state.size).toBe(MAX_DIR_STORES)
|
||||
|
||||
const idle = transitionDirectoryCache(over.state, accessed("/pinned", DIR_IDLE_TTL_MS + 3_000))
|
||||
|
||||
// `/newer` sat idle for the TTL; `/next` did not yet, and the pinned stores never leave.
|
||||
expect(idle.effects).toEqual([{ type: "evict", key: directoryKey("/newer") }])
|
||||
expect(idle.state.has(directoryKey("/next"))).toBe(true)
|
||||
expect(idle.state.has(directoryKey("/pinned"))).toBe(true)
|
||||
})
|
||||
|
||||
test("keeps the directory just accessed when every other store is pinned", () => {
|
||||
const pinned = replay(Array.from({ length: MAX_DIR_STORES }, (_, index) => accessed(`/pinned-${index}`, 1, true)))
|
||||
const result = transitionDirectoryCache(pinned.state, accessed("/active", 2))
|
||||
|
||||
expect(result.effects).toEqual([{ type: "create", key: directoryKey("/active"), directory: "/active" }])
|
||||
expect(result.state.has(directoryKey("/active"))).toBe(true)
|
||||
})
|
||||
|
||||
test("evicts a store once its last reader releases it", () => {
|
||||
const pinned = replay([
|
||||
...Array.from({ length: MAX_DIR_STORES - 1 }, (_, index) => accessed(`/pinned-${index}`, 2, true)),
|
||||
accessed("/held", 1, true),
|
||||
accessed("/held", 1, true),
|
||||
accessed("/active", 3),
|
||||
])
|
||||
|
||||
expect(pinned.state.size).toBe(MAX_DIR_STORES + 1)
|
||||
|
||||
const once = transitionDirectoryCache(pinned.state, { type: "released", key: directoryKey("/held"), at: 4 })
|
||||
expect(once.effects).toEqual([])
|
||||
expect(once.state.get(directoryKey("/held"))?.pins).toBe(1)
|
||||
|
||||
const last = transitionDirectoryCache(once.state, { type: "released", key: directoryKey("/held"), at: 4 })
|
||||
expect(last.effects).toEqual([{ type: "evict", key: directoryKey("/held") }])
|
||||
expect(last.state.size).toBe(MAX_DIR_STORES)
|
||||
})
|
||||
|
||||
test("ignores a release of an unknown or unpinned directory", () => {
|
||||
const state = replay([accessed("/repo", 1)]).state
|
||||
|
||||
for (const directory of ["/repo", "/unknown"]) {
|
||||
const result = transitionDirectoryCache(state, { type: "released", key: directoryKey(directory), at: 2 })
|
||||
expect(result.state).toBe(state)
|
||||
expect(result.effects).toEqual([])
|
||||
}
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,84 @@
|
||||
import { DIR_IDLE_TTL_MS, MAX_DIR_STORES } from "./types"
|
||||
import type { DirectoryKey } from "./utils"
|
||||
|
||||
/** A directory's cached store. Each reactive reader pins it while it holds the store. */
|
||||
export type DirectoryEntry = {
|
||||
readonly directory: string
|
||||
readonly pins: number
|
||||
readonly lastAccessAt: number
|
||||
}
|
||||
|
||||
export type DirectoryCacheState = ReadonlyMap<DirectoryKey, DirectoryEntry>
|
||||
|
||||
export type DirectoryCacheEvent =
|
||||
| {
|
||||
readonly type: "accessed"
|
||||
readonly key: DirectoryKey
|
||||
readonly directory: string
|
||||
/** The reader holds the store until it releases it. */
|
||||
readonly pin: boolean
|
||||
readonly at: number
|
||||
}
|
||||
| { readonly type: "released"; readonly key: DirectoryKey; readonly at: number }
|
||||
|
||||
export type DirectoryCacheEffect =
|
||||
| { readonly type: "create"; readonly key: DirectoryKey; readonly directory: string }
|
||||
| { readonly type: "evict"; readonly key: DirectoryKey }
|
||||
|
||||
export type DirectoryCacheTransition = {
|
||||
readonly state: DirectoryCacheState
|
||||
readonly effects: readonly DirectoryCacheEffect[]
|
||||
}
|
||||
|
||||
export function createDirectoryCacheState(): DirectoryCacheState {
|
||||
return new Map()
|
||||
}
|
||||
|
||||
export function transitionDirectoryCache(
|
||||
state: DirectoryCacheState,
|
||||
event: DirectoryCacheEvent,
|
||||
): DirectoryCacheTransition {
|
||||
const entry = state.get(event.key)
|
||||
|
||||
if (event.type === "accessed") {
|
||||
const next = new Map(state).set(event.key, {
|
||||
directory: entry?.directory ?? event.directory,
|
||||
pins: (entry?.pins ?? 0) + (event.pin ? 1 : 0),
|
||||
lastAccessAt: event.at,
|
||||
})
|
||||
|
||||
return evict(
|
||||
next,
|
||||
event.at,
|
||||
entry ? [] : [{ type: "create", key: event.key, directory: event.directory }],
|
||||
event.key,
|
||||
)
|
||||
}
|
||||
|
||||
if (!entry || entry.pins === 0) return { state, effects: [] }
|
||||
const next = new Map(state).set(event.key, { ...entry, pins: entry.pins - 1 })
|
||||
|
||||
if (entry.pins > 1) return { state: next, effects: [] }
|
||||
|
||||
return evict(next, event.at, [])
|
||||
}
|
||||
|
||||
// Unpinned stores leave once idle for the TTL, and the least recently used ones leave while the cache is over its
|
||||
// limit. The directory just accessed always stays.
|
||||
function evict(
|
||||
entries: Map<DirectoryKey, DirectoryEntry>,
|
||||
at: number,
|
||||
effects: DirectoryCacheEffect[],
|
||||
keep?: DirectoryKey,
|
||||
): DirectoryCacheTransition {
|
||||
const overflow = entries.size - MAX_DIR_STORES
|
||||
|
||||
const evicted = [...entries]
|
||||
.filter(([key, entry]) => key !== keep && entry.pins === 0)
|
||||
.toSorted(([, a], [, b]) => a.lastAccessAt - b.lastAccessAt)
|
||||
.flatMap(([key, entry], index) => (index < overflow || at - entry.lastAccessAt >= DIR_IDLE_TTL_MS ? [key] : []))
|
||||
|
||||
evicted.forEach((key) => entries.delete(key))
|
||||
|
||||
return { state: entries, effects: [...effects, ...evicted.map((key) => ({ type: "evict" as const, key }))] }
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
import { describe, expect, test } from "bun:test"
|
||||
import { toggleMcp } from "./mcp"
|
||||
|
||||
describe("toggleMcp", () => {
|
||||
test("runs the status action before refreshing the owning query", async () => {
|
||||
const calls: string[] = []
|
||||
|
||||
const input = (status: "connected" | "needs_auth" | "disabled") => ({
|
||||
status,
|
||||
connect: async () => {
|
||||
calls.push("connect")
|
||||
},
|
||||
disconnect: async () => {
|
||||
calls.push("disconnect")
|
||||
},
|
||||
authenticate: async () => {
|
||||
calls.push("authenticate")
|
||||
},
|
||||
refresh: async () => {
|
||||
calls.push("refresh")
|
||||
},
|
||||
})
|
||||
|
||||
await toggleMcp(input("connected"))
|
||||
expect(calls).toEqual(["disconnect", "refresh"])
|
||||
|
||||
calls.length = 0
|
||||
await toggleMcp(input("needs_auth"))
|
||||
expect(calls).toEqual(["authenticate", "refresh"])
|
||||
|
||||
calls.length = 0
|
||||
await toggleMcp(input("disabled"))
|
||||
expect(calls).toEqual(["connect", "refresh"])
|
||||
})
|
||||
|
||||
test("does not toggle a server while its connection is pending", async () => {
|
||||
const calls: string[] = []
|
||||
await toggleMcp({
|
||||
status: "pending",
|
||||
connect: async () => {
|
||||
calls.push("connect")
|
||||
},
|
||||
disconnect: async () => {
|
||||
calls.push("disconnect")
|
||||
},
|
||||
authenticate: async () => {
|
||||
calls.push("authenticate")
|
||||
},
|
||||
refresh: async () => {
|
||||
calls.push("refresh")
|
||||
},
|
||||
})
|
||||
expect(calls).toEqual([])
|
||||
})
|
||||
})
|
||||
@@ -1,18 +0,0 @@
|
||||
import type { McpServer } from "@opencode/client/promise"
|
||||
|
||||
export async function toggleMcp(input: {
|
||||
status: McpServer["status"]["status"]
|
||||
connect: () => Promise<void>
|
||||
disconnect: () => Promise<void>
|
||||
authenticate: () => Promise<void>
|
||||
refresh: () => Promise<void>
|
||||
}) {
|
||||
if (input.status === "pending") return
|
||||
await {
|
||||
connected: input.disconnect,
|
||||
needs_auth: input.authenticate,
|
||||
disabled: input.connect,
|
||||
failed: input.connect,
|
||||
}[input.status]()
|
||||
await input.refresh()
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
import { describe, expect, test } from "bun:test"
|
||||
import { createRefreshQueue } from "./queue"
|
||||
import { directoryKey } from "./utils"
|
||||
|
||||
const tick = () => new Promise((resolve) => setTimeout(resolve, 10))
|
||||
|
||||
describe("createRefreshQueue", () => {
|
||||
test("clears queued directories by normalized key", async () => {
|
||||
const calls: string[] = []
|
||||
|
||||
const queue = createRefreshQueue({
|
||||
paused: () => false,
|
||||
key: directoryKey,
|
||||
bootstrap: async () => {},
|
||||
bootstrapInstance: (directory) => {
|
||||
calls.push(directory)
|
||||
},
|
||||
})
|
||||
|
||||
queue.push("C:\\tmp\\demo")
|
||||
queue.clear("C:/tmp/demo")
|
||||
|
||||
await tick()
|
||||
|
||||
expect(calls).toEqual([])
|
||||
queue.dispose()
|
||||
})
|
||||
|
||||
test("passes the original directory to bootstrapInstance", async () => {
|
||||
const calls: string[] = []
|
||||
|
||||
const queue = createRefreshQueue({
|
||||
paused: () => false,
|
||||
key: directoryKey,
|
||||
bootstrap: async () => {},
|
||||
bootstrapInstance: (directory) => {
|
||||
calls.push(directory)
|
||||
},
|
||||
})
|
||||
|
||||
queue.push("C:\\tmp\\demo")
|
||||
|
||||
await tick()
|
||||
|
||||
expect(calls).toEqual(["C:\\tmp\\demo"])
|
||||
queue.dispose()
|
||||
})
|
||||
})
|
||||
@@ -1,98 +0,0 @@
|
||||
type QueueInput = {
|
||||
paused: () => boolean
|
||||
bootstrap: () => Promise<void>
|
||||
bootstrapInstance: (directory: string) => Promise<void> | void
|
||||
key?: (directory: string) => string
|
||||
}
|
||||
|
||||
export function createRefreshQueue(input: QueueInput) {
|
||||
const queued = new Map<string, string>()
|
||||
let root = false
|
||||
let running = false
|
||||
let timer: ReturnType<typeof setTimeout> | undefined
|
||||
|
||||
const key = input.key ?? ((directory: string) => directory)
|
||||
|
||||
const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0))
|
||||
|
||||
const take = (count: number) => {
|
||||
if (queued.size === 0) return [] as string[]
|
||||
const items: string[] = []
|
||||
|
||||
for (const [id, directory] of queued) {
|
||||
queued.delete(id)
|
||||
items.push(directory)
|
||||
|
||||
if (items.length >= count) break
|
||||
}
|
||||
|
||||
return items
|
||||
}
|
||||
|
||||
const schedule = () => {
|
||||
if (timer) return
|
||||
timer = setTimeout(() => {
|
||||
timer = undefined
|
||||
void drain()
|
||||
}, 0)
|
||||
}
|
||||
|
||||
const push = (directory: string) => {
|
||||
if (!directory) return
|
||||
queued.set(key(directory), directory)
|
||||
|
||||
if (input.paused()) return
|
||||
schedule()
|
||||
}
|
||||
|
||||
const refresh = () => {
|
||||
root = true
|
||||
|
||||
if (input.paused()) return
|
||||
schedule()
|
||||
}
|
||||
|
||||
async function drain() {
|
||||
if (running) return
|
||||
running = true
|
||||
|
||||
try {
|
||||
while (true) {
|
||||
if (input.paused()) return
|
||||
|
||||
if (root) {
|
||||
root = false
|
||||
await input.bootstrap()
|
||||
await tick()
|
||||
continue
|
||||
}
|
||||
|
||||
const dirs = take(2)
|
||||
|
||||
if (dirs.length === 0) return
|
||||
await Promise.all(dirs.map((dir) => input.bootstrapInstance(dir)))
|
||||
await tick()
|
||||
}
|
||||
} finally {
|
||||
running = false
|
||||
|
||||
// oxlint-disable-next-line no-unsafe-finally -- intentional: early return skips schedule() when paused
|
||||
if (input.paused()) return
|
||||
|
||||
if (root || queued.size) schedule()
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
push,
|
||||
refresh,
|
||||
clear(directory: string) {
|
||||
queued.delete(key(directory))
|
||||
},
|
||||
dispose() {
|
||||
if (!timer) return
|
||||
clearTimeout(timer)
|
||||
timer = undefined
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -1,14 +1,26 @@
|
||||
import type { Agent, Config, LspStatus, Path, ProviderListResponse, VcsInfo } from "@/runtime/server/types"
|
||||
import type {
|
||||
Agent,
|
||||
Config,
|
||||
Path,
|
||||
Project,
|
||||
ProviderAuthResponse,
|
||||
ProviderListResponse,
|
||||
VcsInfo,
|
||||
} from "@/runtime/server/types"
|
||||
import type { ReferenceInfo } from "@opencode/client/promise"
|
||||
import type { CommandInfo, McpResource, McpServer } from "@opencode/client/promise"
|
||||
import type { Accessor } from "solid-js"
|
||||
import type { SetStoreFunction, Store } from "solid-js/store"
|
||||
import type { CommandInfo, McpResource } from "@opencode/client/promise"
|
||||
import { ProjectState } from "../persistence"
|
||||
|
||||
export type ProjectMeta = NonNullable<typeof ProjectState.Type.value>
|
||||
|
||||
export type GlobalStore = {
|
||||
path: Path
|
||||
project: Project[]
|
||||
provider_auth: ProviderAuthResponse
|
||||
config: Config
|
||||
}
|
||||
|
||||
export type State = {
|
||||
status: "loading" | "partial" | "complete"
|
||||
agent: Agent[]
|
||||
command: CommandInfo[]
|
||||
reference: ReferenceInfo[]
|
||||
@@ -19,49 +31,12 @@ export type State = {
|
||||
config: Config
|
||||
path: Path
|
||||
mcp_ready: boolean
|
||||
mcp: {
|
||||
[name: string]: McpServer["status"]
|
||||
}
|
||||
mcp_resource: {
|
||||
[key: string]: McpResource
|
||||
}
|
||||
lsp_ready: boolean
|
||||
lsp: LspStatus[]
|
||||
vcs: VcsInfo | undefined
|
||||
}
|
||||
|
||||
export type MetaCache = {
|
||||
store: Store<typeof ProjectState.Type>
|
||||
setStore: SetStoreFunction<typeof ProjectState.Type>
|
||||
ready: Accessor<boolean>
|
||||
}
|
||||
|
||||
export type ChildOptions = {
|
||||
bootstrap?: boolean
|
||||
mcp?: boolean
|
||||
}
|
||||
|
||||
export type DirState = {
|
||||
lastAccessAt: number
|
||||
}
|
||||
|
||||
export type EvictPlan = {
|
||||
stores: string[]
|
||||
state: Map<string, DirState>
|
||||
pins: Set<string>
|
||||
max: number
|
||||
ttl: number
|
||||
now: number
|
||||
}
|
||||
|
||||
export type DisposeCheck = {
|
||||
directory: string
|
||||
hasStore: boolean
|
||||
pinned: boolean
|
||||
booting: boolean
|
||||
loadingSessions: boolean
|
||||
}
|
||||
|
||||
export const MAX_DIR_STORES = 30
|
||||
|
||||
export const DIR_IDLE_TTL_MS = 20 * 60 * 1000
|
||||
|
||||
@@ -260,7 +260,7 @@ function createServerController(
|
||||
function withLocalMeta(project: Project): Project {
|
||||
if (project.id !== "global") return project
|
||||
|
||||
return { ...project, ...sync.child(project.worktree, { bootstrap: false })[0].projectMeta }
|
||||
return { ...project, ...sync.child(project.worktree)[0].projectMeta }
|
||||
}
|
||||
|
||||
const list = createMemo(() => sync.data.project.map(withLocalMeta))
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
import { expect, test } from "bun:test"
|
||||
import { reconnectOrder } from "./connection"
|
||||
|
||||
test("held directories refresh before the rest, otherwise keeping their order", () => {
|
||||
const held = new Set(["/b", "/d"])
|
||||
expect(reconnectOrder(["/a", "/b", "/c", "/d"], (directory) => held.has(directory))).toEqual(["/b", "/d", "/a", "/c"])
|
||||
expect(reconnectOrder(["/a", "/c"], (directory) => held.has(directory))).toEqual(["/a", "/c"])
|
||||
})
|
||||
@@ -21,8 +21,3 @@ export function createConnectionSync(input: {
|
||||
|
||||
return { handleEvent }
|
||||
}
|
||||
|
||||
// Directories a mounted view holds refresh first; the rest keep their existing order behind them.
|
||||
export function reconnectOrder(directories: string[], held: (directory: string) => boolean) {
|
||||
return [...directories.filter(held), ...directories.filter((directory) => !held(directory))]
|
||||
}
|
||||
|
||||
@@ -1,12 +1,9 @@
|
||||
import type { Config, Path, Project, ProviderAuthResponse } from "@/runtime/server/types"
|
||||
import { showToast } from "@/shell/notifications/toast"
|
||||
import { getFilename } from "@opencode/util/path"
|
||||
import { getOwner, onCleanup, untrack } from "solid-js"
|
||||
import type { Config, Project } from "@/runtime/server/types"
|
||||
import { getOwner, onCleanup } from "solid-js"
|
||||
import { createStore } from "solid-js/store"
|
||||
import { useLanguage } from "@/runtime/i18n/language"
|
||||
import { type ServerSDK } from "./client"
|
||||
import {
|
||||
bootstrapDirectory,
|
||||
bootstrapGlobal,
|
||||
loadGlobalConfigQuery,
|
||||
loadPathQuery,
|
||||
@@ -14,61 +11,26 @@ import {
|
||||
loadProjectsQuery,
|
||||
} from "./global-sync/bootstrap"
|
||||
import { createChildStoreManager } from "./global-sync/child-store"
|
||||
import type { ProjectMeta } from "./global-sync/types"
|
||||
import { formatServerError } from "@/runtime/server/errors"
|
||||
import { queryOptions, useMutation, useQueries, useQuery, useQueryClient } from "@tanstack/solid-query"
|
||||
import { createRefreshQueue } from "./global-sync/queue"
|
||||
import { directoryKey, normalizeProjectInfo, updateProjectInfo } from "./global-sync/utils"
|
||||
import { PathKey } from "@/workspaces/path-key"
|
||||
import type { ServerScope } from "@/runtime/server/scope"
|
||||
import type { GlobalStore, ProjectMeta } from "./global-sync/types"
|
||||
import { useMutation, useQueries, useQuery, useQueryClient } from "@tanstack/solid-query"
|
||||
import { normalizeProjectInfo, updateProjectInfo } from "./global-sync/utils"
|
||||
import { persisted } from "@/runtime/persistence/storage"
|
||||
import type { ServerApi } from "@/runtime/server/api"
|
||||
import { toggleMcp } from "./global-sync/mcp"
|
||||
import { createConnectionSync, reconnectOrder } from "./server-sync/connection"
|
||||
import { usePlatform } from "@/runtime/platform/platform"
|
||||
import { createConnectionSync } from "./server-sync/connection"
|
||||
import type { Data } from "@opencode/client/solid"
|
||||
import { createWorktreeInventory, withWorktreeInventory, worktreeInventoryViewKey } from "@/workspaces/inventory"
|
||||
|
||||
type GlobalStore = {
|
||||
path: Path
|
||||
project: Project[]
|
||||
provider_auth: ProviderAuthResponse
|
||||
config: Config
|
||||
reload: undefined | "pending" | "complete"
|
||||
}
|
||||
|
||||
const loadLspQuery = (scope: ServerScope, directory: string) =>
|
||||
queryOptions({
|
||||
queryKey: [scope, directory, "lsp"] as const,
|
||||
// TODO: Restore LSP status when the V2 client exposes an LSP API.
|
||||
queryFn: async () => [],
|
||||
})
|
||||
|
||||
function makeQueryOptionsApi(scope: ServerScope, serverAPI: () => ServerApi) {
|
||||
return {
|
||||
globalConfig: () => loadGlobalConfigQuery(scope),
|
||||
path: () => loadPathQuery(scope, null, serverAPI().location),
|
||||
lsp: (directory: PathKey) => loadLspQuery(scope, directory),
|
||||
}
|
||||
}
|
||||
|
||||
export type QueryOptionsApi = ReturnType<typeof makeQueryOptionsApi>
|
||||
|
||||
function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
|
||||
const language = useLanguage()
|
||||
const platform = usePlatform()
|
||||
const owner = getOwner()
|
||||
|
||||
if (!owner) throw new Error("ServerSync must be created within owner")
|
||||
|
||||
const booting = new Map<string, Promise<void>>()
|
||||
const queryOptionsApi = makeQueryOptionsApi(serverSDK.scope, () => serverSDK.api)
|
||||
const connected = () => serverSDK.connection.status() === "connected"
|
||||
|
||||
const [configQuery, pathQuery] = useQueries(() => ({
|
||||
queries: [
|
||||
{ ...queryOptionsApi.globalConfig(), enabled: connected() },
|
||||
{ ...queryOptionsApi.path(), enabled: connected() },
|
||||
{ ...loadGlobalConfigQuery(serverSDK.scope), enabled: connected() },
|
||||
{ ...loadPathQuery(serverSDK.scope, null, serverSDK.api.location), enabled: connected() },
|
||||
],
|
||||
}))
|
||||
|
||||
@@ -87,9 +49,6 @@ function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
|
||||
|
||||
return configQuery.data ?? {}
|
||||
},
|
||||
get reload() {
|
||||
return updateConfigMutation.isPending ? "pending" : undefined
|
||||
},
|
||||
})
|
||||
|
||||
const queryClient = useQueryClient()
|
||||
@@ -129,45 +88,11 @@ function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
|
||||
enabled: connected(),
|
||||
}))
|
||||
|
||||
const paused = () => untrack(() => globalStore.reload) !== undefined
|
||||
|
||||
const queue = createRefreshQueue({
|
||||
paused,
|
||||
key: directoryKey,
|
||||
bootstrap: () => queryClient.fetchQuery({ queryKey: [serverSDK.scope, "bootstrap"] }),
|
||||
bootstrapInstance,
|
||||
})
|
||||
|
||||
const children = createChildStoreManager({
|
||||
owner,
|
||||
connected,
|
||||
scope: serverSDK.scope,
|
||||
persist: persisted,
|
||||
isBooting: (directory) => booting.has(directory),
|
||||
isLoadingSessions: () => false,
|
||||
onBootstrap: (directory) => {
|
||||
if (!connected()) return
|
||||
void bootstrapInstance(directory)
|
||||
},
|
||||
onMcp: (directory) => {
|
||||
void Promise.all([
|
||||
data.location.command.sync({ directory }),
|
||||
data.location.mcp.server.sync({ directory }),
|
||||
data.location.mcp.resource.sync({ directory }),
|
||||
]).catch((err) => {
|
||||
showToast({
|
||||
variant: "error",
|
||||
title: language.t("toast.project.reloadFailed.title", { project: getFilename(directory) }),
|
||||
description: formatServerError(err, language.t),
|
||||
})
|
||||
})
|
||||
},
|
||||
onDispose: (directory) => {
|
||||
const key = directoryKey(directory)
|
||||
queue.clear(key)
|
||||
},
|
||||
translate: language.t,
|
||||
queryOptions: queryOptionsApi,
|
||||
data,
|
||||
global: {
|
||||
get path() {
|
||||
@@ -186,55 +111,9 @@ function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
|
||||
},
|
||||
connected: () => {
|
||||
if (bootstrap.data !== undefined && !bootstrap.isFetching) void bootstrap.refetch()
|
||||
// The refresh queue re-syncs two directories at a time, held ones first. Syncing every active
|
||||
// directory here as well sent the whole catalog fan-out for all of them at once.
|
||||
reconnectOrder(Object.keys(children.children).filter(children.active), children.pinned).forEach((directory) =>
|
||||
queue.push(directory),
|
||||
)
|
||||
},
|
||||
})
|
||||
|
||||
async function bootstrapInstance(directory: string) {
|
||||
const key = directoryKey(directory)
|
||||
|
||||
if (!key) return
|
||||
const pending = booting.get(key)
|
||||
|
||||
if (pending) return pending
|
||||
|
||||
children.pin(key)
|
||||
|
||||
const promise = Promise.resolve().then(async () => {
|
||||
const child = children.ensureChild(directory)
|
||||
await Promise.all([
|
||||
data.location.sync({ directory }),
|
||||
bootstrapDirectory({
|
||||
directory,
|
||||
scope: serverSDK.scope,
|
||||
mcp: children.mcp(key),
|
||||
global: {
|
||||
config: globalStore.config,
|
||||
path: globalStore.path,
|
||||
project: globalStore.project,
|
||||
},
|
||||
api: serverSDK.api,
|
||||
store: child[0],
|
||||
setStore: child[1],
|
||||
translate: language.t,
|
||||
queryClient,
|
||||
}),
|
||||
])
|
||||
})
|
||||
|
||||
booting.set(key, promise)
|
||||
void promise.finally(() => {
|
||||
booting.delete(key)
|
||||
children.unpin(key)
|
||||
})
|
||||
|
||||
return promise
|
||||
}
|
||||
|
||||
// Mirrors the server's list: unarchived projects, most recently active first. Unknown projects join the list and
|
||||
// archived ones leave it.
|
||||
function applyProjectUpdate(update: Parameters<typeof updateProjectInfo>[1]) {
|
||||
@@ -278,30 +157,10 @@ function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
|
||||
return
|
||||
}
|
||||
|
||||
if (!event.location) {
|
||||
if (event.type === "config.updated" || event.type === "agent.updated") bootstrap.refetch()
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
const directory = event.location.directory
|
||||
const key = directoryKey(directory)
|
||||
|
||||
if (!children.active(key)) return
|
||||
children.mark(key)
|
||||
|
||||
if (event.type === "config.updated" || event.type === "agent.updated") queue.push(key)
|
||||
if (!event.location && (event.type === "config.updated" || event.type === "agent.updated")) bootstrap.refetch()
|
||||
})
|
||||
|
||||
onCleanup(unsub)
|
||||
onCleanup(() => {
|
||||
queue.dispose()
|
||||
})
|
||||
onCleanup(() => {
|
||||
for (const directory of Object.keys(children.children)) {
|
||||
children.disposeDirectory(directoryKey(directory))
|
||||
}
|
||||
})
|
||||
|
||||
const projectApi = {
|
||||
update: applyProjectUpdate,
|
||||
@@ -330,61 +189,10 @@ function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
|
||||
data: globalStore,
|
||||
set: setGlobalStore,
|
||||
child: children.child,
|
||||
disableMcp: children.disableMcp,
|
||||
// bootstrap,
|
||||
updateConfig: updateConfigMutation.mutateAsync,
|
||||
project: projectApi,
|
||||
worktrees,
|
||||
mcp: {
|
||||
toggle: async (directory: string, name: string) => {
|
||||
const key = directoryKey(directory)
|
||||
const status = children.child(key, { bootstrap: false })[0].mcp[name]?.status
|
||||
|
||||
if (!status) return
|
||||
await toggleMcp({
|
||||
status,
|
||||
connect: async () => {
|
||||
await serverSDK.api.experimental.mcp.connect({ server: name, location: { directory: key } })
|
||||
},
|
||||
disconnect: async () => {
|
||||
await serverSDK.api.experimental.mcp.disconnect({ server: name, location: { directory: key } })
|
||||
},
|
||||
authenticate: async () => {
|
||||
const server = (await serverSDK.api.mcp.list({ location: { directory: key } })).data.find(
|
||||
(item) => item.name === name,
|
||||
)
|
||||
|
||||
if (!server?.integrationID) throw new Error(`MCP server ${name} has no authentication integration`)
|
||||
|
||||
const integration = await serverSDK.api.integration.get({
|
||||
integrationID: server.integrationID,
|
||||
location: { directory: key },
|
||||
})
|
||||
|
||||
const method = integration.data?.methods.find((item) => item.type === "oauth" && !item.form?.length)
|
||||
|
||||
if (!method || method.type !== "oauth")
|
||||
throw new Error(`MCP server ${name} requires an interactive authentication form`)
|
||||
|
||||
const attempt = await serverSDK.api.integration.oauth.connect({
|
||||
integrationID: server.integrationID,
|
||||
methodID: method.id,
|
||||
location: { directory: key },
|
||||
})
|
||||
|
||||
platform.openExternal(attempt.data.url)
|
||||
},
|
||||
refresh: async () => {
|
||||
data.location.mcp.server.invalidate({ directory: key })
|
||||
data.location.mcp.resource.invalidate({ directory: key })
|
||||
await Promise.all([
|
||||
data.location.mcp.server.sync({ directory: key }),
|
||||
data.location.mcp.resource.sync({ directory: key }),
|
||||
])
|
||||
},
|
||||
})
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,13 +1,11 @@
|
||||
import { expect, test } from "bun:test"
|
||||
import { createComponent, createMemo, createRoot, getOwner } from "solid-js"
|
||||
import { createMemo, createRoot, getOwner } from "solid-js"
|
||||
import { createStore, reconcile } from "solid-js/store"
|
||||
import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
|
||||
import { Predicate } from "effect"
|
||||
import type { Data } from "@opencode/client/solid"
|
||||
import type { persisted } from "@/runtime/persistence/storage"
|
||||
import { createChildStoreManager } from "@/runtime/server/global-sync/child-store"
|
||||
import { MAX_DIR_STORES } from "@/runtime/server/global-sync/types"
|
||||
import type { QueryOptionsApi } from "@/runtime/server/sync"
|
||||
import { ServerScope } from "@/runtime/server/scope"
|
||||
|
||||
// SAFETY: the child store reads only these location lists, and only from its getters.
|
||||
@@ -25,12 +23,6 @@ const data = {
|
||||
},
|
||||
} as unknown as Data
|
||||
|
||||
// SAFETY: the child store builds only the LSP query, which this value provides.
|
||||
// oxlint-disable-next-line anti-slop/no-chained-type-assertions -- see SAFETY above
|
||||
const queryOptions = {
|
||||
lsp: (directory: string) => ({ queryKey: [directory, "lsp"], queryFn: async () => [] }),
|
||||
} as unknown as QueryOptionsApi
|
||||
|
||||
// Runs under the browser build: the server build of Solid never re-runs the memo.
|
||||
test("keeps project stores alive when a memo over more directories than the store limit re-runs", async () => {
|
||||
const created: string[] = []
|
||||
@@ -61,41 +53,22 @@ test("keeps project stores alive when a memo over more directories than the stor
|
||||
}
|
||||
|
||||
const root = createRoot((dispose) => {
|
||||
let manager: ReturnType<typeof createChildStoreManager> | undefined
|
||||
const owner = getOwner()
|
||||
|
||||
createComponent(QueryClientProvider, {
|
||||
client: new QueryClient(),
|
||||
get children() {
|
||||
const owner = getOwner()
|
||||
if (!owner) throw new Error("owner required")
|
||||
|
||||
if (!owner) throw new Error("owner required")
|
||||
|
||||
manager = createChildStoreManager({
|
||||
owner,
|
||||
connected: () => false,
|
||||
scope: ServerScope.local,
|
||||
persist,
|
||||
isBooting: () => false,
|
||||
isLoadingSessions: () => false,
|
||||
onBootstrap() {},
|
||||
onMcp() {},
|
||||
onDispose() {},
|
||||
translate: (key) => key,
|
||||
queryOptions,
|
||||
data,
|
||||
global: { path: { state: "", config: "", worktree: "", directory: "", home: "" } },
|
||||
})
|
||||
|
||||
return undefined
|
||||
},
|
||||
const manager = createChildStoreManager({
|
||||
owner,
|
||||
scope: ServerScope.local,
|
||||
persist,
|
||||
translate: (key) => key,
|
||||
data,
|
||||
global: { path: { state: "", config: "", worktree: "", directory: "", home: "" } },
|
||||
})
|
||||
|
||||
if (!manager) throw new Error("manager required")
|
||||
const children = manager
|
||||
createMemo(() => directories.map((directory) => manager.child(directory)[0].projectMeta))
|
||||
|
||||
createMemo(() => directories.map((directory) => children.child(directory, { bootstrap: false })[0].projectMeta))
|
||||
|
||||
return { manager: children, dispose }
|
||||
return { manager, dispose }
|
||||
})
|
||||
|
||||
try {
|
||||
@@ -103,7 +76,8 @@ test("keeps project stores alive when a memo over more directories than the stor
|
||||
while (hydrations.length > 0) await Promise.all(hydrations.splice(0))
|
||||
|
||||
expect(created.filter((key) => key === "workspace:project")).toHaveLength(directories.length)
|
||||
expect(directories.map((directory) => root.manager.children[directory]?.[0].projectMeta?.name)).toEqual(
|
||||
// Read outside the memo, so these reads pin nothing; a store evicted earlier would be created again here.
|
||||
expect(directories.map((directory) => root.manager.child(directory)[0].projectMeta?.name)).toEqual(
|
||||
directories.map(() => "stored"),
|
||||
)
|
||||
} finally {
|
||||
|
||||
Reference in New Issue
Block a user