@neurocode-ai/app 1.18.8

package/src/wsl/settings-model.ts

@@ -0,0 +1,341 @@
+import fuzzysort from "fuzzysort"
+import type {
+  WslInstalledDistro,
+  WslOnlineDistro,
+  WslNeurocodeCheck,
+  WslServersPlatform,
+  WslServerRuntime,
+  WslServersState,
+} from "./types"
+
+export type AddServerText = {
+  key: string
+  params?: Record<string, string>
+}
+
+export type DistroStatusTone = "success" | "warning" | "muted"
+
+export type DistroStatus = {
+  label: AddServerText
+  tone: DistroStatusTone
+}
+
+export type AddServerPrimaryButton = {
+  variant: "neutral" | "contrast"
+  label: AddServerText
+  disabled: boolean
+  action: "install-neurocode" | "add" | null
+  loading: boolean
+  width: string | null
+}
+
+export type AddServerRuntimeState = "loading" | "pendingRestart" | "checking" | "unavailable" | "ready"
+
+export type AddableProbePlan = {
+  key: string
+  distros: string[]
+}
+
+export type AutoProbePlan = { key: "runtime"; action: "probeRuntime" } | { key: "distros"; action: "refreshDistros" }
+
+export type AddServerProbePlan =
+  | { kind: "auto"; key: string; plan: AutoProbePlan }
+  | { kind: "addable"; key: string; plan: AddableProbePlan }
+
+export type WslAddServerView = "main" | "catalog"
+
+function isHiddenDistro(name: string) {
+  return /^docker-desktop(?:-data)?$/i.test(name)
+}
+
+export const wslRuntimeRetryable = (runtime: WslServerRuntime) =>
+  runtime.kind === "failed" || runtime.kind === "stopped"
+
+export function wslNeurocodeAction(check?: WslNeurocodeCheck) {
+  if (!check) return
+  if (!check.resolvedPath) return "Install neurocode"
+  if (check.matchesDesktop === false) return "Update neurocode"
+}
+
+export function wslDistroReady(state: WslServersState | undefined, name: string) {
+  const installed = state?.installed.find((item) => item.name === name)
+  const probe = state?.distroProbes[name]
+  if (!probe || !installed) return false
+  if (installed.version === 1) return false
+  return probe.canExecute && probe.hasBash && probe.hasCurl
+}
+
+export function addServerViewModel(input: {
+  state: WslServersState | undefined
+  view: WslAddServerView
+  selectedDistro: string | null
+  catalogSearch: string
+  catalogTarget: string | null
+  adding: boolean
+  probingAddable: boolean
+}) {
+  const state = input.state
+  const visibleInstalledDistros = (state?.installed ?? []).filter((item) => !isHiddenDistro(item.name))
+  const visibleOnlineDistros = (state?.online ?? []).filter((item) => !isHiddenDistro(item.name))
+  const existingServerDistros = new Set((state?.servers ?? []).map((item) => item.config.distro))
+  const addableInstalledDistros = visibleInstalledDistros.filter((item) => !existingServerDistros.has(item.name))
+  const selectedDistro = addServerSelectedDistro(input.selectedDistro, visibleInstalledDistros, addableInstalledDistros)
+  const neurocodeCheck = selectedDistro ? (state?.neurocodeChecks[selectedDistro] ?? null) : null
+  const installableDistros = addServerInstallableDistros(visibleInstalledDistros, visibleOnlineDistros)
+  const filteredInstallableDistros = addServerFilteredInstallableDistros(installableDistros, input.catalogSearch)
+  const catalogTarget = addServerCatalogTarget(input.catalogTarget, filteredInstallableDistros)
+  const busy = !!state?.job || input.adding || input.probingAddable
+
+  return {
+    busy,
+    runtimeState: addServerRuntimeState(state),
+    visibleInstalledDistros,
+    visibleOnlineDistros,
+    addableInstalledDistros,
+    selectedDistro,
+    neurocodeCheck,
+    wslReady: !!state?.runtime?.available && !state?.pendingRestart,
+    distroStatuses: Object.fromEntries(
+      addableInstalledDistros.flatMap((item) => {
+        const status = addServerDistroStatus({ state, name: item.name, probingAddable: input.probingAddable })
+        if (!status) return []
+        return [[item.name, status]]
+      }),
+    ) as Record<string, DistroStatus | undefined>,
+    primaryButton: addServerPrimaryButton({
+      state,
+      selectedDistro,
+      neurocodeCheck,
+      adding: input.adding,
+      probingAddable: input.probingAddable,
+    }),
+    installableDistros,
+    filteredInstallableDistros,
+    catalogTarget,
+    installingCatalogDistro: state?.job?.kind === "install-distro",
+  }
+}
+
+function addServerSelectedDistro(
+  selected: string | null,
+  visibleInstalledDistros: WslInstalledDistro[],
+  addableInstalledDistros: WslInstalledDistro[],
+) {
+  if (selected && addableInstalledDistros.some((item) => item.name === selected && item.version !== 1)) return selected
+  const defaultDistro = visibleInstalledDistros.find((item) => item.isDefault)
+  if (
+    defaultDistro &&
+    defaultDistro.version !== 1 &&
+    addableInstalledDistros.some((item) => item.name === defaultDistro.name)
+  ) {
+    return defaultDistro.name
+  }
+  return addableInstalledDistros.find((item) => item.version !== 1)?.name ?? null
+}
+
+function addServerRuntimeState(state: WslServersState | undefined): AddServerRuntimeState {
+  if (!state) return "loading"
+  if (state.pendingRestart) return "pendingRestart"
+  if (!state.runtime) return "checking"
+  if (!state.runtime.available) return "unavailable"
+  return "ready"
+}
+
+function addServerDistroStatus(input: {
+  state: WslServersState | undefined
+  name: string
+  probingAddable: boolean
+}): DistroStatus | undefined {
+  const installed = input.state?.installed.find((item) => item.name === input.name)
+  if (installed?.version === 1) return { label: { key: "wsl.onboarding.distroStatus.unsupported" }, tone: "muted" }
+  const job = input.state?.job
+  const probe = input.state?.distroProbes[input.name]
+  if (!probe) {
+    if (input.probingAddable || (job?.kind === "probe-addable" && job.distros.includes(input.name))) {
+      return checkingStatus()
+    }
+    return
+  }
+  if (!probe.canExecute) {
+    if (!installed) {
+      return { label: { key: "wsl.onboarding.distroNotInstalled", params: { distro: input.name } }, tone: "warning" }
+    }
+    return { label: { key: "wsl.onboarding.openDistroOnce", params: { distro: input.name } }, tone: "warning" }
+  }
+  if (!probe.hasBash || !probe.hasCurl) {
+    return { label: { key: "wsl.onboarding.distroStatus.missingTools" }, tone: "warning" }
+  }
+  const check = input.state?.neurocodeChecks[input.name]
+  if (!check) {
+    if (input.probingAddable || (job?.kind === "probe-addable" && job.distros.includes(input.name))) {
+      return checkingStatus()
+    }
+    return
+  }
+  if (check.matchesDesktop === false) return { label: { key: "wsl.onboarding.updateNeurocode" }, tone: "warning" }
+  if (!check.resolvedPath) return { label: { key: "wsl.onboarding.distroStatus.neurocodeMissing" }, tone: "warning" }
+  if (check.error) return { label: { key: "wsl.onboarding.installNeurocode" }, tone: "warning" }
+  return { label: { key: "wsl.onboarding.distroStatus.ready" }, tone: "success" }
+}
+
+function checkingStatus(): DistroStatus {
+  return { label: { key: "wsl.onboarding.distroStatus.checking" }, tone: "muted" }
+}
+
+function addServerPrimaryButton(input: {
+  state: WslServersState | undefined
+  selectedDistro: string | null
+  neurocodeCheck: WslNeurocodeCheck | null
+  adding: boolean
+  probingAddable: boolean
+}): AddServerPrimaryButton {
+  const ready = !!input.selectedDistro && wslDistroReady(input.state, input.selectedDistro)
+  const probingSelected = input.probingAddable && !addServerSelectedDistroSettled(input.state, input.selectedDistro)
+  const probingNeurocode =
+    probingSelected ||
+    (ready &&
+      (!input.neurocodeCheck ||
+        (!!input.selectedDistro &&
+          input.state?.job?.kind === "probe-addable" &&
+          input.state.job.distros.includes(input.selectedDistro))))
+  const installingNeurocode =
+    input.state?.job?.kind === "install-neurocode" && input.state.job.distro === input.selectedDistro
+  if (!ready || probingNeurocode) {
+    return {
+      variant: "contrast",
+      label: probingSelected ? { key: "wsl.onboarding.distroStatus.checking" } : { key: "wsl.server.add" },
+      disabled: true,
+      action: null,
+      loading: probingSelected,
+      width: null,
+    }
+  }
+  if (!addServerNeurocodeReady(input.neurocodeCheck)) {
+    const update = !!input.neurocodeCheck?.resolvedPath && input.neurocodeCheck.matchesDesktop === false
+    return {
+      variant: "neutral",
+      label: installingNeurocode
+        ? { key: "wsl.onboarding.updatingNeurocode" }
+        : update
+          ? { key: "wsl.onboarding.updateNeurocode" }
+          : { key: "wsl.onboarding.installNeurocode" },
+      disabled: !!input.state?.job || input.adding,
+      action: "install-neurocode",
+      loading: installingNeurocode,
+      width: update ? "138px" : "129px",
+    }
+  }
+  return {
+    variant: "contrast",
+    label: input.adding ? { key: "wsl.onboarding.adding" } : { key: "wsl.server.add" },
+    disabled: input.adding || !!input.state?.job,
+    action: "add",
+    loading: input.adding,
+    width: null,
+  }
+}
+
+function addServerNeurocodeReady(check: WslNeurocodeCheck | null) {
+  return !!check?.resolvedPath && check.matchesDesktop !== false && !check.error
+}
+
+function addServerSelectedDistroSettled(state: WslServersState | undefined, selectedDistro: string | null) {
+  if (!selectedDistro) return false
+  const installed = state?.installed.find((item) => item.name === selectedDistro)
+  if (installed?.version === 1) return false
+  if (!state?.distroProbes[selectedDistro]) return false
+  if (!wslDistroReady(state, selectedDistro)) return true
+  return !!state.neurocodeChecks[selectedDistro]
+}
+
+function addServerInstallableDistros(installedDistros: WslInstalledDistro[], onlineDistros: WslOnlineDistro[]) {
+  const installed = new Set(installedDistros.map((item) => item.name))
+  const hasVersionedUbuntu = onlineDistros.some((item) => /^Ubuntu-\d/.test(item.name))
+  return onlineDistros
+    .filter((item) => !installed.has(item.name))
+    .filter((item) => item.name !== "Ubuntu" || !hasVersionedUbuntu)
+}
+
+function addServerFilteredInstallableDistros(installableDistros: WslOnlineDistro[], search: string) {
+  const query = search.trim()
+  if (!query) return installableDistros
+  return fuzzysort.go(query, installableDistros, { keys: ["label", "name"] }).map((item) => item.obj)
+}
+
+function addServerCatalogTarget(target: string | null, distros: WslOnlineDistro[]) {
+  if (target && distros.some((item) => item.name === target)) return target
+  return distros[0]?.name ?? null
+}
+
+export function addableProbePlan(input: {
+  state: WslServersState | undefined
+  view: WslAddServerView
+  adding: boolean
+  selectedDistro: string | null
+  addableInstalledDistros: WslInstalledDistro[]
+}) {
+  const state = input.state
+  if (!state?.runtime?.available || state.pendingRestart || input.view !== "main" || input.adding) return
+  if (state.job) return
+  const ordered = input.selectedDistro
+    ? [
+        ...input.addableInstalledDistros.filter((item) => item.name === input.selectedDistro),
+        ...input.addableInstalledDistros.filter((item) => item.name !== input.selectedDistro),
+      ]
+    : input.addableInstalledDistros
+  const pending = ordered.flatMap((item) => {
+    if (item.version === 1) return []
+    if (!state.distroProbes[item.name]) return [`distro:${item.name}`]
+    if (wslDistroReady(state, item.name) && !state.neurocodeChecks[item.name]) return [`neurocode:${item.name}`]
+    return []
+  })
+  if (!pending.length) return
+  return {
+    key: pending.join("|"),
+    distros: ordered.filter((item) => item.version !== 1).map((item) => item.name),
+  } satisfies AddableProbePlan
+}
+
+export function autoProbePlan(input: { state: WslServersState | undefined; busy: boolean }) {
+  if (!input.state || input.busy || input.state.pendingRestart) return
+  if (!input.state.runtime) return { key: "runtime", action: "probeRuntime" } satisfies AutoProbePlan
+  if (!input.state.runtime.available) return
+  if (input.state.installed.length || input.state.online.length) return
+  return { key: "distros", action: "refreshDistros" } satisfies AutoProbePlan
+}
+
+export function addServerProbePlan(input: {
+  state: WslServersState | undefined
+  view: WslAddServerView
+  adding: boolean
+  busy: boolean
+  selectedDistro: string | null
+  addableInstalledDistros: WslInstalledDistro[]
+}) {
+  const auto = autoProbePlan({ state: input.state, busy: input.busy })
+  if (auto) return { kind: "auto", key: `auto:${auto.key}`, plan: auto } satisfies AddServerProbePlan
+  const addable = addableProbePlan(input)
+  if (addable) return { kind: "addable", key: `addable:${addable.key}`, plan: addable } satisfies AddServerProbePlan
+}
+
+export function createProbeFailureGate() {
+  let failed: string | undefined
+  return {
+    accepts(key: string) {
+      return key !== failed
+    },
+    settle(key: string, error?: unknown) {
+      if (error) failed = key
+    },
+    reset() {
+      failed = undefined
+    },
+  }
+}
+
+export async function runAddableProbePlan(input: {
+  plan: AddableProbePlan
+  api: Pick<WslServersPlatform, "probeAddable">
+}) {
+  await input.api.probeAddable(input.plan.distros)
+}

package/src/wsl/settings.tsx

@@ -0,0 +1,173 @@
+import { useDialog } from "@neurocode-ai/ui/context/dialog"
+import { Tag } from "@neurocode-ai/ui/v2/badge-v2"
+import { ButtonV2 } from "@neurocode-ai/ui/v2/button-v2"
+import { Icon as IconV2 } from "@neurocode-ai/ui/v2/icon"
+import { IconButtonV2 } from "@neurocode-ai/ui/v2/icon-button-v2"
+import { MenuV2 } from "@neurocode-ai/ui/v2/menu-v2"
+import { useMutation } from "@tanstack/solid-query"
+import fuzzysort from "fuzzysort"
+import { type Accessor, For, Show, createMemo } from "solid-js"
+import type { useServerManagementController } from "@/components/dialog-select-server"
+import { ServerHealthIndicator } from "@/components/server/server-row"
+import { useLanguage } from "@/context/language"
+import { usePlatform } from "@/context/platform"
+import { ServerConnection } from "@/context/server"
+import { showToast } from "@/utils/toast"
+import { DialogAddWslServer } from "./dialog-add-server"
+import { useWslServers } from "./context"
+import { wslOpencodeAction, wslRuntimeRetryable } from "./settings-model"
+
+type Controller = ReturnType<typeof useServerManagementController>
+
+export function isWslServer(server: ServerConnection.Any) {
+  return server.type === "sidecar" && server.variant === "wsl"
+}
+
+export function AddServerMenu(props: { onAddServer: () => void }) {
+  const platform = usePlatform()
+  const dialog = useDialog()
+  const language = useLanguage()
+  const openAddWsl = () => {
+    dialog.push(() => <DialogAddWslServer />)
+  }
+  return (
+    <Show
+      when={platform.wslServers}
+      fallback={
+        <ButtonV2 variant="ghost-muted" icon="plus" onClick={props.onAddServer}>
+          {language.t("dialog.server.add.button")}
+        </ButtonV2>
+      }
+    >
+      <MenuV2 gutter={4} modal={false} placement="bottom-end">
+        <MenuV2.Trigger as={ButtonV2} variant="ghost-muted" icon="plus">
+          {language.t("dialog.server.add.button")}
+        </MenuV2.Trigger>
+        <MenuV2.Portal>
+          <MenuV2.Content>
+            <MenuV2.Item onSelect={props.onAddServer}>{language.t("dialog.server.add.button")}</MenuV2.Item>
+            <MenuV2.Item onSelect={openAddWsl}>{language.t("wsl.server.add")}</MenuV2.Item>
+          </MenuV2.Content>
+        </MenuV2.Portal>
+      </MenuV2>
+    </Show>
+  )
+}
+
+export function useFilteredWslServers(filter: Accessor<string>) {
+  const wsl = useWslServers()
+  return createMemo(() => {
+    const servers = wsl.data?.servers ?? []
+    const query = filter().trim()
+    if (!query) return servers
+    return fuzzysort
+      .go(query, servers, { keys: [(item) => item.config.distro, (item) => item.config.id] })
+      .map((x) => x.obj)
+  })
+}
+
+export function WslServerSettings(props: {
+  controller: Controller
+  servers: ReturnType<typeof useFilteredWslServers>
+}) {
+  const platform = usePlatform()
+  const language = useLanguage()
+  const wsl = useWslServers()
+  const api = platform.wslServers
+
+  const request = useMutation(() => ({
+    mutationFn: (action: () => Promise<unknown>) => action(),
+    onError: (error) =>
+      showToast({
+        variant: "error",
+        title: language.t("common.requestFailed"),
+        description: error instanceof Error ? error.message : String(error),
+      }),
+  }))
+
+  const remove = (key: ServerConnection.Key) => {
+    request.mutate(() => props.controller.handleRemove(key))
+  }
+
+  return (
+    <Show when={api}>
+      <For each={props.servers()}>
+        {(item) => {
+          const key = ServerConnection.Key.make(item.config.id)
+          const check = () => wsl.data?.opencodeChecks[item.config.distro]
+          const opencodeAction = () => wslOpencodeAction(check())
+          const busy = () => wsl.data?.job?.kind === "install-neurocode" && wsl.data.job.distro === item.config.distro
+          return (
+            <div class="settings-v2-servers-row">
+              <div class="settings-v2-servers-lead">
+                <ServerHealthIndicator health={props.controller.status()[key]} />
+                <div class="settings-v2-servers-copy">
+                  <span class="flex min-w-0 items-center gap-1">
+                    <span class="settings-v2-servers-name">{item.config.distro}</span>
+                    <span class="shrink-0 rounded-[3px] border border-v2-border-border-base px-1 py-0.5 text-[9px] leading-none text-v2-text-text-muted">
+                      {language.t("wsl.server.label")}
+                    </span>
+                  </span>
+                  <span class="settings-v2-servers-meta">
+                    <Show when={check()?.version}>{(version) => `v${version()}`}</Show>
+                  </span>
+                </div>
+              </div>
+              <div class="settings-v2-servers-actions">
+                <Show when={props.controller.canDefault() && props.controller.defaultKey() === key}>
+                  <Tag>{language.t("dialog.server.status.default")}</Tag>
+                </Show>
+                <Show when={opencodeAction()}>
+                  {(label) => (
+                    <ButtonV2
+                      size="small"
+                      disabled={busy() || request.isPending}
+                      onClick={() => api && request.mutate(() => api.installOpencode(item.config.distro))}
+                    >
+                      {busy() ? language.t("wsl.server.updating") : label()}
+                    </ButtonV2>
+                  )}
+                </Show>
+                <MenuV2 gutter={4} modal={false} placement="bottom-end">
+                  <MenuV2.Trigger
+                    as={IconButtonV2}
+                    variant="ghost-muted"
+                    size="small"
+                    icon={<IconV2 name="outline-dots" />}
+                    aria-label={language.t("common.moreOptions")}
+                  />
+                  <MenuV2.Portal>
+                    <MenuV2.Content>
+                      <MenuV2.Group>
+                        <MenuV2.GroupLabel>{language.t("wsl.server.menu.label")}</MenuV2.GroupLabel>
+                        <Show when={wslRuntimeRetryable(item.runtime)}>
+                          <MenuV2.Item onSelect={() => api && request.mutate(() => api.startServer(key))}>
+                            {language.t("wsl.server.retryStart")}
+                          </MenuV2.Item>
+                        </Show>
+                        <Show when={props.controller.canDefault() && props.controller.defaultKey() !== key}>
+                          <MenuV2.Item onSelect={() => props.controller.setDefault(key)}>
+                            {language.t("dialog.server.menu.default")}
+                          </MenuV2.Item>
+                        </Show>
+                        <Show when={props.controller.canDefault() && props.controller.defaultKey() === key}>
+                          <MenuV2.Item onSelect={() => props.controller.setDefault(null)}>
+                            {language.t("dialog.server.menu.defaultRemove")}
+                          </MenuV2.Item>
+                        </Show>
+                        <MenuV2.Separator />
+                        <MenuV2.Item onSelect={() => remove(key)}>
+                          {language.t("dialog.server.menu.delete")}
+                        </MenuV2.Item>
+                      </MenuV2.Group>
+                    </MenuV2.Content>
+                  </MenuV2.Portal>
+                </MenuV2>
+              </div>
+            </div>
+          )
+        }}
+      </For>
+    </Show>
+  )
+}

package/src/wsl/types.ts

@@ -0,0 +1,85 @@
+export type WslRuntimeCheck = {
+  available: boolean
+  version: string | null
+  error: string | null
+}
+
+export type WslInstalledDistro = {
+  name: string
+  version: number | null
+  isDefault: boolean
+}
+
+export type WslOnlineDistro = {
+  name: string
+  label: string
+}
+
+export type WslDistroProbe = {
+  name: string
+  canExecute: boolean
+  hasBash: boolean
+  hasCurl: boolean
+  error: string | null
+}
+
+export type WslNeurocodeCheck = {
+  distro: string
+  resolvedPath: string | null
+  version: string | null
+  expectedVersion: string | null
+  matchesDesktop: boolean | null
+  error: string | null
+}
+
+export type WslServerConfig = {
+  id: string
+  distro: string
+}
+
+export type WslServerRuntime =
+  | { kind: "starting" }
+  | { kind: "ready"; url: string; username: string | null; password: string | null }
+  | { kind: "failed"; message: string }
+  | { kind: "stopped" }
+
+export type WslServerItem = {
+  config: WslServerConfig
+  runtime: WslServerRuntime
+}
+
+export type WslJob =
+  | { kind: "runtime"; startedAt: number }
+  | { kind: "distros"; startedAt: number }
+  | { kind: "install-wsl"; startedAt: number }
+  | { kind: "install-distro"; distro: string; startedAt: number }
+  | { kind: "probe-addable"; distros: string[]; startedAt: number }
+  | { kind: "install-neurocode"; distro: string; startedAt: number }
+
+export type WslServersState = {
+  runtime: WslRuntimeCheck | null
+  installed: WslInstalledDistro[]
+  online: WslOnlineDistro[]
+  distroProbes: Record<string, WslDistroProbe>
+  neurocodeChecks: Record<string, WslNeurocodeCheck>
+  pendingRestart: boolean
+  servers: WslServerItem[]
+  job: WslJob | null
+}
+
+export type WslServersEvent = { type: "state"; state: WslServersState }
+
+export type WslServersPlatform = {
+  getState(): Promise<WslServersState>
+  subscribe(cb: (event: WslServersEvent) => void): () => void
+  probeRuntime(): Promise<void>
+  refreshDistros(): Promise<void>
+  installWsl(): Promise<void>
+  installDistro(name: string): Promise<void>
+  probeAddable(distros: string[]): Promise<void>
+  installNeurocode(name: string): Promise<void>
+  openTerminal(name: string): Promise<void>
+  addServer(distro: string): Promise<WslServerConfig>
+  removeServer(id: string): Promise<void>
+  startServer(id: string): Promise<void>
+}

package/sst-env.d.ts

@@ -0,0 +1,10 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+/* biome-ignore-all lint: auto-generated */
+
+/// <reference path="../../sst-env.d.ts" />
+
+import "sst"
+export {}

package/test-browser/command-palette.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test"
+import type { Project } from "@neurocode-ai/sdk/v2/client"
+import type { SessionInfo } from "@neurocode-ai/client/promise"
+import { createRoot } from "solid-js"
+import { createServerSessionEntries } from "@/components/command-palette"
+import type { LocalProject } from "@/context/layout"
+import { ServerConnection } from "@/context/server"
+import { getProjectAvatarSource } from "@/pages/layout/helpers"
+
+const stored: Project = {
+  id: "project-1",
+  name: "Palette project",
+  worktree: "/workspace/project",
+  sandboxes: [],
+  time: { created: 1, updated: 1 },
+}
+
+const session: SessionInfo = {
+  id: "session-1",
+  projectID: stored.id,
+  agent: "build",
+  model: { id: "model-1", providerID: "provider-1" },
+  cost: 0,
+  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+  location: { directory: stored.worktree },
+  title: "Palette session",
+  time: { created: 1, updated: 2 },
+}
+
+describe("command palette sessions", () => {
+  test("uses the home project avatar and cancels superseded searches", async () => {
+    const server = ServerConnection.Key.make("selected-server")
+    const opened: LocalProject = {
+      ...stored,
+      icon: { override: "home-project-avatar" },
+      expanded: true,
+    }
+    const searches: string[] = []
+    const result = await new Promise<Awaited<ReturnType<ReturnType<typeof createServerSessionEntries>>>>(
+      (resolve, reject) => {
+        createRoot((dispose) => {
+          const search = createServerSessionEntries({
+            server,
+            opened: () => [opened],
+            stored: () => [{ ...stored, icon: { url: "stored-project-avatar" } }],
+            load: async (text) => {
+              searches.push(text)
+              return {
+                data: [session, { ...session, id: "archived-session", time: { ...session.time, archived: 3 } }],
+              }
+            },
+            untitled: () => "Untitled",
+            category: () => "Sessions",
+          })
+          const first = search("palette")
+          const second = search("palette session")
+          Promise.all([first, second])
+            .then(([cancelled, entries]) => {
+              expect(cancelled).toEqual([])
+              resolve(entries)
+            })
+            .catch(reject)
+            .finally(dispose)
+        })
+      },
+    )
+
+    expect(searches).toEqual(["palette session"])
+    expect(result).toHaveLength(1)
+    expect(getProjectAvatarSource(result[0]?.project?.id, result[0]?.project?.icon)).toBe("home-project-avatar")
+    expect(result[0]).toMatchObject({
+      server,
+      sessionID: session.id,
+      description: stored.name,
+      project: { id: stored.id, icon: opened.icon },
+    })
+  })
+})