@neurocode-ai/app 1.18.8

package/src/context/global-sync/home-session-index.ts

@@ -0,0 +1,174 @@
+import type { Event, Session, SessionV2Info, V2SessionListResponse } from "@neurocode-ai/sdk/v2/client"
+import type { QueryClient } from "@tanstack/solid-query"
+import { trimSessions } from "./session-trim"
+import { pathKey } from "@/utils/path-key"
+
+export const HOME_V2_SESSION_PAGE_LIMIT = 5_000
+
+export type HomeSessionEvent = {
+  type: "session.created" | "session.updated" | "session.deleted"
+  properties: { sessionID: string; info: Session }
+}
+export type HomeSessionEvents = {
+  sequence: number
+  entries: Array<{ sequence: number; event: HomeSessionEvent }>
+}
+export type HomeSessionIndex = {
+  sessions: Session[]
+  eventSequence: number
+}
+
+export const homeSessionIndexKey = (server: string) => ["home", "session-index", server] as const
+export const homeSessionEventsKey = (server: string) => ["home", "session-events", server] as const
+
+type HomeSessionPage = { data?: V2SessionListResponse }
+
+export async function loadHomeSessionIndex(
+  list: (
+    input: { limit: number; order: "desc"; cursor?: string },
+    options: { signal?: AbortSignal },
+  ) => Promise<HomeSessionPage>,
+  eventSequence = 0,
+  signal?: AbortSignal,
+) {
+  const data: SessionV2Info[] = []
+  let cursor: string | undefined
+
+  for (;;) {
+    const response = await list(
+      {
+        limit: HOME_V2_SESSION_PAGE_LIMIT,
+        order: "desc",
+        ...(cursor ? { cursor } : {}),
+      },
+      { signal },
+    )
+    const page = response.data!
+    data.push(...page.data)
+    if (page.data.length < HOME_V2_SESSION_PAGE_LIMIT || !page.cursor.next)
+      return { sessions: parseHomeSessionIndex(data), eventSequence }
+    cursor = page.cursor.next
+  }
+}
+
+export function appendHomeSessionEvent(current: HomeSessionEvents | undefined, event: HomeSessionEvent) {
+  const sequence = (current?.sequence ?? 0) + 1
+  return {
+    sequence,
+    entries: [...(current?.entries ?? []), { sequence, event }],
+  }
+}
+
+export function trimHomeSessionEvents(current: HomeSessionEvents | undefined, sequence: number): HomeSessionEvents {
+  return {
+    sequence: current?.sequence ?? sequence,
+    entries: (current?.entries ?? []).filter((entry) => entry.sequence > sequence),
+  }
+}
+
+export function homeSessionIndexSessions(index: HomeSessionIndex | undefined, events: HomeSessionEvents | undefined) {
+  if (!index) return []
+  return (events?.entries ?? [])
+    .filter((entry) => entry.sequence > index.eventSequence)
+    .reduce((sessions, entry) => applyHomeSessionEvent(sessions, entry.event), index.sessions)
+}
+
+export function homeSessionIndexRefresh(event: Event["type"], connected: boolean) {
+  if (event === "server.connected") return { connected: true, refetch: connected }
+  return {
+    connected,
+    refetch: event === "global.disposed" || event === "session.next.moved",
+  }
+}
+
+export function createHomeSessionIndexCache(queryClient: QueryClient, server: string) {
+  const indexKey = homeSessionIndexKey(server)
+  const eventsKey = homeSessionEventsKey(server)
+  let connected = false
+
+  return {
+    indexKey,
+    eventsKey,
+    eventSequence() {
+      return queryClient.getQueryData<HomeSessionEvents>(eventsKey)?.sequence ?? 0
+    },
+    complete(sequence: number) {
+      // Keep events received after the fetch began so its response cannot overwrite them.
+      queryClient.setQueryData<HomeSessionEvents>(eventsKey, (current) => trimHomeSessionEvents(current, sequence))
+    },
+    sessions(index: HomeSessionIndex | undefined, events: HomeSessionEvents | undefined) {
+      return homeSessionIndexSessions(index, events)
+    },
+    apply(event: HomeSessionEvent) {
+      if (!queryClient.getQueryState(indexKey)) return
+      const next = appendHomeSessionEvent(queryClient.getQueryData<HomeSessionEvents>(eventsKey), event)
+      if (queryClient.isFetching({ queryKey: indexKey, exact: true }) > 0) {
+        queryClient.setQueryData(eventsKey, next)
+        return
+      }
+
+      const index = queryClient.getQueryData<HomeSessionIndex>(indexKey)
+      if (index) {
+        queryClient.setQueryData<HomeSessionIndex>(indexKey, {
+          sessions: homeSessionIndexSessions(index, next),
+          eventSequence: next.sequence,
+        })
+      }
+      queryClient.setQueryData<HomeSessionEvents>(eventsKey, { sequence: next.sequence, entries: [] })
+    },
+    refresh(event: Event["type"]) {
+      const result = homeSessionIndexRefresh(event, connected)
+      connected = result.connected
+      if (!result.refetch) return
+      void queryClient.refetchQueries({ queryKey: indexKey, exact: true, type: "active" })
+    },
+  }
+}
+
+// TODO(v2): This deliberately dumb full-table scan is necessary because the
+// current V2 API orders by creation time and cannot filter roots, archives, or
+// multiple directories. A bounded page could omit an old session updated today.
+// Once released, use client.v2.project.list() and client.v2.session.list({
+// parentID: null, order: "desc" }), then remove this adapter and its V1 fields.
+export function parseHomeSessionIndex(sessions: SessionV2Info[]): Session[] {
+  return sessions.flatMap((item) => {
+    if (item.parentID || typeof item.time.archived === "number") return []
+    return [toLegacySummary(item)]
+  })
+}
+
+export function retainHomeSessions(sessions: Session[], limit: number, now: number) {
+  const grouped = Map.groupBy(sessions, (session) => pathKey(session.directory))
+  return [...grouped.values()].flatMap((items) => trimSessions(items, { limit, permission: {}, now }))
+}
+
+export function applyHomeSessionEvent(sessions: Session[], event: HomeSessionEvent) {
+  const info = event.properties.info
+  const index = sessions.findIndex((session) => session.id === info.id)
+  if (event.type === "session.deleted" || info.parentID || typeof info.time.archived === "number") {
+    if (index === -1) return sessions
+    return sessions.toSpliced(index, 1)
+  }
+  if (event.type !== "session.created" && event.type !== "session.updated") return sessions
+  if (index === -1) return [...sessions, info]
+  return sessions.with(index, info)
+}
+
+function toLegacySummary(session: SessionV2Info): Session {
+  return {
+    id: session.id,
+    slug: session.id,
+    projectID: session.projectID,
+    workspaceID: session.location.workspaceID,
+    directory: session.location.directory,
+    path: session.subpath,
+    parentID: session.parentID,
+    cost: session.cost,
+    tokens: session.tokens,
+    title: session.title,
+    agent: session.agent,
+    model: session.model,
+    version: "",
+    time: session.time,
+  }
+}

package/src/context/global-sync/mcp.test.ts

@@ -0,0 +1,54 @@
+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([])
+  })
+})

package/src/context/global-sync/mcp.ts

@@ -0,0 +1,19 @@
+import type { McpServer } from "@neurocode-ai/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,
+    needs_client_registration: input.connect,
+  }[input.status]()
+  await input.refresh()
+}

package/src/context/global-sync/queue.test.ts

@@ -0,0 +1,46 @@
+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()
+  })
+})

package/src/context/global-sync/queue.ts

@@ -0,0 +1,87 @@
+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
+    },
+  }
+}

package/src/context/global-sync/session-cache.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "bun:test"
+import type { Message, Part, PermissionRequest, QuestionRequest, SessionStatus, Todo } from "@neurocode-ai/sdk/v2/client"
+import type { FileDiffInfo } from "@neurocode-ai/client/promise"
+import { dropSessionCaches, pickSessionCacheEvictions } from "./session-cache"
+
+const msg = (id: string, sessionID: string) =>
+  ({
+    id,
+    sessionID,
+    role: "user",
+    time: { created: 1 },
+    agent: "assistant",
+    model: { providerID: "openai", modelID: "gpt" },
+  }) as Message
+
+const part = (id: string, sessionID: string, messageID: string) =>
+  ({
+    id,
+    sessionID,
+    messageID,
+    type: "text",
+    text: id,
+  }) as Part
+
+describe("app session cache", () => {
+  test("dropSessionCaches clears orphaned parts without message rows", () => {
+    const store: {
+      session_status: Record<string, SessionStatus | undefined>
+      session_diff: Record<string, FileDiffInfo[] | undefined>
+      todo: Record<string, Todo[] | undefined>
+      message: Record<string, Message[] | undefined>
+      session_message: Record<string, never[] | undefined>
+      part: Record<string, Part[] | undefined>
+      permission: Record<string, PermissionRequest[] | undefined>
+      question: Record<string, QuestionRequest[] | undefined>
+      part_text_accum_delta: Record<string, string | undefined>
+    } = {
+      session_status: { ses_1: { type: "busy" } as SessionStatus },
+      session_diff: { ses_1: [] },
+      todo: { ses_1: [] as Todo[] },
+      message: {},
+      session_message: {},
+      part: { msg_1: [part("prt_1", "ses_1", "msg_1")] },
+      permission: { ses_1: [] as PermissionRequest[] },
+      question: { ses_1: [] as QuestionRequest[] },
+      part_text_accum_delta: { prt_1: "streamed text" },
+    }
+
+    dropSessionCaches(store, ["ses_1"])
+
+    expect(store.message.ses_1).toBeUndefined()
+    expect(store.part.msg_1).toBeUndefined()
+    expect(store.part_text_accum_delta.prt_1).toBeUndefined()
+    expect(store.todo.ses_1).toBeUndefined()
+    expect(store.session_diff.ses_1).toBeUndefined()
+    expect(store.session_status.ses_1).toBeUndefined()
+    expect(store.permission.ses_1).toBeUndefined()
+    expect(store.question.ses_1).toBeUndefined()
+  })
+
+  test("dropSessionCaches clears message-backed parts", () => {
+    const m = msg("msg_1", "ses_1")
+    const store: {
+      session_status: Record<string, SessionStatus | undefined>
+      session_diff: Record<string, FileDiffInfo[] | undefined>
+      todo: Record<string, Todo[] | undefined>
+      message: Record<string, Message[] | undefined>
+      session_message: Record<string, never[] | undefined>
+      part: Record<string, Part[] | undefined>
+      permission: Record<string, PermissionRequest[] | undefined>
+      question: Record<string, QuestionRequest[] | undefined>
+      part_text_accum_delta: Record<string, string | undefined>
+    } = {
+      session_status: {},
+      session_diff: {},
+      todo: {},
+      message: { ses_1: [m] },
+      session_message: {},
+      part: { [m.id]: [part("prt_1", "ses_1", m.id)] },
+      permission: {},
+      question: {},
+      part_text_accum_delta: {},
+    }
+
+    dropSessionCaches(store, ["ses_1"])
+
+    expect(store.message.ses_1).toBeUndefined()
+    expect(store.part[m.id]).toBeUndefined()
+  })
+
+  test("pickSessionCacheEvictions preserves requested sessions", () => {
+    const seen = new Set(["ses_1", "ses_2", "ses_3"])
+
+    const stale = pickSessionCacheEvictions({
+      seen,
+      keep: "ses_4",
+      limit: 2,
+      preserve: ["ses_1"],
+    })
+
+    expect(stale).toEqual(["ses_2", "ses_3"])
+    expect([...seen]).toEqual(["ses_1", "ses_4"])
+  })
+})

package/src/context/global-sync/session-cache.ts

@@ -0,0 +1,62 @@
+import type { Message, Part, PermissionRequest, QuestionRequest, SessionStatus, Todo } from "@neurocode-ai/sdk/v2/client"
+import type { FileDiffInfo } from "@neurocode-ai/client/promise"
+import type { SessionMessageInfo } from "@neurocode-ai/client/promise"
+
+export const SESSION_CACHE_LIMIT = 40
+
+type SessionCache = {
+  session_status: Record<string, SessionStatus | undefined>
+  session_diff: Record<string, FileDiffInfo[] | undefined>
+  todo: Record<string, Todo[] | undefined>
+  message: Record<string, Message[] | undefined>
+  session_message: Record<string, SessionMessageInfo[] | undefined>
+  part: Record<string, Part[] | undefined>
+  permission: Record<string, PermissionRequest[] | undefined>
+  question: Record<string, QuestionRequest[] | undefined>
+  part_text_accum_delta: Record<string, string | undefined>
+}
+
+export function dropSessionCaches(store: SessionCache, sessionIDs: Iterable<string>) {
+  const stale = new Set(Array.from(sessionIDs).filter(Boolean))
+  if (stale.size === 0) return
+
+  for (const key of Object.keys(store.part)) {
+    const parts = store.part[key]
+    if (!parts?.some((part) => stale.has(part?.sessionID ?? ""))) continue
+    for (const part of parts) {
+      delete store.part_text_accum_delta[part.id]
+    }
+    delete store.part[key]
+  }
+
+  for (const sessionID of stale) {
+    delete store.message[sessionID]
+    delete store.todo[sessionID]
+    delete store.session_message[sessionID]
+    delete store.session_diff[sessionID]
+    delete store.session_status[sessionID]
+    delete store.permission[sessionID]
+    delete store.question[sessionID]
+  }
+}
+
+export function pickSessionCacheEvictions(input: {
+  seen: Set<string>
+  keep: string
+  limit: number
+  preserve?: Iterable<string>
+}) {
+  const stale: string[] = []
+  const keep = new Set([input.keep, ...Array.from(input.preserve ?? [])])
+  if (input.seen.has(input.keep)) input.seen.delete(input.keep)
+  input.seen.add(input.keep)
+  for (const id of input.seen) {
+    if (input.seen.size - stale.length <= input.limit) break
+    if (keep.has(id)) continue
+    stale.push(id)
+  }
+  for (const id of stale) {
+    input.seen.delete(id)
+  }
+  return stale
+}

package/src/context/global-sync/session-load.ts

@@ -0,0 +1,33 @@
+import type { SessionApi } from "@neurocode-ai/client/promise"
+import { normalizeSessionInfo } from "@/utils/session"
+import type { NeurocodeClient } from "@neurocode-ai/sdk/v2/client"
+
+export async function loadRootSessions(input: { api: Pick<SessionApi, "list">; directory: string; limit: number }) {
+  const result = await input.api.list({
+    directory: input.directory,
+    parentID: null,
+    limit: input.limit,
+    order: "desc",
+  })
+  return {
+    data: result.data.map(normalizeSessionInfo),
+    limit: input.limit,
+    limited: true,
+  } as const
+}
+
+export async function loadRootSessionsV1(input: { client: NeurocodeClient; directory: string; limit: number }) {
+  try {
+    const result = await input.client.session.list({ directory: input.directory, roots: true, limit: input.limit })
+    return { data: result.data, limit: input.limit, limited: true } as const
+  } catch {
+    const result = await input.client.session.list({ directory: input.directory, roots: true })
+    return { data: result.data, limit: input.limit, limited: false } as const
+  }
+}
+
+export function estimateRootSessionTotal(input: { count: number; limit: number; limited: boolean }) {
+  if (!input.limited) return input.count
+  if (input.count < input.limit) return input.count
+  return input.count + 1
+}

package/src/context/global-sync/session-trim.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test"
+import type { PermissionRequest, Session } from "@neurocode-ai/sdk/v2/client"
+import { trimSessions } from "./session-trim"
+
+const session = (input: { id: string; parentID?: string; created: number; updated?: number; archived?: number }) =>
+  ({
+    id: input.id,
+    parentID: input.parentID,
+    time: {
+      created: input.created,
+      updated: input.updated,
+      archived: input.archived,
+    },
+  }) as Session
+
+describe("trimSessions", () => {
+  test("keeps base roots and recent roots beyond the limit", () => {
+    const now = 1_000_000
+    const list = [
+      session({ id: "a", created: now - 100_000 }),
+      session({ id: "b", created: now - 90_000 }),
+      session({ id: "c", created: now - 80_000 }),
+      session({ id: "d", created: now - 70_000, updated: now - 1_000 }),
+      session({ id: "e", created: now - 60_000, archived: now - 10 }),
+    ]
+
+    const result = trimSessions(list, { limit: 2, permission: {}, now })
+    expect(result.map((x) => x.id)).toEqual(["a", "b", "c", "d"])
+  })
+
+  test("keeps children when root is kept, permission exists, or child is recent", () => {
+    const now = 1_000_000
+    const list = [
+      session({ id: "root-1", created: now - 1000 }),
+      session({ id: "root-2", created: now - 2000 }),
+      session({ id: "z-root", created: now - 30_000_000 }),
+      session({ id: "child-kept-by-root", parentID: "root-1", created: now - 20_000_000 }),
+      session({ id: "child-kept-by-permission", parentID: "z-root", created: now - 20_000_000 }),
+      session({ id: "child-kept-by-recency", parentID: "z-root", created: now - 500 }),
+      session({ id: "child-trimmed", parentID: "z-root", created: now - 20_000_000 }),
+    ]
+
+    const result = trimSessions(list, {
+      limit: 2,
+      permission: {
+        "child-kept-by-permission": [{ id: "perm-1" } as PermissionRequest],
+      },
+      now,
+    })
+
+    expect(result.map((x) => x.id)).toEqual([
+      "child-kept-by-permission",
+      "child-kept-by-recency",
+      "child-kept-by-root",
+      "root-1",
+      "root-2",
+    ])
+  })
+})