@neurocode-ai/app 1.18.8

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

@@ -0,0 +1,57 @@
+import type { PermissionRequest, Session } from "@neurocode-ai/sdk/v2/client"
+import { cmp } from "./utils"
+import { SESSION_RECENT_LIMIT, SESSION_RECENT_WINDOW } from "./types"
+
+export function sessionUpdatedAt(session: Session) {
+  return session.time.updated ?? session.time.created
+}
+
+export function compareSessionRecent(a: Session, b: Session) {
+  const aUpdated = sessionUpdatedAt(a)
+  const bUpdated = sessionUpdatedAt(b)
+  if (aUpdated !== bUpdated) return bUpdated - aUpdated
+  return cmp(a.id, b.id)
+}
+
+export function takeRecentSessions(sessions: Session[], limit: number, cutoff: number) {
+  if (limit <= 0) return [] as Session[]
+  const selected: Session[] = []
+  const seen = new Set<string>()
+  for (const session of sessions) {
+    if (!session?.id) continue
+    if (seen.has(session.id)) continue
+    seen.add(session.id)
+    if (sessionUpdatedAt(session) <= cutoff) continue
+    const index = selected.findIndex((x) => compareSessionRecent(session, x) < 0)
+    if (index === -1) selected.push(session)
+    if (index !== -1) selected.splice(index, 0, session)
+    if (selected.length > limit) selected.pop()
+  }
+  return selected
+}
+
+export function trimSessions(
+  input: Session[],
+  options: { limit: number; permission: Record<string, PermissionRequest[]>; now?: number },
+) {
+  const limit = Math.max(0, options.limit)
+  const cutoff = (options.now ?? Date.now()) - SESSION_RECENT_WINDOW
+  const all = input
+    .filter((s) => !!s?.id)
+    .filter((s) => !s.time?.archived)
+    .sort((a, b) => cmp(a.id, b.id))
+  const roots = all.filter((s) => !s.parentID)
+  roots.sort(compareSessionRecent)
+  const children = all.filter((s) => !!s.parentID)
+  const base = roots.slice(0, limit)
+  const recent = takeRecentSessions(roots.slice(limit), SESSION_RECENT_LIMIT, cutoff)
+  const keepRoots = [...base, ...recent]
+  const keepRootIds = new Set(keepRoots.map((s) => s.id))
+  const keepChildren = children.filter((s) => {
+    if (s.parentID && keepRootIds.has(s.parentID)) return true
+    const perms = options.permission[s.id] ?? []
+    if (perms.length > 0) return true
+    return sessionUpdatedAt(s) > cutoff
+  })
+  return [...keepRoots, ...keepChildren].sort((a, b) => cmp(a.id, b.id))
+}

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

@@ -0,0 +1,135 @@
+import type {
+  Agent,
+  Config,
+  LspStatus,
+  Message,
+  Part,
+  Path,
+  PermissionRequest,
+  QuestionRequest,
+  ReferenceInfo,
+  Session,
+  SessionStatus,
+  Todo,
+  VcsInfo,
+} from "@neurocode-ai/sdk/v2/client"
+import type { FileDiffInfo } from "@neurocode-ai/client/promise"
+import { NormalizedProviderListResponse } from "@neurocode-ai/session-ui/context"
+import type { CommandInfo, McpResource, McpServer, SessionMessageInfo } from "@neurocode-ai/client/promise"
+import type { Accessor } from "solid-js"
+import type { SetStoreFunction, Store } from "solid-js/store"
+
+export type ProjectMeta = {
+  name?: string
+  icon?: {
+    override?: string
+    color?: string
+  }
+  commands?: {
+    start?: string
+  }
+}
+
+export type State = {
+  status: "loading" | "partial" | "complete"
+  agent: Agent[]
+  command: CommandInfo[]
+  reference: ReferenceInfo[]
+  project: string
+  projectMeta: ProjectMeta | undefined
+  icon: string | undefined
+  provider_ready: boolean
+  provider: NormalizedProviderListResponse
+  config: Config
+  path: Path
+  session: Session[]
+  sessionTotal: number
+  session_status: {
+    [sessionID: string]: SessionStatus
+  }
+  session_working(id: string): boolean
+  session_diff: {
+    [sessionID: string]: FileDiffInfo[]
+  }
+  todo: {
+    [sessionID: string]: Todo[]
+  }
+  permission: {
+    [sessionID: string]: PermissionRequest[]
+  }
+  question: {
+    [sessionID: string]: QuestionRequest[]
+  }
+  mcp_ready: boolean
+  mcp: {
+    [name: string]: McpServer["status"]
+  }
+  mcp_resource: {
+    [key: string]: McpResource
+  }
+  lsp_ready: boolean
+  lsp: LspStatus[]
+  vcs: VcsInfo | undefined
+  limit: number
+  message: {
+    [sessionID: string]: Message[]
+  }
+  session_message: {
+    [sessionID: string]: SessionMessageInfo[]
+  }
+  part: {
+    [messageID: string]: Part[]
+  }
+  part_text_accum_delta: {
+    [partID: string]: string
+  }
+}
+
+export type VcsCache = {
+  store: Store<{ value: VcsInfo | undefined }>
+  setStore: SetStoreFunction<{ value: VcsInfo | undefined }>
+  ready: Accessor<boolean>
+}
+
+export type MetaCache = {
+  store: Store<{ value: ProjectMeta | undefined }>
+  setStore: SetStoreFunction<{ value: ProjectMeta | undefined }>
+  ready: Accessor<boolean>
+}
+
+export type IconCache = {
+  store: Store<{ value: string | undefined }>
+  setStore: SetStoreFunction<{ value: string | undefined }>
+  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
+export const SESSION_RECENT_WINDOW = 4 * 60 * 60 * 1000
+export const SESSION_RECENT_LIMIT = 50

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

@@ -0,0 +1,133 @@
+import { describe, expect, test } from "bun:test"
+import type {
+  AgentListOutput,
+  ModelDefaultOutput,
+  ModelListOutput,
+  ProviderListOutput,
+} from "@neurocode-ai/client/promise"
+import { directoryKey, normalizeAgentList, normalizePermissionRequest, normalizeProviderList } from "./utils"
+
+describe("normalizeAgentList", () => {
+  test("adapts current agents to the app agent shape", () => {
+    const result = normalizeAgentList([
+      {
+        id: "build",
+        name: "Build",
+        mode: "primary",
+        hidden: false,
+        color: "primary",
+        model: { id: "gpt-5", providerID: "openai", variant: "high" },
+        request: { settings: { temperature: 0.2, topP: 0.9 }, headers: {}, body: {} },
+        system: "Build software",
+        permissions: [{ action: "read", resource: "*", effect: "allow" }],
+      },
+    ] as AgentListOutput["data"])
+
+    expect(result).toEqual([
+      {
+        name: "build",
+        description: undefined,
+        mode: "primary",
+        hidden: false,
+        temperature: 0.2,
+        topP: 0.9,
+        color: "primary",
+        permission: [{ permission: "read", pattern: "*", action: "allow" }],
+        model: { providerID: "openai", modelID: "gpt-5" },
+        variant: "high",
+        prompt: "Build software",
+        options: { temperature: 0.2, topP: 0.9 },
+        steps: undefined,
+      },
+    ])
+  })
+})
+
+describe("normalizePermissionRequest", () => {
+  test("adapts the current permission request to app state", () => {
+    expect(
+      normalizePermissionRequest({
+        id: "permission-1",
+        sessionID: "session-1",
+        action: "read",
+        resources: ["README.md"],
+        save: ["*.md"],
+        metadata: { path: "README.md" },
+        source: { type: "tool", messageID: "message-1", callID: "call-1" },
+      }),
+    ).toEqual({
+      id: "permission-1",
+      sessionID: "session-1",
+      permission: "read",
+      patterns: ["README.md"],
+      always: ["*.md"],
+      metadata: { path: "README.md" },
+      tool: { messageID: "message-1", callID: "call-1" },
+    })
+  })
+})
+
+describe("normalizeProviderList", () => {
+  test("groups current models into the app provider catalog", () => {
+    const result = normalizeProviderList(
+      [{ id: "openai", name: "OpenAI", package: "@ai-sdk/openai" }] as ProviderListOutput["data"],
+      [
+        {
+          id: "gpt-5",
+          modelID: "gpt-5",
+          providerID: "openai",
+          name: "GPT-5",
+          capabilities: { tools: true, input: ["text", "image"], output: ["text"] },
+          variants: [{ id: "high" }],
+          time: { released: 1 },
+          cost: [{ input: 1, output: 2, cache: { read: 0.1, write: 0.2 } }],
+          status: "active",
+          enabled: true,
+          limit: { context: 128_000, output: 8_192 },
+        },
+        {
+          id: "gpt-old",
+          modelID: "gpt-old",
+          providerID: "openai",
+          name: "GPT Old",
+          capabilities: { tools: false, input: ["text"], output: ["text"] },
+          variants: [],
+          time: { released: 0 },
+          cost: [],
+          status: "deprecated",
+          enabled: true,
+          limit: { context: 1, output: 1 },
+        },
+      ] as ModelListOutput["data"],
+      { id: "gpt-5", providerID: "openai" } as ModelDefaultOutput["data"],
+    )
+
+    expect(result.connected).toEqual(["openai"])
+    expect(result.default).toEqual({ openai: "gpt-5" })
+    expect(result.all.get("openai")?.models["gpt-old"]).toBeUndefined()
+    expect(result.all.get("openai")?.models["gpt-5"]).toMatchObject({
+      id: "gpt-5",
+      providerID: "openai",
+      capabilities: { toolcall: true, attachment: true },
+      cost: { input: 1, output: 2 },
+      variants: { high: {} },
+    })
+  })
+})
+
+describe("directoryKey", () => {
+  test("normalizes slashes", () => {
+    expect(String(directoryKey("C:\\Repos\\sst\\neurocode"))).toBe("C:/Repos/sst/neurocode")
+    expect(String(directoryKey("C:/Repos/sst/neurocode"))).toBe("C:/Repos/sst/neurocode")
+  })
+
+  test("preserves backslashes in posix paths", () => {
+    expect(String(directoryKey("/tmp/foo\\bar"))).toBe("/tmp/foo\\bar")
+  })
+
+  test("trims trailing slashes without breaking roots", () => {
+    expect(String(directoryKey("C:/Repos/sst/opencode/"))).toBe("C:/Repos/sst/neurocode")
+    expect(String(directoryKey("C:/"))).toBe("C:/")
+    expect(String(directoryKey("/"))).toBe("/")
+  })
+})

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

@@ -0,0 +1,171 @@
+import type {
+  AgentListOutput,
+  ModelDefaultOutput,
+  ModelListOutput,
+  PermissionV2Request,
+  ProviderListOutput,
+} from "@neurocode-ai/client/promise"
+import type { Agent, PermissionRequest, Project, Provider, ProviderListResponse } from "@neurocode-ai/sdk/v2/client"
+import type { Project as CurrentProject } from "@neurocode-ai/client/promise"
+import { NormalizedProviderListResponse } from "@neurocode-ai/session-ui/context"
+export { pathKey as directoryKey, type PathKey as DirectoryKey } from "@/utils/path-key"
+
+export const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
+
+export function normalizeAgentList(input: AgentListOutput["data"] | Agent[]): Agent[] {
+  if (input.every((agent) => !("request" in agent))) return input as Agent[]
+  return (input as AgentListOutput["data"]).map((agent) => ({
+    name: agent.id,
+    description: agent.description,
+    mode: agent.mode,
+    hidden: agent.hidden,
+    temperature:
+      typeof agent.request.settings.temperature === "number" ? agent.request.settings.temperature : undefined,
+    topP: typeof agent.request.settings.topP === "number" ? agent.request.settings.topP : undefined,
+    color: agent.color,
+    permission: agent.permissions.map((rule) => ({
+      permission: rule.action,
+      pattern: rule.resource,
+      action: rule.effect,
+    })),
+    model: agent.model && { providerID: agent.model.providerID, modelID: agent.model.id },
+    variant: agent.model?.variant,
+    prompt: agent.system,
+    options: agent.request.settings,
+    steps: agent.steps,
+  }))
+}
+
+export function normalizePermissionRequest(input: PermissionV2Request | PermissionRequest): PermissionRequest {
+  if ("permission" in input) return input
+  return {
+    id: input.id,
+    sessionID: input.sessionID,
+    permission: input.action,
+    patterns: input.resources,
+    always: input.save ?? [],
+    metadata: input.metadata ?? {},
+    tool:
+      input.source?.type === "tool" ? { messageID: input.source.messageID, callID: input.source.callID } : undefined,
+  }
+}
+
+export function normalizeProviderList(
+  providers: ProviderListOutput["data"] | ProviderListResponse,
+  models?: ModelListOutput["data"],
+  defaultModel?: ModelDefaultOutput["data"],
+): NormalizedProviderListResponse {
+  if (!Array.isArray(providers)) {
+    return {
+      ...providers,
+      all: new Map(
+        providers.all.map((provider) => [
+          provider.id,
+          {
+            ...provider,
+            models: Object.fromEntries(
+              Object.entries(provider.models).filter(([, model]) => model.status !== "deprecated"),
+            ),
+          },
+        ]),
+      ),
+    }
+  }
+  const all = new Map<string, Provider>()
+
+  for (const provider of providers) {
+    all.set(provider.id, {
+      id: provider.id,
+      name: provider.name,
+      source: "custom",
+      env: [],
+      options: provider.settings ?? {},
+      models: {},
+    })
+  }
+
+  for (const model of models ?? []) {
+    const provider = all.get(model.providerID)
+    if (!provider || model.status === "deprecated") continue
+    const cost = model.cost.find((item) => item.tier === undefined) ?? model.cost[0]
+    provider.models[model.id] = {
+      id: model.id,
+      providerID: model.providerID,
+      api: {
+        id: model.modelID,
+        url: "",
+        npm: model.package ?? provider.id,
+      },
+      name: model.name,
+      family: model.family,
+      capabilities: {
+        temperature: false,
+        reasoning: false,
+        attachment: model.capabilities.input.some((item) => item !== "text"),
+        toolcall: model.capabilities.tools,
+        input: {
+          text: model.capabilities.input.includes("text"),
+          audio: model.capabilities.input.includes("audio"),
+          image: model.capabilities.input.includes("image"),
+          video: model.capabilities.input.includes("video"),
+          pdf: model.capabilities.input.includes("pdf"),
+        },
+        output: {
+          text: model.capabilities.output.includes("text"),
+          audio: model.capabilities.output.includes("audio"),
+          image: model.capabilities.output.includes("image"),
+          video: model.capabilities.output.includes("video"),
+          pdf: model.capabilities.output.includes("pdf"),
+        },
+        interleaved: false,
+      },
+      cost: {
+        input: cost?.input ?? 0,
+        output: cost?.output ?? 0,
+        cache: {
+          read: cost?.cache.read ?? 0,
+          write: cost?.cache.write ?? 0,
+        },
+      },
+      limit: model.limit,
+      status: model.status,
+      options: model.settings ?? {},
+      headers: model.headers ?? {},
+      release_date: new Date(model.time.released).toISOString().slice(0, 10),
+      variants: Object.fromEntries(model.variants.map((variant) => [variant.id, variant.settings ?? {}])),
+    }
+  }
+
+  return {
+    all,
+    connected: providers.map((provider) => provider.id),
+    default: Object.fromEntries(
+      providers.flatMap((provider) => {
+        const model =
+          defaultModel?.providerID === provider.id
+            ? defaultModel
+            : models?.find((item) => item.providerID === provider.id && item.status !== "deprecated")
+        return model ? [[provider.id, model.id]] : []
+      }),
+    ),
+  }
+}
+
+export function sanitizeProject(project: Project) {
+  if (!project.icon?.url && !project.icon?.override) return project
+  return {
+    ...project,
+    icon: {
+      ...project.icon,
+      url: undefined,
+      override: undefined,
+    },
+  }
+}
+
+export function normalizeProjectInfo(project: Project | CurrentProject): Project {
+  return {
+    ...project,
+    vcs: project.vcs === "git" ? "git" : undefined,
+  }
+}

package/src/context/global.tsx

@@ -0,0 +1,161 @@
+import { createSimpleContext } from "@neurocode-ai/ui/context"
+import { createEffect, createMemo, createRoot } from "solid-js"
+import { createStore } from "solid-js/store"
+import { createServerProjects, RECENTLY_CLOSED_DISPLAY_LIMIT, ServerConnection, useServer } from "./server"
+import { pathKey } from "@/utils/path-key"
+import { useServerHealth } from "@/utils/server-health"
+import { createServerSdkContext } from "./server-sdk"
+import { createServerSyncContext } from "./server-sync"
+import { getOwner } from "solid-js/web"
+import { QueryClient } from "@tanstack/solid-query"
+import type { ServerScope } from "@/utils/server-scope"
+
+export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext({
+  name: "Global",
+  init: () => {
+    const server = useServer()
+    const serverHealth = useServerHealth(
+      () => server.list,
+      () => true,
+    )
+    const [store, setStore] = createStore({
+      settings: {
+        serverKey: undefined as ServerConnection.Key | undefined,
+      },
+    })
+
+    const settingsServer = createMemo(() => {
+      const list = server.list
+      return list.find((conn) => ServerConnection.key(conn) === store.settings.serverKey) ?? list[0]
+    })
+
+    createEffect(() => {
+      const conn = settingsServer()
+      const key = conn ? ServerConnection.key(conn) : undefined
+      if (store.settings.serverKey !== key) setStore("settings", "serverKey", key)
+    })
+
+    const serverCtxs = new Map<
+      ServerConnection.Key,
+      { dispose: () => void; serverCtx: ReturnType<typeof createServerCtx> }
+    >()
+
+    const owner = getOwner()
+
+    const ensureServerCtx = (conn: ServerConnection.Any) => {
+      const key = ServerConnection.key(conn)
+      const existing = serverCtxs.get(key)
+      if (existing) return existing.serverCtx
+      const root = createRoot((dispose) => {
+        const serverCtx = createServerCtx(conn, server.scope(key), server.projects.forServer(key))
+        return { dispose, serverCtx }
+      }, owner as any)
+      serverCtxs.set(key, root)
+      return root.serverCtx
+    }
+
+    createMemo(() => {
+      for (const conn of server.list) {
+        ensureServerCtx(conn)
+      }
+    })
+
+    createEffect(() => {
+      for (const [key] of serverCtxs) {
+        if (!server.list.find((conn) => ServerConnection.key(conn) === key)) {
+          const { dispose } = serverCtxs.get(key)!
+          dispose()
+          serverCtxs.delete(key)
+        }
+      }
+    })
+
+    return {
+      servers: {
+        list: () => server.list,
+        health: serverHealth,
+      },
+      settings: {
+        server: {
+          get key() {
+            return store.settings.serverKey
+          },
+          selected: settingsServer,
+          set(key: ServerConnection.Key) {
+            if (store.settings.serverKey !== key) setStore("settings", "serverKey", key)
+          },
+        },
+      },
+      ensureServerCtx(conn: ServerConnection.Any) {
+        return ensureServerCtx(conn)
+      },
+    }
+  },
+})
+
+function createServerCtx(
+  conn: ServerConnection.Any,
+  scope: ServerScope,
+  projects: ReturnType<typeof createServerProjects>,
+) {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        refetchOnReconnect: false,
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+      },
+    },
+  })
+  const sdk = createServerSdkContext(conn, scope)
+  const sync = createServerSyncContext(sdk)
+
+  function enrich(project: { worktree: string; expanded: boolean }) {
+    const [childStore] = sync.child(project.worktree, { bootstrap: false })
+    const projectID = childStore.project
+    const metadata = projectID
+      ? sync.data.project.find((x) => x.id === projectID)
+      : sync.data.project.find((x) => x.worktree === project.worktree)
+
+    // Preserve local icon override from per-workspace localStorage cache (childStore.icon).
+    // Without this, different subdirectories of the same git repo would share the same
+    // icon from the database instead of using their individual overrides.
+    const base = { ...metadata, ...project }
+    if (childStore.icon) {
+      return { ...base, icon: { ...base.icon, override: childStore.icon } }
+    }
+    return base
+  }
+
+  const projectsList = createMemo(() => projects.list().map(enrich))
+  const recentlyClosedList = createMemo(() => {
+    const known = new Set(sync.data.project.map((project) => pathKey(project.worktree)))
+    return projects
+      .recentlyClosed()
+      .filter((worktree) => known.has(pathKey(worktree)))
+      .slice(0, RECENTLY_CLOSED_DISPLAY_LIMIT)
+      .map((worktree) => enrich({ worktree, expanded: false }))
+  })
+
+  const isLocal =
+    (conn?.type === "sidecar" && conn.variant === "base") || (conn?.type === "http" && isLocalHost(conn.http.url))
+
+  return {
+    queryClient,
+    sdk,
+    sync,
+    isLocal,
+    projects: {
+      ...projects,
+      list: projectsList,
+      recentlyClosed: recentlyClosedList,
+    },
+  }
+}
+
+export type ServerCtx = ReturnType<typeof createServerCtx>
+
+function isLocalHost(url: string) {
+  const host = url.replace(/^https?:\/\//, "").split(":")[0]
+  if (host === "localhost" || host === "127.0.0.1") return "local"
+}